Java-多态-抽象类-接口

多态

概述

某一个事物，在不同时刻表现出来的不同状态。
前提
a:要有继承关系。
b:要有方法重写。 其实没有也是可以的，但是如果没有这个就没有意义。
c:要有父类引用指向子类对象。
父 f = new 子();

public class MyTest {
    public static void main(String[] args) {
        
        //多态：指的是一种事物，在不同时刻，所表现出的不同状态。
        //猫 是一只 猫   Cat cat=new Cat();  猫 cat=new 猫();
        // 猫也可是一种动物  Animal an=new Cat(); 动物 an=new 猫();

        //多态的前提：要有继承，如果没有继承，那多态也无从谈起
        //多态要有方法重写，当然你不重写，语法上来说，不报错，但是多态的存在就没有意义
        // 父类引用指向子类对象

       // Cat cat = new Cat();
       // cat.eat();

        //多态的方式：父类引用，指向子类对象
        Animal an = new Dog();
        an.eat();

        an=new Cat();
        an.eat();


    }
}

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

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

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

成员访问特点

a:成员变量
编译看左边，运行看左边。
b:构造方法
创建子类对象的时候，会访问父类的构造方法，对父类的数据进行初始化。
c:成员方法
编译看左边，运行看右边。
d:静态方法
编译看左边，运行看左边。

public class MyTest {
    public static void main(String[] args) {

         //多态的形式访问成员变量的特点
        //多态的形式访问成员变量：编译看左边，运行看左边
        Fu fu = new Zi();
        System.out.println(fu.num);

        //多态的形式访问成员方法的特点:编译看左边，运行看右边 （子类重写了父类的方法）

        fu.fuShow();

        //静态方法：不参与重写
        fu.fuShow2();
        Fu.fuShow2();
        Zi.fuShow2();
    }
}

class Fu {
    int num = 100;

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

    public static void fuShow2() {
        System.out.println("fu 静态 show");
    }
}

class Zi extends Fu {
    int num = 200;

    @Override
    public void fuShow() {
        System.out.println("zi show");
    }

    public static void fuShow2() {
        System.out.println("zi 静态 show");
    }
}

好处与弊端

好处
a:提高了代码的维护性(继承保证)
b:提高了代码的扩展性(由多态保证)
弊端
不能使用子类特有的功能

抽象类

概述

在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。
特点
a:抽象类和抽象方法必须用abstract关键字修饰
抽象类格式: abstract class 类名 {}
抽象方法格式: public abstract void eat();
b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
c:抽象类中可以有构造方法,抽象类不能进行实例化,那么要构造方法有什么作用呢?
用于子类访问父类数据时的初始化
d:抽象类不能直接实例化那么，抽象类如何实例化呢?
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
e:抽象类的子类
要么是抽象类
要么重写抽象类中的所有抽象方法

成员特点

A:抽象类的成员特点
a:成员变量：既可以是变量，也可以是常量。
b:构造方法：有。
用于子类访问父类数据的初始化。
c:成员方法：既可以是抽象的，也可以是非抽象的。
B:抽象类的成员方法特性：
a:抽象方法 强制要求子类做的事情。
b:非抽象方法 子类继承的事情，提高代码复用性。

public class MyTest {
    public static void main(String[] args) {
        //abstract 抽象的 可以修饰类，修饰方法

        //1.abstract 修饰类，此类就不能直接实例化
       // Animal animal = new Animal();
        //2.abstract 修饰方法：修饰的方法，要求子类必须重写
 }
}


abstract class Animal{

    public abstract void eat();/*{
        System.out.println("吃饭");
    }*/
}


class Dog extends Animal{


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

class Cat extends Animal{

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

接口

接口特点
a:接口用关键字interface表示 格式:

interface 接口名 {}

b:类实现接口用implements表示 格式:

 class 类名 implements 接口名 {}

c:接口不能实例化

按照多态的方式来实例化。
d:接口的子类
a:可以是抽象类。但是意义不大。
b:可以是具体类。要重写接口中的所有抽象方法。

成员特点

成员变量；只能是常量，并且是静态的。
默认修饰符：public static final
建议：自己手动给出。
构造方法：接口没有构造方法。
成员方法：只能是抽象方法。
默认修饰符：public abstract
建议：自己手动给出。

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

a:类与类：
继承关系,只能单继承,可以多层继承。
b:类与接口：
实现关系,可以单实现,也可以多实现。
并且还可以在继承一个类的同时实现多个接口。
c:接口与接口：
继承关系,可以单继承,也可以多继承。

抽象类和接口的区别

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