public List <string> Get()
{
var output = new List <string>();
baseClass obj;
obj = new baseClass();
output.Add(obj.show());
obj = new derivedClass();
output.Add(obj.show());
return(output);
}
//public class seaInhClass : seaClass { }
// Use this for initialization
void Start()
{
baseClass baseClassInstance = new baseClass();
derivedClass deriveClassInstacne = new derivedClass();
baseClassInstance.virMethod();
deriveClassInstacne.virMethod();
//没有override过的虚方法采用基类中的实现
baseClassInstance.virMethod2();
deriveClassInstacne.virMethod2();
}
// Use this for initialization
void Start()
{
baseClass instanceBaseClass = new baseClass();
derivedClass instanceDerivedClass = new derivedClass();
//基类实例调用基类方法
instanceBaseClass.methodInBaseClass();
//派生类实例调用派生类方法
instanceDerivedClass.methodInDerivedClass();
//派生类实例调用基类公共字段
print(instanceDerivedClass.intInBaseClass);
//派生类实例调用基类公共方法
instanceDerivedClass.methodInBaseClass();
}
void Start()
{
derivedClass myInstance = new derivedClass();
//当使用实例调用方法时，执行的是hide基类方法后的新方法
myInstance.myMethod();
ImyInterface interfaceInstance;
interfaceInstance = myInstance;
//派生类默认支持基类的接口
//当使用接口调用方法时，虽然基类中的方法被hide了，但调用的仍是基类中的方法
interfaceInstance.myMethod();
}
void Start()
{
baseClass baseClassInstance = new baseClass();
derivedClass derivedClassInstance = new derivedClass();
//基类实例无法转换为派生类，结果为null
print(baseClassInstance as derivedClass);
//派生类实例可以转换为基类，结果为派生类
print(derivedClassInstance as baseClass);
//基类实例可以转换为所支持的接口
print(baseClassInstance as myInterface);
//若基类实例支持某接口，则其派生类实例亦可转换为所支持的接口
print(derivedClassInstance as myInterface);
}
// Use this for initialization
void Start()
{
baseClass baseClassInstance1, baseClassInstance2;
derivedClass derivedClassInstance = new derivedClass();
//隐式类型转换
baseClassInstance1 = derivedClassInstance;
//显式类型转换
baseClassInstance2 = (baseClass)derivedClassInstance;
independentClass independentClassInstance;
//不相关的类不能进行隐式转换或者显式转换
//independentClassInstance = derivedClassInstance;
//independentClassInstance = (independentClass)derivedClassInstance;
}
// Use this for initialization
void Start()
{
baseClass baseClassInstance;
derivedClass derivedClassInstance = new derivedClass();
derivedClassInstance.methodToHide();
derivedClassInstance.methodToOverride();
//多态
baseClassInstance = derivedClassInstance;
baseClassInstance.methodToHide();
baseClassInstance.methodToOverride();
//只在派生类中才定义的方法，在利用多态赋予给基类变量后不能使用
//baseClassInstance.useBaseMethod();
//即便被override,但通过base关键词仍可调用基类方法
derivedClassInstance.useBaseMethod();
}
public static void execute()
{
char exec = '-';
if (exec == '+') {
Console.WriteLine("Exemple d'utilisation de constructeurs:\r\n");
classe c1 = new classe(); // le constructeur statique est appelé lors de la 1ere instance uniquement
classe c2 = new classe(); // seul le constructeur classe est appelé lors d'une creation de 2eme instance
//classe1 c1 = new classe1(); // impossible car le constructeur est privé
derivedClass c = new derivedClass("Thierry"); // L'instantiation appel successivement l'ensemble des constructeurs de classe et hérité
Console.WriteLine(c.nom + " " + c.prenom + " " + c.age.ToString());
Console.WriteLine("\r\n");
}
}
// Use this for initialization
void Start()
{
baseClass baseClassInstance = new baseClass();
derivedClass derivedClassInstance = new derivedClass();
//假若<A>is<B>中，<A>是<B>或<B>的派生类的实例，则返回true
print(derivedClassInstance is derivedClass);
print(derivedClassInstance is baseClass);
classWithInterface classWithInterfaceInstance = new classWithInterface();
myInterface myInterfaceInstance = classWithInterfaceInstance;
//接口变量与接口进行比较
print(myInterfaceInstance is myInterface);
//实例与接口进行比较
print(classWithInterfaceInstance is myInterface);
}
//class derivedClass3 : sealedClass { } // Impossible car sealedClass est SEALED
public static void execute()
{
char exec = '-';
if (exec == '+') {
Console.WriteLine("Exemple d'utilisation de classe abstraite ou sealed:\r\n");
baseClass bc = new baseClass();
derivedClass dc = new derivedClass();
baseClass bcdc = new derivedClass(); // une instance de derivedClass référencé par un type baseClass
bc.methode1(); // Base: methode1
bc.methode2(); // Base: methode2
dc.methode1(); // Derived: methode1
dc.methode2(); // Derived: methode2
bcdc.methode1(); // Base: methode1 -> new a remplacé methode1 DANS derivedClass pas dans baseClass OR bcdc REFERENCE un type baseClass
bcdc.methode2(); // Derived: methode2 -> override a remplacé methode2 DANS baseClass DONC la REFERENCE à baseClass utilise la methode de derivedClass
Console.WriteLine("\r\n");
}
}
//Main-----------------------------------------------------------------------------
static void Main(string[] args)
{
//Inheritance and Polymorphism
//Instantiate derived class and access its inherited public method
derivedClass d = new derivedClass(7, "Smith");
Console.WriteLine(d.Legs); //returns 4
d.Bark(); //returns Woof
d.Speak();
Console.WriteLine(derivedClass.Number);
//protected members of base class
d.SayName(); //Works because derived class SayName method has access to base class' field/var
//d.LastName = "Jones"; //error, due to "protected" protection level in base class
//Polymorphism
Shape c = new Circle();
c.Draw(); //outputs circle
Shape r = new Rectangle();
r.Draw(); //outputs rectangle
//Abstract class
abstractClass v = new abstractCircle();
v.Draw(); //circle
//Interface
IShape z = new interfaceCircle();
z.Draw(); //Outputs circle drawing
ISquash y = new interfaceCircle();
y.Squash(); //Outputs about squashing
//Namespaces
System.Console.WriteLine("Hello"); //Here, "System" would be required if "using System;" was not called at the start of the file.
}
// Use this for initialization
void Start()
{
derivedClass derivedClassInstance = new derivedClass(2);
//多层指定调用
derivedClass2 derivedClassInstance2 = new derivedClass2(2);
}
