day15——面向对象(多态性)
一、上节课回顾
1、匿名对象：
new 构造方法();
就是没有名字的对象。随着被创建而使用一次。（一次性）。
new 构造方法().方法名();
new 构造方法().方法名();
2、面向对象的三大特征：
A：封装性："打包"，
方法的封装。
类的封装。
属性：成员变量，给对象使用的。
对象.属性--->赋值，取值
对象.方法--->对象将方法调用
变量：
直接写在类里：成员变量，描述这个类别的外部特征。使用变量
直接写在方法里：局部变量，存储数据。
classPerson{
privateintage;//人的年龄：[0,150]
publicvoidsetAge(intage){
if(如果age合理){
this.age=age;
}else{
//不合理的数据，不要赋值了
}
}
publicintgetAge(){
returnthis.age;
}
}
classTest1{
publicstaticvoidmain(String[]args){
Personp1=newPerson();
p1.age=-1000;//赋值，取值
}
}
如何对属性进行封装？访问权限修饰符：private default protected public
step1：使用private修饰属性
使用private修饰的成员变量，方法，都限制在本类内访问
step2：提供setter方法，用于给属性赋值
step3：提供getter方法，用于取值
属性的类型是boolean类型，isXXX(){}
设计一个类的原则：
属性封装，private，提供get和set方法
方法要public
提供无参构造
B：继承性：两个类的关系。
一个类B类，继承了另一个类A类。
A类：父类，基类，超类，SuperClass
B类：子类，派生类 ，SubClass
继承的作用？
提高类的可重用性。类的扩展。
模拟现实
一个子类继承了一个父类？
子类可以直接使用父类的非私有化的属性和方法。
子类可以新增自己的属性和方法。
子类可以将父类已有的方法重新实现。方法的重写。
语法：关键字：extends，词义：扩展
C：多态性
二、本节课内容
第一周：基本语法，规则
第二周：分支，循环，逻辑性，方法，数组：引用类型的数组。栈，堆。。。
第三周：思想，规则：
类
对象
new
构造方法
创建对象
内存分析
访问属性
赋值，取值
访问方法
this
。。。
2.1、子类对象的创建过程
实例化子类对象的过程：
1、先调用父类的构造方法
默认调用父类的无参构造方法。
2、再调用子类的构造方法
我们通过代码演示，发现当创建子类对象的时候，默认会先调用父类的构造方法。
调用子类的构造方法中，先调用了父类的构造方法，默认调用的父类的无参构造方法。
1、子类的构造方法中，第一行一定是调用了父类的构造方法。
2、如果没有显示的调用父类的构造方法，那么编译器会自动添加一个：super()，父类的无参构造方法。
3、子类的构造方法中，既可以调用父类的无参构造方法，也可以调用父类的有参构造方法。
4、父类的构造方法：
无参构造：super();
有参构造：super(参数);
2.2、super关键字
用法一：super()，指代父类的构造方法。
如果有多个父类的构造方法，那么要靠参数区分。
super()，无参构造
super(参数)，父类的有参构造方法。。
注意点：super()，指代父类的构造方法，一定是位于第一行。同this()指代本类构造方法。
方法二：直接访问父类的属性和方法
super.属性--->父类的属性。
super.方法--->父类的方法
this.属性
this.方法
2.3、方法的重写
重载(overload)：一个功能方法的多种写法。
同一个类中，方法名必须一致，参数列表必须不同。
重写(override)：继承结构。
概念：在继承结构中，子类将父类已有的方法，重新实现，这叫方法的重写。
如果在子类中，存在方法的重写，那么默认调用的是重写之后的方法。
方法重写的规则：
1、继承结构中。
2、方法的声明，必须和父类的一致。
方法名必须和父类一致
参数列表必须和父类一致
返回值必须和父类一致
3、访问权限，不能比父类更加严格。
4、子类重写的方法，不能抛出比父类更大更多的异常。
/*
* 1.父类的方法，访问权限：public
* 子类重写，只能public
* 2.父类的方法，访问权限：protected
* 子类重写，protected，public
* 3.父类的方法，访问权限：default
* 子类重写，default，protected，public
* 4.父类的方法，访问权限：private
对于子类来讲，该方法根本不可见。
*/
2.4、访问权限修饰符
访问权限：就是在哪能访问。通过访问权限修饰符来实现。
作用：限制可见度。
private：私有的。本类中。
默认的：(default)：注意，啥修饰符都不写，就是默认的。本类。同包下可以访问。
protected：受保护的。本类，同包下，不同包(子类使用)
public，没有限制的。
private---> default--->protected--->public
使用原则：
修饰类：只能是public和default
修饰成员：变量和方法：以上4个修饰符都可以。
局部变量，不能使用这些修饰符。
2.5、对象的多态性
2.5.1 什么是多态
其实就是事物的多种形态。
类的实例：new出来的---->对象。
父类：Animal
属性：name，age
方法：eat(),sleep()
子类：Cat
新增属性：color
新增方法：catchMouse()
重写方法：eat()
子类：Dog
新增方法：lookDoor()
重写方法：eat()
Animal a1 = new Animal();//a1能够访问的是父类的属性和父类的方法
Cat c1 = new Cat();//c1能够访问name，age，子类新增color。sleep()，子类重写eat，子类新增catchMouse()
Dog d1 = new Dog();//d1父类属性：name，age，方法：sleep()，子类重写eat(),子类新增lookDoor()
结论：对于子类对象，如果方法存在重写， 那么一定是调用重写之后的方法。
2.6、向上转型和向下转型
向上转型：一个子类对象看成了父类类型。那么就失去了子类新增。
Animal a2 = new Cat();//
a2,本身是子类对象，但是看成父类类型。
那么能够访问父类的属性，不能访问子类的新增属性。
能够访问方法，以及子类重写的方法。
三、总结
1、子类对象的创建过程：（知道）
1、子类的构造方法的第一行，一定是调用了父类的构造方法。如果没有，那么编译器自动添加：super();
2、先调用父类的构造，然后再执行子类的构造。
2、super关键字：（记住）
用法一：指代父类的构造方法。super()。位于第一行。
用法二：直接访问父类的属性和方法。
3、方法的重写：（会用）
概念：继承关系中，子类将父类已有的方法重新实现。
英文：override
规则：
4、访问权限：访问权限修饰符，用于控制可见度。（知道）
private：本类
default：本类，同包
protected：本类，同包，不同包(限于继承结构)
public：没有限制
5、对象的多态性：(未完待续。。)
向上转型：将子类的对象，看成父类的类型。就"失去"了子类的新增。
四、作业
1、课堂代码敲3遍
2、。。。
3、预习明天内容：
