第九单元 面向对象一：类与对象

踏云揽月

假设，班级里40位同学，我们用程序保存40位学生的信息：学号，姓名，性别，生日，身份证号。如果是你，你会怎么实现？
小菜同学拿到这个题，奋书疾笔，马上写出如下代码：

1. ArrayList list = new ArrayList();
2. ​
3. string stuNo1="10001";
4. string name1 = "张三";
5. string sex="男";
6. Datetime birthday1 = Datetime.Parse("1998-08-08");
7. string idCard1 = "362530199808080510";
8. list.add(stuNo1);
9. list.add(name1);
10. ... list.add....
11.    
12. ........//经过1个半小时后，终于到了第40位。

复制代码

 
那如果是有4000，4万？你是不是立马从入门到卸载了？面向对象来告诉你解决方案！！
1. 面向对象概念

面向对象编程（ OOP，Object Oriented Programming ）

• 并不是一个技术，而是一种编程指导思想。
  
• 把现实世界的具体事物全部看成一个一个的对象来解决实际问题。
  

为什么要用面向对象编程
生活中我们解决问题就是按照对象化的方式进行的。如果程序也能够按照生活的中的方式来解
决问题，那么程序就更符合人类的思维习惯，代码看起来会更易理解、更简单、更易维护。
 
面向对象编程共同三大特性：封装，继承，多态。

在C# 中，一定要时刻的牢记这句话：一切皆为object（对象）;

2. 封装

封装 被定义为"把一个或多个项目封闭在一个物理的或者逻辑的包中"。在面向对象程序设计方法论中，封装是为了防止对实现细节的访问。
抽象和封装是面向对象程序设计的相关特性。抽象允许相关信息可视化，封装则使开发者实现所需级别的抽象。
访问修饰符

C# 封装根据具体的需要，设置使用者的访问权限，并通过 访问修饰符 来实现。
一个 访问修饰符 定义了一个类成员的范围和可见性。C# 支持的访问修饰符如下所示：

• public：所有对象都可以访问；
  
• private：对象本身在对象内部可以访问；
  
• protected：只有该类对象及其子类对象可以访问
  
• internal：同一个程序集的对象可以访问；
  
• protected internal：访问限于当前程序集或派生自包含类的类型。
  

实现封装的方式共有三种：类的封装，属性封装，方法的封装。
封装的作用：

• 隐藏细节，设置访问权限，提高安全性
  
• 代码复用。
  
• 提高代码的可读性
  

3. 什么是类

类是一组具有相同事物和行为的抽象（物以类聚）。
类在实现生活中是不存在的，看不见，摸不着。例如：人类，狗类，猫科类，灵长类.... 这些事物都只是一些抽象的概念，并不是指具体的物体。如果我说：小明今天吃了三碗饭，小红的头发很长，那么，小明，小红 是指人类的具体对象，lucky（一只猫） 这个月身体长得很快，这也指的是对象，因为lucky是实实在在存在的。
人为什么不和狗分为一类？
答：因为人和狗的体征行为都不一样！！再次强调类：类是一组具有相同事物和行为的抽象（物以类聚）。人会思考，人会制作工具，而狗不会。
 
对象：是真实存在的具体实例。
类(设计图)：是对象共同特征的描述（抽象）。

 
在C#中，必须先设计类，才能获得对象。

 
4. 如何定义类

定义类的关键字是class，命名规范为首字母大写，以帕斯卡（大驼峰）方式命名 如：

1. <访问修饰符> class 类名
2. {
3.     // 构造器（下一个单元会讲到）
4.    
5.     // 字段
6.    
7.     // 属性(特征)
8.    
9.     // 方法（行为）
10.    
11.     // 事件(C# 高级阶段学习)
12.    
13.     // 索引器(c# 高级阶段学习)
14.    
15. }

复制代码

1. <br>如：

复制代码

1. public class Person
2. {
3.     // 字段
4.     private string name;
5.    
6.     // 属性
7.     public string Name
8.     {
9.         get
10.         {
11.             return name;
12.         }
13.         set
14.         {
15.             value=name;
16.         }
17.     }
18.    
19.     // 方法
20.     public void eat()
21.     {
22.         Console.WriteLine("吃饭,我要吃油焖大虾");
23.     }
24. }

复制代码

 
其中，字段，属性，方法，被统称为类的成员。字段，属性 被称为成员变量，方法被称为成员方法。
访问标识符  指定了对类及其成员的访问规则。如果没有指定，则使用默认的访问标识符。类的默认访问标识符是 internal，成员的默认访问标识符是 private。
5. 字段与属性

字段一般是私有的(private)，属于类的私有信息，如：姓名，年龄，身份证号等等信息都是属于人类的私有信息。

1. public class Person
2. {
3.     private string name;
4.     private int age;
5. }

复制代码

 
属性是类对外提供访问字段的途径，一般是公有的(public) ，如：别人问你年龄，女孩子一般说18岁。此时她说的18岁是她自己对外主动暴露出来的，事实上她的真实年龄信息是私有的，只有她自己知道，到底是不是18岁我们其实是不清楚的。

1. public class Person
2. {
3.     private string name;
4.     private int age;
5.    
6.     public string Name
7.     {
8.         // get 访问器
9.         get
10.         {
11.             return name;
12.         }
13.         // set 访问器
14.         set
15.         {
16.             value=name;
17.         }
18.     }
19.    
20.     public int Age
21.     {
22.         get
23.         {
24.             return 18;
25.         }
26.         set
27.         {
28.             value = age;
29.         }
30.     }
31. }

复制代码

Get, Set 访问器都可以设置访问修饰符哦，默认的访问修饰符都是public.
c# 9.0 之后 还支持 Init访问器， 调用方可使用属性初始化表达式语法 ， 在创建表达式中设置这些值 。 但构造完成后，这些属性将变为只读

 
字段与属性的区别

• 字段是私有的(private)，属性是公开的(public)。
  
• 属性具有读写器( get, set)
  
• 字段命名，以小驼峰命名，属性以帕斯卡(大驼峰)命名。
  
• 属性并没有真正存储数据
  

只读属性
也就是只提供了， Get 访问器，没有Set 访问器。

1. public class Person
2. {
3.     private short orderState
4.    
5.     public string OrderState
6.     {
7.         get
8.         {
9.             switch(orderState){
10.                 case 1:
11.                     return "待支付";
12.                 case 2:
13.                     return "待发货";
14.                 case 3:
15.                     return "待收货";
16.                 case 4:
17.                     return "已完成";
18.                 default:
19.                     return "待支付";
20.             }
21.         }
22.     }
23. }

复制代码

 
只写属性
也就是只提供了， Set 访问器，没有Get 访问

1. public class Person
2. {
3.     private string pwd
4.    
5.     public string Password
6.     {
7.         set { value = pwd;} // 没有Get
8.     }
9. }

复制代码

 
属性简写
如果一个类中，属性只是直接对字段进行读写，那么，这个属性字段就可进行简写。
例如：

1. public class Person
2. {
3.     private string name;
4.     private int age;
5.    
6.     public string Name
7.     {
8.         get { return name; }
9.         set { value=name; }
10.     }
11.    
12.     public int Age
13.     {
14.         get { return 18; }
15.         set { value = age; }
16.     }
17. }
18. // 简化后
19. public class Person
20. {
21.     public string Name {get; set;}
22.     public int Age {get; set;}
23. }

复制代码

 
我们刚说过，属性是对字段的封装，但是简写后的属性根本就看不到类，岂不是自相矛盾吗？其实简写属性中其实隐藏了字段，如果通过反编译工具编译 MS IL 或者通过反射技术去查看，我们会可以将它隐藏的字段读取出来。
6. 类的对象(实例)

语法：

1. 类名 对象名 = new 类名();
2. 如：
3. Person per = new Person();

复制代码

　　
使用对象

1. 访问属性: 对象名.成员属性
2. 访问行为: 对象名.方法名(…)

复制代码

 
例如：

1. public class Person
2. {
3.     private string name
4.    
5.     public string Name
6.     {
7.         set { value = name;}
8.         get { return name;}
9.     }
10.    
11.     public void Eat()
12.     {
13.         Console.WriteLine($"姓名：{name},他正在吃饭..");
14.     }
15. }
16. class Program
17. {
18.     static void Main(string[] args)
19.     {
20.         Person per1 = new Person();
21.         per1.Name = "张三"; // 访问属性
22.         per1.Eat();  // 调用成员方法
23.         
24.         Person per2 = new Person();
25.         per2.Name = "李四"; // 访问属性
26.         per2.Eat();  // 调用成员方法
27.     }
28. }

复制代码

输出结果：

1. 姓名：张三,他正在吃饭..
2. 姓名：李四,他正在吃饭..

复制代码

　　
7. 构造方法

学构造方法的目的？

• 真正知道对象具体是通过什么得到的。
  
• 能够掌握为对象赋值的其他写法。
  

构造方法的作用

• 用于初始化一个类的对象，并返回对象的地址。
  
• 简化对象初始化的过程
  

语法

1. 修饰符 类名(形参列表)
2. {
3.         ...
4. }
6. public class Car
7. {
8.     ...
9.     // 无参数构造器
10.     public Car()
11.     {
12.             ...
13.     }
14.     // 有参数构造器
15.     public Car(String n, String b)
16.     {
17.             ...
18.     }
19. }

复制代码

　　
初始化对象的格式

1. 类名 对象名称 = new 构造器；
2. Car c = new Car();

复制代码

　　
构造器的分类

• 无参数构造器（默认存在的）：初始化的对象时，成员变量的数据均采用默认值。
  
• 有参数构造器：在初始化对象的时候，同时可以为对象进行赋值。
  

注意事项

• 任何类定义出来，默认就自带了无参数构造器，写不写都有。
  
• 一旦定义了有参数构造器，无参数构造器就没有了，此时就需要自己写一个无参数构造器了。
  

1. public class Car
2. {
3.         ...
4.         // 无参数构造器（默认存在的）
5. }
7. public class Car
8. {
9.     ...
10.     public Car()
11.     {
12.         // 无参数构造器（需要写出来了）
13.     }   
14.     public Car(String n, String b)
15.     {
16.         // 有参数构造器
17.         }
18. }

复制代码

 
8. 两个变量指向同一个对象

1. class Student
2. {
3.     public string Name { get; set; }
4.     public string Sex  { get; set; }
5.     public string Hobby  { get; set; }
6.    
7.     public void Study()
8.     {
9.         Console.WriteLine($"姓名:{Name},性别：{Sex},爱好：{Hobby}");
10.     }
11. }
12. public static void main(String[] args)
13. {
14.     Student s1 = new Student();
15.     s1.Name = "小明";
16.     s1.Sex = '男';
17.     s1.Hobby = "游戏、睡觉、听课";
18.     s1.Study();
19.     // 把学生类型的s1变量赋值给学生类型的s2变量
20.     Student s2 = s1;
21.     s2.Hobby = "爱提问";
22.    
23.     Console.WriteLine(s2.Name);
24.     Console.WriteLine(s2.Sex);
25.    
26.     Console.WriteLine(s1.Hobby);
27.     s2.Study();
28. }

复制代码

 
输出结果：

1. 姓名：小明，性别：男，爱好：游戏、睡觉、听课
2. 小明
3. 男
4. 爱提问
5. 姓名：小明，性别：男，爱好：爱提问

复制代码

　　
内存分布图

思考：如果某个对象，被当作方法参数传递之后，在方法体内对象（形参）的某些属性被修改，那么实参对象的属性会发生变化吗？

9. this 关键字

假设有如下一段代码：

1. public class Person
2. {
3.     private string name;
4.     private string age;
5.     public Person(string name,string age)
6.     {
7.         name = name; // 此处很有可能会有问题！！
8.         age = age;   // 此处很有可能会有问题！！
9.     }
10. }

复制代码

 
编译器很有可能分不清 name 到底是形参还是成员变量，怎么破？ this 关键字就可以帮忙解决。
this关键字

• this关键字可以出现在成员方法、构造器中，代表当前对象的地址。
  
• 作用：访问当前对象的成员变量、成员方法。
  

1. public class Person
2. {
3.     private string name;
4.     private string age;
5.     public Person(string name,string age)
6.     {
7.         this.name = name;
8.         this.age = age;
9.     }
10. }

复制代码

10 . 作业

<ol  start=""><li >学生类：
<ul  data-mark="*"><li >字段：姓名，性别，成绩，零钱
<li >
属性：姓名：性别，成绩( 只写Set访问器)，成绩等级（成绩差，60