C#高级进阶教程_00_设计模式_面向对象的第四大特性——抽象_虚方法&抽象方法、抽象类&接口

2021-10-19

字数统计: 2.9k字 | 阅读时长≈ 11分

** 4-5个月的课程（录制于2019年4月15日——2019年8月15日）**

程序设计，第一堂课：首先搞懂面向对象的思想。（POP-OOP-AOP-DDD）

POP思想：

POP:面向过程编码，一路执行下去，不好扩展。

OOP思想：

面向对象思想。

一个对象类定义了具有相似性质的一组对象。

OOP(Object Oriented Programming,面向对象程序设计)

网站、AO、ERP等。

具体体现案例：把大象装进冰箱。

编码前，把需求以对象维度去拆分。
功能怎么产生的？对象与对象之间的交互，就是类与类之间的依赖。
只要交互的借口不变，这样对象内部的变化不影响其他对象。
把一个整体功能拆分成对象，来进行细化，对象直接可以重用。
基于类来做，但是也局限于类。

OOP、OO(Object Oriented)

01、三大特性：封装、继承、多态。

02、重写（overwrite）、覆写（override）、重载（overload）

** 03、抽象类接口**

**
**

面向对象，将程序中发生的事转成一个个的对象。对象有对应的功能！

将面向过程的思想转到面向对象的思想。（不要考虑具体逻辑，分步骤完成是面向过程的思想）需要的是将对象拆解出来。

每个对象完成自己的核心动作。对象与对象相互调用联系。（OO）

AOP思想：

AOP:Aspect-Oriented Programming 面向切面的编程。

不破坏对象封装的前提下，为对象提供额外的功能！

补充了OOP的局限性。

DDD思想：

** **领域驱动设计。应对更复杂的业务逻辑情况。

框架思维：

可编辑、可扩展、可维护。

面向对象，容易很多依赖。面向接口编程相对较好一些。术业有专攻！

1 2	Player player=new Player(); player.PlayIphone(new Iphone()); //里面具体发生了什么并不知道，只知道结果

面向对象第一个思想：封装！与面向过程最大的改变。

01、将相关性一致的放在一起。封装成一个类型。类实例化出来就是一个对象。

02、封装是隐藏具体的实现细节，对外只提供接口。

03、封装可以实现数据安全。（public、private、internal、protected进一步认识）

04、内部修改保持稳定。

05、提高重用性。

06、分工合作职责分明。

07、方便构建，大型复杂系统。

面向对象第二个思想：继承！

** 01、将类相同的东西，完全一样的拿出来放在父类中。即为父类（基类）这样就出现了子类（派生类)，出现了继承。子类只需要写特有的东西。**

** **02、继承可以去除重复代码。（默认子类只能继承公开的）

03、可以实现多态。

04、逆变/协变。

05、侵入性很强的类关系。父类尽量写的比较精准，父类所有的属性方法都被继承了

06、this、base 关键字的使用

1 2	BasePhone phone01=new iPhone(); //协变 phone01.Call();

1 2	BasePhone phone02=new Lumia(); phone01.Call();

07、抽象/接口等

面向对象第三个思想：多态！

** 通过继承实现的不同对象，调用相同方法，表现出不同的行为，称之为多态。**

** 一方面子类都得有，另一方面又子类各不相同。**

**
**

** ** 01、方法的重载。
02、接口+实现。
03、抽象类+实现。
04、继承+重写。
05、虚方法+重写。

面向对象第四个思想：抽象！

** 一方面子类都得有，另一方面又子类各不相同。做成抽象。****
**

** 抽象类是一个父类！（父类+约束的没有实现的方法（只有方法名，没有方法体）**** **

** 抽象方法，只有方法名，没有方法体。约束了所有的子类都有这个方法。子类必须重写（override）****
**

抽象方法必须出现在抽象类里面！**
**

** **** 抽象类不能被实例化**。但是可以子类实现重新方法后，用子类实例化。抽象类是用来继承的。

**
**

1
2
3

Base phone01=new iPhone();//不能 new Base();
phone01.Call();
phone01.System();

1
2
3

Base phone02=new Lumia();//不能 new Base();
phone02.Call();
phone02.System();

最终调用Call()与System(),显示出不同的结果。这种表现形式称之为多态。也叫运行时多态。

关键点一：虚方法与抽象方法的选择

** 虚方法：父类virtual，带有默认实现的。子类override。虚方法可以不用重写实现。（可以有选择的重写）（连续继承）虚方法可以实现多重重写。（以最终的重写为准）密封sealed之后，就不能被重写了，不能被继承了！ Base指定调用直接父类的方法。**

** 抽象方法：父类abstract，不带默认实现的。子类不用重写。抽象方法必须重写实现。**

** **base/this的使用：this不能在静态方法中使用，只能在实例方法中使用，表示当前实例的对象。this一般可以省略。表示调用的实例。

base在构造函数中的使用。

public abstract class ParentClass                           //抽象类
{
   /// <summary>
   /// CommonMethod
   /// </summary>
   public void CommonMethod()                               //普通方法
   {
       Console.WriteLine("ParentClass CommonMethod");
   }

   /// <summary>
   /// virtual  虚方法  必须包含实现 但是可以被重载
   /// </summary>
   public virtual void VirtualMethod()                     //虚方法的重载01
   {
       Console.WriteLine("ParentClass VirtualMethod");
   }

   public virtual void VirtualMethod(string name)          //虚方法的重载02
   {
       Console.WriteLine("ParentClass VirtualMethod");
   }

   public abstract void AbstractMethod();                  //抽象方法
}

public class ChildClass : ParentClass
{
  /// <summary>
  /// new 隐藏
  /// 非常不推荐在子类隐藏父类的方法
  /// goto
  /// </summary>
  public new void CommonMethod()                         //子类隐藏了父类方法的应用！子类篡改了普通方法。
  {
      Console.WriteLine("ChildClass CommonMethod");
      // base this
  }


  public void CommonMethod(string name)
  {
      Console.WriteLine("ChildClass CommonMethod");
  }

  public void CommonMethod(int id, string name = "", string des = "", int size = 0)
  {
      Console.WriteLine("ChildClass CommonMethod");
  }
  public void CommonMethod(string name, int id)
  {
      Console.WriteLine("ChildClass CommonMethod");
  }
  /// <summary>
   /// 抽象方法必须覆写
   /// </summary>
   public sealed override void AbstractMethod()
   {
       //this.CommonMethod();//this是当前这个类型的实例的方法
       Console.WriteLine("ChildClass AbstractMethod");
   }
}

public static void Test()
{
   ParentClass instance = new ChildClass();
   instance.VirtualMethod("");  //调用父类的，因为子类没有重写
   instance.VirtualMethod();    //调用子类的，因为子类已经重写
   
   Console.WriteLine("——————下面是instance.CommonMethod()——————");
   instance.CommonMethod();  //普通方法的调用，调用的父类的(虽然子类中隐藏了父类的此方法)。        编译时确定                   左边为准；编译时确定；  为了效率
   
   Console.WriteLine("——————下面是instance.VirtualMethod()——————");
   instance.VirtualMethod(); //虚方法的调用，  看有没有重写，来确定调用哪里的（ override为了灵活） 运行时确定                   右边为准(没有override 还是左边)；运行时确定；  为了灵活
   
   Console.WriteLine("——————下面是instance.AbstractMethod()——————");
   instance.AbstractMethod();//抽象方法的调用，抽象方法必须实现，调用的是子类的实现过的方法        运行时确定                   右边为准；运行时确定；  为了灵活
}

Base调用父类无参的构造函数。

public class GrandClass : ChildClass
{
  public GrandClass(int id) : base()              //继承父类的无参数的构造函数，此时的base（）可以省略。
  { }
}

public class GrandChildClass : GrandClass
{
   public GrandChildClass(int id) : base(id)     //继承父类的有参数的构造函数，此时必须这样写，因为父类的构造函数是有参数的！
   { }
}

也可以写成：(但不太推荐)

public class GrandChildClass : GrandClass
{
  public GrandClass() : this(13)
  { }   
}

关键点二：接口与抽象类的选择****

接口语法：

不能使用写访问修饰符（ 全部默认为Public****）

不能包含字段。**
**

不能使用类，委托…

不能包含方法的实现。

可以使用属性。

可以声明事件。接口为什么可以声明事件而不能声明委托呢？

可以使用索引器。

接口的继承称之为实现。

** 而抽象类的继承要重写。**

1 2	IExtend extend01=new iPhone();//不能 new extend(); extend01.Video(); //调用接口中的方法的实现

1 2	IExtend extend02=new Lumia(); extend02.Viedo();

最终调用Video()显示出不同的结果。这种表现形式称之为多态。也叫运行时多态。

Base phone01=new iPhone();//不能 new Base();
phone01.Video();          //无法调用到

IExtend extend01=new iPhone();//不能 new extend();
extend01.Call();              //无法调用到

以上无法调用是编译器的限制。编译时没有，运行时有。可以考虑到Dynamic。

如果突破使用Dynamic关键字，动态。让c#具有了弱语言类型的特性。编译器在编译的时候不再对类型进行检查。

编译时/运行时？

面向抽象的编程思想再次深思！

public class Player
{
  public int Id { get; set; }
  public string Name { get; set; }
  private int Salary { get; set; }

  public void UserIphone(iPhone phone)
  {
     Console.WriteLine("******************");
     phone.Call();
     phone.Text();
  }
  public void UserMi(Mi phone)
  {
     Console.WriteLine("******************");
     phone.Call();
     phone.Text();
  }
  public void UserLumia(Lumia phone)
  {
    Console.WriteLine("******************");
    phone.Call();
    phone.Text();
  }
}

public void User(BasePhone phone)                  //  设计模式的六大原则，依赖倒置原则！  面向抽象而不是面向细节！不依赖底层的实现，依赖底层的抽象！（IOC应用的实践）  DIP？
                                                   //  面向抽象的缺点：只能使用“抽象通用的东西”。“个性化的东西”不可以用。
 {
  Console.WriteLine("******************");
  phone.Call();
  phone.Text();
 }

进一步引申, 常用的方式：

public void Use<T>(T phone) where T : BasePhone, IExtend      // 约束 & 继承 & 抽象类 & 接口 & 泛型    // 使用泛型更加灵活，但是使用泛型的时候要指定成具体的类别。
{   
  Console.WriteLine("******************");
  phone.Call();
  phone.Text();
  phone.Video();
}

怎么选择接口还是抽象类？

**
**

** 抽象类：父类+约束（既可以包含未实现的也可以包含实现的方法）**

** 接口：纯碎的约束（只有未实现的方法）**

**
**

** 单继承多实现：**抽象类只能单继承。接口可以实现多个接口，接口更灵活。

抽象类：另外赋予了语义。（是一个什么东西） is a… … 抽象类完成通用实现。（通用，一类东西）

** 接口：接口描述的是功能性的。 **Can do！接口可以横跨任何产品。（U盘，功能性）

** 使用原则：**

01、子类都一样的放在父类；
** 02、子类都有但不同的，使用抽象类；**
** 03、该特点有的有，有的没有，使用接口。**
工作中的使用经验：*
共有的使用抽象类，个性独有的使用接口。*
*接口是对功能（动作）的抽象，抽象类是对根源的抽象。接口是动作的集合，抽象类更像一个类的模板（属性/状态的集合）。
*

** 工作中接口用的更多！接口更简单灵活！除非共有的东西需要继承使用抽象类！**

IBaseService —— BaseService ——UserSerrvice

** 使用抽象类的情况下，一般都可以使用接口来代替。**

**
**

迭代器的使用！IEnumerable

** 什么时候用静态方法？什么时候用普通方法？ **

能普通就普通，这个方法没有什么扩展了，只是工具方法，可以静态。静态调用方便一些。静态不会被GC回收。

** 静态函数中，只能访问静态成员，不允许访问实例成员。（成员指的是字段与属性）**

实例函数中，既可以使用静态成员，也可以使用实例成员。
静态类中只允许有静态成员，不允许出现实例成员。

** out与ref的使用？**

**
**

** this关键字的使用？**

**
**

** break/cont**

知识点理解之后的应用！理解程序设计！

类和结构的基础知识。

将blog文件重新整理回来！

重新了解数据结构！（冒泡排序等！！）

本文作者： 梁俊可
本文链接： http://ljk3d.com/2021/10/19/cSharpNote/CSharp高级进阶教程_00_设计模式_面向对象的第四大特性——抽象_虚方法&抽象方法、抽象类&接口/
版权声明： 梁俊可工作室