C#基础-面向对象-多态

多态，不同对象对同一方法的不同实现

使用abstract关键字表示抽象类

 // 表示是一个抽象类
public abstract class Animal
{
    private string name;
    private double weight;
}

抽象类

// 表示是一个抽象类
public abstract class Animal
{
    private string name;
    private double weight;

    public string Name { get => name; set => name = value; }
    public double Weight { get => weight; set => weight = value; }

    public Animal() { }
    public Animal(string _name,double _weight)
    {
        this.Name = _name;
        this.Weight = _weight;
    }
}

抽象类不能被实例化

public class Dog:Animal
    {
    }

Dog类继承抽象类Animal后可以实例化

static void Main(string[] args)
{

    Dog d = new Dog();
    d.Name = "Dog";
    d.Weight = 10;
}

抽象类中的抽象方法

1.方法就没有主体，只有定义
2.子类在继承抽象类时，必须实现抽象类中的抽象方法
3.使用override进行重写

Animal中ShowInfo是抽象方法

// 表示是一个抽象类
public abstract class Animal
{
    // 省略··· 

    public void Show()
    {
        Console.WriteLine("名字：{0}，体重：{1}",this.Name,this.Weight);
    }
    // 如果一个方法声明为abstract抽象方法，方法就没有主体，只有定义
    // 继承这个抽象类的所有子类都要实现这个方法
    public abstract void ShowInfo();
}

Dog中使用override重写

public class Dog:Animal
{
    // 子类在继承抽象类时，必须实现抽象类中的抽象方法
    // 使用override进行重写
    public override void ShowInfo()
    {
        Console.WriteLine("这是子类重写父类的抽象方法");
    }
}

实现效果如下：

static void Main(string[] args)
{
    Dog d = new Dog();
    d.Name = "Dog";
    d.Weight = 10;
    d.Show();
    d.ShowInfo();
}

多态定义：不同对象对同一方法做出不同的实现

Animal是一个抽象类

// 表示是一个抽象类
public abstract class Animal
{
    // 省略··· 
    // 抽象类的抽象方法ShowInfo()
    public abstract void ShowInfo();
}

Dog中使用override重写继承Animal

public class Dog:Animal
{
public override void ShowInfo()
    {
        Console.WriteLine("这是Dog重写Animal的抽象方法");
    }
}

新建Pig类继承Animal

public class Pig:Animal
{
    public override void ShowInfo()
    {
        Console.WriteLine("Pig对Animal的抽象方法实现");
    }
}

抽象类中父类可以通过子类实现

实现效果如下：

static void Main(string[] args)
{
    // 多态定义：不同对象对同一方法做出不同的实现
    // 抽象类不能直接被实例化
    // 抽象类的父类指向子类，具体实现可以由子类实现
    Animal d = new Dog();   // 父类指向Dog类
    d.ShowInfo();
    d = new Pig();          // 父类指向Pig类
    d.ShowInfo();
}

效果如下：

接口

应用：为了实现跨行转账业务，定义了一个接口，该接口包含了一个用于存取款的方法和一个返回余额的属性

接口只能对方法定义

抽象类和接口的区别：抽象类有字段和属性，接口没有
抽象类只能单一继承，接口可以多个继承

IBank接口

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApp6
{
    // 接口只是对于方法定义
    // 抽象类和接口的区别：抽象类有字段和属性，接口没有
    // 抽象类只能单一继承，接口可以多个继承
    interface IBank
    {
        
        // 定义了一个接口，只有接口定义，没有方法实现
        // 它是特殊的抽象方法，没有abstract关键字
        // 子接口实现也不需要像抽象方法一样用override
        void Zhuan(double dzhuan);
    }
}

IUser接口

namespace ConsoleApp6
{
    interface IUser
    {
    }
}

对接口的继承使用

// 银行卡
// 可以继承多个接口
class UserCard:IBank,IUser
{
    public void Zhuan(double dZhuan)
    {
        // 继承了接口函数
    }
}