2020.7.25多态、抽象

01_多态

01.1定义：

指的是一种事物，在不同时刻，所表现出的状态。

​ 举例：

​ Fu fu=new Zi();

01.2多态的一个前提;

1. 要有一个继承，没有继承，多态就无从谈起。

2. 要有方法重写。当然不重写也可以，三十失去了意义

3. 要有父类引用指向子类对象

01.3多态中的成员访问特点

1. 多态的形式访问成员变量，编译看左边，运行也看左边。
2. 多态的形式访问成员变量，访问的都是父类。

01.4多态的形式访问成员方法

• 编译看左边，运行看右边。编译器看父类中有没有这个方法，实际调用时会以子类重写过后为准。如果子类没有重写，以父类为准。

01.5多态的好处：

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

01.6多态弊端：

• 就是不能调用子类特有的功能。

• 我们可以采用向下转型，那调用子类特有的功能

• Zi zi=(Zi)fu;

• 向上转型，多态就是向上

案例演示：

package com.Homework.day09.note.congzi;
//09.05_ 案例演示 孔子装爹
/*
 *  孔子爹，是一名Java讲师，非常有名，张三慕名前来，把孔子爹请到家里去讲课，此时就剩孔子一个人在家玩游戏。
 * 这时候，李四也来孔子的家里，请孔子爹去他家里讲课，那这时孔子爹不在家，这个孔子不想失去这笔生意，他就乔装打扮一下，打扮成他爹的模样，去李四家里给李四讲课。实际他讲的是论语。讲完之后，孔子回到家，觉得假扮他爹太累了，所以卸下装扮，做回他自己，愉快的玩游戏去了。
 *
 * */
public class Father {
    int age=55;
    public void teacher(){
        System.out.println("教书");
    }
}
--------------------------
package com.Homework.day09.note.congzi;

public class CongZi extends Father{
    int age=20;
    public void teacher(){
        System.out.println("教游戏");
    }
    public void Play(){
        System.out.println("玩游戏");
    }
}
-------------------------
package com.Homework.day09.note.congzi;

public class Demo1 {
    public static void main(String[] args) {
        /*Father fa = new Father();
        System.out.println(fa.age);
        fa.teacher();*/
        Father fa1  = new CongZi();
        System.out.println(fa1.age);
        fa1.teacher();
				//向下转型
        CongZi cozi=(CongZi)  fa1;
        cozi.Play();
    }
}

--------------------------------------下午-----------------------------------------

02_抽象类abstract

02.1定义：

• 父类他也不知道子类对共性功能的具体实现，所以没有必要给出共性功能的具体实现.

• 抽取所有子类的共性功能但是不给出共性功能的具体实现，而是交有子类根据自身的特性做以具体的实现。

• 可以修饰类、方法

02.2_抽象类的语法特点

1、抽象类中可以没有抽象方法，也可以有抽象方法。这样设计的考虑，非抽象方法可以让子类直接继承，对于抽象方法，是要求子类必须重写父类所有的抽象方法。

2、一个类中一旦有了抽象方法，这个类必须是抽象类。

3、抽象类是不能直接实例化的。可以采用多态的形式间接实例化。

4、抽象类中的所有抽象方法，强制子类必须重写。

5、抽象类的子类有两种选择，选择1就是重写抽象类中的所有的抽象方法，选择二，你自己是个抽象方法。

6、抽象类有构造方法，作用就是让子类间接的实例化父类。

案例演示1：

package com.Homework.day09.note.zoo;
//抽象类
public abstract class Animal {
    String name;
    int age;
   //抽象方法
   public abstract void eat();

   /* 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 Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }*/
}
---------------------------
package com.Homework.day09.note.zoo;

public class Cat extends Animal{

    @Override
    public void eat() {
        System.out.println("小饼干");
    }
}
-----------------------
package com.Homework.day09.note.zoo;

import com.Homework.day09.note.zoo.Animal;

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("大骨头");
    }
}
------------------------
package com.Homework.day09.note.zoo;

public class Demo3 {
    public static void main(String[] args) {
        //创建对象
        Animal an=new Cat();
        System.out.println(an.name = "tom");
        System.out.println(an.age = 2);
        an.eat();
        Animal an1=new Dog();
    }
}

案例演示2：

package com.Homework.day09.note.bangong;

public abstract class Company {
    String name;
    double number;
    double salary;
    public abstract void work();
}
----------------
package com.Homework.day09.note.bangong;

public class Employee extends Company {
    @Override
    public void work() {
        System.out.println("站着工作");
    }
}
-----------------
package com.Homework.day09.note.bangong;

public class Manager extends Company {
    double bonus;
    @Override
    public void work() {
        System.out.println("睡觉工作");
    }
}
----------------------
package com.Homework.day09.note.bangong;

public class Test1 {
    public static void main(String[] args) {
        //创建员工对象
        Company co=new Employee();
        System.out.println(co.name = "dudu");
        System.out.println(co.number = 17070020);
        System.out.println(co.salary = 9000000);
        co.work();
        Company co2=new Manager();
        System.out.println(co2.name = "....");
        System.out.println(co2.number = 1707056);
        System.out.println(co2.salary = 999999);
        //向下转型
        Manager ma= (Manager) co2;
        ma.bonus=200000;//奖金
        System.out.println(ma.bonus);
        co2.work();
    }
}

abstract不能和哪些关键字共存?
	private    冲突--abstract强制子类重写，私有类不能重写
	final      冲突--									，常量不能重写。
	static     不能共存 无意义-static不参与重写，abstract必须重写