C#核心学习

特征——成员变量

行为——成员方法

初始化调用——构造函数
释放时调用——析构函数

保护成员变量——成员属性

像数组一样使用——索引器

类名点出使用——静态成员

自定义对象可计算——运算符重载

静态类和静态构造函数

拓展方法

内部内和分部类

知识点一 内部类
    概念：在一个类中再申明一个类

    特点：使用时要用包裹者点出自己

    作用：亲密关系的变现

    注意：访问修饰符作用很大   

 class Person
    {
        public int age;
        public string name;
        public Body body;
        public class Body
        {
            Arm leftArm;
            Arm rightArm;
            class Arm
            {

            }
        }
    }

知识点二 分部类
    概念：把一个类分成几部分申明

    关键字：partial

    作用：分部描述一个类，增加程序的拓展性

    注意：
    分部类可以写在多个脚本文件中
    分部类的访问修饰符要一致
    分部类中不能有重复成员   

partial class Student
    {
        public bool sex;
        public string name;

        partial void Speak();
    }

    partial class Student
    {
        public int number;

        partial void Speak()
        {
            //实现逻辑
        }

        public void Speak(string str)
        {

        }
    }

知识点三 分部方法

概念：将方法的申明和实现分离
    特点
    1.不能加访问修饰符 默认私有
    2.只能在分部类中申明
    3.返回值只能是void
    4.可以有参数但不用 out关键字    局限性大，了解即可

   

class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("内部类和分部类");

            Person p = new Person();

            Person.Body body = new Person.Body();
        }
    }

 

继承

知识点一 基本概念

    一个类A继承一个类B
    类A将会继承类B的所有成员
    A类将拥有B类的所有特征和行为

    被继承的类称为 父类、基类、超类

   继承的类称为子类、派生类

    子类可以有自己的特征和行为    

    特点
    1.单根性 子类只能有一个父类
    2.传递性 子类可以间接继承父类的父类  
 

知识点二 基本语法

class 类名 : 被继承的类名
    {

    }

实例

    class Test
    {

    }

    class Teacher
    {
        姓名
        public string name;
        职工号
        protected int number;
        介绍名字
        public void SpeakName()
        {
            number = 10;
            Console.WriteLine(name);
        }
    }

    class TeachingTeacher : Teacher
    {
        科目
        public string subject;
        介绍科目
        public void SpeakSubject()
        {
            number = 11;
            Console.WriteLine(subject + "老师");
        }
    }

    class ChineseTeacher:TeachingTeacher
    {
        public void Skill()
        {
            Console.WriteLine("一行白鹭上青天");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("继承的基本规则");

            TeachingTeacher tt = new TeachingTeacher();
            tt.name = "怪盗基德";
            tt.number = 1;
            tt.SpeakName();

            tt.subject = "Unity";
            tt.SpeakSubject();

            ChineseTeacher ct = new ChineseTeacher();
            ct.name = "怪盗基德";
            ct.number = 2;
            ct.subject = "语文";
            ct.SpeakName();
            ct.SpeakSubject();
            ct.Skill();
        }
    }

知识点四 访问修饰符的影响

    public - 公共 内外部访问
    private - 私有 内部访问
    protected - 保护 内部和子类访问

    internal - 内部的 只有在同一个程序集的文件中，内部类型或者是成员才可以访问
  

知识点五 子类和父类的同名成员

    概念 ：C#中允许子类存在和父类同名的成员
    但是 极不建议使用

    总结

继承基本语法
    class 类名:父类名
    1.单根性：只能继承一个父类
    2.传递性：子类可以继承父类的父类的所有内容
    3.访问修饰符 对于成员的影响

    4.极奇不建议使用 在子类中申明和父类同名的成员
 

里氏替换原则

知识点一 基本概念

里氏替换原则是面向对象七大原则中最重要的原则
概念：任何父类出现的地方，子类都可以替代
重点：语法表现——父类容器装子类对象,因为子类对象包含了父类的所有内容
作用：方便进行对象存储和管理

知识点二 基本实现

    class GameObject
    {

    }

    class Player:GameObject
    {
        public void PlayerAtk()
        {
            Console.WriteLine("玩家攻击");
        }
    }

    class Monster:GameObject
    {
        public void MonsterAtk()
        {
            Console.WriteLine("怪物攻击");
        }
    }

    class Boss:GameObject
    {
        public void BossAtk()
        {
            Console.WriteLine("Boss攻击");
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("里氏替换原则");

            里氏替换原则 用父类容器 装载子类对象
            GameObject player = new Player();
            GameObject monster = new Monster();
            GameObject boss = new Boss();

            GameObject[] objects = new GameObject[] { new Player(), new Monster(), new Boss() };
        }
    }

知识点三 is和as

基本概念 
             is：判断一个对象是否是指定类对象
             返回值：bool  是为真 不是为假

             as：将一个对象转换为指定类对象
             返回值：指定类型对象
             成功返回指定类型对象，失败返回null

            基本语法
             类对象 is 类名   该语句块 会有一个bool返回值 true和false
             类对象 as 类名   该语句块 会有一个对象返回值 对象和null           

 if( player is Player )
            {
                Player p = player as Player;
                p.PlayerAtk();
                (player as Player).PlayerAtk();
            }

            for (int i = 0; i < objects.Length; i++)
            {
                if( objects[i] is Player )
                {
                    (objects[i] as Player).PlayerAtk();
                }
                else if( objects[i] is Monster )
                {
                    (objects[i] as Monster).MonsterAtk();
                }
                else if (objects[i] is Boss)
                {
                    (objects[i] as Boss).BossAtk();
                }
            }

    总结

    概念：父类容器装子类对象
    作用：方便进行对象的存储和管理
    使用：is和as
     is 用于判断
     as 用于转换
     注意：不能用子类容器装父类对象
 

继承中的构造函数

知识回顾
    构造函数
    实例化对象时调用的函数
    主要用来初始化成员变量
    每个类 都会有一个默认的无参构造函数

    语法

  访问修饰符 类名()
    {
    }
    不写返回值
    函数名和类名相同
    访问修饰符根据需求而定,一般为public

 构造函数可以重载
    可以用this语法重用代码

    注意
    有参构造会顶掉默认的无参构造
    如想保留无参构造需重载出来

    class Test
    {
        public int testI;
        public string testStr;
        public Test()
        {

        }

        public Test(int i)
        {
            this.testI = i;
        }
        public Test(int i, string str) : this(i)
        {
            this.testStr = str;
        }
    }

知识点一 继承中的构造函数 基本概念

特点：
    当申明一个子类对象时，先执行父类的构造函数，再执行子类的构造函数

    注意：
1.父类的无参构造 很重要
2.子类可以通过base关键字 代表父类 调用父类构造
 

知识点二 继承中构造函数的执行顺序

 父类的父类的构造——>。。。父类构造——>。。。——>子类构造

   

class GameObject
    {
        public GameObject()
        {
            Console.WriteLine("GameObject的构造函数");
        }
    }
    class Player:GameObject
    {
        public Player()
        {
            Console.WriteLine("Player的构造函数");
        }
    }
    class MainPlayer : Player
    {
        public MainPlayer()
        {
            Console.WriteLine("MainPlayer的构造函数");
        }
    }

知识点三 父类的无参构造函重要

子类实例化时 默认自动调用的 是父类的无参构造 所以如果父类无参构造被顶掉 会报错
 

    class Father
    {
        public Father()
        {

        }

        public Father(int i)
        {
            Console.WriteLine("Father构造");
        }
    }


    class Son:Father
    {
        #region 知识点四 通过base调用指定父类构造
        public Son(int i) : base(i)
        {
            Console.WriteLine("Son的一个参数的构造");
        }

        public Son(int i, string str):this(i)
        {
            Console.WriteLine("Son的两个参数的构造");
        }
        #endregion
    }




    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("继承中的构造函数");

            MainPlayer mp = new MainPlayer();

            Son s = new Son(1,"1412");
        }
    }

    总结

    继承中的构造函数
    特点：执行顺序 是先执行父类的构造函数 再执行子类的 从老祖宗开始 依次一代一代向下执行

    父类中的无参构造函数 很重要
    如果被顶掉 子类中就无法默认调用无参构造了
    解决方法：
    1.始终保持申明一个无参构造
    2.通过base关键字 调用指定父类的构造
    注意：区分this和base的区别