抽象abstract和接口详解

1什么是抽象(abstract)?​

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

引例

1创建一个abstract类

package ExtendLearn;
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;
    }
}

abstract是无法实例化的，例如我们去实例化这个抽象类

\package ExtendLearn;
public class AbstractTest {
    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();
    }
}

编译运行会发生以下错误

2继承一个抽象类

虽然不能实例化抽象类，但是可以通过继承实例化一个新的类。

package ExtendLearn;
    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;
        }
    }

3实例化这个类

运行结果

Constructing an Employee
Constructing an Employee
Call mailCheck using Salary reference --
Within mailCheck of Salary class 
Mailing check to Mohd Mohtashim with salary 3600.0

Call mailCheck using Employee reference--
Within mailCheck of Salary class 
Mailing check to John Adams with salary 2400.0

Process finished with exit code 0

4抽象方法

抽象方法的定义如下:

public abstract class Employee
{
    public abstract double computePay();
}

package ExtendLearn;

public class Salary extends Employee
{
    private String name="kkk";
    public String getName()
    {
        return this.name;
    }
}

package ExtendLearn;
public class AbstractTest
{
    public static void main(String[] args) {
        Salary test=new Salary();
        System.out.println(test.getName());
    }
}

运行结果：

kkk

抽象总结：

• 抽象类必须使用abstract修饰符来定义，抽象方法也必须使用abstract修饰符来修饰。
• 抽象类不能实例化。
• 抽象类可以包含成员变量、方法（普通方法和抽象方法都可）、构造器、初始化块、内部类（接口、枚举）5种成分。
• 含有抽象方法的类只能被定义成抽象类。

2什么是接口？

​ 接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

1接口与类和抽象类的对比

1接口和类的相似之处

• 接口文件保存在.java文件中，文件名使用接口名
• 一个接口可以由多个方法
• 接口的字节码文件保存在.class结尾的文件中
• 接口相应的字节码文件必须在与包名称相匹配的目录结构中

2接口和类的区别

• 接口不能用于实例化对象
• 接口没有构造方法
• 接口中的所有方法都是抽象方法
• 接口中除了static和final变量，不能有成员变量
• 接口不是被类继承，而是要被类实现
• 接口支持多继承

3接口特性

• 接口中的每一个方法都是隐式抽象的，接口中的方法会被指定为public abstract。
• 接口中可以有变量，变量被隐式的指定为public static final变量。
• 接口中的方法不能在接口中实现，只能由实现接口的类来实现。

4抽象类和接口的区别

1.抽象类中的方法可以由方法体，接口不行。
2.抽象类中的成员变量可以有各种类型。
3.接口中不能有静态代码块和静态方法，抽象类可以有静态代码块和静态方法。
4.一个类可以实现多个接口，而一个类只能继承一个抽象类。

3接口的具体例子

1定义一个接口

文件结构:

package ExtendLearn;

public interface InterfaceTest {
    public void eat();
    public void travel();
}

• 声明接口时不必使用abstract关键字
• 接口中的方法也是隐式抽象的，不必使用abstract关键字
• 接口的方法是public的。

2接口的实现

语法：implements+需要重写的接口

package ExtendLearn;

public class InterfaceTest implements InterfaceDemo {
    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[]){
        InterfaceTest m = new InterfaceTest();
        m.eat();
        m.travel();
    }
}

3重写接口中方法是需要注意

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

4实现接口时需要注意

• 一个类可以同时实现多个接口。
• 一个类只能继承一个类，但是能实现多个接口。
• 一个接口能继承另一个接口或者多个接口。

5接口的继承

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);
}