C#面向对象基本概念总结

Posted 2021-02-04 fllowerqq

快过年了，发一篇自己的复习总结。以下内容均是个人理解，如文章有幸被浏览，如有错误的地方欢迎大家提出，相互学习相互进步！

面向对象三大基本特征：封装，继承，多态

一、类

（对象声明的三种方式：以普通基类身份声明的变量并用基类对象赋值，以普通基类身份声明的变量并用子类对象赋值，以子类身份声明的变量并用子类对象赋值，抽象类声明的变量必须由子类进行赋值（抽象类不能new））

1、类的分类：普通基类，抽象基类（abstract）：抽象类天生（public）是给人继承的，不能new（声明对象），纯抽象类（接口）

2、基本概念

• 类的统一成员分类：私有成员（仅在类的内部使用），共有成员（全宇宙可见），受保护成员（在类的内部和子类中使用）
• 子类继承基类：子类可以继承基类的共有成员和受保护成员，不能继承私有成员
• 子类访问基类成员时一般要使用base关键字
• 类成员的扫描顺序：以谁身份声明的变量就在谁身上开始扫描，先近后远
• 类的访问原则：类的外部只能访问类的共有成员，子类可访问基类的共有成员和受保护成员（继承）
• 构造函数：函数名和类名相同（函数没有返回类型，使用public修饰）

4、类的成员分类：

• 普通基类虚成员：类成员使用virtual 关键字修饰的为类的虚成员，可以被子类重写，被子类重新的条件条件是子类的同名方法必须由override关键字修饰（使用情景：以基类身份声明的变量，并以子类对象赋值，当调用方法时现在基类身上开始扫描，找到需要使用的方法并且方法是用virtual关键字修饰的虚成员，转而向子类进行扫描，如果在子类身上找到对应的方法，并且该方法用override关键字进行修饰，那么就调用子类方法，否则调用基类自己的方法）
• 抽象类成员：实例成员(在子类身上得到体现)，抽象成员：抽象类中的抽象成员没有具体的实现，也就是没有方法体，就是没有花括号。所以继承抽象基类的子类必须实现基类的抽象成员，才能使抽基类的抽象成员得到体现

5、抽象类特别注意事项：继承抽象类的子类必须实现抽象类的抽象成员，就是必须使用override（重写）关键子修饰基类同名抽象成员

6、对继承概念的认识：子类继承了基类，在程序入口调用方法时，子类的构造函数继承了基类的构造函数。以子类身份声明的变量并以子类对象赋值，当调用子类中成员时，按照类的访问规则，此时我们可以发现，基类通过子类继承的构造函数，获得了具体的成员

二、接口

interface声明接口，接口是纯抽象类，不能new。接口定义一些成员，不是用public关键字修饰，默认就是共有的////接口成员是纯虚成员

主程序中调用接口时注意：

• 以接口身份声明的变量必须以实现接口的类的对象进行赋值
• 以那个接口身份声明的变量只能点出这个接口定义的成员（当一个类型继承了多个接口时，使用这个类型调用接口时）
• 接口成员是方法的声明（王老师名言）

接口的实现：实现接口的类必须实现接口成员

接口的显示实现和隐式实现：当类实现单接口时一般使用隐式实现，实现多接口特别是多接口中定义了同名成员时要使用显示实现(加接口名前缀)

￡子类访问基类：在子类的内部可以访问基类共有成员和受保护成员，在子类的外部。子类对象只能访问基类的共有成员（类的外部只能访问类的共有成员）

三、继承

子类继承基类，基类的构造函数：声明子类对象时，子类的构造函数要先给基类构造函数传参，基类构造函数先于子类构造函数执行

四、函数的重载：一个类中，函数名相同签名不同的方法称为函数的重载，签名指：返回类型，参数类型，参数数量，参数的顺序

五、区别普通基类虚成员和抽象基类抽象成员

• 普通基类虚成员使用virtual关键字修饰，其子类可以不必重写（override）其虚成员
• 抽象基类抽象成员使用abstract关键字修饰，其抽象成员没有具体的实现必须由子类来实现（override）

六、抽象基类多态的理解：子类继承抽象基类使用基类作为一个大的主题，使用引擎类对基类的访问，实现对每个继承基类子类成员的调用（联想动物代码）

七、接口（纯抽象类）和抽象类的异同：

• 异：接口是纯抽象类，不能有任何实例成员，抽象类可以存在实例成员，并在子类中可以得到体现。接口使用关键字interface修饰，抽象类使用abstract修饰，接口的成员不使用任何的修饰字，抽象类抽象成员使用abstract进行修饰，子类继承抽象基类必须重写基类中的抽象成员（override）
• 同：接口的成员（方法），抽象类的抽象成员不能具体的实现，也就是没有方法体，也就是没有花括号，只需要声明

八、接口实现多态（多变性、灵活性）：语法级别优化代码

声明：以下代码中出现的中文全是本人自称为新时代“爱因斯坦”的东北老师的作品?

1、声明接口，实现接口的类

 1 namespace OODemo
 2 {
 3     //接口是纯抽像类，不能有任何实例成员，接口的成员是方法的声明
 4     public interface IWeapon
 5     {
 6         //接口成员天生就是public所以你不能加public关键字
 7         void Fire();
 8     }
 9     //实现接口的类必须实现接口成员
10     public class Gun : IWeapon
11     {
12         public void Fire()
13         {
14             Console.WriteLine("pa peng pa peng");
15         }
16     }
17 
18     public class Sword : IWeapon
19     {
20         public void Fire()
21         {
22             Console.WriteLine("七剑下天山");
23         }
24 
25     }
26 
27     public class Tank : IWeapon
28     {
29         public void Fire()
30         {
31             Console.WriteLine("压死你");
32         }
33     }
34 
35     public class Xiaomugun : IWeapon
36     {
37         public void Fire()
38         {
39             Console.WriteLine("扎死你");
40         }
41     }
42 }

2、使用一个“引擎类”：Engine作为中间层以接口类型的变量为参数

 1 namespace OODemo
 2 {
 3   
 4     class Engine
 5     {
 6         //耦合//解耦//分离关注点
 7         public static void Play(IWeapon w)
 8         {
 9             w.Fire();
10         }
11     }
12 }

 

3、使用实现了接口的类作为参数，调用各自实现接口成员的功能

 1 namespace OODemo
 2 {
 3     class Program
 4     {
 5         static void Main(string[] args)
 6         {
 7             Engine.Play(new Gun());
 8           
 9             Engine.Play(new Tank());
10             Engine.Play(new Sword());
11             Engine.Play(new Xiaomugun());
12         }
13 
14         public void Fire()
15         {
16             Console.WriteLine("七剑下天山");
17         }
18     }
19 }

九、抽象类实现多态：方式和接口实现多态的相似，一下直接书写举例代码（接口和抽象类实现多态的异同没弄明白）

问题：接口和抽象类都可以实现多态，只需要有一个就可以了，要么接口要么抽象类，为什么两个都存在？那么那个更好些？

1、声明三个基础类继承抽象类Animal
抽象类：
namespace OODemo
{
    abstract class  Animal
    {
        public abstract void Play();
    }
}

基础类：
namespace OODemo
{
    class Cat : Animal
    {
        public override void Play()
        {
            Console.WriteLine("喵喵喵，快给我条鱼");
        }
    }

 class Dog : Animal
    {
        public override void Play()
        {
            Console.WriteLine("汪汪汪，快给我根肉骨头");
        }

    }

 class Mouse : Animal
    {
        public override void Play()
        {
            Console.WriteLine("zhi zhi zhi");
        }
    }
}

使用引擎类

namespace OODemo
{
    class Engine
    {
        public void Play(Animal a)
        {
            a.Play();
        }
    }
}

调用

namespace OODemo
{
    class Program
    {
        static void Main(string[] args)
        {
            //有爽，啰嗦，玩就玩吗，你还playdog,playcat的
            Engine e = new Engine();
            //e.Play(new Animal());

            Dog dd = new Dog();
            e.Play(dd);
            ////dd.PlayD();

            Cat cc = new Cat();
            e.Play(cc);
            ////cc.PlayC();

            Snake sn = new Snake();
            e.Play(sn);

            Mouse m = new Mouse();
            e.Play(m);
        }
    }
}

静态类，静态方法