day10——面向对象三大特征
提纲：
1、面向对象
2、类和对象
3、方法的重载
4、构造方法
5、this关键字
6、匿名对象
7、作业加芊芊老师vx领取最新资料哦
面向对象的三大特征：
1、封装性
2、继承性
3、多态性
一、封装性
1.1、封装的概念
封装的概念：尽可能的隐藏对象的内部的细节。
"打包",包起来。为了保护数据的安全性。
某宝购物，电视机。。。。
面向对象中的封装性，不仅仅是对属性进行封装。
一段代码，写了3遍--->封装成一个方法
一堆方法，用了3遍--->封装成工具类：Arrays工具类
。。。
一个方法，一个类，都是一种封装。1.1.1 private关键字
词义："私有的"。
是一个访问权限修饰符：
修饰符：public，private，static，final，abstract。。。
访问权限：在哪个范围内能够访问。
作用：限制在本类中才能访问。
private，修饰属性，修饰方法，不能修饰类。
1.1.2 getter和setter方法
为了保护属性的数据安全，使用了private访问权限修饰符，限制了只能在类中使用。那么对于外部的对象，如何给属性进行操作？赋值，取值。
使用setter方法，给属性进行赋值。
set，词义，设置。。
语法格式：
/*
public void set成员变量名(形式参数){//要给成员变量进行赋值
this.属性 = 参数名;
}
例如：
public void setAge(int age){
//.....
this.age = age;
}
*/
使用getter方法，获取属性值
get，词义，获取
/*
public 成员变量的类型 get成员变量名(){
return this.成语变量名;
}
例如：
public int getAge(){
return this.age;
}
*/1.1.3 类的设计原则
- 成员变量(属性)，私有化(使用private修饰)。添加getter方法和setter方法。
- 公开方法(public修饰)。
- 至少提供无参的构造方法，有参(随意)。
所以说对类中的属性，进行封装的步骤：
step1：使用private关键字，修饰成员变量(属性)。
step2：提供setter方法，用于对属性进行赋值。
public void set属性名(参数){
this.属性名 = 参数;
}
step3：提供getter方法，用于获取属性值。
public 属性值类型 get属性名(){
return this.属性名;
}
属性封装，注意点：
如果一个属性是boolean类型的，get方法的写法：方法名是特殊：isXXX()
private boolean married;//是否已婚
//对于boolean类型的get方法：两个状态
public boolean isMarried(){
return this.married;
}扩展内容：
数组有长度：表示该数组中存储的元素的个数。
数组的属性：arr.length
字符串也有长度：表示该字符串中字符的个数。
"abc"，"hello","he llo"
字符串的方法：str.length();二、继承性
2.1、继承的概念
2.2.1 生活中的继承
继承"遗产"。
子承父业。儿子可以继承父亲的东西。2.2.2 Java中的继承的概念
继承指的是两个类的关系。如果一个类(子类)，继承了另外一个类(父类)。那么子类就可以直接使用父类的非私有化的成员(属性，和方法)。
2.2.3 继承的好处
1、实现代码的重用和扩展。
避免重复的代码：父类写的非私有化的属性和方法，子类不用再写了，直接使用。
类的扩展：思想，子类扩展父类的功能。(父类是人，子类是学生)
2、模拟现实世界的关系。
2.2.4 类的继承
- 关键字：extends，词义：扩展的。描述两个类的关系：子类，父类。
- 被继承的类：父类，根类，超类，基类，SuperClass
- 继承的类：子类，派生类，SubClass
2.2.5 继承的语法
public class FatherClass{
//属性
//方法
}
public class ChildClass extends FatherClass{
//新增的属性
//方法：重写，新增
}一旦两个类存在了继承的关系，那么：
- 子类可以直接使用父类的非私有化的属性(成员变量)和方法(成员方法)。
- 子类还可以新增自己的属性和方法。
- 子类可以重写父类已有的方法。
2.2.6 什么样的两个类适合继承关系
要两个类，满足is-a 的范式
子类 是一个 特殊的 父类。eat()，sleep()
name，age，color
狗类：继承动物
eat()，sleep()
name，age
猫类：继承动物
学生，继承人
工人，继承人
小汽车，继承 车
2.2.7 继承的注意点
1、两个类存在了继承关系。
子类可以使用父类的属性和方法
但是父类不能使用子类的属性和方法。
2、Java语言的继承是局限性：单继承。
一个子类，只能有一个父类。
Java语言，不允许多继承，但是可以多层继承。
一个父类，爷爷类，太爷爷，祖爷爷。。祖宗。。
一个父类是可以有多个子类的。
2.3 子类对象的创建过程
实例化子类对象的过程：
- 1、先调用父类的构造方法
- 默认调用父类的无参构造方法。
- 2、再调用子类的构造方法
我们通过代码演示，发现当创建子类对象的时候，默认会先调用父类的构造方法。
调用子类的构造方法中，先调用了父类的构造方法，默认调用的父类的无参构造方法。
1、子类的构造方法中，第一行一定是调用了父类的构造方法。
2、如果没有显示的调用父类的构造方法，那么编译器会自动添加一个：super()，父类的无参构造方法。
3、子类的构造方法中，既可以调用父类的无参构造方法，也可以调用父类的有参构造方法。
4、父类的构造方法：
无参构造：super();
有参构造：super(参数);
2.4、super关键字
用法一：super()，指代父类的构造方法。
如果有多个父类的构造方法，那么要靠参数区分。
super()，无参构造
super(参数)，父类的有参构造方法。。
注意点：super()，指代父类的构造方法，一定是位于第一行。同this()指代本类构造方法。
方法二：直接访问父类的属性和方法
super.属性--->父类的属性。
super.方法--->父类的方法
this.属性
this.方法
2.5、方法的重写
重载(overload)：一个功能方法的多种写法。
同一个类中，方法名必须一致，参数列表必须不同。
重写(override)：继承结构。
概念：在继承结构中，子类将父类已有的方法，重新实现，这叫方法的重写。
如果在子类中，存在方法的重写，那么默认调用的是重写之后的方法。方法重写的规则：
1、继承结构中。
2、方法的声明，必须和父类的一致。
方法名必须和父类一致
参数列表必须和父类一致
返回值必须和父类一致
3、访问权限，不能比父类更加严格。
4、子类重写的方法，不能抛出比父类更大更多的异常。
/*
* 1.父类的方法，访问权限：public
* 子类重写，只能public
* 2.父类的方法，访问权限：protected
* 子类重写，protected，public
* 3.父类的方法，访问权限：default
* 子类重写，default，protected，public
* 4.父类的方法，访问权限：private
对于子类来讲，该方法根本不可见。
*/
2.6、访问权限修饰符
访问权限：就是在哪能访问。通过访问权限修饰符来实现。
作用：限制可见度。
private：私有的。本类中。
默认的：(default)：注意，啥修饰符都不写，就是默认的。本类。同包下可以访问。
protected：受保护的。本类，同包下，不同包(子类使用)
public，没有限制的。
private---> default--->protected--->public
使用原则：
- 修饰类：只能是public和default
- 修饰成员：变量和方法：以上4个修饰符都可以。
- 局部变量，不能使用这些修饰符。
三、多态性
什么是多态
其实就是事物的多种形态。
3.1、对象的多态性
指的是子类对象的多种形态：
子类对象--->看成父类的类型。
子类对象--->看成子类的类型。
1、如果声明了一个父类类型的引用(=左边)，创建的是父类的对象(=右边)。
可以访问父类的属性和方法。（不能访问子类的）
2、如果声明了一个子类类型的引用(=左边)，创建的也是子类的对象(=右边)。
可以访问父类的属性和方法。
还可以访问子类的新增。
以及子类的重写。
3、如果声明了一个父类类型的引用(=左边),但是实际上指向了一个子类对象。(=右边)
可以访问父类的属性和方法。
以及子类重写的方法。但是不能访问子类的新增。
类的实例：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()
结论：对于子类对象，如果方法存在重写， 那么一定是调用重写之后的方法。
3.2、向上转型和向下转型
向上转型：一个子类对象，看成了父类的类型。（自动转换）
那么只能访问父类的属性和方法，以及子类重写的方法。失去了子类的新增。
向下转型：向上转型后，子类对象看成了父类类型，然后再看成子类类型。（强制转换）
可以重新访问子类的新增属性和方法。
向下转型的注意点：不是所有的父类引用都能转成子类类型。向下转型的前提：是一个子类对象先向上转型了，再转回来，那是可以的。但是如果没有向上转型，直接父类对象转为子类类型，报错：ClassCastException。
看一个引用，能够访问哪些成员：
看=左边是什么类型的声明：
父类类型：那么能够访问父类中声明属性和方法。
看一个引用，具体执行的方法，是否重写了：
看=右边是什么类型的对象：
如果是父类的对象，执行没有重写的方法，父类的方法。
如果是子类的对象，执行的是重写的方法，子类重写后的方法。
举个栗子：
看戏：国粹，京剧
京剧大师：--->
给大家唱戏：
京剧大师：发门票，，要来看戏了。。
病了，无法登台表演。。。
传承：子承父业。儿子也是唱戏的。
儿子画个花脸上台假装爸爸：装爹。
只能唱爹的歌。。。重写的方法。
*卸妆，我是儿子了
可以唱自己的新歌了。。
3.3、instanceof
子类对象向上转型，为父类的类型。自动完成。
但是把一个父类的引用，再转回子类类型。就可能会存在问题。
语法：引用 instanceof 类名
得到的结果：boolean类型
对于对象的多态性，如果想向下转型，那么应该先加个逻辑判断。判断该引用指向对象是否是要转换的类型。否则的话，会产生错误：ClassCastException，打断程序的执行。
所以：所有的向下转型之前，都应该使用instanceof进行判断。
向上转型不需要：子类 is a 父类
3.4、 对象的多态性的应用
如果一个方法，接收了父类类型作为参数，那么实际上传入父类对象和其他的任意子类对象都可以。如果传入子类对象的话，会发生对象的向上转型。
如果一个方法，返回一个父类类型作为返回值，那么在方法中实际上可以返回任意的子类对象。
2.5、多态性概述
多态性：事物的多种形态。
方法：方法的多种形态，指的就是方法的重载。一个功能方法，但是根据参数不同，执行的具体方法也不同。叫做静态多态。程序编译时发生的多态。
对象：对象的多态性，结合方法的重写。一个子类对象，如果看成父类的类型，那么执行的方法就只能父类的以及子类重写的。如果再把该对象向下转型转为子类类型，才可以执行子类的新增方法。
1、方法的重载：
public void getSum(int i,int j){
}
public void getSum(double d1,double d2){
}
2、对象的多态性：子类对象。看成父类类型(向上转型)，或者看成子类类型(向下转型)。
方法的重写：
Animal a = new Animal();//父类类型引用，只能执行父类的方法。
父类的方法。不是重写的
Animal a1 = new Cat();//父类类型引用，执行重写后的方法。父类的方法。
子类重写后的方法。
Cat c1 = (Cat)a1;//子类类型的引用，执行的值重写后的方法，以及子类的新增方法文末福利
大家可以加老师vx领取最新资料哦
别忘了扫码领资料哦，获取【Java高清路线图】和【全套学习视频和配套资料】