public class Test {
  Integer testField;
 
  Integer methodA() {
    return testField;
  }
 
  final Integer methodB() {
    return testField;
  }
}
 
class Test1 extends Test {
  @Override
  Integer methodA() {
    return 1;
  }
 
  @Override              // error, it can not be overrided
  Integer methodB(){
    return 2;
  }
}

namespace implicitExample
{
    class Digit
    {
        public Digit(double d) { val = d; }
        public double val;
        // ...other members
 
        // User-defined conversion from Digit to double
        public static implicit operator double(Digit d)
        {
            return d.val;
        }
        //  User-defined conversion from double to Digit
        public static implicit operator Digit(double d)
        {
            return new Digit(d);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Digit dig = new Digit(7);
            //This call invokes the implicit "double" operator
            double num = dig;
            //This call invokes the implicit "Digit" operator
            Digit dig2 = 12;
            Console.WriteLine("num = {0} dig2 = {1}", num, dig2.val);
            Console.ReadLine();
        }
    }
}

List<?>    // 类型未知，只能添加null
List<? extends Number>    // 类型未知，限定为Number的派生类，只能添加null
List<? super Double>    // 类型位置，限定为Double的基类，可以添加元素

void recordNonOveridableMethodCall(Reason reason, int lineNumber,
     MethodInfo toMethod, Variable methodThis,
     List parameters, Variable returnVariable) {
     //...
}

void recordNonOveridableMethodCall(Reason reason, int lineNumber,
     MethodInfo toMethod, Variable methodThis,
     List parameters, Variable returnVariable) where T : Variable{
     //...
}

class OuterClass
{
    private static int outerStaticField;
    private int outerField;
 
    class InnerClass
    {
        InnerClass()
        {
            outerStaticField = 1;
            //outerField = 1; // compile time error
        }
    }
}