java入门~第十天 面向对象的多态

面向对象的多态性

1.多态

1.01多态的概述

1.多态概述：

​ 某一个事物，在不同时刻表现出来的不同状态。

2.多态前提：
a:要有继承关系。
b:要有方法重写。 其实没有也是可以的，但是如果没有这个就没有意义。
c:要有父类引用指向子类对象。

​ 父 f = new 子();

public class Mytest {
    public static void main(String[] args) {
        Cat cat=new Cat();
        cat.eat();
        Animal an=new Cat();
        an.eat();
    }


}
class Animal{
    public void eat(){ System.out.println("吃饭"); }
}
class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

运行结果：猫吃鱼
猫吃鱼

1.02多态的成员访问特点

1.多态中的成员访问特点：
a:成员变量
编译看左边，运行看左边。
b:构造方法
创建子类对象的时候，会访问父类的构造方法，对父类的数据进行初始化。
c:成员方法
编译看左边，运行看右边。
d:静态方法
编译看左边，运行看左边。
(静态和类相关，算不上重写，所以，访问还是左边的)

public class Mytest {
    public static void main(String[] args) {
        Fu fu = new Zi();
        int n=fu.num;
        System.out.println(n);
        fu.show();
        fu.jing();
        Fu.jing();
        Zi.jing();
    }


}
class Fu{
    public Fu(){ System.out.println("父类空参构造调用"); }
    int num=1;
    public void show(){ System.out.println("fu show"); }
    public static void jing(){ System.out.println("fu jing"); }

}
class Zi extends Fu{
    int num=12;
    public Zi(){ System.out.println("子类空参构造调用"); }

    @Override
    public void show() {
        System.out.println("zi show");
    }
    //静态不能重写
    public static void jing() {
        System.out.println("zi jing");
    }
}

运行结果：

父类空参构造调用
子类空参构造调用
1
zi show
fu jing
fu jing
zi jing

1.03多态的好处和弊端

1.多态的好处：
a:提高了代码的维护性(继承保证)
b:提高了代码的扩展性(由多态保证)

2.通过多态的弊端引出问题
不能使用子类特有的功能

3.解决问题
a:把父类的引用强制转换为子类的引用。(向下转型)

//类的定义
public class Animal {
    public void eat() {
        System.out.println("吃饭");
    }
}

class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
class Pig extends Animal {
    @Override
    public void eat() {
        System.out.println("小猪吃饲料");
    }
}

ublic class TestUtils {
    private TestUtils() {
    }
    //方法形参的设计，用成父类型，那么就可以接收他所有的子类型。能够提高代码的扩展性。
    public static  void testEat(Animal an) {
        //父类引用指向子类对象，
        //多态形式调用成员方法，编译看左边，运行看右边
        // Animal an=cat
        //Animal an=dog
        //Animal an=tiger
        //Animal an=rabbit
        an.eat();
    }
}

public class Mytest {
    public static void main(String[] args) {
        //多态的好处：1，能够提高代码的复用性和维护性（靠继承保证）
        //2.提高代码的扩展性。
        Cat cat = new Cat();
        TestUtils.testEat(cat);
        Pig pig = new Pig();
        TestUtils.testEat(pig);
    }
}
//把我在测试类中提供的这两个方法，放到单独的一个类中

1.04向上转型和向下转型

public class MyTest {
    public static void main(String[] args) {
        //多态的弊端：不能调用子类特有的功能
        Fu fu = new Zi();  //向上转型：多态就是向上转型。

        fu.show();
        //多态，不能直接调用，子类特有的功能。
        //fu.hehe(); 报错。

    /*    Zi zi = new Zi();
        zi.show();
        zi.hehe();
*/
       //我们可以采用向下转型，那调用子类特有的功能
        System.out.println(fu.num); //200
        Zi zi= (Zi) fu; //把父类引用，向下转型为子类型。
        zi.hehe();
        System.out.println(zi.num);  //10
    }
}

class Fu {
    int num=200;
    public void show() {
        System.out.println("fu Show");
    }
}

class Zi extends Fu {
    int num=10;
    @Override
    public void show() {
        System.out.println("zi Show");
    }

    public void hehe() {
        System.out.println("子类特有的方法");
    }
}

1.05多态内存图

2.抽象类

2.01抽象类的概述

​ 在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。

​ 抽象类和抽象方法必须用abstract关键字修饰：
​ 抽象类格式: abstract class 类名 {}
​ 抽象方法格式: public abstract void eat();

abstract 抽象的==，可以修饰类，修饰方法。==

​ 父类，他也不知道，子类对这个共性功能的具体实现，所以也没有必要给出共性功能的具体实现
//抽象类，抽取所有子类的共性功能，但是不给出，共性功能的具体实现，而是交由子类根据自身的特性做以具体的实现。

public class Mytest {
    public static void main(String[] args) {
        Cat cat = new Cat();
        Dog dog = new Dog();
    }
}
abstract class Animal{
    public abstract void eat(); //没有方法体
    public abstract void sleep();
}
class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    @Override
    public void sleep() {
        System.out.println("猫在沙发睡觉");
    }

}
class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void sleep() {
        System.out.println("狗在院子睡觉");
    }
}

抽象类，不能直接实例化，我们可以通过多态的形式，间接实例化父类

public class Mytest {
    public static void main(String[] args) {
       
    }
}
abstract class A{
   int num=50;
   final  int X=200;
    //抽象类有构造方法，作用：用于子类访问父类数据时的初始化
   public A(){
       System.out.println("父类的构造执行了");
   }
}
class C extends A {
    public C(){
        System.out.println("子类的构造执行了");
    }
}

1.抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
2.抽象类中可以有构造方法,抽象类不能进行实例化,那么要构造方法有什么作用呢?
用于子类访问父类数据时的初始化
3.抽象类不能直接实例化那么，抽象类如何实例化呢?
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
4.抽象类的子类
要么是抽象类；
要么重写抽象类中的所有抽象方法。

5.抽象类中所有抽象方法，强制子类必须重写
6.抽象类的子类有中选择，选择1.重写抽象类中的所有抽象方法，选择2：你自己也是个抽象类
7.可以没有抽象方法,也可以有抽象方法。这样设计的考虑，非抽象方法，可以让子类直接继承使用，对于抽象方法，是要求子类必须重写的。

抽象类练习老师案例：

public class Mytest {
    public static void main(String[] args) {
        Person p = new Teacher();
        p.sleep();
        p.eat();
        Teacher teacher= (Teacher) p ;
        // ((Teacher) p).teach();
        teacher.teach();
        p=new Student();
        p.sleep();
        p.eat();
        Student s= (Student) p;
        s.playGame();

    }
}
 abstract class Person {

    public abstract void eat();

    public abstract void sleep();

}
 class Student extends Person{
    @Override
    public void eat() {
        System.out.println("学生在餐厅吃饭");
    }

    @Override
    public void sleep() {
        System.out.println("学生晚睡");
    }
    public void playGame(){
        System.out.println("学生玩游戏");
    }
}
class Teacher extends Person {

    @Override
    public void eat() {
        System.out.println("老师爱吃燃面");
    }

    @Override
    public void sleep() {
        System.out.println("老师早早就上床歇息了");
    }

    public void teach() {
        System.out.println("老师教书");
    }
}

运行结果：老师早早就上床歇息了
老师爱吃燃面
老师教书
学生晚睡
学生在餐厅吃饭
学生玩游戏

抽象类练习员工案例：

假如我们在开发一个系统时需要对员工(Employee)类进行设计，员工包含3个属性：姓名、工号以及工资(salary)。
经理(Manager)也是员工，除了含有员工的属性外，另为还有一个奖金(bonus)属性。
然后定义工作的方法.
请使用继承的思想设计出员工类和经理类。

public class Mytest {
    public static void main(String[] args) {
        Person P= new Manager();
        P.name = "沈公子";
        P.id = 10;
        P.sal = 2000;
        System.out.println(P.name);
        System.out.println(P.id);
        System.out.println(P.sal);
        P.work();
        Manager m = (Manager) P;
        m.bonus = 6000;
        m.businessTrip();
        System.out.println(m.bonus);
        P = new Employee();
        //类型转换异常。
        //java.lang.ClassCastException:org.westos.demo6.Manager cannot be cast to org.westos.demo6.Employee
        Employee e = (Employee)P;
        P.name = "王五";
        P.id = 22;
        P.sal = 1000;
        System.out.println(P.name);
        System.out.println(P.id);
        System.out.println(P.sal);
        P.work();
        
        
    }
}
abstract class Person {
         //姓名、工号以及工资(salary)。
         //工作的方法
         public String name;
         public int id;
         public double sal;

         public abstract void work();
}
class Manager extends Person{
     double bonus;
     @Override
     public void work() {
         System.out.println("经理工作的内容是管理工作");
     }
     public void businessTrip(){
         System.out.println("经理需要出差");
     }

 }

class Employee extends Person{
    @Override
    public void work() {
        System.out.println("员工在一线进行生产工作");
    }
}   

2.02抽象类的成员特点

抽象类的成员特点：
1:成员变量：既可以是变量，也可以是常量。
2:构造方法：有。
用于子类访问父类数据的初始化。
3成员方法：既可以是抽象的，也可以是非抽象的。

抽象类的成员方法特性：
1:抽象方法 强制要求子类做的事情。
2:非抽象方法 子类继承的事情，提高代码复用性。

补充：抽象类中的面试题

​ <1>一个类如果没有抽象方法，可不可以定义为抽象类 ? 如果可以，有什么意义 ?
​ 可以，这个类不想让外界创建对象。
​ <2>abstract不能和哪些关键字共存 ?
private 矛盾 abstract 强制子类必须重写 private 私有的不能继承，重写不了
final 矛盾 final方法子类不能重写 abstract 又强制重写。
static 方法不参与重写 abstract 他又要重写。

3接口

3.01接口的概述

​ 为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，将来哪些猫狗需要被培训，只需要这部分猫狗把这些额外功能实现即可。

接口特点：
a:接口用关键字interface表示 格式: interface 接口名 {}
b:类实现接口用implements表示 格式: class 类名 implements 接口名 {}
c:接口不能实例化
那么，接口如何实例化呢?
按照多态的方式来实例化。
d:接口的子类
a:可以是抽象类。但是意义不大。
b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)

public abstract class Animal {
    public abstract void eat();
    public abstract void sleep();
}

public class Dog extends Animal implements MyInterface{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void sleep() {
        System.out.println("狗睡觉");
    }

    @Override
    public void jump() {
        System.out.println("狗经过不断学习，学会为了跳高");
    }
}

public interface  MyInterface {
    //在接口中，提供扩展的功能
    public abstract void jump();
}

public class Mytest {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Animal p=dog;
        p.eat();
        p.sleep();
        MyInterface myInterface=dog ;
        myInterface.jump();
    }
}

运行结果：狗吃骨头
狗睡觉
狗经过不断学习，学会为了跳高

3.02接口的成员特点

接口成员特点
成员变量；只能是常量，并且是静态的。
默认修饰符：public static final
建议：自己手动给出。
构造方法：接口没有构造方法。
成员方法：只能是抽象方法。
默认修饰符：public abstract（JDK1.7 之前接口中的方法，全部是抽象方法）不存在非抽象方法。

​ 接口不能直接new对象。

3.03类与类,类与接口,接口与接口的关系

类与类,类与接口,接口与接口的关系
a:类与类：
extends 继承关系,只能单继承,可以多层继承。
b:类与接口：
implements 实现关系,可以单实现,也可以多实现。
并且还可以在继承一个类的同时实现多个接口。这个类，要把他所有实现的接口中的所有抽象方法都要重写。
c:接口与接口：
extends继承 关系,可以单继承,也可以多继承。

3.04抽象类与接口的区别

1.成员区别
抽象类：
成员变量：可以变量，也可以常量
构造方法：有
成员方法：可以抽象，也可以非抽象
接口：
成员变量：只可以常量
成员方法：只可以抽象
2.关系区别
类与类
继承，单继承
类与接口
实现，单实现，多实现
接口与接口
继承，单继承，多继承
3.设计理念区别
抽象类 被继承体现的是：”is a”的关系。 抽象类中定义的是该继承体系的共性功能。
接口 被实现体现的是：”like a”的关系。 接口中定义的是该继承体系的扩展功能。

注意：JDK1.8之后在接口中提供了用default修饰的方法，可以给出功能的具体实现，子类可以继承下去用
JDK1.8之后在接口中也可以定义静态方法

interface AA{
   // void ccc();
   public default void aa(){
       System.out.println("aaa");
   }
   public static void test(){
       System.out.println("abc");
   }
}

总结：

抽象类和接口的区别：
(1)抽象类中，可以定义抽象方法，也可以定义非抽象方法。
接口：接口里面定义的是抽象方法，JDK1.8可以定义 default修饰的方法和静态方法。

(2)抽象类有构造方法的，接口没有构造方法这一说。
抽象类可以定义成员变量也可以定义常量，接口中全是公共的静态常量。
(3)设计思想：抽象类，他是抽象所有子类的共性功能，并不给出共性功能的具体实现，而是交由子类根据自身的差异性，去做具体实现。

接口：体现一种扩展的思想，通常用来定义一些规范和规则，哪些事物想要具备这些扩展功能，可以实现具体的接口。接口他只需要维护一套规范或者说规则，那么具体对规范的实现，是由子类来具体实现的。