笔记：Java_封装继承多态
高内聚，低耦合：
高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合：仅暴露少量的方法给外部使用。
一、封装：
含义：
1. 指把对象的属性和行为看成一个密不可分的整体，将这两者“封装”在一个密不可分的独立单位（即对象）中；
2. 指“信息隐藏”，把不需要外界知道的信息隐藏起来，有些对象的属性及行为为允许外界用户知道或使用，但不允许更改，而另一些属性或行为，则不允许外界知道，或只允许使用对象的功能，而尽可能隐蔽对象的功能实现细节。通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
- 一句话：私有属性（privat），使用getter/setter。通过getter获得这个数据，通过setter给这个数据设置值。
- 快捷键：
1. 生成无参构造方法：Alt+Insert,然后选中Constructor；
2. 生成getter/setter方法：Alt+Insert,然后选中getter/setter。
public class Student {
//姓名
private String name;
//手机号码
private String number;
//性别
private char sex;
//年龄
private int age;
//提供一些可以操作这个属性的方法
//提供一些public的get、set方法
//get 获得这个数据
public String getName(){
return this.name;
}
//set 给这个数据设置值
public void setName(String name){
this.name = name;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age > 120 || age < 0) {
this.age = 3;
}else{
this.age = age;
}
}
}
/*
封装
*/
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("燚晗");
s1.setAge(18);
s1.setSex('女');
s1.setNumber("186XXXX7052");
Student s2 = new Student();
s2.setName("杨焕");
s2.setAge(23);
s2.setSex('男');
s2.setNumber("173XXXX2809");
System.out.println("姓名："+
s1.getName()+"\n"+"年龄："+s1.getAge()+"\n"+
"性别：" + s1.getSex()+"\n"+
"手机号码："+s1.getNumber()+"\n");
System.out.println("姓名："+
s2.getName()+"\n"+"年龄："+s2.getAge()+"\n"+
"性别：" + s2.getSex()+"\n"+
"手机号码："+s2.getNumber());
}
}
二、继承：
extends的意思是"扩展"。子类是父类的扩展。
-
Java只有单继承(这样理解：一个儿子只能有一个爸爸，一个爸爸可以拥有多个儿子)，没有多继承！实现多继承要用interface。
-
继承只是类与类之间的一种关系。除此之外，还有依赖、组合、聚合等。
-
继承关系的俩个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
-
子类和父类之间，从意义上讲应该具有"is a"的关系。
-
子类可以继承父类的所有方法。
-
在子类方法中访问一个变量：
1.子类局部范围找
2.子类成员范围找
3. 父亲成员范围找
4. 如果都没有就报错（不考虑 父亲的父亲） -
继承中构造方法的访问特点：
子类中所有的构造方法（无参/带参构造）默认会访问父类中无参的构造方法！原因: 1. 因为子类会继承父类的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化； 2. 每一个子类构造方法的第一条语句默认都是：super()。 -
this指向当前类、super指向父类，访问父类的属性
- super注意：
1.super调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或者构造方法中，
3.super和this不能同时调用构造方法
4.super()和this()只能出现在构造方法的第一行
- Super VS this：
1. 代表对象不同：
this： 调用本类的成员变量/成员方法/构造方法；
super：调用父类的成员变量/成员方法（但注意权限修饰符的影响，比如不能访问private成员）、以及调用父类的构造方法的访问（但只限构造方法中使用，且必须是第一条语句。）
2. 前提：
this：没继承也可以使用
super：只能在继承的前提条件下使用
3. 构造方法不同：
this：本类的构造
super：父类的构造
重写：需要有继承的关系，子类继承父类的方法！
* 重写都是方法的重写，和属性无关
* //A是子类，B是父类。父类B的引用指向子类A1.方法名必须相同、参数列表必须相同 2.子类不可以重写父类中的私有方法(private) 3.修饰符：子类的修饰符访问权限不可以低于父类的修饰符的访问权限(范围可以扩大：public > protect > default > private) 4.重写可能抛出异常：范围，可以缩小，但不能扩大；ClassNotFoundException -->Exception(大) - super注意：
-
重写，子类的方法和父类要一致：方法体不同！
-
为什么需要重写：父类的功能，子类不一定需要，或者不一定满足；
-
快捷键：Alt + Insert，然后选中overside;
方法重写 VS 方法重载（覆盖）:
| 区别 | 重写 | 重载 |
|---|---|---|
| 英文： | override | overload |
| 位置不同： | 同一个类中 | 子类和父类间 |
| 作用不同： | 在一个类里面为一种行为提供多种实现方式并提高可读性 | 父类方法无法满足子类的要求，子类通过方法重写满足要求 |
| 修饰符： | 无关 | 大于等于 |
| 返回值： | 无关 | 小于等于 |
| 方法名： | 相同 | 相同 |
| 参数： | 不同 | 相同 |
| 抛出异常： | 无关 | 小于等于 |
public class Animals {
private String name;
private int age;
public Animals() {
}
public Animals(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Cat extends Animals {
public Cat() {
}
public Cat(String name, int age) {
super(name, age);
}
public void catchMouse(){
System.out.println("开始抓老鼠！");
}
}
public class Dog extends Animals {
public Dog() {
}
public Dog(String name, int age) {
super(name, age);
}
public void lookDoor(){
System.out.println("狗开始看门！");
}
}
/*
继承
*/
public class Test {
public static void main(String[] args) {
Cat cat = new Cat();
cat.setName("汤姆");
cat.setAge(3);
System.out.println(cat.getName()+","+cat.getAge());
cat.catchMouse();
Dog dog = new Dog("小黑",5);
System.out.println(dog.getName()+","+dog.getAge());
dog.lookDoor();
}
}
三、多态：
即同一方法可以根据发送对象的不同而采用多种不同的行为方式
- 一个对象的实际类型是确定的，但可以指向对象的引用的类型很多
- 动态编译：类型：可扩展性
- 多态的注意事项：
1.多态是方法的多态，属性没有多态
2.父类和子类，有联系 类型转换异常！ ClassCastException!
3.存在条件：继承关系，方法需要重写，父类引用指向子类对象！ father f1 = new Son(); - 不能重写：
1. static方法，静态方法，属于类，它不属于实例；
2. final常量，常量池里的，无法修改，不能重写；
3. private方法； - 多态的好处和弊端：
**好处：**提高了程序的扩展性。具体体现：，定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作；
**弊端：**不能使用子类的特有功能(使用向上/下转型)。
public class Animal {
public int age = 40;
public void eat(){
System.out.println("动物吃东西~");
}
}
public class Cat extends Animal { //多态条件一 ： 继承
public int age = 20;
public int weight = 10;
@Override //多态条件二 ： 重写
public void eat() {
System.out.println("猫爱吃鱼！");
}
public void playGame(){
System.out.println("猫捉迷藏！");
}
}
public class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗爱吃骨头!");
}
}
public class AnimalOperator {
public void useAnimal(Animal a){
a.eat();
}
}
public class AnimalDemo {
public static void main(String[] args) {
/*
// 多态条件三 ： 用父类引用子类对象
Animal a = new Cat();//多态的形式创建的对象
System.out.println(a.age); //结果输出：40
// System.out.println(a.weight); //报错，Animals中没有weight
a.eat(); // 结果输出：猫吃鱼
// a.playGame(); //报错，Animals中没有playGame()
*/
//创建动物操作类的对象，调用方法
AnimalOperator ao = new AnimalOperator();
Cat c = new Cat();
ao.useAnimal(c);
Dog d = new Dog();
ao.useAnimal(d);
}
}
/*
Animals a = new Cat();//多态的形式创建的对象
多态的形式访问成员变量：编译看左边（父类Animals），运行看左边（父类Animals）
多态的形式访问成员方法：编译看左边（父类Animals），运行看右边（子类Cat）
*/