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

2023-12-15 23:29:47

一、封装

????????封装:将类的某些信息隐藏在类的内部(用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类封装了两个私有字段nameage。通过公共的构造函数和设置器方法(如SetNameSetAge),我们可以控制对内部状态的访问和修改。这样,外部代码只能通过这些公共方法来访问和修改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和两个派生类DogCat。每个派生类都重写了基类的Speak方法。在主程序中,我们创建了一个Animal类型的引用,但实际上它指向了一个Dog对象或一个Cat对象。当我们调用这个引用的Speak方法时,会调用实际对象的Speak方法,这就是多态性的体现。

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

文章来源:https://blog.csdn.net/qiaodahua/article/details/135025829
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。