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

抽象类

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

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

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

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

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

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

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

　　

 1 //定义抽象类Animal类
 2  abstract class Animal {
 3     //定义抽象方法shout(),没有方法体
 4     abstract void shout();
 5 }
 6 //定义Dog类继承抽象类Animal类
 7 class Dog extends Animal{
 8      //实现抽象方法
 9     @Override
10     void shout() {
11         System.out.println("汪汪汪....");
12     }
13 }
14 
15 //定义测试类
16 class Example {
17     public static void main(String[] args) {
18         Dog dog = new Dog(); //实例化Dog对象
19         dog.shout();
20     }
21  }

运行结果：

 抽象类总结规定

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

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

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

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

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

　

接口

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

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

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

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

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

接口特性

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

接口的声明

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

　

 

接口的实现

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

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

  • 接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。
  • 接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字。
  • 接口中的方法都是公有的。
 1 //定义了接口Animal
 2  interface Animal {
 3      int Id = 1;//定义全局变量
 4      void breathe();//定义抽象方法breathe()
 5      void run(); //定义抽象方法run()
 6 }
 7 //定义Dog类实现了Animal接口
 8 class Dog implements Animal{
 9 
10     //实现breathe()方法
11     public void breathe() {
12         System.out.println("狗在吐舌头！");
13     }
14 
15     //实现run()方法
16     public void run() {
17         System.out.println("狗在奔跑！");
18     }
19 }
20 //定义测试类
21 class Example {
22     public static void main(String[] args) {
23         Dog dog = new Dog(); //实例化Dog对象
24         dog.breathe(); //调用Dog类的breathe()方法
25         dog.run();//调用Dog类的run()方法
26     }
27  }

运行结果：

 

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

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

接口的特点

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

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

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

 

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

 1 //定义了接口Animal
 2  interface Animal {
 3      int Id = 1;//定义全局变量
 4      void breathe();//定义抽象方法breathe()
 5      void run(); //定义抽象方法run()
 6 }
 7 //定义了LandAnimal接口并继承了Animal接口
 8 interface LandAnimal extends Animal{  //接口继承接口
 9      void liveOnland(); //定义了程序抽象方法
10 }
11 //定义Dog类实现了LandAnimal接口
12 class Dog implements LandAnimal{
13 
14     //实现breathe()方法
15     public void breathe() {
16         System.out.println("狗在吐舌头！");
17     }
18 
19     //实现run()方法
20     public void run() {
21         System.out.println("狗在奔跑！");
22     }
23 
24     //实现liveOnland()方法
25     public void liveOnland() {
26         System.out.println("狗生活在陆地上");
27     }
28 }
29 //定义测试类
30 class Example {
31     public static void main(String[] args) {
32         Dog dog = new Dog(); //实例化Dog对象
33         dog.breathe(); //调用Dog类的breathe()方法
34         dog.run();//调用Dog类的run()方法
35         dog.liveOnland();//调用Dog类的liveOnland()方法
36     }
37  }

运行结果：

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

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

1  interface 接口1{
2      程序代码····
3  }
4   interface 接口2{
5      程序代码····
6  }
7  interface 接口3 extends 接口1,接口2{
8      程序代码····
9  }

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

 1  interface 接口1{
 2      程序代码····
 3  }
 4   interface 接口2{
 5      程序代码····
 6  }
 7  class 类名 implements 接口1,接口2{
 8      程序代码····
 9  }
10

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

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

抽象类和接口的区别

 总结:

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

一句话总结：

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

 

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

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/wx60079/p/13406896.html