C#学习相关系列之数据类型类的三大特性（二）

一、封装

????????封装：将类的某些信息隐藏在类的内部（用private修饰），不允许外部程序直接访问，需要访问也是访问该类为其提供的公共属性。

装属性的作用：防止类中的数据被恶意修改。

封装属性的好处：1.可以隐藏类的实现细节

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?2.外部只能通过访问规定的属性来访问数据，保护数据

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?3.方便加入控制语句，即对数据做约束
?

?

代码例子：

public class Person  
{  
    // 私有字段  
    private string name;  
    private int age;  
  
    // 公共构造函数  
    public Person(string name, int age)  
    {  
        this.name = name;  
        this.age = age;  
    }  
    // 特性可以保护数据安全
    public int Age
    {
        get { return age; }
        set { age =value; }
    }  
    // 公共方法，用于获取姓名  
    public string GetName()  
    {  
        return name;  
    }  
  
    // 公共方法，用于设置姓名  
    public void SetName(string newName)  
    {  
        name = newName;  
    }  
  
    // 公共方法，用于获取年龄  
    public int GetAge()  
    {  
        return age;  
    }  
  
    // 公共方法，用于设置年龄  
    public void SetAge(int newAge)  
    {  
        if (newAge > 0 && newAge < 150) // 简单的年龄验证逻辑  
        {  
            age = newAge;  
        }  
        else  
        {  
            throw new ArgumentOutOfRangeException("Invalid age.");  
        }  
    }  
}

????????在上面的例子中，Person类封装了两个私有字段name和age。通过公共的构造函数和设置器方法（如SetName和SetAge），我们可以控制对内部状态的访问和修改。这样，外部代码只能通过这些公共方法来访问和修改Person对象的内部状态，而不能直接访问或修改私有字段。这提高了代码的可维护性和健壮性，因为我们可以控制对内部状态的访问和修改，并在必要时添加额外的验证逻辑。?

?二、继承

1. 代码重用：继承允许我们定义一个类，然后创建其他类从已有的类中派生出来。这样，我们可以重用基类中的方法和属性，减少代码的重复编写。
2. 扩展性：继承使得我们能够定义一个基类，然后根据需要创建派生类来扩展或修改基类的功能。这使得代码更加灵活，可以根据需求进行扩展和定制。
3. 层次结构：通过继承，我们可以建立类之间的层次结构，使得代码更加有组织性和层次性。这有助于理解代码的结构和功能，以及更好地进行代码维护和调试。
4. 多态性：继承是实现多态性的基础。通过继承，我们可以创建具有相同接口但具有不同实现的方法和属性，从而实现多态性。这使得代码更加灵活，可以根据实际需求选择不同的实现方式。

// 基类  
public class Animal  
{  
    public string Name { get; set; }  
  
    public void Eat()  
    {  
        Console.WriteLine($"{Name} is eating.");  
    }  
}  
  
// 派生类  
public class Dog : Animal  
{  
    public void Bark()  
    {  
        Console.WriteLine($"{Name} is barking.");  
    }  
}  
  
// 使用继承  
public class Program  
{  
    public static void Main(string[] args)  
    {  
        Dog dog = new Dog();  
        dog.Name = "Tommy";  
        dog.Eat(); // 继承了Animal类的Eat方法  
        dog.Bark(); // Dog类自己的Bark方法  
    }  
}

继承的特征：

1.子类继承了父类的非私有的属性与方法，构造方法除外

2.子类在创建构造方法时需要调用父类构造方法；

????????????????格式：派生类名（总参数列表（父子类的参数））：base（父类参数）{}

3. 在创建子类对象时，系统会默认的先调用父类的构造方法，在调用子类的构造方法

4. 子类想使用父类的属性和方法时，需要用到base关键字（base.） ??

重写与重载的区别：

1.作用范围不同，重写发生在具有父子关系的两个类中的同名方法，而重载是在同一个类中同名方法。

2.不同点不同，重写的两个方法的返回值与参数相同，方法的声明不同（也就是{ }中的内容不同），重载的方法只要参数列表不同

?三、多态

多态：是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

代码例子：

using System;  
  
// 基类  
class Animal  
{  
    public void Speak()  
    {  
        Console.WriteLine("Animal speaks.");  
    }  
}  
  
// 派生类1  
class Dog : Animal  
{  
    public override void Speak()  
    {  
        Console.WriteLine("Dog barks.");  
    }  
}  
  
// 派生类2  
class Cat : Animal  
{  
    public override void Speak()  
    {  
        Console.WriteLine("Cat meows.");  
    }  
}  
  
class Program  
{  
    static void Main()  
    {  
        // 创建一个Animal引用指向Dog对象  
        Animal myDog = new Dog();  
        // 调用基类Animal的Speak方法，实际上调用的是Dog的Speak方法，因为myDog是Animal类型，但实际上指向的是Dog对象。这就是多态性。  
        myDog.Speak(); // 输出 "Dog barks."  
  
        // 创建一个Animal引用指向Cat对象  
        Animal myCat = new Cat();  
        // 同样，调用基类Animal的Speak方法，实际上调用的是Cat的Speak方法。  
        myCat.Speak(); // 输出 "Cat meows."  
    }  
}

?????????在这个例子中，我们有一个基类Animal和两个派生类Dog和Cat。每个派生类都重写了基类的Speak方法。在主程序中，我们创建了一个Animal类型的引用，但实际上它指向了一个Dog对象或一个Cat对象。当我们调用这个引用的Speak方法时，会调用实际对象的Speak方法，这就是多态性的体现。

其实多态的作用就是把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。
以上程序也体现了开放封闭原则，如果以后有人需要扩展这个程序，还想再添加一个牛（cow），很容易，只需要添加一个cow类，继承Animal，重写speak()方法，添加给父类对象就可以了。至此，该程序的扩展性得到了提升，而又不需要查看源代码是如何实现的就可以扩展新功能。这就是多态带来的好处。