第十三天

抽象类顾名思义，比较抽象，所以我们从三个问题来入手讲解：

1.这个东西有什么用？用来干什么的？它的意义在哪里？（显然，如果是没用的东西，就没必要浪费时间了；其实，弄懂了这个问题，就掌握了60%）

2.这个概念或者技能点怎么用？也就是它的表现形式，如关键字、修饰词、语法什么的。。。（这个占20%）

3.这个东西在用的过程中，有哪些关键点和细节点？（占20%）

上面三个问题搞清楚了，剩下的就是去用了。。。“无他，但手熟尔。”

 

一、第一个问题：抽象类有什么用？它存在的意义是什么？

这回答这个问题之前，先看一下动物界里的一个例子：首先，有一个父类Animal，接着有两个子类，分别是鸟Bird和狗Dog，如下：

public class Animal {
   public void bark() {  
   }
}

public class Bird extends Animal{
    @Override
    public void bark() {
      System.out.println("小鸟是叽叽叫声");
    }  
}

public class Dog extends Animal{
    @Override
    public void bark() {
        System.out.println("汪汪叫");
    }
}

可以看到，父类Animal有一个叫唤的方法bark（），两个子类都继承了这个方法，并进行了重写，Bird是唧唧叫，Dog是汪汪叫，现在的问题是Animal怎么叫？它的bark（）方法体里应该输出什么样的叫声，是“汪汪”还是“唧唧”？

显然，动物是个抽象的集合名词，我们并不知道动物Animal怎么叫，所以，bark（）方法在父类中实现不了，或者说实现了没有任何意义，bark（）方法只能在子类中根据具体情况去实现。这样的话就可以把父类Animal中的bark（）方法声明为abstract抽象方法，此时这个类也成了abstract抽象类。

至此，也就可以回答第一个问题，抽象类用来做什么的？抽象类自己并不能实例化，它存在的意义就是为了让子类继承。对于一个父类，它的某个方法在父类中实现没有任何意义，必需在子类中根据具体情况实现，那么这个方法可以声明为abstract抽象方法，此时这个父类也成了abstract抽象类。（当然，你也许会想，就像上面那样，函数的花括弧里为空不也可以？是的，语法上没毛病，甚至用法上也没毛病，但一般还是把它抽象成abstract方法。原因有三点：1.就像上面说的，这样弄“实现了没有任何意义”；2.Java里面不鼓励函数体的内容为空；3.用法上子类继承父类后，子类会被强制重写父类中的抽象方法，起到一个提醒和约束的作用。）

二、第二个问题：抽象类怎么用？表现形式是什么样的？

这个问题相对简单，就是语言设计者的一些规定，Java中规定用abstract来修饰抽象方法和抽象类。上面的Animal类写成如下形式：

public abstract class Animal {//class前面有abstract关键字的类，就是抽象类
   public abstract void bark();
   //这种有abstract关键字的方法，我们叫抽象方法，抽象方法就是不能实现的方法，没有方法体的方法
}
//一个类中，只要存在抽象方法，那么Java语法规则要求，类上面必须加abstract关键

三、第三个问题：抽象类在用的过程中有哪些关键点？

抽象类并不是只能包含象方抽法，他也可以包含普通的成员方法和成员变量。它和普通类的区别主要有三点：

1.抽象类中的抽象方法只能用public或protected修饰。因为，抽象方法来到世间就是为了让子类继承重写的，而private的方法不能被子类继承，显然矛盾。

2.抽象类不能创建对象，即不能实例化。因为，抽象类中包含没有实现的抽象方法，是不完整的，所以不能用来创建对象。（有一种特殊情况，就是一个类中并没有抽象方法，但是类class有abstract修饰，被声明为抽象类，那么这个类也是抽象类，也不能实例化。）

3.如果一个类继承于一个抽象类，那么子类必须实现父类的抽象方法。否则，子类继承的方法还是抽象方法，子类也变成了抽象类，要用abstract修饰。

在其他方面，抽象类和普通类并无区别。

public abstract class Animal {//class前面有abstract关键字的类，就是抽象类
    private int a = 10; //抽象类中的普通属性
   public abstract void bark();
   //这种有abstract关键字的方法，我们叫抽象方法，抽象方法就是不能实现的方法，没有方法体的方法
   public void say() {  //抽象类中的普通方法
       System.out.println("抽象类中，我们是可以写普通的方法");
   }
}
//一个类中，只要存在抽象方法，那么Java语法规则要求，类上面必须加abstract关键

public class Bird extends Animal{
    @Override
    public void bark() {
      System.out.println("小鸟是叽叽叫声");
    }  
}

public class Dog extends Animal{
    @Override
    public void bark() {
        System.out.println("汪汪叫");
    }
}

    public class Test {
        public static void main(String[] args)  {
            Dog dog = new Dog();
            dog.bark();//调用子类中实现的抽象方法
            dog.say();//调用抽象类中的普通方法     
    }
}

接口

1、接口是什么？有什么意义？

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，但基本没什么意义，在我的开发经验里还没有在实际项目中在接口声明变量的应用。

 

通俗来讲，我们前面学习了抽象类，理解了抽象类，在看接口，就要容易理解一些了，我们可以这样理解接口，抽象类里可以有不实现的方法（抽象方法，存在的目的是让继承抽象类的子类去实现的），当然也可以有普通实现了的方法，那么接口呢？它里面的所有的方法都必须是抽象方法，所以我们可以把接口理解为比抽象类更加抽象的一种类型，它的存在就是为了给实现接口的“子类”来到世间的！

2、接口的实现语法，在Java中，定一个接口的形式如下：

public interface InterfaceTest {
    public void test1();//在接口中所有的方法都是抽象方法，可以省略 abstract
    
    public String test2();
    
    default void test3() {}//jdk1.8以后的新特性
}

public class InterfaceTestMain implements InterfaceTest{
  //接口不实现  会报错
    @Override
    public void test1() {
        // TODO Auto-generated method stub   
    }
    @Override
    public String test2() {
        // TODO Auto-generated method stub
        return null;
    }
}

3、注意接口有关的关键点

在jdk1.8以后增加default方法。default修饰的方法是可以在接口的实现类中不实现的。

 

要让一个类遵循某组特定的接口需要使用implements关键字，具体格式如下：

class ClassName implements Interface1,Interface2,[....]{

}

可以看出，允许一个类遵循多个特定的接口。如果一个非抽象类遵循了某个接口，就必须实现该接口中的

所有方法。对于遵循某个接口的抽象类，可以不实现该接口中的抽象方法。

public interface Usb {  //接口相当于规则，凡是实现这个接口的类，你必须在实现类里定义这两个方法
   public void install();
   public void work();
}

public class Phone implements Usb{

    @Override
    public void install() {
      System.out.println("为手机安装usb驱动");
    }

    @Override
    public void work() {
       System.out.println("通过usb接口，来给手机传递数据");
    }

}

public class Print implements Usb{

    @Override
    public void install() {
     System.out.println("为打印机安转usb驱动");
    }

    @Override
    public void work() {
    System.out.println("打印机通过usb接口打印文档");
        
    }

}

public class Computer {
    public void plugin (Usb usb) {
        usb.install();//表面上，我们调用的是接口里的抽象方法，实质上，真正调用的是连接上电脑的设备里实现的具体的方法
        usb.work();
    }
}

public class Test {
     public static void main(String[] args) {
          Computer computer =  new Computer();
            Phone phone = new Phone();
            Print print = new Print();
            computer.plugin(phone);
            computer.plugin(print);
            //结果如下
//            为手机安装usb驱动
//            通过usb接口，来给手机传递数据
//            为打印机安转usb驱动
//            打印机通过usb接口打印文档
    }   
}