C#面向对象、类(Class)与对象、属性(Oroperty)和字段(Field)

*面向对象：

面向对象的编程思想:万物皆对象

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

面向对象 三大特征: 封装 (用程序语言来形容对象) + 继承 (复用封装对象的代码; 儿子继承父亲,复用现成代码) + 多态 (同样行为的不同表现,儿子继承父亲的基因但有不同的行为表现)

面向对象七大特征: 开口原则 依赖倒转原则 里氏替换原则 单一职责原则 接口隔离原则 合成复用原则 迪米特法则

*类(Class)与对象：

类：就是 一个定义了 数据类型的 模板，比如，学生类，汽车类，动物类.... 就是拥有相同信息和行为的抽象的一个概念，某一类事物的总称 引用类型

一个类的创建 实际上并没有任何数据，它们仅仅定义了一个类是什么，意味着什么，有什么组成，以及可以执行什么操作

对象：是实实在在的个体，由类创建 是类的实例化，由某一个类创建（new）出来的，一个你能想象的或者看到的，比如，一个学生，一辆汽车，一个动物

类成员：一个类中包含的具体信息（属性）和行为（方法），我们称为类成员

namespace _01_类与对象
{
    internal class Program
    {
        static void Main(string[] args)
        {
            People p1 = new People();
            p1.name = "吴亦";
            p1.age = 222;
            p1.eat();
            People p2 = new People();
            p2.name = "罗志";
            p2.eat();
            // 需求：计算矩形的面积
            Zone zone = new Zone();
            Console.WriteLine("请输入长度：");
            zone.width = int.Parse(Console.ReadLine());
            Console.WriteLine("请输入宽度：");
            zone.height = int.Parse(Console.ReadLine());
            Console.WriteLine($"矩形的面积为：{zone.Area()}m²");
            //汽车
            car ca = new car();
            ca.pp = "奥迪A7L";
            ca.ys = "黑色";
            ca.jg = 700000;
            ca.Car();
        }
    }
    //类的创建
    //类一般创建在namespace下，以class关键字开头，类的主体由{}包裹
    //类名用帕斯卡命名法   同一个语句块中的不同类 不能重名
    /*
     * 格式：
     * 访问修饰符 class  类名
     *{
     * 类成员，分为三大类：字段 属性 方法
     * 
     * 成员变量 ，也叫做字段
     * 访问修饰符 成员类型 成员的名称1
     * 访问修饰符 成员类型 成员的名称2
     * 访问修饰符 成员类型 成员的名称3
     * 访问修饰符 成员类型 成员的名称4
     * 
     * 成员方法：
     *   访问修饰符 方法的返回值类型  方法名称1(参数){
     *          方法的实现
     *   }
     *    访问修饰符 方法的返回值类型  方法名称2(参数){
     *          方法的实现
     *   }
     * }
     */
​
    //访问修饰符：指定了 一个类 以及这个类的成员 的可访问性
    //可以通过 这个标识符，来控制某个类的成员的可访问性 
​
    //public：公共的  公开的  所有地方都可以访问
    //private：私有的，类内部可以访问  
    //protected: 只有该类及子类可以访问(后续详讲)
    //internal：只能在当前项目访问
    //protected internal：允许在同一程序集中的任何位置以及包含类派生的类型内部当我成员（后续讲解）
​
    //类和成员都有默认的修饰符
    //类的 默认修饰符：internal  只能 在当前 项目访问
    //类成员 默认修饰符：private 私有的 类的 内部访问
    class People
    {
        //成员变量
        public string name;
        public int age;
        char sex;
​
        // 成员方法
        public void eat()
        { Console.WriteLine($"{name}吃饭"); }
        public void sleep()
        { Console.WriteLine("睡觉"); }
    }
    class Zone
    {
        public int width;
        public int height;
        public int Area()
        { return width * height; }
    }
    class car
    {
        public int jg;
        public string pp;
        public string ys;
        public void Car()
        { Console.WriteLine($"汽车的品牌{pp},颜色{ys},价格{jg}元"); }
    }
}

•对象(Object)：

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

当我们创建一个类的同时，也会拥有一个数据类型，所有这个类实例化出来的对象，都属于这个类型

internal class Program
{
    static void Main(string[] args)
    {
        //实例化对象的语法
        //类名 变量名;    //类名 变量名 = null;(null代表空)    //类名 变量名 = new 类名();
        People p1 = new People();
        People p2 = new People();
        // 通过：对象名.成员名称  的方式来操作对象的成员
        // 设置：对象名.成员名称 = 值
        p1.name = "蔡徐";
        p1.age = 18;
        p1.sex = '坤';
        p2.name = "吴亦";
        p2.age = 17;
        p2.sex = '0';
        //获取： 对象名.成员名称
        Console.WriteLine(p1.name);
        Console.WriteLine(p2.name);
        // 成员****类里面的方法
        p1.eat();
        //对象也可以在初始化的同时进行对象成员的初始化
        Person p3 = new Person() {Name="紫诺",Age=20,Gender="女" };
        Person p4 = new Person() { Name = "帅", Age = 22 ,Gender = "男" };
        p3.SayHello();
        p4.SayHello();
    }
}
public class People
{
    //默认成员变量访问修饰符是私有的 private   要想在类的外部访问  需要手动设置访问修饰符
    public string name;
    public int age;
    public char sex;
    double money;
    //成员方法
    public void eat()
    {
        money = 1000;
        Console.WriteLine("吃饭");
        //在类方法中，使用this来表示当前类创建的那个对象
        Console.WriteLine($"{this.name}吃饭");
        //访问当前类的其他成员可以省略this
        Console.WriteLine($"{name}吃饭");
        Console.WriteLine(money);
    }
}
​
class Person
{
    public string Name;
    public int Age;
    public string Gender;
    public void SayHello()
    { Console.WriteLine($"Hell,my name is {Name}. I am {Age} years old and I am {Gender}"); }
}

•修饰符使用范围测试:

static void Main(string[] args)
        {
            //引用其他项目中的类
            //1.在当前项目引用上点击右键
            //2.添加引用点击项目勾选需要使用的类所在的项目
            //3.点击确定
            //4.在当前项目using 引入类项目所在的命名空间（namespace 后面的名字）
            People people = new People(); 
        }

•属性(Oroperty)和字段(Field):

属性基本概念:

1.用于保护成员变量

2.为成员属性的获取和赋值添加逻辑处理

3.解决public private protected 的局限性

internal class Program
{
    static void Main(string[] args)
    {
        // 字段 是一个私有的
        // 属性 一般是公开的
        // 字段和属性都是成员变量
        People people = new People();
        people.Age = 100;
        Console.WriteLine(people.Age);
        Test test = new Test();
        //test.abc= true;
        test.Age = -1;
        Console.WriteLine(test.Age);
        Console.WriteLine(test.B);
        test.B = "bbb";
        Console.WriteLine(test.B);
    }
}
public class People
{
    //类 是由 成员变量 和 成员方法 组成
    //成员变量 就是 字段 用来存储信息的
    public string name;
    //类 的成员 可以通过 设置访问修饰符 来控制访问权限，
    //如果这个成员是 一个私有的 还想访问 我们可以 通过 属性和方法 来操作
​
    //为了保证对象的数据不会被随意更改，我们通常会使用属性来定义
    //公开的成员变量属性名（使用大驼峰），使用字段定义私有的成员变量（使用小驼峰）
    
    //成员属性语法:
    //访问修饰符 属性类型 属性名{ get{}set{} }
    private int age;//100
    public int Age
    {
        //获取Age属性的时候执行
        get
        {
            Console.WriteLine("get方法执行的");                         
            //get代码块中 通过return返回当前属性的值
            //可以在返回之前添加一些逻辑规则
            //意味着 这个属性可以获取的内容
            return age;
        }
        //设置Age属性时执行
        set
        {
            //可以在设置之前添加一些逻辑规则
            //value 关键字 用于表示 外部传入的值
            age = value;
            Console.WriteLine("set方法执行了");
            //set方法中有一个value， 这个value就是修改之后的值
            Console.WriteLine(value);
            if (value < 0)
            {
                //抛出一个错误异常，让代码报错并停止
                throw new Exception("Age属性不能小于0");
            }
            if (value > 150)
            {
                //抛出一个错误，让代码报错并停止
                throw new Exception("Age属性不能大于150");
            }
            age = value;//age=100
        }
    }
}
class Test
{
    //我们有时候只需要定义一个公开的属性，不需要拦截操作
    /*  private string name;
      public string Name { get => name;set=>name=value; }*/
    //简化
    public string Name { get; set; }
    public int Age { get; set; }
    //字段默认值设置
    private string a = "aaa";
    //属性的默认值
    private string b = "b和B的默认值";
    public string B { get => b; set => b = value; }
    // public string C { get; set; } = "C的默认值";
    public bool abc
    { get { return Age >= 18; } }
}   
//总结
//1.成员属性概念:一般是用来保护成员变量的
//2.成员属性的使用和变量一样 外部用对象点出
//3.get中需要return内容;set中用value表示传入的内容
//4.get和set语句块中可以加逻辑处理
//5.get和set可以加访问修饰符，但是要按照一定的规则进行添加
//6.get和set可以只有一个
//7.自动属性是属性语句块中只有get和set，一般用于 外部能得不能改这种情况