C#核心知识回顾——3.继承构造、拆装箱、多态

news2024/11/24 2:51:36

1.继承中的构造函数：

特点：
当申明一个子类对象时
先执行父类的构造函数，再执行子类的构造函数
注意！！：
1.父类的无参构造很重要
2.子类可以通过base关键字代表父类调用父类构造

public class Mother 
{
    //父类的无参构造很重要
    //子类实例化默认调用父类无参构造，如果父类无参构造被顶掉，会报错
    public Mother() { }

    public Mother(int i) { }
}
public class son: Mother
{
    
}

使用base关键字：

public class Mother 
{
    public Mother(int i) { }
}
public class son: Mother
{
    //通过bade指定父类构造
    public son(int i):base(i) { }
}

使用this关键字：

public class Mother 
{
    public Mother(int i) { }
}
public class son: Mother
{
    //通过bade指定父类构造
    public son(int i):base(i) { }

    /// <summary>
    /// 用 this 相当于调用son(int i)这个函数。
    /// 运行流程就是：父类构造--son（int i）--son(int i,int j)
    /// </summary>
    public son(int i,int j):this(i) { }
}

2.object和拆装箱：

public class Mother {}
public class son: Mother{
    public void send()
    {
        Debug.Log("son");
    }
}
public class GetInfo : MonoBehaviour
{
    private void Start()
    {
        Mother mother = new son();
        //万物之父object
        object obj = mother;        

        //引用类型：
        //1.普通
        object objson = new son();
        //转换使用
        if(obj is son)
        {
            (obj as son).send();
        }
        //2.特殊引用类型（string、数组）
        object str = "123";
        //两种方式
        string str2 = str as string;
        string str3 = str.ToString();

        object arr = new int[10];
        //两种方式
        int[] ar = arr as int[];
        int[] ar2 = (int[])arr;

        //值类型：
        object o = 1f;
        //转换使用,强转
        float f = (float)o;
    }   
}

值类型存入object：装箱。 object转换为值类型：拆箱。

装箱
把值类型用引用类型存储
栈内存会迁移到堆内存中

拆箱
把引用类型存储的值类型取出来
堆内存会迁移到栈内存中

好处：不确定类型时可以方便参数的存储和传递
坏处：存在内存迁移，增加性能消耗

3.多态：

静态多态:
编译时多态一函数重载，开始就写好的

运行时多态（vo b、抽象函数、接口）：
1.vob
v：virtual(虚函数）
o：override(重写）
b：base(父类）

2.抽象类、抽象方法

3.接口

1.vob重写虚方法：

public class Mother {
    public void Set()
    {
        Debug.Log("mother");
    }
    /// <summary>
    /// 虚函数定义
    /// </summary>
    public virtual void Get() {
        Debug.Log("mm");
    }
}
public class son: Mother{
    public new void Set()
    {
        Debug.Log("son");
    }
    /// <summary>
    /// 重写虚函数
    /// </summary>
    public override void Get()
    {
        //base.Get();
        Debug.Log("sss");
    }
}
public class GetInfo : MonoBehaviour
{
    private void Start()
    {
        ///未使用多态，此时输出的还是父类方法的函数
        Mother mom = new son();
        mom.Set();

        ///使用多态输出的是子类的
        mom.Get();
    }   
}

2.抽象类、抽象方法

抽象类：被抽象关键字abstract修饰的类

特点：
1.不能被实例化的类
2.可以包含抽象方法
3.继承抽象类必须重写其抽象方法

抽象方法：

又叫纯虚方法
用abstract关键字修饰的方法

特点
1.只能在抽象类中申明
2.没有方法体
3.不能是私有的
4.继承后必须实现用override重写

 abstract class Mother {
    public string name;
    
    //抽象方法必须是public，且没有方法体
    public abstract void BodyDof();
}
class Son : Mother
{
    public override void BodyDof(){}
}

总结：
抽象类被abstract修饰的类不能被实例化可以包含抽象方法
抽象方法没有方法体的纯虚方法继承后必须去实现的方法

注意：
如何选择普通类还是抽象类
1.不希望被实例化的对象，相对比较抽象的类可以使用抽象类
2.父类中的行为不太需要被实现的，只希望子类去定义具体的规则的可以选择抽象类然后使用其中的抽象方法来定义规则

作用：
整体框架设计时会使用

 abstract class Piture {  
    public abstract void MianJi();
    public abstract void ZhouChang();
}
class Yuan : Piture
{
    public override void MianJi()
    {
        Debug.Log("圆面积π*r*r");
    }

    public override void ZhouChang()
    {
        Debug.Log("圆周长2*π*r");
    }
}
class JuXing : Piture
{
    public override void MianJi()
    {
        Debug.Log("矩形面积a*b");
    }

    public override void ZhouChang()
    {
        Debug.Log("矩形周长2*(a+b)");
    }
}

3.接口：

接口是行为的抽象规范
它也是一种自定义类型
关键字：interface

接口申明规范
1.不包含成员变量
2.只包含方法、属性、索引器、事件
3.成员不能被实现
4.成员可以不用写访问修饰符，不能是私有的
5.接口不能继承类，但是可以继承另一个接口

接口的使用规范
1.类可以继承多个接口
2.类继承接口后，必须实现接口中所有成员

特点：
1.它和类的申明类似
2.接口是用来继承的
3.接口不能被实例化，但是可以作为容器存储对象

 interface Piture {
    //方法
    void Name();
    //属性
    string Info
    {
        get; 
        set;
    }
    //索引器
    int this[int index]
    {
        get;
        set;
    }
    //事件
    event Action eventthing; 
}
class Yuan : Piture
{
    //1.类可以继承1个类，n个接口
    //2.继承接口，必须实现全部内容，并且都是public
    public int this[int index] {
        get { return 0; }
        set { } }
    public string Info { 
        get { return ""; }
        set { } }
    public event Action eventthing;
    /// <summary>
    /// 3.实现的接口函数，可以继续加virtual在子类重写
    /// </summary>
    public virtual void Name(){}
}

接口的使用场景：