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)

    {

        // 继承了接口函数

    }

}

巴特西