C#中的类

类

就是一个定义了数据类型的蓝图"模版"

例如：人类，动物类，等……一个类的创建实际上并没有任何的数据，它仅仅定义了一个类是什么。

对象：对象就是类的实例，由某一个类创建后(new)出来的实打实的对象。

类成员：一个类中包含多个信息(属性)和行为(方法)，这些信息统称为类成员。

类和对象是面向对象的编程语言的一大核心。

类：就是用拥有相同的信息和行为的抽象的一个概念，某一类事务。

对象：是实在的一个个体，由类进行创建的，是类的实例。

类的创建

类一般在namespace代码块中创建，class关键子开头，类的主体是一个{}

格式:

访问修饰符 class 类名{

类成员，分为三大类：字段，属性，方法

成员变量：就叫做字段

“访问修饰符 成员的类型 成员的名称1 ”

“访问修饰符 成员的类型 成员的名称2 ”

成员方法：

访问修饰符 方法返回值类型 方法名称1(参数){方法体}

访问修饰符 方法返回值类型 方法名称2(参数){方法体}

}

class People
{
    //添加成员变量, 字段
    //字段一般是私有的
    //不用private修饰，默认也是私有的
    private string name;
    int age;
    char sex;
    
    //添加成员变量, 属性
    //属性一般是公开的
    //用public修饰
    public string Name；

    //添加成员方法，函数
    //方法可以是私有的也可以是公开的
    //方法如果是类内部自己使用，就可以定义成私有的
    public void eat()
    {
        Console.WriteLine("吃饭");
    }
    private void slepp()
    {
        Console.WriteLine("睡觉");
    }

}

访问修饰符

访问修饰符：指定一个类以及这个类的成员的可访问性，通过这个标识控制这个类及整个类的某一个成员的可访问性。

public :公共的，所有地方都可以访问(重要)。

private :私有的，类内部可以访问的(重要)。

internal :只能再当前的项目中访问(重要)。

protected :只能再当前类和其子类可以访问(后续讲解)。

protected internal :允许在同一个程序集中的任何位置以及包含类派生的类型内部访问内部成员。

类和类成员都有默认的修饰符

类的默认修饰符是internal，只能在当前项目中访问。

类成员默认的修饰符：private，私有的，类的内部可以访问。

对象

对象是类的实现，使用new关键字根据一个类创建该类的实例化对象

当我们创建一个类的同时，将拥有一个数据类型，所以这个类的实例化出来的都属于这个类型。

internal class Program
{
    static void Main(string[] args)
    {
        //使用new关键字，将类实例化成一个对象
        People people = new People();
        Console.WriteLine(people); //_05_对象.People

        //通过“对象.成员名称”的方式来操作对象成员。
        Console.WriteLine(people.name);
        people.name = "张杰";
        people.age = 40;
        people.sex = '男';

        //通过“对象.方法(参数)”来调用类中的方法
        people.eat("大米饭");
        Console.WriteLine(people.a); 
        Console.WriteLine(people.str);



        People people1 = new People();
        people1.name = "谢娜";
        people1.age = 40;
        people1.sex = '女';

        people1.eat("菠萝蜜");
    }
}


class People
{
    //默认类成员的访问修饰符是 private 私有的，类的内部访问。
    public string name;
    public int age;
    public char sex;

    //默认私有的，在方法外部访问不到
    double money = 10000000;

    //添加一个可访问的方法“代参的”
    public void eat(string f)
    {
        Console.WriteLine($"{this.name}喜欢{f}");
        Console.WriteLine(money);
    }

    //访问范围：在当前的项目内
    internal int a = 10;
    internal string str = "hello";
}

类的继承

C#是面向对象的编程语言，面向对象编程的四项基本原则：

抽象：将实体相关特性和交互建模为类，以定义系统的抽象表示。

封装：隐藏对象的内部状态和功能，并仅允许通过一组公共函数进行访问。

继承：根据现有的抽象(类)创建新抽象(类)的能力。

多态(多形态)：跨多个抽象(类)以不同方式实现继承属性或方法的能力。

继承

根据现有的类，生成一个新的类。

当创建一个类的时候，可以不需要重新编写新的成员和方法，而是继承于现有的类。

这个被继承类我们称之为“父类”(基类)，这个新的类我们称之为“子类”(派生类)。

如果一个类没有继承任何的类，那么它就默认继承object“c#中所有的类，都直接或者间接继承于object， object是所有类的“终极基类”封顶了。”

//基本类
class People
{
    public string Name {  get; set; }
    public int Age { get; set; }
    public char Sex {  get; set; }

    public void Eat()
    {
        Console.WriteLine($"{Name},吃饭");
    }
}

static void Main(string[] args)
{
    People people = new People()
    {
        Name = "张三",
        Age = 30,
        Sex = '男'
    };
    people.Eat();//张三，吃饭
}

派生类
在定义一个类的时候，使用“ : 基类 ”实现继承。
当一个类继承另一个类，子类将自动拥有父类的成员(成员变量，成员方法)
class Student : People
{
    public string StndentId {  get; set; }   
    public string Schoole {  get; set; }
    public void Study()
    {
        Console.WriteLine($"我是{Name}，在{Schoole}学校上学");
    }
}
//子类在继承父类的同时会继承父类的字段、属性和方法，也能进行赋值、调用等操作
//同时子类也拥有自己的字段、属性和方法
static void Main(string[] args)
{
    Student student = new Student()
    {
        Name = "Tom",
        Age = 10,
        Sex = '男',
        Schoole = "智游",
        StndentId = "2024001"
        
    };
    student.Eat();//Tom，吃饭
    student.Study();//我是Tom，在智游学校上学
}
基类和派生类并不是绝对的一个概念，是相对的，一个类可以同时是基类或派生类。
class SmallStudent : Student
{
    public void Cry()
    {
        Console.WriteLine("hello!");
    }
}
//同理，子类的子类也能继承父类的字段、属性和方法
//也拥有自己的字段、属性和方法
SmallStudent sd = new SmallStudent()
{
    Name = "MinTom",
    Age = 1,
    Sex = '男',
    Schoole = "家里蹲",
    StndentId = "001"
};
sd.Eat();//MinTom，吃饭
sd.Study();//我叫MinTom，在家里蹲学校上学
sd.Cry();//hello！