1. 封装
封装就是把抽象出的数据[属性]和对数据的操作[方法]封装在一起，数据被保护在内部，程序的其他部分只有通过
被授权的操作[方法]，才能对数据进行操作。
1.1 封装实现的步骤
1）将属性私有化【不能直接修改属性】
2）提供一个公共的set方法，用于对属性的判断及赋值
3）提供一个公共的get方法，用于获取属性的值
// 封装的基本构成
package com.test;
public class Encapsulation {
public static void main(String[] args) {
Person person = new Person();
person.setName("Jack");
System.out.println(person.info());
}
}
class Person {
public String name;
private int age;
private double salary;
public Person() {
}
public Person(String name, int age, double salary) {
this.setName(name);
this.setAge(age);
this.setSalary(salary);
}
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 double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public String info() {
return "信息为:name=" + name + "age=" + age + "salary=" + salary;
}
}
2. 继承
继承可以解决代码复用，让我们的编程更加靠近人类思维，当多个类存在相同属性(变量)，和方法时，可以从这些类中抽出父类，在夫类中定义这些相同的属性和方法，所有的字类不需要重新定义这些属性和方法，只需要
extends来声明继承父类即可。
2.1 创建子类对象时 父类构造器会被调用
当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有无参构造器，则必须在子类的构造器中用
super去指定使用父类的哪个构造器完成对父类的初始化工作，否则编译无法通过
2.2 super 关键字
- 调用父类构造器，分工明确，父类属性由父类初始化，字类属性由字类初始化，
- 当字类中有和父类中的成员（属性和方法）重名时，为了访问父类的成员，必须通过super，如果没有重名，使用super，this，直接访问时一样的效果
3. 多态
(1 一个对象的编译类型和运行类型可以不一致。
（2 编译类型在定义对象时就确定了不能改变。
（3 运行类型是可以改变的。编译类型看定义时 = 号的左边，运行类型看 = 号的右边
父类对象的引用可以指向字类
3.1 多态的前提
两个对象存在继承关系；多态的向上转型.
Animal animal = new Cat() 父类引用指向字类对象，animal可以调用父类中国的所有成员，但是不能调用字类的特有成员（cat类中的特有属性方法）
向上转型：编译时 按照编译类型来定义，自身类不能调用字类方法，运行时属于运行类型，符合继承的就近原则规则，可以访问到字类中重写了父类的方法。
向下转型：字类类型 引用名 = （字类类型）父类引用；当向下转型后，就可以调用字类类型中的所有成员。Cat cat = (Cat) animal; 可以调用字类的特有成员
访问属性 看 编译类型
访问方法 看 运行类型
3.2 动态绑定机制
当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定；（方法永远从运行类型对象开始查找）
当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用；
3.3 多态数组
实现 讲一个person类、两个学生类、两个老师类放入数组并执行say方法；分别执行对象的私有方法。
public class PloyArray {
public static void main(String[] args) {
Person[] persons = new Person[5];
persons[0] = new Person("jack", 20);
persons[1] = new Student("andy",18,100);
persons[2] = new Student("smith",19,40);
persons[3] = new Teacher("scout",30,10000);
persons[4] = new Teacher("angela",40,12000);
for (int i = 0; i < persons.length; i++) {
System.out.println(persons[i].say());
if(persons[i] instanceof Student){ // 判断运行类型是否是学生
((Student) persons[i]).stady(); // 向下转型
}
if(persons[i] instanceof Teacher){ // 判断运行类型是否是老师
((Teacher) persons[i]).teach(); // 向下转型
}
}
}
}
// 学生类
package com.cuname;
public class Student extends Person{
private double score;
public Student(String name, int age, double score) {
super(name, age);
this.score = score;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
@Override
public String say() {
return "学生 " + super.say() + " score=" + score;
}
public void stady(){
System.out.println("学生" + getName() + " 正在学java");
}
}
// 输出：
jack 20
学生 andy 18 score=100.0
学生andy 正在学java
学生 smith 19 score=40.0
学生smith 正在学java
老师 scout 30 salary=10000.0
老师scout正在讲Java
老师 angela 40 salary=12000.0
老师angela正在讲Java
3.4 多态参数
package com.poly;
public class PolyParmeter {
public static void main(String[] args) {
Worker work = new Worker("小王",6000);
Manager manager = new Manager("jack",6500,20000);
PolyParmeter polyParmeter = new PolyParmeter();
polyParmeter.showEmpAnnual(work);
polyParmeter.showEmpAnnual(manager);
polyParmeter.TestWork(work);
polyParmeter.TestWork(manager);
}
public void showEmpAnnual(Employee e){
System.out.println(e.getAnnual());
}
public void TestWork(Employee e){
if(e instanceof Worker){
((Worker) e).work();
}
if(e instanceof Manager){
((Manager) e).manage();
}
}
}
// 经理类
package com.poly;
public class Manager extends Employee{
private double bonus;
public Manager(String name, double salary, double bonus) {
super(name, salary);
this.bonus = bonus;
}
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
public void manage(){
System.out.println("经理" + getName() + "正在管理员工");
}
@Override
public double getAnnual() {
return super.getAnnual() + bonus;
}
}
4. equals
是object类中的方法，只能判断引用类型
5. finalize 方法
当对象被回收时，系统自动调用该对象的finalize方法，字类可以重写该方法，做一些释放资源的操作
