[Java面向对象]封装继承多态

封装、继承和多态是面向对象编程的三大特征。

封装

封装概念

封装就是把抽象出的数据（属性）和对数据的操作（方法）封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的操作（方法）才能对数据进行操作。

封装的好处

1. 隐藏实现的细节
   一个操作具体的实现过程往往很复杂，通过封装用户和调用者可以直接使用提供的方法进行操作，不用关心其实现细节。

2. 可以对数据进行验证，保证其安全合理
   进行封装后，私有化类的成员变量，类中的实例变量不能直接进行查看和修改，用户需要通过提供的getter和setter方法才能操作，在方法中可以对用户输入的数据进行验证，从而控制数据的范围。

封装的实现步骤

将属性进行私有化private （不能直接修改属性）
提供公共的setter方法，用于对属性判断并赋值
提供公共的getter方法，用于获取属性的值

class person{private String name;//私有化,不能直接操作private int age;    //通过getter方法得到数据信息public String getName(){return name;}public int getAge(){return age;}//通过setter方法设置属性public void setName(String name){this.name = name;}public void setAge(int age){if (age < 1 || age > 150){//对数据进行验证，保证其在合理的范围内System.out.println("年龄需要在1~150之内~");}this.age = age;}}

继承

继承概念

继承可以提高代码的复用性，让编程更加靠近人类思维。当多个类存在相同的属性（变量）和方法时，可以从这些类中抽象出父类，在父类中定义相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends关键字来声明继承父类即可。

在子类中也可以重写父类的方法，这样子类在调用该方法时执行的是重写后的方法。

public class test {public static void main(String[] args) {cat cat = new cat();cat.speak();}}class Animal {//父类public void speak(){System.out.println("动物会叫~");}}class cat extends Animal{//子类@Overridepublic void speak() {//重写父类的speak（）方法System.out.println("喵喵~");}}

继承的好处

代码的复用性提高了
代码的扩展性和维护性提高了

子类对象实例化过程

1.从结果上来看：
继承性，子类继承父类以后就获取了父类中声明的属性或方法，创建子类对象后，在堆空间中就会加载所有父类中声明的属性。
2.从过程上来看：
当通过子类的构造器创建子类对象时，一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器，直到调用了java.lang.Object类中空参的构造器为止。正因为加载过所有的父类的结构，所以才可以看到内存中有父类的结构，子类对象才可以考虑进行调用。

多态

多态基本介绍

一个方法或者对象具有多种形态（多态是建立在封装和继承的基础之上的）；父类的引用指向子类的对象；允许不同类的对象对同一消息作出响应。不同对象调用相同方法即使参数也相同，最终表现行为是不一样的。

多态的具体体现

1. 方法的多态
   重写和重载

重载在方法调用之前，编译器就确定了要调用的具体的方法，称为静态绑定
对于多态而言，只有等到方法调用的那一刻解释运行器才会确定要调用的具体方法，称为动态绑定

public class test {public static void main(String[] args) {A a = new A();//通过不同的参数来调用a的sum（）方法，就是调用的不同方法,体现方法的多态System.out.println(a.sum(1,2));System.out.println(a.sum(1,2,3));B b = new B();//根据不同的对象调用say()方法，会调用不同的方法a.say();b.say();}
}class A {public int sum(int num1,int num2){return num1 + num2;}public int sum(int num1,int num2,int num3){//sum（）方法的重载return num1 + num2 + num3；}public void say(){System.out.println("这是A的say()方法~")；}
}class B extends A{//子类@Overridepublic void say(){//重写父类的say()方法System.out.println("这是B的say()方法~")；}
}

对象的多态（多态的核心）

一个对象的编译类型和运行类型可以不一致
在编译期只能调用父类中声明的方法，运行期实际执行的是子类中重写的方法
编译类型是定义对象时就确定的，不能改变
运行类型是可以变化的

Animal animal = new Dog();
//编译类型是Animal,而运行类型是Dog(向上转型)
animal = new Cat();
//编译类型还是Animal，运行类型变成了Cat
对象的多态在使用时需注意：

前提：两个对象存在继承关系
本质：父类的引用指向了子类的对象
虚拟方法调用：向上转型后调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法，此时父类的方法叫做虚拟方法
向上转型后内存中实际是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时只能调用父类中声明的属性和方法，不能使用子类的特有成员（可以使用强制转换进行向下转型）
动态绑定机制 ：
当调用对象方法的时候，该方法会和该对象的运行类型绑定
当调用对象属性的时候，没有绑定，哪里声明，哪里使用（看编译类型）

对象的多态的应用

1. 多态数组
   数组的定义类型为父类类型，里面保存的实际类型为子类类型

class Person{}
class student extends{}
class teacher extends{}class text{public static void main(String[] args){Person[] persons = new Person[3];person[1] = new Person();//编译类型为父类Person，运行类型为子类person[2] = new studet();person[3] = new teacher();}
}

2. 多态参数
   方法定义的形参类型为父类1类型，实参类型允许为子类类型

class Employee{}class Worker extends Employee{}
class Manager extends Employee{}
class master{public static void salary(Employee e){}
}class text{public static void main(String[] args){Worker worker = new Worker();Manager manager = new Manager();//形参为父类，可传入子类的对象master.salary(worker);master.salary(manager);}
}