java抽象类和接口

抽象类：使用关键字abstract声明的类叫做抽象类，如果一个类里包含了一个或多个抽象方法，类就必须指定为abstract。

抽象方法：指一些只有方法声明，而没有方法体的方法。

特点：0.使用关键字abstract

　　   1.只有抽象类中才可以有抽象方法

　　　2.抽象类无法进行实例化

使用与不使用的区别：如果不使用抽象方法的话，子类不会被强制要求重写父类中的方法。约束的作用无法体现

意义：体现在继承当中,在父类中定义的抽象方法，子类必须要重写并进行实现。起到规范和约束的作用。

/**
 * 描述老师的一个类
 */
public abstract class Teacher {

    //现在需求是大型的教务系统，涉及到很多的老师，中小学，大学，IT讲师

    //自我介绍，因为感觉方法中写什么都不到位，所以定义成一个抽象类方法
    public  abstract void welcome();
}

public class JavaTeacher extends Teacher {

    @Override
    public void welcome() {
        System.out.println("大家好，我是很厉害的Java老师");
    }
}

public class TestTeacher {

    public static void main(String[] args){
        //抽象类无法实例化，但是我们可以使用抽象类的引用来保存其子类的实例
        Teacher teacher = new JavaTeacher();
        teacher.welcome();
    }
    
}

接口：

定义：形态也像一个类，却不是类，里面只能放置抽象方法。java接口是一系列方法的声明，使一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

意义：定义规范，统一访问，解耦。

特点：大项目中作用大，小项目中作用小

要点：对应关键字 interface

　　   实现接口时用implements，需要写全部抽象方法

　　   类可以实现接口，一个类只可以继承一个父类，但是可以实现多个接口。接口中不可以定义变量

举个例子：有很多个老师，但是老师的方法都是讲课，只是讲的内容不一样而已，所以在接口中声明抽象方法，每个老师实现同样的方法，只是里面的内容不一样而已。

代码实现一个例子：

1.在接口中先定义好（Npc应当具有）所有的规范（抽象方法）。

2.将子实现类中的通用代码提取出来，创建一个抽象类来放置这些代码，抽象类实现接口，子类继承抽象类

3.在抽象类中可以放子类的通用代码，实现代码的服用，还可以不去实现接口中一些子类不同实现形式不同的抽象方法。

用游戏做一个代码的demo，首先定义一个接口，想让他有哪些方法：

package npc;

public interface Npc {

    //做自我介绍
    public void info();

    //帮助一下玩家
    public void help();
}

然后有两个类分别是司机和医生

package npc;

public class Doctor implements Npc {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void info() {
        System.out.println("你好，我叫"+name);
    }

    @Override
    public void help() {
        System.out.println("我的医术高明，可以治病救人");
    }
}

package npc;

public class Driver implements Npc {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void info() {
        System.out.println("你好，我叫"+name);
    }

    @Override
    public void help() {
        System.out.println("我是老司机，请上车");
    }
}

但是，问题来了，他们有重复的get和set方法，所以，可以把重复的一部分拿出来，但是放到接口里面是不可以的，接口里面不可以声明变量。所以我们需要建立一个类，让司机类和医生类都继承这个类。但是每个类的帮助方法都不一样，如果让这个类去实现接口，他会报错，因为Mynpc只是为了过渡一下，把公共的部分放在这里面，但是报错提示必须实现接口的help方法。但是help方法不能在MyNpc里面写。

package npc;

public class MyNpc implements Npc{

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void info() {
        System.out.println("我叫"+name);
    }
    
}

 所以，我们就需要把MyNpc变成抽象类，这样的话，抽象类可以不用实现接口中所有的方法，因为接口中本身就是抽象方法，抽象方法不需要在实现抽象方法。

package npc;

public abstract class MyNpc implements Npc{

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void info() {
        System.out.println("我叫"+name);
    }    
}

然后：Doctor.java和Driver.java就只剩下了很简明的一行代码：

package npc;

public class Driver extends MyNpc{


    @Override
    public void help() {
        System.out.println("我是老司机，快上车");
    }
}

package npc;

public class Doctor extends MyNpc {

    @Override
    public void help() {
        System.out.println("我的医术高明，可以治病救人");
    }
}

测试类中： 

package npc;

public class Test {
    public static void main(String[] args){
        Npc npc = new Doctor();
        npc.help();

        npc = new Driver();
        npc.help();
    }
}

结果：

接口和抽象类的相同与不同之处：

1、抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。

2、抽象类要被子类继承，接口要被类实现。

3、接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现

4、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。

5、抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。

6、抽象方法只能申明，不能实现，接口是设计的结果 ，抽象类是重构的结果

7、抽象类里可以没有抽象方法

8、如果一个类里有抽象方法，那么这个类只能是抽象类

9、抽象方法要被实现，所以不能是静态的，也不能是私有的。

10、接口可继承接口，并可多继承接口，但类只能单根继承。