Java基础7-一文搞懂抽象类和接口，从基础到面试题，揭秘其本质区别（一)

//有抽象方法的类也必须被声明为abstract
public abstract class Test1 {
 
    //抽象方法，不能有“{}”
    public abstract void f();
    
}复制代码

//有抽象方法的类也必须被声明为abstract
public class Test1 {
 
    public static void main(String[] args) {
        Teacher teacher=new Teacher("教师");
        teacher.work();
        
        Driver driver=new Driver("驾驶员");
        driver.work();
    }
    
}
//一个抽象类
abstract class People{
    //抽象方法
    public abstract void work();
}
class Teacher extends People{
    private String work;
    public Teacher(String work) {
        this.work=work;
    }
    @Override
    public void work() {
        System.out.println("我的职业是"+this.work);
    }
    
}
class Driver extends People{
    private String work;
    public Driver(String work) {
        this.work=work;
    }
    @Override
    public void work() {
        System.out.println("我的职业是"+this.work);
    }
    
}复制代码

People people=new Teacher("教师");
people.work();复制代码

People people=new People() {
    @Override
    public void work() {
        //实现这个方法的具体功能
    }
        };复制代码

当一个类的一个或多个方法是抽象方法时。
当类是一个抽象类的子类，并且不能实现父类的所有抽象方法时。
当一个类实现一个接口，并且不能实现接口的所有抽象方法时。
注意：
上面说的是这些情况下一个类将称为抽象类，没有说抽象类就一定会是这些情况。
抽象类可以不包含抽象方法，包含抽象方法的类就一定是抽象类。
事实上，抽象类可以是一个完全正常实现的类。复制代码

问你个问题，你知道什么是“东西”吗？什么是“物体”吗？“麻烦你，小王。帮我把那个东西拿过来好吗”在生活中，你肯定用过这个词－－东西。小王：“你要让我帮你拿那个水杯吗？”你要的是水杯类的对象。而东西是水杯的父类。通常东西类没有实例对象，但我们有时需要东西的引用指向它的子类实例。
你看你的房间乱成什么样子了，以后不要把东西乱放了，知道么？
上面讲的只是子类和父类。而没有说明抽象类的作用。抽象类是据有一个或多个抽象方法的类，必须声明为抽象类。抽象类的特点是，不能创建实例。
这些该死的抽象类，也不知道它有什么屁用。我非要把它改一改不可。把抽象类中的抽象方法都改为空实现。也就是给抽象方法加上一个方法体，不过这个方法体是空的。这回抽象类就没有抽象方法了。它就可以不在抽象了。
当你这么尝试之后，你发现，原来的代码没有任何变化。大家都还是和原来一样，工作的很好。你这回可能更加相信，抽象类根本就没有什么用。但总是不死心，它应该有点用吧，不然创造Java的这伙传说中的天才不成了傻子了吗？
一个抽象类小游戏
接下来，我们来写一个小游戏。俄罗斯方块！我们来分析一下它需要什么类？我知道它要在一个矩形的房子里完成。这个房子的上面出现一个方块，慢慢的下落，当它接触到地面或是其它方块的尸体时，它就停止下落了。然后房子的上面又会出现一个新的方块，与前一个方块一样，也会慢慢的下落。在它还没有死亡之前，我可以尽量的移动和翻转它。这样可以使它起到落地时起到一定的作用，如果好的话，还可以减下少几行呢。这看起来好象人生一样，它在为后来人努力着。当然，我们不是真的要写一个游戏。所以我们简化它。我抽象出两个必须的类，一个是那个房间，或者就它地图也行。另一个是方块。我发现方块有很多种，数一下，共6种。它们都是四个小矩形构成的。但是它们还有很多不同，例如：它们的翻转方法不同。先把这个问题放到一边去，我们回到房子这个类中。
房子上面总是有方块落下来，房子应该有个属性是方块。当一个方块死掉后，再创建一个方块，让它出现在房子的上面。当玩家要翻转方法时，它翻转的到底是哪个方块呢？当然，房子中只有一个方块可以被翻转，就是当前方块。它是房子的一个属性。那这个属性到底是什么类型的呢？方块有很多不同啊，一共有6种之多，我需要写六个类。一个属性不可能有六种类型吧。当然一个属性只能有一种类型。
我们写一个方块类，用它来派生出6个子类。而房子类的当前方块属性的类型是方块类型。它可以指向任何子类。但是，当我调用当前方块的翻转方法时，它的子类都有吗？如果你把翻转方法写到方块类中，它的子类自然也就有了。可以这六种子类的翻转方法是不同的。我们知道'田'方块，它只有一种状态，无论你怎么翻转它。而长条的方块有两种状态。一种是‘－’，另一种是‘｜’。这可怎么办呢？我们知道Java的多态性，你可以让子类来重写父类的方法。也就是说，在父类中定义这个方法，子类在重写这个方法。
那么在父类的这个翻转方法中，我写一些什么代码呢？让它有几种状态呢？因为我们不可能实例化一个方块类的实例，所以它的翻转方法中的代码并不重要。而子类必须去重写它。那么你可以在父类的翻转方法中不写任何代码，也就是空方法。
我们发现，方法类不可能有实例，它的翻转方法的内容可以是任何的代码。而子类必须重写父类的翻转方法。这时，你可以把方块类写成抽象类，而它的抽象方法就是翻转方法。当然，你也可以把方块类写为非抽象的，也可以在方块类的翻转方法中写上几千行的代码。但这样好吗？难道你是微软派来的，非要说Java中的很多东西都是没有用的吗？
当我看到方块类是抽象的，我会很关心它的抽象方法。我知道它的子类一定会重写它，而且，我会去找到抽象类的引用。它一定会有多态性的体现。
但是，如果你没有这样做，我会认为可能会在某个地方，你会实例化一个方块类的实例，但我找了所有的地方都没有找到。最后我会大骂你一句，你是来欺骗我的吗，你这个白痴。
把那些和“东西”差不多的类写成抽象的。而水杯一样的类就可以不是抽象的了。当然水杯也有几千块钱一个的和几块钱一个的。水杯也有子类，例如，我用的水杯都很高档，大多都是一次性的纸水杯。
记住一点，面向对象不是来自于Java，面向对象就在你的生活中。而Java的面向对象是方便你解决复杂的问题。这不是说面向对象很简单，虽然面向对象很复杂，但Java知道，你很了解面向对象，因为它就在你身边。

package demo;
//构建一个抽象类People
abstract class People{
    //父类属性私有化
    private String name;
    private int age;
    //提供父类的构造器
    public People(String name,int age){
        this.name = name;
        this.age = age;
    }
    //提供获取和设置属性的getter()/setter()方法
    public String getName() {
        return name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
    
    //提供一个抽象方法
    public abstract void talk();    
}
 
//定义一个接口
interface Study{
    //设置课程数量为3
    int COURSENUM = 3;
    //构建一个默认方法
    default void stu(){
        System.out.println("学生需要学习"+COURSENUM+"门课程");
    }
}
 
//再定义一个接口
interface Write{
    //定义一个抽象方法
    void print();
}
 
//子类继承People,实现接口Study,Write
class Student extends People implements Study,Write{
    //通过super关键字调用父类的构造器
    public Student(String name, int age) {
        super(name, age);
    }
    //实现父类的抽象方法
    public void talk() {
        System.out.println("我的名字叫"+this.getName()+",今年"+this.getAge()+"岁");
    }
    //实现Write接口的抽象方法
    public void print() {
        System.out.println("学生会写作业");
    }
}
 
public class InterfaceDemo{
    public static void main(String[] args) {
        //构建student对象
        Student student = new Student("dodo", 22);
        //调用父类的抽象方法
        student.talk();
        //调用接口Write中的抽象方法
        student.print();
        //调用接口Study中的默认方法
        student.stu();
    }
}复制代码

如电脑可以和各个设备连接，提供统一的USB接口，其他设备只能通过USB接口和电脑相连

代码实现：

package demo;
 
interface USB 
{
    public void work() ;    // 拿到USB设备就表示要进行工作
}
 
class Print implements USB         //实现类（接口类）    
{                               // 打印机实现了USB接口标准（对接口的方法实现）
    public void work() 
   {
        System.out.println("打印机用USB接口，连接,开始工作。") ;
    }
}
class Flash implements USB         //实现类（接口类）                  
{                                  // U盘实现了USB接口标准（对接口的方法实现）
    public void work() 
    {
        System.out.println("U盘使用USB接口，连接,开始工作。") ;
    }
}
 
class Computer 
{
    public void plugin(USB usb)             //plugin的意思是插件，参数为接收接口类
    {
        usb.work() ;    // 按照固定的方式进行工作
    }
}
public class InterfaceStandards { public static void main(String args[]) { Computer computer = new Computer() ; computer.plugin(new Print()) ; //实例化接口类， 在电脑上使用打印机 computer.plugin(new Flash()) ; //实例化接口类， 在电脑上使用U盘 }}复制代码

class Computer 
{
    public void plugin(USB usb)             //plugin的意思是插件，参数为接收接口类
    {
        usb.work() ;    // 按照固定的方式进行工作
    }
}复制代码

public class InterfaceStandards 
{
    public static void main(String args[]) 
    {   
        Computer computer = new Computer() ;
        
        USB usb = new Print();
        computer.plugin(usb) ;   //实例化接口类， 在电脑上使用打印机
        usb = new Flash();
        computer.plugin(usb) ;   //实例化接口类， 在电脑上使用U盘
    }
}
复制代码

首先我们来认识一下什么是工厂模式？工厂模式是为了解耦：把对象的创建和使用的过程分开。就是Class A 想调用 Class B ，那么A只是调用B的方法，而至于B的实例化，就交给工厂类。

其次，工厂模式可以降低代码重复。如果创建对象B的过程都很复杂，需要一定的代码量，而且很多地方都要用到，那么就会有很多的重复代码。我们可以这些创建对象B的代码放到工厂里统一管理。既减少了重复代码，也方便以后对B的创建过程的修改维护。

由于创建过程都由工厂统一管理，所以发生业务逻辑变化，不需要找到所有需要创建B的地方去逐个修正，只需要在工厂里修改即可，降低维护成本。同理，想把所有调用B的地方改成B的子类C，只需要在对应生产B的工厂中或者工厂的方法中修改其生产的对象为C即可，而不需要找到所有的new B（）改为newC()。
复制代码

package demo;
 
import java.util.Scanner;
 
interface Fruit                        //定义一个水果标准
{
    public abstract void eat();
}
 
class Apple implements Fruit
{
    public void eat()
    {
        System.out.println("吃苹果");
    }
}
class Orange implements Fruit
{
    public void eat()
    {
        System.out.println("吃橘子");
    }
}
 
class factory
{
    public static Fruit getInstance(String className)  //返回值是Fruit的子类
    {
        if("apple".equals(className))
        {
            return new Apple();
        }
        else if("orange".equals(className))
        {
            return new Orange();
        }
        else
        {
            return null;
        }
    }
}
 
public class ComplexFactory {
    public static void main(String[] args)
    {    
        System.out.println("请输入水果的英文名:");
        Scanner sc = new Scanner(System.in);
        String ans = sc.nextLine();
        Fruit f = factory.getInstance(ans);   //初始化参数
        f.eat();
        sc.close();
    }
}
复制代码

总结点评：在接口的学习中，大家可以理解接口是特殊的抽象类，java中类可以实现多个接口，接口中成员属性默认是public static final修饰，可以省略；成员方法默认是public abstract修饰，同样可以省略，接口中还可定义带方法体的默认方法，需要使用default修饰。利用接口我们还可以制定标准，还能够使用工厂模式，将对象的创建和使用过程分开。
复制代码

public interface Animal{//所有动物都会吃public void eat();
//所有动物都会飞
public void fly();
复制代码

}

public abstract class Animal{//所有动物都会吃public abstract void eat();
//所有动物都会飞
public void fly(){};
复制代码

}

public class concreteAnimal implements Animal{//所有动物都会吃public void eat(){}
//所有动物都会飞
public void fly(){}
复制代码

}

public class concreteAnimal extends Animal{//所有动物都会吃public void eat(){}
//所有动物都会飞
public void fly(){}
复制代码

}