Java 面试系列 ——1.Java基础接口和抽象类

最新推荐文章于 2024-05-23 18:18:28 发布

不会飞的龙-IT

最新推荐文章于 2024-05-23 18:18:28 发布

阅读量120

点赞数

分类专栏：面试 java javase 文章标签： Java 面试 javase

本文链接：https://blog.csdn.net/lpl12345/article/details/100857100

版权

javase 同时被 3 个专栏收录

8 篇文章 0 订阅

订阅专栏

java

4 篇文章 0 订阅

订阅专栏

面试

3 篇文章 0 订阅

订阅专栏

接口和抽象类

接口和抽象类这两个东西很抽象，很相似，但是二者之间到底有何关系，有了抽象类可以满足编程的基本需求了，为什么又会出现接口呢？java，C#等高级语言都是不支持继承多个父类的，因为多重继承很复杂，很容易产生问题，单重继承又很拘束，因为有些具体的方法父类没有！这该怎么办呢，高级语言中的接口就出现了，它解决了单重继承的缺点！

接下来举个例子，一个抽象类人，然后我将它实例化成具体的人——小明，小明就有了一般人的具体的行为，比如可以走路，说话，看电影。。但是一般的人不会做饭，我想给小明加一项技能——做饭，这该怎么办呢，这时候哦就可以通过接口给小明加上一项技能——做饭！完美，此时小明又想学习钢琴，没关系，在继续找一个钢琴的接口，去实现它就好了，这时候小明就会了弹钢琴！

1.接口

接口（硬件类接口）是指同一计算机不同功能层之间的通信规则称为接口。接口（软件类接口）是指对协定进行定义的引用类型。其他类型实现接口，以保证它们支持某些操作。接口指定必须由类提供的成员或实现它的其他接口。与类相似，接口可以包含方法、属性、索引器和事件作为成员。

（1）Java接口定义

Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。两种含义：一，Java接口，Java语言中存在的结构，有特定的语法和结构；二，一个类所具有的方法的特征集合，是一种逻辑上的抽象。前者叫做“Java接口”，后者叫做“接口”。

（2）Java接口功能

在Java语言规范中，一个方法的特征仅包括方法的名字，参数的数目和种类，而不包括方法的返回类型，参数的名字以及所抛出来的异常。在Java编译器检查方法的重载时，会根据这些条件判断两个方法是否是重载方法。但在Java编译器检查方法的置换时，则会进一步检查两个方法(分处超类型和子类型)的返还类型和抛出的异常是否相同。接口实现和类继承的规则不同，为了数据的安全，继承时一个类只有一个直接父类，也就是单继承，但是一个类可以实现多个接口，接口弥补了类的不能多继承缺点，继承和接口的双重设计既保持了类的数据安全也变相实现了多继承。Java接口本身没有任何实现，因为Java接口不涉及表象，而只描述public行为，所以Java接口比Java抽象类更抽象化。但是接口不是类，不能使用new 运算符实例化一个接口。如 x=new comparable（......）;//这个是错误来的。但是可以声明接口变量Comparable x; //这是允许的。Java接口的方法只能是抽象的和公开的，Java接口不能有构造器，Java接口可以有public、static和final属性。即接口中的属性可以定义为 public static final int value=5; 接口把方法的特征和方法的实现分割开来。这种分割体现在接口常常代表一个角色，它包装与该角色相关的操作和属性，而实现这个接口的类便是扮演这个角色的演员。一个角色由不同的演员来演，而不同的演员之间除了扮演一个共同的角色之外，并不要求其它的共同之处。

（3）接口的声明

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

[可见度] interface 接口名称 [extends 其他的接口名] {
        // 声明变量
        // 抽象方法
}

实例

Animal.java 文件代码：
/* 文件名 : Animal.java */ 
interface Animal { 
    public void eat(); 
    public void travel(); 
}

（4）接口的实现

实现一个接口的语法，可以使用这个公式：

Animal.java 文件代码：
...implements 接口名称[, 其他接口名称, 其他接口名称..., ...] ...

实例

MammalInt.java 文件代码：
/* 文件名 : MammalInt.java */
public class MammalInt implements Animal{
 
   public void eat(){
      System.out.println("Mammal eats");
   }
 
   public void travel(){
      System.out.println("Mammal travels");
   } 
 
   public int noOfLegs(){
      return 0;
   }
 
   public static void main(String args[]){
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

（5）接口的继承

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

下面的Sports接口被Hockey和Football接口继承：

// 文件名: Sports.java
public interface Sports
{
   public void setHomeTeam(String name);
   public void setVisitingTeam(String name);
}
 
// 文件名: Football.java
public interface Football extends Sports
{
   public void homeTeamScored(int points);
   public void visitingTeamScored(int points);
   public void endOfQuarter(int quarter);
}
 
// 文件名: Hockey.java
public interface Hockey extends Sports
{
   public void homeGoalScored();
   public void visitingGoalScored();
   public void endOfPeriod(int period);
   public void overtimePeriod(int ot);
}

（6）接口的多继承

在Java中，类的多继承是不合法，但接口允许多继承。

在接口的多继承中extends关键字只需要使用一次，在其后跟着继承接口。如下所示：

public interface Hockey extends Sports, Event

以上的程序片段是合法定义的子接口，与类不同的是，接口允许多继承，而 Sports及 Event 可能定义或是继承相同的方法

2.抽象类

（1）Java抽象类的定义

Java语言中，用abstract 关键字来修饰一个类时，这个类叫作抽象类。抽象类是它的所有子类的公共属性的集合，是包含一个或多个抽象方法的类。抽象类可以看作是对类的进一步抽象。在面向对象领域，抽象类主要用来进行类型隐藏。

（2）Java抽象类的具体描述

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

（3）Java抽象类的实例

在Java语言中使用abstract class来定义抽象类。如下实例：

Employee.java 文件代码：
/* 文件名 : Employee.java */
public abstract class Employee
{
   private String name;
   private String address;
   private int number;
   public Employee(String name, String address, int number)
   {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }
   public double computePay()
   {
     System.out.println("Inside Employee computePay");
     return 0.0;
   }
   public void mailCheck()
   {
      System.out.println("Mailing a check to " + this.name
       + " " + this.address);
   }
   public String toString()
   {
      return name + " " + address + " " + number;
   }
   public String getName()
   {
      return name;
   }
   public String getAddress()
   {
      return address;
   }
   public void setAddress(String newAddress)
   {
      address = newAddress;
   }
   public int getNumber()
   {
     return number;
   }
}

注意到该 Employee 类没有什么不同，尽管该类是抽象类，但是它仍然有 3 个成员变量，7 个成员方法和 1 个构造方法。现在如果你尝试如下的例子：

AbstractDemo.java 文件代码：
/* 文件名 : AbstractDemo.java */
public class AbstractDemo
{
   public static void main(String [] args)
   {
      /* 以下是不允许的，会引发错误 */
      Employee e = new Employee("George W.", "Houston, TX", 43);
 
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
    }
}

当你尝试编译AbstractDemo类时，会产生如下错误：

Employee.java:46: Employee is abstract; cannot be instantiated
      Employee e = new Employee("George W.", "Houston, TX", 43);
                   ^
1 error

（4）继承抽象类

我们能通过一般的方法继承Employee类：

Salary.java 文件代码：
/* 文件名 : Salary.java */
public class Salary extends Employee
{
   private double salary; //Annual salary
   public Salary(String name, String address, int number, double
      salary)
   {
       super(name, address, number);
       setSalary(salary);
   }
   public void mailCheck()
   {
       System.out.println("Within mailCheck of Salary class ");
       System.out.println("Mailing check to " + getName()
       + " with salary " + salary);
   }
   public double getSalary()
   {
       return salary;
   }
   public void setSalary(double newSalary)
   {
       if(newSalary >= 0.0)
       {
          salary = newSalary;
       }
   }
   public double computePay()
   {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

尽管我们不能实例化一个 Employee 类的对象，但是如果我们实例化一个 Salary 类对象，该对象将从 Employee 类继承 7 个成员方法，且通过该方法可以设置或获取三个成员变量。

AbstractDemo.java 文件代码：
/* 文件名 : AbstractDemo.java */
public class AbstractDemo
{
   public static void main(String [] args)
   {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
 
      System.out.println("Call mailCheck using Salary reference --");
      s.mailCheck();
 
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
    }
}

（5）抽象方法

如果你想设计这样一个类，该类包含一个特别的成员方法，该方法的具体实现由它的子类确定，那么你可以在父类中声明该方法为抽象方法。Abstract 关键字同样可以用来声明抽象方法，抽象方法只包含一个方法名，而没有方法体。抽象方法没有定义，方法名后面直接跟一个分号，而不是花括号。

public abstract class Employee
{
   private String name;
   private String address;
   private int number;
   
   public abstract double computePay();
   
   //其余代码
}

声明抽象方法会造成以下两个结果：

如果一个类包含抽象方法，那么该类必须是抽象类。
任何子类必须重写父类的抽象方法，或者声明自身为抽象类。

继承抽象方法的子类必须重写该方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该抽象方法，否则，从最初的父类到最终的子类都不能用来实例化对象。

如果Salary类继承了Employee类，那么它必须实现computePay()方法：

Salary.java 文件代码：
/* 文件名 : Salary.java */
public class Salary extends Employee
{
   private double salary; // Annual salary
  
   public double computePay()
   {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
 
   //其余代码
}

3.接口和抽象类的区别

（1）接口可以多继承，抽象类不能实现多继承。

（2）接口只能定义抽象规则，抽象类既能定义抽象规则也可以提供已经实现的成员。

（3）接口是一组行为规范，抽象类是一个不完全的类，着重于族的概念。

（4）接口支持回调，抽象类不能实现回调，因为继承不支持。

（5）接口只包含方法，属性，索引器，事件的签名，但不能定义字段和包含实现的方法，抽象类可以定义属性，字段，包含有实现的方法。

（6）接口可以作用于值类型和引用类型，抽象类只能作用于引用类型（如：Struct只能继承接口）

（7）抽象类应主要用于关系密切的对象，而接口则是适合为不相关的类提供通用功能。

（8）接口着重于Can——Do关系类型，抽象类则偏重于IS——A式关系

（9）接口多定义对象的行为，抽象类多定义对象的属性

（10）如果要设计小而简练的功能块，则使用接口，如果要设计大的功能单元，则使用抽象类。

（11）接口对应的是面向对象编程思想的重要原则：面向接口编程，

抽象类对应的则是设计模式的精髓：面向抽象编程

PS：抽象类的子类继承可以推迟，而接口不可以。

不会飞的龙-IT

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java 面试系列 ——1.Java基础接口和抽象类

接口和抽象类接口和抽象类这两个东西很抽象，很相似，但是二者之间到底有何关系，有了抽象类可以满足编程的基本需求了，为什么又会出现接口呢？java，C#等高级语言都是不支持继承多个父类的，因为多重继承很复杂，很容易产生问题，单重继承又很拘束，因为有些具体的方法父类没有！这该怎么办呢，高级语言中的接口就出现了，它解决了单重继承的缺点！接下来举个例子，一个抽象类人，...
复制链接

扫一扫