1.面向对象基础(封装、继承、多态、抽象类)0711

小技巧：F12转向定义，ctrl+E+D对齐代码,ctrl+R+E封装字段
面向对象
封装 继承 多态
对象：世间万物皆对象
一切事物都是对象
对象是一个具体的，
对象的组成：一个是特征（属性），一个行为（方法）

类：是抽象的概念，是一种数据类型，引用类型
类是创建对象的模板
空的构造函数，带参数的构造函数；字段，属性(ctrl+R+E)；方法
类组成：字段、属性、方法、构造函数、事件等

同一个cs文件中可以有多个类

类的语法：
[访问修饰符] class 类名
{
}
字段的命名：骆驼命名
属性：是一个聪明的字段。封装字段。 帕斯卡命名

[访问修饰符] 数据类型 属性名
{
get{}
set{}
}
属性三种形式：
读写属性，既有get访问器，又有set访问器
只读属性，只有get访问器
只写属性，只有set访问器

变量的作用域
局部变量：方法内部的变量
成员变量：直接属于类的变量

构造函数：是一种特殊的方法，给类初始化（给类内部的字段初始化）
没有返回值，名字必须和类名一致
[访问修饰符] 类名([参数列表])
{
}

实例成员 静态成员

静态方法 方法使用static去修饰
调用的时候使用 类名.方法名() 例：Console.WriteLine("")
实例方法 对象名.方法名()
例： Student stu = new Student();
stu.SayHi();

静态成员属于类所有，非静态成员属于类的实例所有。
C#静态方法属于类所有，类实例化前即可使用
在实例方法中可以直接调用静态方法，
在静态方法中不可以直接调用实例方法
静态方法和静态变量创建后始终使用同一块内存(静态存储区)，而使用实例的方式会创建多个内存
案例：猜拳

封装 黑匣子 隐藏具体实现
继承
使代码可以重用
子类继承父类的属性和方法 :
单根继承性 继承具有传递性

所有的类都直接或间接的继承自Object

this 代表当前类的实例,base 代表父类的实例
子类构造函数必须指明调用父类哪个构造函数
访问级别约束
子类的访问级别要比父类的低
方法、属性等暴露的返回值、参数的数据类型不能比方法、属性或者所在类的可访问级别低

多态 不同对象执行同一行为（方法）有不同的表现

里氏替换原则
让父类引用指向子类对象
Person per = new Student();
per是父类的引用，它不知道有哪些子类
不能使用父类的引用，调用子类的成员

is if (shapes[i] is Circle)
as Circle cir = shapes[i] as Circle; 如果转换失败返回null

熟练计算形状的案例
(1)Person.cs（父类）
Person p = new Person();
p.Name = "张三";
Console.WriteLine(p.ToString());//输出"张三",若是不重写ToString,则输出"_08_多态.Person"

public override string ToString()
{
return name;
}
(2)Student.cs:
public override string ToString()
{
return "学生的姓名"+ base.name;
}
====================================================================================
//里氏替换原则

//让父类引用指向子类对象
Person p = new Student("张三",18,"男");
//判断p对象是否是Student类型
if (p is Student)
{
Console.WriteLine("学生");
}
// 类型转换 只能转换引用类型
Student s = p as Student;
if (s != null)
{
s.SayHello();

}

//类也是一种数据类型，而且是引用类型，记住下面的这种用法
Person[] pers = {
new Student("张三",18,"男"),
new Student("李四",18,"男"),
new Student("王五",18,"男"),
new Teacher("老杨",18,"男"),
new Teacher("老赵",18,"男"),
new Teacher("老邹",18,"男")
};
foreach (Person item in pers)
{
if (item is Student)
{
//Student s = item as Student;
//s.SayHello();
Console.Write("学生 ");
}
else if (item is Teacher)
{
Console.Write("老师 ");
}
item.SayHi();
}
抽象类和抽象方法 abstract
抽象类
不能被实例化的类 不能去new
!!抽象类用来实现继承 和 多态
抽象类定义的是公共的实现和能力（抽象方法，没有实现）
抽象类中可以包含抽象成员，也可以不包含
抽象类不能被密封
抽象方法
抽象方法不能有实现
抽象方法必须出现在抽象类中
抽象方法必须被子类重写(override)，除非子类也是抽象类
子类必须实现(重写)父类中的所有抽象方法

(1)Person.cs(父类)
public abstract class Person
{
//abstract抽象
//抽象方法，抽象方法不能有实现
//抽放方法 必须出现在抽象类中
//抽象方法 必须在子类中重写
public abstract void SayHi();//注意不能实现，即不能有大括号{}
public abstract void Standup();
}
(2)Student.cs(子类)
子类继承抽象类，必须重写抽象类中所有的抽象方法

//重写抽象方法
public override void SayHi()
{
Console.WriteLine("大家好，我是"+base.name+"学生");
}

public override void Standup()
{
Console.WriteLine("老师好");
}
(3)Teacher.cs(子类)
public override void SayHi()
{
Console.WriteLine("同学们好，我是"+base.name+"老师");
}

public override void Standup()
{
Console.WriteLine("起立");

}

Shape[] shapes = {
new Circle(5),
new Circle(6),
new Circle(7),
new Square(10,20),
new Square(20,40)
};

foreach (Shape shape in shapes)
{
if (shape is Circle)
{
Circle c = shape as Circle;
Console.WriteLine("园==" + "半径："+c.R);
}
else if (shape is Square)
{
Square s = shape as Square;
Console.WriteLine("矩形=="+"长："+s.Width + "---高:"+s.Height);
}
Console.WriteLine("面积：" + shape.GetArae());
Console.WriteLine("周长：" + shape.GetLong());
}
多态的作用：把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。