面向对象之多态

多态

概述
	一个事物的多种形态
	举例：
    	1.猫可以是猫的类型 Cat cat = new Cat();
    	2.猫可以是动物的类型 Animal animal = new Cat();
前提
	需要存在继承
	需要方法重写 没有方法重写代码不会报错 但是会没有意义
	需要父类的引用指向子类 父类名 fu = new 子类名();
成员特点
	1.成员变量
		编译看左边 运行也看左边
    2.构造方法
    	创建子类对象时 会访问父类的构造方法 对父类的数据进行初始化
    3.成员方法
    	编译看左边 运行看右边
    4.静态方法
    	编译看左边 运行也看左边
    	静态和类是相关的
好处
	提高了代码的复用性(继承保证)
	提高了代码的扩展性(多态保证)
弊端
	不能直接使用子类的特有方法
	需要向下转型来解决
格式
	以猫类和动物类举例
	向上转型 Animal animal = new Cat();
	向下转型 Cat cat = (Cat) animal;

---

多态例题

孔子装爹

孔子爹会讲java 孔子会讲论语
赵三来找孔子爹学习java 李四也来找孔子爹来学习java
孔子爹给赵三教java 孔子只能假扮孔子爹去给李四教java

public class MyTest {
    public static void main(String[] args) {
        //向上转型 孔子假扮孔子爹
        KongZiFu fu = new KongZi();
        //孔子的外表跟他爹一样
        System.out.println(fu.age);//60
        //这里不能调用孔子的特有方法
        fu.teach();

        //向下转型 孔子卸妆了
        KongZi zi = (KongZi) fu;
        //孔子变回自己了
        System.out.println(zi.age);//30
        //解决了不能调用子类特有方法
        zi.pretendToBe();
    }
}
/*
60
教论语
30
孔子装爹
*/

public class KongZiFu {
    int age = 60;

    public void teach(){
        System.out.println("教Java");
    }
}

public class KongZi extends KongZiFu{
    int age = 30;

    //重写了父类的teach()方法
    @Override
    public void teach() {
        System.out.println("教论语");
    }
    //孔子特有方法 pretendToBe(假扮)方法 需要通过向下转型来调用
    public void pretendToBe(){
        System.out.println("孔子装爹");
    }
}

判断程序1

class Fu {
		public void show() {
			System.out.println("fu show");
		}
	}

class Zi extends Fu {
    public void show() {
        System.out.println("zi show");
    }

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

class DuoTaiTest3 {
    public static void main(String[] args){
        Fu f = new Zi();
        f.method(); //编译不通过
        f.show();
    }
}

---

判断程序2

class A {
    public void show() { //1
        show2();
    }
    public void show2() { //2
        System.out.println("我");
    }
}

class B extends A {
    public void show2() { //3
        System.out.println("爱");
    }
}

class C extends B {
    public void show() { //4
        super.show();
    }
    public void show2() { //5
        System.out.println("你");
    }
}

public class DuoTaiTest4 {
    public static void main(String[] args) {
        A a = new B();
        a.show(); //爱 运行看右边  123

        B b = new C();
        b.show(); //你 4125
    }
}

多态数组

定义一个Person类{name, age, job}
初始化Person对象数组有3个person对象
并按照age从大到小进行排序 提示 使用冒泡排序

public class MyTest {
    public static void main(String[] args) {
        Person[] person = new Person[3];
        person[0] = new Person("jack", 19, "服务员");
        person[1] = new Person("tom", 18, "老师");
        person[2] = new Person("smith", 30, "java工程师");

        Person p = new Person();
        p.sort(person);
        System.out.println("==排序后对象数组情况==");
        for (int i = 0; i < person.length; i++) {
            System.out.println(person[i]);
        }
    }
}
/*
==排序后对象数组情况==
Person{name='smith', age=30, job='java工程师'}
Person{name='jack', age=19, job='服务员'}
Person{name='tom', age=18, job='老师'}
*/

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

    public Person() {
    }

    public Person(String name, int age, String job) {
        this.name = name;
        this.age = age;
        this.job = job;
    }
	//打印方法
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", job='" + job + '\'' +
                '}';
    }
	//冒泡排序
    public Person[] sort(Person[] person){
        Person temp = null;
        for (int i = 0; i < person.length-1; i++) {
            for (int j = 0; j < person.length-1-i; j++) {
                if (person[j].age < person[j+1].age){
                    temp = person[j];
                    person[j] = person[j+1];
                    person[j+1] = temp;
                }
            }
        }
        return person;
    }
}