学习 Unity 3D游戏开发日常笔记（C# 第三周）

学习 Unity 3D游戏开发日常笔记（C# 第三周）

周一	周二	周三	周四	周五
面向对象（类、属性、方法（函数））	静态：static	Sealed	接口	总结面向对象
构造函数	静态类	虚方法	显示实现接口
析构函数	单例	抽象方法和抽象类	知识点
总结：结构体和类之间的区别	继承	虚方法和抽象类的选择	索引器
类字段保护（属性）	什么叫全局变量？		重载运算符
什么叫局部变量？

2019.7.22（一）

面向对象：

类：是对相同属性和行为的一个抽象描述，是对某一个群体的综合描述

属性：这个对象所特有的特征

方法（函数）：这个对象所拥有的行为

构造函数：是类进行构造一个对象的函数；是一个对象的起始，在堆中开辟区域；

1. 在构造对象时直接通过构造函数重载方法对对象初始化，构造函数必须通过new调用，构造函数名必须和类名一致，没有返回类型；
2. 当我们类中没有写构造函数时，系统会默认添加一个无参构造函数；如果类中有有参构造，那么系统不会给添加一个默认无参构造函数；
3. This在构造函数中的另一种用法：
   

析构函数：

这个对象销毁所执行的方法，我们一般不写，系统会自动添加。当系统调用垃圾回收时，系统会调用析构函数回收内存区域；

总结：结构体和类之间的区别：

1. 结构体对象时值类型的，类对象是引用类型的；
2. 类如果没有构造函数，默认添加一个无参构造，如果有有参构造，那么默认不会添加无参构造；
   结构体不能自己添加无参构造，是默认添加的，如果有了有参构造，系统还是会给添加无参构造；
3. 结构体有参构造函数需要当前结构体所有属性进行完全赋值；类不需要；
4. 类的属性可以赋默认值，结构体不能赋默认值；

类字段保护：

Get：是得到的意思，在get方法中返回return对应的值给调用处，

Set：是value值是外界赋值给Age的值，我们可以再set方法中进行一次筛选，选择是否赋值给age；

2019.7.23（二）

静态：static：

①静态类型的变量是类最先加载到内存区域的；（静态方法不可以调用非静态方法，但是非晶态方法可以调用静态方法）；
②静态变量或者方法，不是对象所单独拥有的；是所有对象共有的；通过类名、属性或者方法直接访问；
③静态区域的内容，是整个类中最后销毁的，也就是说不能乱声明静态属性或方法；

静态类：

单例 ---- 用于管理类，比如GameManager；

静态类 ---- 用于工具类，写工具给其他开发者调用的，比如系统提供的Console.ReadLine（）；

1. 静态类在项目一运行就加载到内存；
2. 静态类声明周期最长，所以整个项目中，能不写静态类就不写；
3. 静态类是整个项目所共享的，静态类方法在整个项目中都可以通过类名调用；

单例：

什么类需要单例？–这个类不能有多个对象，比如游戏管理类；

特点：

①整个项目中这个类只有一个对象；
②单例类的写法：把构造函数私有化；

继承：

1. object类是C#中所有类的父类；

2. 访问修饰符
   子类名 ： 父类名
   {

   }
   ①一个类只能继承一个类（一个类只能有一个直接父类）；
   ②子类保存父类的所有方法和属性；
   ③base 和 this关键字在构造函数中的不同作用；
   ④派生类的构造函数需要指向一个父类的构造，如果不指定将会指向父类默认（无参）构造

3. 访问修饰符 ：
   ①public 公共的 ，所有类中了可以访问
   ②protected 保护类型的 ，在本类和子类中可以访问
   ③private 私有的，只有在本类中可以访问；类中声明变量默认是private
   ④Internal: 程序集中可以使用；

4. new关键字，如果在子类中声明的一个成员，与父类中重名，将默认启用new关键字，将会为这个新的成员申请一个新的空间，而父类中的成员将会被隐藏。

5. 里氏替换：is as 的用法；
   

什么叫全局变量？

变量时类的一部分，有效范围是整个类，类中的所有方法都可以访问；即使声明在类的最后一行，在方法里也可以使用；

什么叫局部变量？

在一个固定的代码块中声明的变量；作用域是当前声明的地方到代码块结束，声明之前不能用；一般类对象临时使用，可以使用代码块括号括起来，减小类对象作用域也就是减少了对象的生命周期，提高代码效率。

2019.7.24（三）

1.Sealed：

修饰类时，当前类就不能被继承（封闭类）；
修饰虚方法时，子类不能重写该方法；

2.虚方法：

①在父类中使用virtual修饰方法，子类中使用Override对其重写；
②子类重写了父类的虚方法，new一个子类对象赋值给父类声明一个变量；
当我们调用p2的speak虚方法，起始调用的是Chinese中重写的speak方法；
③new 关键字覆盖 和 virtual override 区别：
New关键字覆盖的方法，什么类的对象调用什么类的方法
Override调用的是生成对象时最后重写的方法；
④完成基类虚方法子类重写条件：方法名一致，返回值类型一致，参数类型个

virtual override:

new:

3.抽象方法和抽象类：

①要用abstract修饰，必须在抽象类中；
②抽象方法没有具体的方法体；
③抽象类也需要abstract修饰，继承抽象类的子类，必须实现所有抽象类中的抽象方法；
④虽然抽象类不能有实例对象，但是也可以写构造方法，子类构造方法规则跟普通子类没有区别；

4.虚方法和抽象类的选择：

①父类是否需要实例化，需要实例化这时候用虚方法，用普通类；
②如果父类不需要实例化，可以考虑用抽象类；
③一般会使用抽象类中加虚方法混合使用，子类可以选择性实现的方法，使用虚方法，必须实现的方法用抽象方法；

2019.7.25（四）

接口

1.使用interface关键字修饰，接口的方法和属性不许有方法体；
2.接口不能有构造函数，要知道他不是类，当然也就不能有接口类对象了；
3.成员默认是public；
4.类可以实现多个接口，接口也可以继承接口，当一个类继承其他类并且要实现接口时，基类必须写在前面；

显示实现接口

结果：

知识点：

	引用类型默认值是null；
	值类型默认值是0；---------每一种编程语言不一样；

索引器：

namespace 索引器
{

    class Person
    {
        public string name;
        public int age;
        public string sex;
        public string address;
        public float height;

        public Person() { }
        public Person(string name,int age,string sex,string address,float height)
        {
            this.name = name;
            this.age = age;
            this.sex = sex;
            this.address = address;
            this.height = height; 
        }

        public string this[int x] {
            get {
                switch (x)
                {
                    case 0:
                        return name;
                    case 1:
                        return age.ToString();
                    case 2:
                        return sex;
                    case 3:
                        return address;
                    case 4:
                        return height.ToString();
                    default:
                        return "下标号越界";
                }
            }
            set {
                switch (x)
                {
                    case 0:
                        name = value;
                        break;
                    case 1:
                        age = int.Parse( value);
                        break;
                    case 2:
                        sex = value;
                        break;
                    case 3:
                        address = value;
                        break;
                    case 4:
                        height = float.Parse(value);
                        break;
                    default:
                        break;
                }
            }

        }

        public  void SayHello()
        {
            Console.WriteLine("哈罗，我是" + name);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            
            Person zhangsan = new Person("张三", 20, "男", "中国", 1.75f);
            zhangsan[1] = "34";
            Console.WriteLine(zhangsan[1]);

            Console.ReadLine();
        }
    }
}

重载运算符：

2019.7.26（五）

总结面向对象：

1. 封装：怎么写一个类？有哪些属性、字段、方法
2. 继承：里氏替换（is as ）；提高代码使用效率；base
3. 多态：同一个方法作用于不同的对象产生不同效果；
   1. 虚函数：virtual 虚函数可以写在普通类中、也可以写在抽象类中；子类可以重写父类中的虚方法，也可以不重写；
   2. 抽象类、抽象函数：abstract抽象函数必须写在抽象类中、子类必须重写 、抽象类不能有对象、抽象函数没有函数体
   3. 接口：不是类，更偏向对类的补充；一个类可以实现多个接口（接口使用i起来特别灵活）