封装、继承、多态

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 关键字

1. 调用父类构造器，分工明确，父类属性由父类初始化，字类属性由字类初始化，
2. 当字类中有和父类中的成员（属性和方法）重名时，为了访问父类的成员，必须通过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方法，字类可以重写该方法，做一些释放资源的操作