uinty3D学习C#基础语言

uinty3D学习C#基础语言
1.  virtual和override

1.virual用在基类中，指定一个虚方法（属性），表示 这个方法（属性）可以重写。voerride用在派生类中，表示对基类方法（属性）的重写。

例如：
     class Test
     {
       public virtual void Print()
     {
         Console.WriteLine("我是基类的Print 虚方法");
     }
     }
      class Text2:Text
    {
        public override void Print ()
    {
             Console.WriteLine("我是子类重写了的Print方法");
      //使用base关键可以在子类中访问基类同名的方法。
     //base.Print ();
      }
     public sealed override void Show()
      {
            Console.WriteLine("我是阻止派生类重写的Show方法");
      }
      }
代码运行结果：我是子类重写了的Print方法

2.
父类的引用指向子类的实例
     class  Text
     {
         public void Print ()
    {
            Console.WrinteLine ("我是基类的Print虚方法");
     }
     }
      class  Text2:Text
     {
         public void Pirnt ()
    {
      Console.WriteLine("我是子类重写了的Print方法");
    }
    }
      class Program
    {
       static void Main (string [] agrs)
    {
         Text ts=new Text2(); //父类的引用指向子类的实例
        ts.Print();
       Consoel.ReadKey();
     }
     }

   代码运行结果为：我是基类的print虚方法。

  virtual和override的总结：

 1.virtual关键字和override关键字是成对出现的，否则是语法错误。
 2.派生类可以通过将重写声明为sealed来停止虚的继承。这需要在类成员声明中的override关键字前面放置sealed关键字。
 3.在子类中重写基类中的虚方法时，可以使用base关键字调用基类中的虚方法。

2 . 多态

多态定义：通过继承实现的不同对象调用相同的方法，表现出不用的行为，就是多态。

注意：C#继承：子类使用父类的方法。             C#多态：父类使用子类的方法。

例子：
        public abstract class Girth
      {
                 public int getSide(){}
      }//这就是继承
         public  class Circular:Graph
   {
         public overriode int getSides()    //子类使用父类的方法
      {
            return 1;
      }
  }
         public class square:Graph
   {
      public override int getSides()  //子类使用父类的方法
       {
                  return 2;
        }
   }
     class Program
    {
     static void Main(striing [] agrs )
       {
        Circual c=new Circual();
        Console.WriteLine(c.getSides());
        Square s=new Square();
       Console.WriteLine(s.getSides());
        //这就是多态的运用
      Graph g;
       g=new Circular();
       g.getSides();       //父类使用子类的方法
       g=new Square();
       g.getSides();           //父类使用子类的方法
     Console.ReadKey();
        }
    }

3.索引器

索引器介绍：是一种特殊的类成员，它能够让对象以类似数组的方式来存取，使程序看起来更为直观，更容易编写。

索引器定义：
    C#中的类成员可以是任意类型，包括数组和和集合。当一个类包含了数组和集合成员时，索引器将大大简化对数组或集合成员的存取操作。

定义索引器的方法与定义属性有些相似，一般如下：
[修饰符]       数据类型      this[索引类型  index]  
     {
       set{//设置属性代码}
       get{//获取属性代码}
    }
修饰符包括：   public ， protected， private，internal，new，virtual，sealed， override，abstract，extern。

数据类型是表示将要存取的数组和集合元素的类型。
 
索引器类型表示该索引器使用那一类型的索引来存取数组或集合元素，可以是整数，可以是字符或是字符串；this表示操作本本对象的数组或集合成员，可以简单把它理解成所引起的名字，因此索引器不能具有用户定义的名字。而且一个程序只能有一个索引器。

4.私有构造函数：

            定义：私有构造函数是一种特殊的实例构造函数。它通常用在只包含静态成员的类中。如果类具有一个或多个私有构造函数而没有公共构造函数，则不允许其他类（除了嵌套类）创建该类的实例。

            作用：构造函数可用于对象的初始化操作,当对象调用类时，就自动力调用了构造函数，构造函数可以自定义，也可以默认

    class PrivateClass
        {
            //private PrivateClass() {
            //    Console.WriteLine("aaaaaaaaaaa");//可以被自己实例化
            //}
        }
        class PrivateClass2
        {
            //static void Main(string[] args)
            //{
            //    //PrivateClass pc = new PrivateClass();
            //    Console.ReadKey();//不可以被其他类实例化
            //}
        }

 

5.析构函数：

           析构函数的名字和类名一样，不过要在前面加上 ~ 。对一个类来说，只能允许一个析构函数，析构函数不能有参数，并且也没有返回值。析构函数的作用是完成一个清理工作，如释放从堆中分配的内存。 一个类中可以有多个构造函数，但析构函数只能有一个。对象被析构的顺序，与其建立时的顺序相反，即后构造的对象先析构。

           作用：析构函数是释放对象调用的内存空间。构造函数可以是多个，析构函数一至少只有一个。

    class DestructorClass
        {
            public DestructorClass()
            {
                Console.WriteLine("我是构造函数");
            }
            //析构函数(释放内存空间)
            ~DestructorClass()
            {
                Console.WriteLine("我是析构函数");
            }
            //static void Main(string[] args){
            //     DestructorClass dc=new DestructorClass();
            //     dc = null;//赋为空
            //     GC.Collect();调用垃圾搜集器
            //     Console.ReadKey();
            //}
             
        }


析构函数和构造函数的区别：

构造函数的功能是在创建对象时，使用给定的值来将对象初始化。

析构函数的功能是用来释放一个对象的。在对象删除前，用它来做一些清理工作，它与构造函数的功能正好相反。


更多精彩内容请到：http://www.gopedu.com/