C#记录二

异常处理

class Program
    {
        static void Main(string[] args)
        {
            try//try块中，只要有一行代码发生异常，try块中后面的代码就不会执行
            {
                int[] myArray = { 1, 2, 3, 4 };
                int myEle = myArray[4];
            }
            catch (IndexOutOfRangeException e)//当异常类型和该类型相同，执行catch块，如果没有参数，则任何异常都执行catch块
            {
                Console.WriteLine("发生异常:IndexOutOfRangeException");
                Console.WriteLine("访问数组下标越界");
            }
            catch(NullReferenceException e)
            {
                Console.WriteLine("发生异常:NullReferenceException");
            }
            catch//前面已经处理了，后面就不处理，不能放在第一个。
            {
                Console.WriteLine("发生异常:未知异常");
            }
            finally//始终会执行的代码
            {
                Console.WriteLine("Finally执行语句");
            }
            Console.WriteLine("test");
            Console.ReadKey();
        }
    }

属性的定义,get方法和set方法

    class MyClass
    {
        private int myIntProperty;     //一般编程规范定义一个私有的变量
        public int MyIntProperty       //然后通过public方法来get或者set该变量
        {
            set
            {
                myIntProperty = value;
                Console.WriteLine("属性中的set被调用");
                Console.WriteLine("SET块中访问value的值是:" + value);
            }
            get//如果没有get块，就不能通过属性取值
            {
                Console.WriteLine("属性中的get被调用");
                return myIntProperty;
            }
        }

        public string Name { get; set; }//编译器会自动给我们提供一个字段来存储name
    }
//下面是对该类的调用
    class Program
    {
        static void Main(string[] args)
        {
            MyClass myclass = new MyClass();
            myclass.MyIntProperty = 10;
            int temp = myclass.MyIntProperty;
            Console.WriteLine(temp);

            myclass.Name = "city";
            Console.WriteLine(myclass.Name);

            Console.ReadKey();
        }
    }

匿名类型

   static void Main(string[] args)
   {
       //var可以定义一个变量，可初始化为任意值，但是初始化一次之后就不能再次更改了。
       int i = 100;
       var j = 1000;
       var a = "asdf";
       var v1 = new Vector3();
   }

继承注意事项

class Program
    {
        static void Main(string[] args)
        {
            //父类BaseEnemy，子类Boss，
            Boss boss = new Boss();
            boss.AI();//父类里面所有的数据成员和函数成员都被继承到子类

            BaseEnemy baseEnemy;//父类声明
            baseEnemy = new Boss();//父类声明的对象，可以用子类去构造，但是反过来不行
            //此时 baseEnemy可以使用Boss的方法
            //使用强制类型转换
            Boss boss1 = (Boss)baseEnemy;
            boss1.Attack();

            BaseEnemy baseEnemy1 = new BaseEnemy();//使用父类声明并且实例化
            //一个对象是什么类型，就看是什么构造的
            //这里的baseEnemy1是父类的构造对象，只有父类的字段
            //所以不能强制转换
            //Boss boss2 = (Boss)baseEnemy1;

            Console.ReadKey();
        }
    }

虚函数

    class Enemy//基类
    {
        //定义一个虚函数，之后可以在集成类中重写
        public void AI()
        {
            Console.WriteLine("基类的AI方法");
        }
        public virtual void Move()//定义了一个虚函数
        {
            Console.WriteLine("基类里面的Move方法");
        } 
    }
    class Boss:Enemy//子类，继承父类
    {
        public override void Move()//关键字override重写该虚函数
        {
            Console.WriteLine("这里是Boss的Move方法");
        }
        public void Attack()
        {
            Move();//这里Move调用的就是重写之后的Move
            AI();
        }
    }

    class Program//调用
    {
        ////在子类里面重写虚函数之后，不管在哪里调用，都是调用重写之后的方法，前提是实例化的时候使用的是该子类
        static void Main(string[] args)
        {
            Boss boss = new Boss();//boss中重写了Move
            boss.Attack();//使用Boss类的Move

            TypeEnemy enemy = new TypeEnemy();//此时使用TypeEnemy实例化的时候，并没有重写Move函数
            enemy.Attack();//使用基类的Move
            Console.ReadKey();
        }
    }

    //输出
    这里是Boss的Move方法
    基类的AI方法
    基类里面的Move方法
    基类的AI方法

隐藏方法：

    class Enemy//基类
    {
        public void Move()
        {
            Console.WriteLine("父类的Move");
        }
    }

    class Boss:Enemy//子类
    {
        //在父类中也有个Move方法，但并不是重写了，而是把父类的方法隐藏，实际还存在
        public void Move()
        {
            Console.WriteLine("子类Boss的Move");
        }
    }

    class Program//调用
    {
        static void Main(string[] args)
        {
            Boss boss = new Boss();//子类声明
            boss.Move();//这个时候直接调用子类的Move

            Enemy boss1 = new Boss();//父类声明
            boss1.Move();//这个时候调用父类得到Move

            Console.ReadKey();
        }
    }

虚函数和隐藏方法的区别：

在虚函数中，如果子类重写了父类的某方法，那么用该子类实例化的对象就无法使用父类的该方法；
隐藏方法中，并不是对父类的方法进行重写，而是隐藏起来，父类的方法还存在
此时，如果是子类声明的对象，就调用子类的方法，如果是父类声明的对象，就调用父类的方法

抽象类

    abstract class Bird_abstractClass//基类，因为类中有抽象方法，所以类也要声明为抽象类
    {
        private float speed;
        public void Eat()
        {

        }
        public abstract void Fly();//当类中有抽象方法的时候，类也需要声明为抽象类，抽象方法没有函数块
    }
    class Crow : Bird_abstractClass//子类，继承后必须要实现抽象方法
    {
        public override void Fly()
        {
            Console.WriteLine("Fly in Crow");
        }
    }

    static void Main(string[] args)//调用
    {
        Crow crow = new Crow();
        crow.Fly();

        Bird_abstractClass bird = new Crow();//我们可以抽象类去声明对象，但不能去构造
        bird.Fly();

        Console.ReadKey();
    }

密封类和密封方法_sealed关键字

    sealed class BaseClass//说明BaseClass是密封类，此时无法被继承
    {
        public void Move(){}//注意，密封类中不能再声明新的虚函数，但可以重写基类的虚函数
    }

    class BaseClass//基类
    {
        public virtual void Move()
        {

        }
    }
    class OverRideBaseClass:BaseClass
    {
        public sealed override void Move()//只能在子类重写的时候使用sealed声明，表示不能被再次重写
        {
            base.Move();
        }
    }
//所以密封类不能被继承，而密封方法只能在重写的时候使用，之后该方法无法再被重写。

static关键字

    class StaticClass
    {
        private int x;
        private int y;
        public static int z;//静态字段    

        public static void TestStatic()
        {
            Console.WriteLine("静态方法");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            //下面声明sc的时候，只有属性里面的x，y，不包括static定义的静态字段，
            //而TestStatic()方法只能通过类名直接访问，不能利用sc访问。
            StaticClass sc = new StaticClass();
            StaticClass.z = 1;
            StaticClass.TestStatic();

            Console.ReadKey();
        }
    }

接口

    interface IFly//定义接口，关键字 interface
    {//接口只声明，不实现
        void Fly();
        void MethodA();
        void MethodB();
    }
    interface IDriveFly:IFly//继承接口，和类相似
    {
        void Method3();
        void Method4();
    }
    class DriveFly : IDriveFly//最后类可以继承接口，需要把接口中的方法全部实现，否则会出现异常。
    {
        public void Fly()
        {
            throw new NotImplementedException();
        }

        public void Method3()
        {
            throw new NotImplementedException();
        }

        public void Method4()
        {
            throw new NotImplementedException();
        }

        public void MethodA()
        {
            throw new NotImplementedException();
        }

        public void MethodB()
        {
            throw new NotImplementedException();
        }
    }

泛型

    class ClassA<T>//T代表一个数据类型，构造的时候需要指定T的类型
    {
        private T a;
        private T b;
        public ClassA(T a,T b)
        {
            this.a = a;
            this.b = b;
        }
        public string GetSum()
        {
            return a + "" + b;
        }
    }
    class Program
    {
        //泛型方法
        public static string GetSumm<T>(T a,T b)
        {
            return a + "" + b;
        }
        static void Main(string[] args)
        {
            var o1 = new ClassA<int>(12, 23);//当我们利用泛型类构造的时候，指定了类型
            string s = o1.GetSum();
            Console.WriteLine(s);
            Console.ReadKey();
        }
    }