（.NET进阶十一）OOP继承/多态

最新推荐文章于 2021-10-24 17:16:12 发布

Tiger_shl

最新推荐文章于 2021-10-24 17:16:12 发布

阅读量357

点赞数 1

分类专栏：学习笔记

本文链接：https://blog.csdn.net/Tiger_shl/article/details/91475613

版权

学习笔记专栏收录该内容

16 篇文章 3 订阅

订阅专栏

一、面向对象核心原则概述

单一职责（SRP：Single reponsibility principle）
1. 针对类的设计而言，对象的单一职责
2. 不能设计万能类，要按照对象的基本要求，添加的属性、方法，都属于对象的本身
开-闭原则（OCP：Open Closed Principle）
1. 使用场景：随需求变化而修改
2. 开：通过增加类的方法解决需求问题而不是修改原有类，开的是增加
3. 闭：对以前他人设计的类或模块最好不要轻易修改，闭的是修改
4. 好处：让需求变化风险可控，让后期维护成本变小
里氏替换原则（LSP:Liskov Substitution Principle）
1. 适用场景：使用继承，并希望使用继承实现程序更多的“动态扩展”（多态）
2. 基本特点：子类可以在任何地方替换它的父类
3. 使用：一般是说父类作为方法参数，方法返回类型的时候，通常是传递一个子类对象，或者返回一个子类对象
接口隔离原则（ISP:Interface Segregation Principle）
1. 含义：接口最小原则
2. 特点：要求尽量使用职能单一的接口，而不使用职能复杂、全面的接口
3. 接口内容太多的后果：接口污染，使用和定义困难，维护成本高，重构系统时首先考虑接口细分
依赖倒置原则（DIP：Dependence Inversion Principle）
1. 不倒置的情况是什么：UI->BLL->DAL(强依赖）
2. 原则特点：要求调用者和被调用者都依赖“抽象”，两者没关联，互不影响
3. 好处：解耦
4. 实现途径：提前设计接口库，依赖接口编程，也就是调用接口，和实现接口，调用接口的不管实现，实现的不管调用，也可以通过抽象类完成
5. 具体做法：接口类库、实例方法和构造方法中使用接口作为参数
迪米特原则（LOD:Law of Demeter）
1. 面向对象三大特性：封装、继承、多态
2. 如何理解：尽量最大化的封装，该用private，internal就不用public
3. 好处：类暴露成员太多，会让调用者痛苦，并且程序的安全性降低；又叫最少知识原则，一个对象应当对其他对象有尽可能少的了解，不和陌生人说话
4. 具体做法
  1. 类的成员、类本身、尽量降低访问权限
  2. 类的内部成员尽量不要直接暴露，而是使用属性（只读等）
  3. 类的设计，尽量最小化
  4. 类之间的引用，尽量最少

二、继承的基本使用

继承的特点
1. 继承顺序的不可逆性：继承是从上往下一次继承，而不可逆序进行
2. 继承的延续性：在继承顺序中，下一级具备上一级的属性和特性
继承的必要性
1. 代码复用，避免重复
2. 一处更新，处处更新
继承的使用方法
1. 抽象公共部分，放在公用类中（父类）
2. 其他类（子类）只需要继承父类，即可拥有父类特征（属性和方法）
3. 根据子类的需求添加属于自己的特征和方法
4. 具体实现：通过冒号实现继承
父类和子类的概述
1. 子类继承父类，父类派生子类
2. 子类又叫派生类，父类叫基类或超类
3. 子类继承父类成员，又有自己独立的成员
4. 继承条件：继承需要符合的关系：is-a的关系

继承中的构造函数

使用this关键字访问父类成员

class Animal
{
    public Animal(){}
    public Animal(string name,string color,string kind)
    {
        this.Color = color;
        this.Name = name;
        this.Kind = kind;
    }

    public string Name{get;set;}
    public string Color{get;set;}
    public string Kind{get;set;}
    public string Favorite{get;set;}
}


class Cat:Animal
{
    //先初始化父类再初始化子类
    public Cat(string name,string color,string kind):base(name,color,kind)
    {
        this.Favorite= favorite;
    }
}

继承中的关键字：this，base，protected
隐式调用：子类的构造函数没有使用base只能调用父类哪个构造函数时，子类默认调用无参构造，此时父类需要提供无参构造
显示调用：如果父类没有无参构造，子类构造函数必须指明调用父类哪个构造函数

继承的总结
1. 传递性，A->B,B->C,C具有A的特性
2. 单根性，单一继承

三、抽象类和抽象方法

概念与使用要点

使用关键字abstract修饰的类，称为抽象类
抽象类只是用来列举一个类所具有的的行为，不能单独通过创建对象来使用，如Animal animal = new Animal();是错误的
抽象类可以有抽象方法，也可以没有任何抽象方法
抽象类不能是静态的（static）或是密封的（sealed）
在抽象类中使用abstract修饰的方法称为抽象方法
抽象方法必须在抽象类中定义，不能再普通类中使用
抽象方法只是一个方法的声明，不能有任何方法体
抽象方法仅仅表示一个应该具有的行为，具体实现由其子类实现
抽象方法在子类中被实现(重写)必须使用关键字override

子类必须重写父类的所有方法，除非子类本身也是抽象类

class Animal
{
    public string Name{get;set;}
    public string Color{get;set;}
    public string Kind{get;set;}
    public string Favorite{get;set;}


    public void Introduced()
    {
        string info = string.Format("我是{0}，穿{1}的衣服，喜欢吃{2}}"，Name，Color，Favorite);
        Console.WriteLine(info);
    }

    public abstract void Have();
    
}


class Cat:Animal
{
    public Cat(string name,string color,string kind,string favorite):base(name,color,kind)
    {
        this.favorite = favorite;
    }
    
    public void Dancing()
    {
        Console.WriteLine(".....");
    }

    //重写父类方法
    public override Have()
    {
        Console.WriteLine("重写的具体业务逻辑");
    }
}

abstract class OtherAnimal:Animal
{
    public OtherAnimal(string name,string color,string kind,string favorite):base(name,color,kind)
}

static void Main(string[] args)
{
    Cat objCat = new Cat("球球"，"黄色","小花猫","小鱼");
    Dog objDog = new Cat("棒棒"，"黑色","小黑狗","排骨");

    List<Animal> list = new List<Animal>();
    list.Add(objCat);
    list.Add(objDog);
    
    foreach(Animal item in list)
    {
        item.Have();
    }
}