一、封装
封装：将类的某些信息隐藏在类的内部（用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对象的内部状态，而不能直接访问或修改私有字段。这提高了代码的可维护性和健壮性，因为我们可以控制对内部状态的访问和修改，并在必要时添加额外的验证逻辑。
二、继承
- 代码重用：继承允许我们定义一个类，然后创建其他类从已有的类中派生出来。这样，我们可以重用基类中的方法和属性，减少代码的重复编写。
- 扩展性：继承使得我们能够定义一个基类，然后根据需要创建派生类来扩展或修改基类的功能。这使得代码更加灵活，可以根据需求进行扩展和定制。
- 层次结构：通过继承，我们可以建立类之间的层次结构，使得代码更加有组织性和层次性。这有助于理解代码的结构和功能，以及更好地进行代码维护和调试。
- 多态性：继承是实现多态性的基础。通过继承，我们可以创建具有相同接口但具有不同实现的方法和属性，从而实现多态性。这使得代码更加灵活，可以根据实际需求选择不同的实现方式。
// 基类
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()方法，添加给父类对象就可以了。至此，该程序的扩展性得到了提升，而又不需要查看源代码是如何实现的就可以扩展新功能。这就是多态带来的好处。