Java学习十之接口和抽象类

接口和抽象类

一、抽象类

1.1什么是抽象类？

抽象类是一种特殊的类
被abstract关键字修饰的类就是抽象类
修饰符 abstract class 类别{
类体
}

在Java中，有些类不适合创建对象，这时可以把类定义成抽象类。
抽象类是不可以创建对象的，但是可作为父类使用。
例：门：开门、关门
防火门：防火
防盗门：防盗

public abstract class Door {
//    使用abstract 修饰类，Door就变成了抽象类，不能创建对象
//    行为
    public void open(){
        System.out.println("开门");
    }
    /*
    * 对于不同的门，关门的动作是不一样的
    * 在父类中没有办法统一去实现
    * 把关门的方法定义成抽象的
    * */
    public abstract void close();

}

```java
public class FireProofDoor extends Door{
    @Override
    public void close() {
        System.out.print("关门:");
        FireProof();
    }

    public void FireProof() {
        System.out.println("启动防火功能");
    }
}

public class AntiTheftDoor extends Door{
    @Override
    public void open() {
        System.out.println("输入密码才能开门");
    }

    @Override
    public void close() {
        System.out.print("关门:");

        antiTheft();

    }
    public void  antiTheft(){
        System.out.println("启动防盗功能");

    }}
public class Main {
    public static void main(String[] args) {
        Door door1=new AntiTheftDoor();
        door1.open();
        door1.close();
        System.out.println("*******************");
        Door door2=new FireProofDoor();
        door2.open();
        door2.close();
    }
}

1.2抽象方法

被abstract修饰的方法就是抽象方法。
抽象方法只有方法的定义，没有方法的实现（没有方法体），结尾必须是；
抽象方法必须由子类实现。
抽象类与抽象方法的关系：
1）抽象类可以拥有类所拥有的一次，包括：属性、方法、构造方法等
抽象类可以拥有抽象方法
2）有抽象方法的类必须是抽象类
3）抽象类的子类有两个选择
          a.实现抽象类中的所有抽象方法，子类就可以是一个普通类
          b. 如果没有实现抽象父系的所有抽象方法，子类必须也是抽象类。

1.3总结

1、抽象方法是没有方法体，如果这个类里面有抽象方法，这个类必须变成抽象类。
2、如果这个类是抽象类，并不要求这个类一定要有抽象方法
3、抽象类里面可以有普通方法，也可以有抽象方法。
4、如果一个类是抽象类，那么这个类就不能被new实例化，只能被其他类继承。
5、抽象方法可以理解为父类（抽象类）定义的一个模板或者规范（自己本身不实现），
子类必须实现这个抽象方法，如果子类不想实现这个方法，那么这个子类也必须要变成抽象类。

二、接口

2.1什么是接口？

接口是一种数据类型.
接口是一种比抽象类更抽象的数据类型
1）接口中定义的变量都是公共的静态的常量，默认使用public static final 关键字修饰
2）接口中定义的方法，默认使用public abstract 关键字修饰

接口是一个纯粹的抽象类（接口里面所有的方法都是抽象方法）
接口就是一个规范，他没有提供任何是实现，具体的功能由实现接口的子类去实现。
接口就是一个规范，可插拔（可以被替换，首先定义一个标准（接口），大家都遵守这个标准，就可以实现互相之间替换）
1、接口是一个纯粹的抽象类，接口里面的方法都是抽象方法 public abstract。
2、接口里面所有的属性public static final

注意：
Java中一个类最多只能有一个直接父类，单继承
但Java中可以让一个类同时实现多个接口，多实现

一个接口也可以继承另一个接口，使用extends
接口也可以继承父接口的所有方法，而且也是单继承

2.2JDK1.8中新特征：

1）函数式接口：接口中只有一个抽象方法
2）允许接口中有静态方法
          static void test(){ 方法体 }
3）允许接口中有默认方法
          default void test(){int i=0;}

注意：
接口的实现类，要么实现接口中所有的抽象方法，
要么实现类就只能是一个抽象类

三、接口和抽象的异同

抽象类
特点:
1.抽象类中可以构造方法
2.抽象类中可以存在普通属性，方法，静态属性和方法。
3.抽象类中可以存在抽象方法。
4.如果一个类中有一个抽象方法，那么当前类一定是抽象类；抽象类中不一定有抽象方法。
5.抽象类中的抽象方法，需要有子类实现，如果子类不实现，则子类也需要定义为抽象的。

java类是单继承的。classB Extends classA
java接口可以多继承。Interface3 Extends Interface0, Interface1, interface……

接口
1.在接口中只有方法的声明，没有方法体。
2.在接口中只有常量，因为定义的变量，在编译的时候都会默认加上
public static final
接口可以有default、static方法
3.在接口中的方法，永远都被public来修饰。
4.接口中没有构造方法，也不能实例化接口的对象。
5.接口可以实现多继承
6.接口中定义的方法都需要有实现类来实现，如果实现类不能实现接口中的所有方法.则实现类定义为抽象类。

同：
1）都不能创建对象
2）都可以有抽象方法
3）接口抽象类在使用时，基本上都是上转型
异：
1）抽象类是类，类和接口是不同的数据类型
2）抽象类在继承时使用的时extends，接口在实现时使用implements
3）抽象类可以有属性，构造方法，普通方法，接口不行。

四、抽象类和接口类结合实例

实例1

public abstract class 英雄 {

    public abstract void 攻击力();
    public abstract void 法术强度();
    public abstract void 物理防御();
    public abstract void 法术防御();
    public abstract void 物理吸血();
    public abstract void 法术吸血();
    public abstract void 物理穿透();
    public abstract void 法术穿透();

    public abstract void 装备1();
    public abstract void 装备2();
    public abstract void 装备3();
    public abstract void 装备4();
    public abstract void 装备5();
    public abstract void 装备6();
    public abstract void 英雄信息();

}


public interface 增益buff {

    public abstract void 洞察之力();
    public abstract void 无敌金身();
    public abstract void 狂暴之力();
    public abstract void 疾射火炮();
    public abstract void 天人合一();


}


public class 人物 extends 英雄 implements 增益buff{
    String name;

    public 人物(String name) {
        this.name = name;
    }

    @Override
    public void 攻击力() {
        System.out.print("攻击力：650"+" ");
    }

    @Override
    public void 法术强度() {
        System.out.print("法术强度:1500"+" ");
    }

    @Override
    public void 物理防御() {
        System.out.print("物理防御:2000"+" ");
    }

    @Override
    public void 法术防御() {
        System.out.print("法术防御:2000"+" ");
    }

    @Override
    public void 物理吸血() {
        System.out.print("物理吸血:90%"+" ");
    }

    @Override
    public void 法术吸血() {
        System.out.print("法术吸血:90%"+" ");
    }

    @Override
    public void 物理穿透() {
        System.out.print("物理穿透:80%"+" ");
    }

    @Override
    public void 法术穿透() {
        System.out.print("法术穿透:80%"+" ");
    }

    @Override
    public void 装备1() {
        System.out.print("装备1:无尽战刃"+" ");
    }

    @Override
    public void 装备2() {
        System.out.print("装备2:幽梦之灵"+" ");
    }

    @Override
    public void 装备3() {
        System.out.print("装备3:死亡之舞"+" ");
    }

    @Override
    public void 装备4() {
        System.out.print("装备4:不朽盾弓"+" ");
    }

    @Override
    public void 装备5() {
        System.out.print("装备5:鬼索的狂暴之刃"+" ");
    }

    @Override
    public void 装备6() {
        System.out.print("装备6:饮血剑");
    }

    @Override
    public void 英雄信息(){
        System.out.println("英雄："+this.name);
        System.out.print("基础属性:");
         攻击力();
         法术强度();
         物理防御();
         法术防御();
         物理吸血();
         法术吸血();
         物理穿透();
        System.out.println();
        System.out.print("装备信息：");
         装备1();
         装备2();
         装备3();
         装备4();
         装备5();
         装备6();
        System.out.println();
        System.out.println("六神装集齐，召唤神龙，获得神龙之力！");
        System.out.println("增益buff：");
         洞察之力();
         无敌金身();
         狂暴之力();
         疾射火炮();
         天人合一();
    }

    @Override
    public void 洞察之力() {
        System.out.println("洞察之力:无限视距，无视战争迷雾"+" ");
    }

    @Override
    public void 无敌金身() {
        System.out.println("无敌金身:全身散发金色光芒，开启后无视任何形式的伤害，开启期间可进行攻击"+" ");
    }

    @Override
    public void 狂暴之力() {
        System.out.println("狂暴之力:获得此buff攻速提升200%，吸血提升200%，攻击力提升30%"+" ");
    }

    @Override
    public void 疾射火炮() {
        System.out.println("疾射火炮:无限攻击距离"+" ");
    }

    @Override
    public void 天人合一() {
        System.out.println("天人合一:免疫控制效果并且减少所受到的伤害"+" ");
    }
}


public class Main {
    public static void main(String[] args) {
        英雄 ZHC=new 人物("ZHC");
        ZHC.英雄信息();
    }
}

实例2

public abstract class AbstractBird {
    public abstract void egg();

}

public interface IFly {
    public abstract void fly();
}


public class DaYan extends AbstractBird implements IFly {
    @Override
    public void egg() {
        System.out.println("DaYan.edd");
    }

    @Override
    public void fly() {
        System.out.println("DaYan.fly");
    }
    public void print(){
        System.out.println("DaYan.print");

    }

}

public class GeZi extends AbstractBird{
    @Override
    public void egg() {
        System.out.println("GeZi.edd");
    }
}


public class Demo {
    @Test
    public void test1(){
        DaYan daYan=new DaYan();
        daYan.egg();
        daYan.fly();
        daYan.print();

        // bird是站在AbstractBird这个角度去看new出来的大雁，
        // 只能看到下蛋这个功能
        AbstractBird abstractBird=new DaYan();
        abstractBird.egg();
        // abstractBird.fly();
        // abstractBird.print();

        // fly是站在IFly这个角度去看new出来的大雁，
        // 只能看到fly这个功能
        IFly iFly=new DaYan();
        iFly.fly();

    }}

继承是严格的父子关系，你继承什么你就是什么：鸽子就是鸟。
父类是抽取了所有子类的共同特征，父类里面的属性和方法是所有子类所共有的属性和方法。
接口是一个标准，一般用在能不能具有某个功能。
把能不能飞定义称为一个接口IFly，实现了这个接口的类就具有了这个功能。