java面向对象（下）-- 抽象类与接口

抽象类

　　在面向对象的概念中，所有的对象都是通过类来描述的，但是反过来，并不是所有的类都是用来描述对象的，如果一个类中没有包含足够的信息来描述一个具体的对象，这样的类就是抽象类。

　　抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

　　由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。

　　父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

　　在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

　　抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

　　当一个类中包含了抽象方法，该类必须使用abstract关键字来修饰，使用abstract关键字来修饰的类被称为抽象类

　　

//定义抽象类Animal类
 abstract class Animal {
    //定义抽象方法shout(),没有方法体
    abstract void shout();
}
//定义Dog类继承抽象类Animal类
class Dog extends Animal{
     //实现抽象方法
    @Override
    void shout() {
        System.out.println("汪汪汪....");
    }
}

//定义测试类
class Example {
    public static void main(String[] args) {
        Dog dog = new Dog(); //实例化Dog对象
        dog.shout();
    }
 }

运行结果：

 抽象类总结规定

•  抽象类不能被实例化(也就是说抽象类生来注定是被继承的，否则定义抽象类就没有意义)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。

•  抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

•  抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。

•  构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。

•  抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

　

接口

　　如果抽象类中的所有方法都是抽象的，则可以将这个类用另一种方式来定义，即接口。

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

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

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

　　接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

接口特性

• 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
• 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
• 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

接口的声明

接口的声明语法格式如下：

　

 

接口的实现

　　由于接口中的方法都是抽象方法，因此不能提供实例化对象的方式来调用接口中的方法。此时需要定义一个类，并使用implements关键字来实现接口中的所有方法。

　　当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。

• 接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。
• 接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字。
• 接口中的方法都是公有的。

//定义了接口Animal
 interface Animal {
     int Id = 1;//定义全局变量
     void breathe();//定义抽象方法breathe()
     void run(); //定义抽象方法run()
}
//定义Dog类实现了Animal接口
class Dog implements Animal{

    //实现breathe()方法
    public void breathe() {
        System.out.println("狗在吐舌头！");
    }

    //实现run()方法
    public void run() {
        System.out.println("狗在奔跑！");
    }
}
//定义测试类
class Example {
    public static void main(String[] args) {
        Dog dog = new Dog(); //实例化Dog对象
        dog.breathe(); //调用Dog类的breathe()方法
        dog.run();//调用Dog类的run()方法
    }
 }

运行结果：

 

重写接口中声明的方法时，需要注意以下规则：

• 类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常。
• 类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型。
• 如果实现接口的类是抽象类，那么就没必要实现该接口的所有方法。

接口的特点

• 一个接口能继承另一个(或多个)接口，这和类之间的继承比较相似。

• 一个类可以同时实现多个接口。

• 一个类继承另一个类时还可以实现接口。

 

一个接口能继承另一个接口，和类之间的继承方式比较相似。接口的继承使用extends关键字，子接口继承父接口的方法。

//定义了接口Animal
 interface Animal {
     int Id = 1;//定义全局变量
     void breathe();//定义抽象方法breathe()
     void run(); //定义抽象方法run()
}
//定义了LandAnimal接口并继承了Animal接口
interface LandAnimal extends Animal{  //接口继承接口
     void liveOnland(); //定义了程序抽象方法
}
//定义Dog类实现了LandAnimal接口
class Dog implements LandAnimal{

    //实现breathe()方法
    public void breathe() {
        System.out.println("狗在吐舌头！");
    }

    //实现run()方法
    public void run() {
        System.out.println("狗在奔跑！");
    }

    //实现liveOnland()方法
    public void liveOnland() {
        System.out.println("狗生活在陆地上");
    }
}
//定义测试类
class Example {
    public static void main(String[] args) {
        Dog dog = new Dog(); //实例化Dog对象
        dog.breathe(); //调用Dog类的breathe()方法
        dog.run();//调用Dog类的run()方法
        dog.liveOnland();//调用Dog类的liveOnland()方法
    }
 }

运行结果：

　　定义了两个接口，其中LandAnimal 继承了Animal接口，因此LandAnimal接口包含了三个抽象方法；当Dog实现了LandAnimal接口时，需要实现两个接口中的三个方法。

也可以通过extends关键字继承多个接口，多个接口之间用逗号隔开

 interface 接口1{
     程序代码····
 }
  interface 接口2{
     程序代码····
 }
 interface 接口3 extends 接口1,接口2{
     程序代码····
 }

一个类通过implements关键字实现接口时，可以实现多个接口，被多个接口之间用逗号隔开

 interface 接口1{
     程序代码····
 }
  interface 接口2{
     程序代码····
 }
 class 类名 implements 接口1,接口2{
     程序代码····
 }
 

一个来在继承另一个类的同时还可以实现接口，此时，extends关键字必须位于implements关键字之前。

 class 类名 extends 父类 implements 接口{
     程序代码····
 }

抽象类和接口的区别

 总结:

1. 抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。
   
2. 抽象类要被子类继承，接口要被类实现。
3. 抽象类里可以没有抽象方法
4. 类可以不实现抽象类和接口声明的所有方法，当然，在这种情况下，类也必须得声明成是抽象的。
5. 抽象类可以在不提供接口方法实现的情况下实现接口。
6. Java接口中声明的变量默认都是final的。抽象类可以包含非final的变量。
7. Java接口中的成员函数默认是public的。抽象类的成员函数可以是private，protected或者是public。
8. 接口是绝对抽象的，不可以被实例化，抽象类也不可以被实例化。
9. 一个类实现接口的话要实现接口的所有方法，而抽象类不一定
10. 类可以实现很多个接口，但是只能继承一个抽象类
11. 接口中没有 this 指针，没有构造函数，不能拥有实例字段（实例变量）或实例方法。

一句话总结：

从设计层面来说，抽象是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。

 

ps:若理解有误，请谅解！