java面向对象三大特征

 

免责声明：java基础资料均来自于韩顺平老师的《循序渐进学Java零基础》教案，具体视频内容可以去B站观看，这些资料仅用于学习交流，不得转载用于商业活动

1.Java面向对象三大特征

Java面向对象编程有三大特征：封装、继承、多态

1.1 封装

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

封装的理解和好处

1）隐藏实现细节：方法(连接数据库)<---d调用(传入参数...)

2）可以对数据进行验证，保证安全合理

1.1.1 封装的实现步骤(三步)

1）将属性进行私有化private【不能直接修改属性】

2）提供一个公共的(public)set方法，用于对属性判断并赋值

   　public void setXxx(类型 参数名){ //Xxx表示某个属性

　　　　//加入数据验证的业务逻辑

　　　　属性=参数名；

　　}

3）提供一个公共的(public)get方法，用于获取属性的值

　　public 数据类型 getXxx(){ //权限判断，Xxx某个属性

　　　　return xx;

      }

public class Encapsulation01 {
    public static void main(String[] args) {
        Person person=new Person();
        person.setName("张三");
        person.setAge(30);
        person.setSalary(3000);
        System.out.println(person.info());
        ;
        System.out.println(person.getSalary());

        System.out.println("=====p的信息=====");
        //自己使用构造器指定属性
        Person p=new Person("p",180,50000);

        System.out.println(p.info());
    }
}

class Person{
    public String name; //名字公开
    private int age; //age 私有化
    private double salary;

    public void say(int n,String name){

    }

    //构造器
    public Person(){

    }

    //三个属性构造器
    public Person(String name,int age,double salary){
       // this.name=name;
       // this.age=age;
       // this.salary=salary;

        //我们可以将set方法卸载构造器中，这样任然可以验证
        setName(name);
        setAge(age);
        setSalary(salary);
    }

    public void setName(String name){
        //加入对数据的校验，相当于增加了业务逻辑
        if(name.length()>=2 && name.length()<=20){
            this.name=name;
        }else {
            System.out.println("名字的长度不对，需要（2-6）个字符，默认名字");
            this.name="无名人";
        }

    }

    public String getName(){
        return name;
    }

    public void setAge(int age){
        //判断
        if(age>=1 && age<=120){//如果是合理范围
            this.age=age;
        }else{
            System.out.println("您设置的年龄不对，需要在（1-120），给默认年龄18");
            this.age=18;
        }
    }

    public int getAge(){
        return age;
    }

    public void setSalary(double salary){
        this.salary=salary;
    }

    public double getSalary(){
        return salary;
    }

    //写一个方法，返回属性信息
    public String info(){
        return "信息为 name="+name+" age="+age+"  薪水="+salary;
    }
}

1.2 继承

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

 1.2.1 继承的基本语法

class 子类 extends 父类{

}

1）子类就会自动拥有父类定义的属性和方法

2）父类又叫超类，基类

3）子类又叫派生类

//父类,是Pupil和Graduate的父类
public class Student {
    //共有属性
    public String name;
    public int age;
    private  double score;//成绩
    //共有方法
    public void setScore(double score){
        this.score=score;
    }

    public void showInfo(){
        System.out.println("学生名"+name+" 年龄"+age+" 成绩"+score);
    }
}


public class Graduate extends Student{//和Pupil不一样
    public void testing(){
        System.out.println("大学生"+name+"正在考大学数学...");
    }
}


public class Pupil extends Student{
    public void testing(){
        System.out.println("小学生"+name+" 正在考小学数学..");
    }
}


public class Extends01 {
    public static void main(String[] args) {
        Pupil pupil=new Pupil();
        pupil.name="王舞";
        pupil.age=10;
        pupil.testing();
        pupil.setScore(80);
        pupil.showInfo();

        System.out.println("========");
        Graduate graduate=new Graduate();
        graduate.name="李四";
        graduate.age=22;
        graduate.testing();;
        graduate.setScore(89.5);
        graduate.showInfo();
    }
}

 继承给变成带来的便利
1）代码的复用性提高了

2）代码的扩展性和维护性提高了

1.2.2 继承的深入讨论

1. 子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问，但是私有属性和方法不能在子类直接访问，要通过父类提供公共的方法去访问
2. 子类必须调用父类的构造器，完成父类的初始化
3. 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过
4. 如果希望指定去调用父类的某个构造器，则显式调用一下：super(参数列表)
5. super在使用时，必须放在构造器第一行（super只能在构造器中使用）
6. super()和this()都只能放在构造器第一行，因此这两个方法不能共存在一个构造器
7. Java所有类都是Object类的子类，Object是所有类的基类
8. 父类构造器的调用不限于直接父类！将一直往上追溯直到Object类(顶级父类)
9. 子类最多只能继承一个父类（指直接继承），即Java中是单继承机制
10. 不能滥用继承，子类和父类之间必须满足is-a的逻辑关系

public class TopBase {//父类是Object

    public TopBase(){
        //super(); Object的无参构造器
        System.out.println("构造器ToBase()被调用...");
    }
}

public class Base  extends TopBase{ //父类
    //4个属性
    public int n1=100;
    protected int n2=200;
    int n3=300;
    private  int n4=400;

    public Base(){//无参构造
        System.out.println("父类Base()构造器被调用...");
    }

    public Base(String name,int age){//有参构造器
        //默认super()
        System.out.println("父类Base(String name,int age)构造器被调用...");
    }

    public Base(String name){
        System.out.println("父类Base(String name)构造器被调用...");
    }

    //父类提供一个public的方法，返回了n4
    public int getN4(){
        return n4;
    }

    public void test100(){
        System.out.println("test100");
    }

    protected void test200(){
        System.out.println("test200");
    }

    void test300(){
        System.out.println("test300");
    }

    private void test400(){
        System.out.println("test400");
    }

    //call
    public void callTest400(){
        test400();
    }
}

public class Sub extends Base{ //子类
    public Sub(String name,int age){
        //调用父类的无参构造器，如下，或者不写 ，默认就是调用super()
        //super(); //父类的无参构造器
        //调用父类的Base(String name)构造器
        //super("zs");
        //调用父类的Base(String name,int age)构造器
        super("张三",20);

        //细节：super在使用时，必须放在构造器第一行
        //细节：super()和this()都只能放在构造器第一行，因此这两个方法不能共存在一个构造器中
        //this() //不能再使用了
        System.out.println("子类Sub(String name,int age)构造器被调用...");
    }

    public Sub(){//无参构造器
        //super();//默认调用父类的无参构造器
        super("smith",10);
        System.out.println("子类Sub()构造器被调用");
    }

    //当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器
    public Sub(String name){
        super("tom",30);
        System.out.println("子类Sub(String name)构造器被调用...");
    }

    public void sayOk(){//子类方法
        //非私有的属性和方法可以再子类直接访问
        //但是私有属性和方法不能在子类直接访问
        System.out.println(n1+" "+n2+" "+n3);
        test100();
        test200();
        test300();
        //test400(); //错误
        //要通过父类提供公共的方法去访问
        System.out.println("n4="+getN4());
        callTest400();
    }
}


public class ExtendsDetail {
    public static void main(String[] args) {
        System.out.println("===第一个对象===");
        Sub sub=new Sub();//创建了子类对象sub
        System.out.println("===第二个对象===");
        Sub sub2=new Sub("jack");//创建了子类对象sub2
        System.out.println("===第三个对象===");
        Sub sub3=new Sub("王五",10);//创建了子类对象sub3
        sub3.sayOk();
    }
}

1.2.3 继承的本质分析（重要）

使用一个案例来分析当子类继承父类，创建子类对象时，内存中到底发生了什么？

提示：当子类对象创建好后，建立查找的关系

public class ExtendsTheory {
    public static void main(String[] args) {
        Son son=new Son();//内存的布局
        /**
         * ->这时请大家注意，要按照查找关系来返回信息
         * （1）首先看子类是否有该属性
         * （2）如果子类有这个属性，并且可以访问，则返回信息
         * （3） 如果子类没有这个属性，就看父类有没有这个属性（如果父类有该属性，并且可以访问，就返回信息...）
         *  (4) 如果父类没有就按照（3）的规则，继续找上级父类，直到Object...
         */
        System.out.println(son.name);//返回就是大头儿子
        System.out.println(son.getAge());//返回的就是39
        System.out.println(son.hobby);//返回的就是旅游
    }
}

class GrandPa{//爷爷类
    String name="大头爷爷";
    String hobby="旅游";
}

class Father extends GrandPa{ //父类
    String name="大头爸爸";
    private int age=39;
    
    public int getAge(){
        return age;
    }
    
}

class Son extends Father{//子类
    String name="大头儿子";
}

1.2.4 子类创建的内存布局

 1.3 super关键字

基本介绍

super代表父类的引用,用于访问父类的属性 、方法、构造器

基本语法

• 访问父类的属性，但不能访问父类的private 属性。 super.属性名；
• 访问父类的方法，但不能访问父类的private方法。 super.方法名(参数列表)
• 访问父类的构造器 。 super(参数列表)；只能放在构造器的第一句，只能出现一句

 

public class Base {//父类是Object
    public int n1=999;
    public int age=111;

    public void cal(){
        System.out.println("Base类的cal()方法...");
    }
    public void eat(){
        System.out.println("Base类的eat()方法...");
    }
}

public class A extends Base{
    //4个属性
    public int n1=100;
    protected int n2=200;
    int n3=300;
    private int n4=400;

    public A(){

    }
    public A (String name){

    }

    public A(String name,int age){

    }

    public void cal(){
        System.out.println("A类的cal()方法...");
    }

    public void test100(){
        System.out.println("A类的test100()方法...");
    }

    protected void test200(){
        System.out.println("A类的test200()方法...");
    }

    void test300(){
        System.out.println("A类的test300()方法...");
    }

    private void test400(){
        System.out.println("A类的test400()方法...");
    }
}

public class B extends A{
    public int n1=888;

    //编写测试方法
    public void test(){
        //super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员
        //如果多个基类（上级类）中都有同名的成员，使用super访问遵循就近原则。A->B->C
        System.out.println("super.n1="+super.n1);
        super.cal();
    }

    //访问父类的属性，但不能访问父类的private属性 super.属性名
    public void hi(){
        System.out.println(super.n1+" "+super.n2+" "+super.n3);
    }

    public void cal(){
        System.out.println("B类中的cal()方法...");
    }

    public void sum(){
        System.out.println("B类的sum()");
        //希望调用父类-A的cal方法
        //这时，因为子类B没有cal方法，因此我们可以使用下面三种方式
        //找到cal方法时（cal()和this.cal()）,顺序是：
        //（1）先找本类，如果有，则调用
        //（2）如果没有，则找父类（如果有，并可以调用，则调用）
        //（3）如果父类没有，则继续找父类的父类，整个规则，就是一样的，直到Object类
        //提示：如果查找方法的过程中，找到了，但是不能当问，则报错，cannout access
        //如果查找方法的过程中，没有找到，则提示方法不存在
        cal();
        this.cal();//等价cal()

        //找到cal方法（super.cal()）的顺序是直接查找父类，其他的规则一样
        super.cal();

        //演示访问属性的规则
        /***
         * n1和this.n1查找的规则是
         * （1）先找本类，如果有，则调用
         * （2）如果没有，则找父类（如果有，并且可以调用，则调用）
         * （3）如果父类没有，则继续找父类的父类，整个规则，就是一样的，直到Object类
         * 提示：如果查找属性的过程中，找到了，但是不能访问，则报错，cannot access
         *      如果查找属性的过程中，没有找到，则提示属性不存在
         */
        System.out.println(n1);
        System.out.println(this.n1);
        // 找n1（super.n1）的顺序是直接查找父类属性，其他的规则一样
        System.out.println(super.n1);
    }

    //访问父类的方法，不能访问父类的private方法super.方法名(参数列表)；
    public void ok(){
        super.test100();
        super.test200();
        super.test300();
        //super.test400();//不能访问父类的private方法
    }
    //访问父类的构造器super(参数列表)；只能放在构造器的第一句，只能出现一句。
    public B(){
        //super();
        //super("jack",10)
        super("jack");
    }
}

public class Super01 {
    public static void main(String[] args){
        B b=new B();//子类对象
        b.sum();
        b.test();
        b.ok();
    }
}

1.3.1 super给编程带来的便利/细节

1. 调用父类的构造器的好处（分工明确，父类属性由父类初始化，子类属性由子类初始化）
2. 当子类中有和父类中的成员（属性和方法）重名时，为了访问父类的成员，必须通过super。如果没有重名，使用super、this、直接访问是一样的效果
3. super的不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员；如果多个基类（上级类）中有同名的成员，使用super访问遵循就近原则A->B->C,当然也需要遵守访问权限的相关规则

1.3.2 super和this的比较

1.4 方法重写/覆盖（override）

1.4.1 基本介绍

简单的说：方法重写（覆盖）就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法重写（覆盖）了父类的方法

public class Animal {
    public void cry() {
        System.out.println("动物叫唤");
    }

    public Object m1(){
        return null;
    }

    public String m2(){
        return null;
    }

    public AAA m3()
    {
        return null;
    }

    protected void eat()
    {

    }
}

class AAA
{


}

class BBB extends AAA
{

Dog.java

public class Dog {
    //1.因为Dog是Animal子类
    //2.Dog的cry方法和Animal的cry定义形式一样（名称、返回类型、参数）
    //3.这时我们就说Dog的cry方法，重写了Animal的cry方法
    public void cry()
    {
        System.out.println("小狗汪汪叫..");
    }

    //细节：子类方法的返回类型和父类方法返回类型一样
    //或者是父类返回类型的子类
    //比如父类返回类型是Object
    //子类返回类型是String
    public String m1()
    {
        return null;
    }

    //这里Object不是String 因此编译错误
//    public Object m2()
//    {
//        return null;
//    }

    public BBB m3()
    {
        return null;
    }

    //细节：子类方法不能缩小父类方法的访问权限
    //public > protected > 默认 > private
    public void eat()
    {

    }
}

Override01.java

public class Override01 {
    public static void main(String[] args)
    {
        //演示方法重写的情况
        Dog dog=new Dog();
        dog.cry();
    }
}

1.4.2 注意事项和使用细节

方法重写也叫方法覆盖，需要满足下面的条件

1. 子类的方法的形参列表、方法名称、要和父类方法的形参列表，方法名称完全一样
2. 子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类
   1. 比如父类返回类型是Object,子类方法返回类型是String
3. 子类方法不能缩小父类方法的访问权限

1.4.3 方法重写和方法重载的比较

1.5 多态

例子，请编写一个程序，Mster类中有一个 Feed(喂食)方法，可以完成主人给动物喂食的信息

 使用多态来解决这个问题

Animal.java

public class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Dog&Cat

public class Dog extends Animal{
    public Dog(String name)
    {
        super(name);
    }
}

public class Cat extends Animal{
    public Cat(String name)
    {
        super(name);
    }
}

Food.java

public class Food {
    private String name;

    public Food(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Bone&Fish

public class Bone extends Food{
    public Bone(String name)
    {
        super(name);
    }
}


public class Fish extends Food{
    public Fish(String name)
    {
        super(name);
    }
}

Master.java

public class Master {
    private String name;

    public Master(String name) {
        this.name = name;
    }

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    //使用多态机制，可以统一的管理主人卫视的问题
    //animal编译类型是Animal，可以指向（接收）Animal子类的对象
    //food编译类型是Food,可以指向（接收）Food子类的对象
    public void feed(Animal animal,Food food)
    {
        System.out.println("主人"+name+"给"+animal.getName()+"吃"+food.getName());
    }

    //主人给小狗喂食骨头
//    public void feed(Dog dog,Bone bone)
//    {
//        System.out.println("主人"+name+"给"+dog.getName()+"吃"+bone.getName());
//    }

    //主人给小猫喂黄花鱼
//    public void feed(Cat cat,Fish fish)
//    {
//        System.out.println("主人"+name+"给"+cat.getName()+"吃"+fish.getName());
//    }

    //如果动物很多，食物很多
    //===>feed方法很多，不利于管理和维护
    //Pig->Rice
    //Tiger->meat
    //...
}

 1.5.1 多【多种】态【状态】基本介绍

方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的

 1.5.2 多态的具体体现

方法的多态 PloyMethod.java

public class PloyMethod {
    public static void main(String [] args){
        //方法重载体现多态
        A a=new A();
        //这里我们传入不同的参数，就会调用不同sum方法，就体现多态
        System.out.println(a.sum(10,20));
        System.out.println(a.sum(10,20,30));

        //方法重写体现多态
        B b=new B();
        a.say();
        b.say();
    }
}

重写和重载就体现多态

public class B {
    public void say(){
        System.out.println("B say()方法被调用...");
    }
}

public class A extends B{
    public int sum(int n1,int n2){//和下面sum构成重载
        return n1 + n2;
    }
    public int sum(int n1,int n2,int n3){
        return n1 + n2 + n3;
    }

    public void say(){
        System.out.println("A say()方法被调用");
    }
}

对象的多态（核心，困难，重点）

• 一个对象的编译类型和运行类型可以不一致
• 编译类型在定义对象时，就确定了，不能改变
• 运行类型是可以变化的
• 编译类型看定义时=号的左边，运行类型看=的右边

父类子类

public class Animal {
    public void cry(){
        System.out.println("Animal cry() 动物在叫");
    }
}

public class Cat extends Animal{
    public void cry(){
        System.out.println("Cat cry()小猫喵喵叫...");
    }
}

public class Dog extends Animal{
    public void cry(){
        System.out.println("Dog cry() 小狗汪汪叫...");
    }
}

PloyObject.java

public class PloyObject {
    public static void main(String[] args){
        //体验对象多态特点
        //animal编译类型就是Animal,运行类型Dog
        Animal animal=new Dog();
        //因为运行时，执行到该行时，animal运行类型是Dog所以cry就是Dog的cry
        animal.cry();//小狗汪汪叫

        //animal编译类型Animal,运行类型就是Cat
        animal=new Cat();
        animal.cry();//小猫喵喵叫
    }
}

 

Animal animal=new Dog();

animal编译类型是Animal,运行类型Dog

animal =new Cat();

animal的运行类型变成了Cat，编译类型仍然是Animal

1.5.3 多态注意事项和细节

多态的前提是：两个对象（类）存在继承关系

多态的向上转型

1）本质：父类的引用指向了子类的对象

2）语法：父类类型 引用名称= new 子类类型();

3）特点：编译类型看左边，运行类型看右边

• 可以调用父类中的所有成员（需要遵守访问权限）
• 不能调用子类中特有成员；
• 最终运行效果看子类的具体实现

多态向下转型

2）语法：子类类型 引用名称= (子类类型) 父类引用;

• 只能强转父类的引用，不能强转父类的对象
• 要求父类的引用必须指向当前目标类型的对象
• 当向下转型后，可以调用子类类型中所有的成员

 父类子类

public class Animal {
    String name="动物";
    int age=10;

    public void sleep() {
        System.out.println("睡");
    }

    public void run()
    {
        System.out.println("跑");
    }

    public void eat(){
        System.out.println("吃");
    }

    public void show(){
        System.out.println("hello,你好");
    }
}


public class Cat extends Animal{
    public void eat(){//方法重写
        System.out.println("猫吃鱼");
    }

    public void catchMouse(){//Cat特有方法
        System.out.println("猫抓老鼠");
    }
}


public class Dog extends Animal{//Dog是Animal的子类
    public void guard(){
        System.out.println("狗看家守院");
    }
}

 PolyDetail.java

public class PolyDetail {
    public static void main(String[] args) {
        //向上转型：父类的引用指向了子类的对象
        //语法：父类类型 引用名 = new 子类类型();
        Animal animal = new Cat();
        Object obj = new Cat();//可以吗？可以Object也是Cat的父类

        //向上转型调用方法的规则如下
        //（1）可以调用父类中的所有成员（需要遵守访问权限）
        //（2）但是不能调用子类特有的成员
        //（#）因为在编译阶段，能调用哪些成员，由编译类型来决定
        //animal.catchMouse();//错误
        //（4）最终运行效果看子类（运行类型）的具体实现，即调用方法时，
        // 按照从子类（运行类型）开始查找方法，然后调用
        animal.eat();//猫吃鱼...
        animal.run();//跑
        animal.show();//hello,你好
        animal.sleep();//睡

        //如果希望可以调用Cat的catchMouse方法
        //多态的向下转型
        //(1)语法：子类类型 引用名 = (子类类型)父类引用;
        //cat的编译类型是Cat,运行类型是Cat
        Cat cat = (Cat) animal;
        cat.catchMouse();//猫抓老鼠
        //（2）要求父类的引用必须指向的是当前目标类型的对象
        //Dog dog = (Dog) animal;//不行 会报错
        //dog.guard();
    }
}

属性没有重写之说，属性的值看编译类型

public class Base {
    int count = 10;//属性
}

class Sub extends Base{
    int count=20;
}

public class PloyDetail02 {
    public static void main(String[] args){
        //属性没有重写之说！属性的值看编译类型
        Base base=new Sub();//向上转型
        System.out.println(base.count);//看编译类型10
        Sub sub=new Sub();
        System.out.println(sub.count);//20
    }
}

instanceOf比较操作符

instanceOf用于判断对象的运行类型是否为XX类型或XX类型的子类

public class PolyDetail03 {
    public static void main(String[] args) {
        BB bb = new BB();
        System.out.println(bb instanceof BB);//true
        System.out.println(bb instanceof AA);//true

        //aa编译类型AA，运行类型BB
        //BB是AA子类
        AA aa = new BB();
        System.out.println(aa instanceof AA);//true
        System.out.println(aa instanceof BB);//true
        
        Object obj=new Object();
        System.out.println(obj instanceof AA);//false;
        String str = "hello";
        //System.out.println(str instanceof AA);
        System.out.println(str instanceof Object); //true
    }
}

class AA{}

class BB extends AA{}

1.5.4 java的动态绑定机制（非常非常重要）

Java重要特性：动态绑定机制

public class DynamicBinding {
    public static void main(String[] args) {
        //a的编译类型是A，运行类型是B
        A a = new B();//向上转型
        System.out.println(a.sum());//40->30
        System.out.println(a.sum1());//30->20

    }
}

class A {
    public int i = 10;
    //动态绑定机制

    public int sum(){
        return getI() + 10;//20+10
    }

    public int sum1(){
        return i + 10;//10+10;
    }

    public int getI(){
        return i;
    }
}

class B extends A{
    public int i = 20;

//    public int sum(){
//        return i + 20;
//    }

    public int getI(){
        return i;
    }

//    public int sum1(){
//        return i + 10;
//    }
}

Java的动态绑定机制

当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定

当调用对象属性时，没有动态绑定机制，哪里声明哪里使用

1.5.5 多态的应用

多态数组

数组的定义类型为父类类型，里面保存的实际元素类型为子类类型

public class Person {
    private String name;
    private int age;

    public Person(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 String say(){
        return name + "\t" + age;
    }
}

Student.java

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;
    }

    //重写父类say
    @Override
    public String say(){
        return "学生 "  + super.say() + "score=" + score;
    }

    //特有方法
    public void study(){
        System.out.println("学生 " + getName() + " 正在学java...");
    }
}

Teacher.java

public class Teacher extends Person{
    private double salary;

    public Teacher(String name,int age,double salary){
        super(name,age);
        this.salary = salary;
    }

    public double getSalary(){
        return salary;
    }

    public void setSalary(double salary){
        this.salary = salary;
    }

    //重写父类的say方法
    @Override
    public String say(){
        return "老师 " + super.say() + " salary=" + salary;
    }

    //特有方法
    public void teach(){
        System.out.println("老师 " + getName() + "正在讲java课程...");
    }
}

PloyArray.java

public class PloyArray {
    public static void main(String[] args) {
        //应用示例：现有一个继承结构如下：要求创建1个Person对象
        //2个Student对象和2个Teacher对象，统一放在数组中，并调用每个对象say方法
        Person [] persons = new Person[5];
        persons[0] = new Person("jack",20);
        persons[1] = new Student("mary",18,100);
        persons[2] = new Student("smith",19,87.5);
        persons[3] = new Teacher("scott",30,20000);
        persons[4] = new Teacher("king",50,25000);

        //循环遍历多态数组，调用say
        for(int i = 0;i < persons.length;i++){
            //person[i]编译类型是Person,运行类型是根据实际情况由JVM来判断
            System.out.println(persons[i].say());//动态绑定机制
            //使用类型判断 + 向下转型
            if(persons[i] instanceof Student){//判断person[1]的运行类型是不是Student
                Student student = (Student) persons[i];//向下转型
                student.study();
                //也可以使用一条语句((Student)persons[i].study())
            }else if(persons[i] instanceof Teacher){
                Teacher teacher=(Teacher) persons[i];
                teacher.teach();
            }else if(persons[i] instanceof Person){
                System.out.println(persons[i].say());
            }else {
                System.out.println("你的类型有误，请检查...");
            }
        }
    }

多态参数

 方法定义的形参类型为父类类型，实参类型允许为子类类型

Employee.java

public class Employee {
    private String name;
    private double salary;

    public Employee(String name,double salary){
        this.name = name;
        this.salary = salary;
    }

    //得到年工资的方法
    public double getAnnual(){
        return  12 * salary;
    }

    public String getName(){
        return name;
    }

    public void setName(String name){
        this.name = name;
    }

    public double getSalary(){
        return salary;
    }

    public void setSalary(double salary){
        this.salary = salary;
    }
}

Manage.java

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() + " is managing");
    }

    //重写获取年薪方法
    @Override
    public double getAnnual(){
        return super.getAnnual() + bonus;
    }
}

Worker.java

public class Worker extends Employee{
    public Worker(String name,double salary){
        super(name,salary);
    }

    public void work(){
        System.out.println("普通员工 " + getName() +"is working");
    }

    @Override
    public double getAnnual(){//因为普通员工没有其他输入，则直接调用父类方法
        return super.getAnnual();
    }
}

PloyParameter.java

public class PloyParameter {
    public static void main(String[] args){
        Worker tom = new Worker("tom",3500);
        Manager milan=new Manager("milan",5000,200000);
        PloyParameter ployParameter=new PloyParameter();
        ployParameter.showEmpAnnual(tom);
        ployParameter.showEmpAnnual(milan);

        ployParameter.testWork(tom);
        ployParameter.testWork(milan);
    }


    //showEmpAnnual(Employee e)
    //实现获取任何员工对象的年工资，并在main方法中调用该方法[e.getAnnual()]
    public void showEmpAnnual(Employee e){
        System.out.println(e.getAnnual());//动态绑定机制
    }

    //添加一个方法，testWork，如果是普通员工，则调用work，如果是经理，则调用manage方法
    public void testWork(Employee e){
        if (e instanceof Worker){
            ((Worker)e).work();//有向下转型操作
        }else if(e instanceof Manager){
            ((Manager) e).manage();
        }else {
            System.out.println("不做处理");
        }
    }
}