首页 > > 程序设计 > Java技术 >

抽象类与接口

2020-05-13 16:08:17来源：博客园阅读 ()

抽象类与接口

抽象类

abstract关键字

可以修饰方法 -----> 抽象方法
也可以修饰类 -----> 抽象类

抽象类可以没有抽象方法，但有抽象方法的类一定要声明为抽象类

抽象类就是：类的抽象

定义抽象类

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

/**
 * 抽象类：半约束，可以不实现。
 * 需要子类去实现，就无法摆脱extends的单继承！
 */
public abstract class Action {

    // 普通方法
    public void say() {
        System.out.println("hello");
    }

    // abstract 抽象方法：只声明方法，不实现。
    public abstract void doSomething();

    // 抽象方法只包含一个方法名，而没有方法体。 
    public abstract void says();

}

抽象类不能实例化对象，只能让子类去实现所有抽象方法后，再实例化子类对象。

抽象类既然不能new对象，那么它有构造器吗？有~

Action.class

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.oop.abstracts;

public abstract class Action {
    public Action() {
    }

    public void say() {
        System.out.println("hello");
    }

    public abstract void doSomething();

    public abstract void says();
}

可以看到编译器给抽象类默认添加了一个无参构造方法！

继承抽象类

/**
 * 继承抽象类的子类，必须实现抽象类的所有抽象方法
 */
public class Run extends Action {
    @Override
    public void doSomething() {
        System.out.println("跑一圈");
    }

    @Override
    public void says() {

    }
}

通过非抽象子类创建对象

public class Application {
    public static void main(String[] args) {
        // 抽象类不能实例化对象
        //  Action action = new Action();
        Run run = new Run();
        run.say();
        run.says();
        run.doSomething();
    }
}

抽象类总结规定

抽象类不能被实例化，只有抽象类的非抽象子类可以创建对象。
抽象类中可以写普通的方法，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
抽象类中的抽象方法只包含一个方法名，而没有方法体。
抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。
构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。

抽象类存在的意义？

抽象类更利于代码的维护和重用，提高开发效率。

抽象类往往用来表征对问题领域进行分析、设计中得复出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。

具体分析如下：

1.因为抽象类不能实例化对象，所以必须要有子类来实现它之后才能使用。

可以把一些具有相同属性和方法的组件进行抽象，更有利于代码和程序制的维护。

比如：本科生和研究生可以抽象成学生，他们有相同的属性和方法。

当你对其中某个类进行修改时会受到父类的限制，提醒开发人员有些东西不能进行随意修改。

对比较重要的东西进知行统一的限制，也算是一种保护，对维护会有很大的帮助。

2.当又有一个具有相似的组件产生时，只需要实现该抽象类就可以获得该抽象类的那些属性和方法。

比如：学校新增了专科生这类学生，那么专科生直接继承学生，然后对自己特有的属性和方法进行补充即可。

这样对于代码的重用也是很好的体现。

所以，Java中抽象类对于代码的维护和重用有很好的帮助，也是Java面向对象的一个重要体现。

抽象类的应用

假如有两个程序知员，两个在两个程序里都要用到一种功能，比如要取一个对象名。

甲自己做了一个方法叫getname，乙也做了一个方法叫qumingzi。

如果两个人要去看对方的程序，那么这个方法要读懂是不是要有一个过程？

如果在公司里，有个抽象类，里面有个抽象方法叫getName。

公司规定，凡遇到这样的问题就实现这个方法。

那么这两个人要读对方的代码岂不是很容易？

接口

接口最能体现OO的精髓，对对象的抽象。

在Java编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。

普通类：只有具体实现
抽象类：具体实现和规范(抽象方法)共存
接口：只有规范！无法自己实现

约束和实现分离->面向接口编程~

声明类的关键字是class，声明接口的关键字是interface

接口就是规范！定义一组规则，它的本质是锲约，制定好之后大家都要遵守。

声明

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

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

/**
 * 用户接口，需要实现类
 * 锻炼抽象的思维
 */
public  interface UserService {
    // 定义的属性默认是静态常量：public static final
    int age = 10;

    // 定义的方法是公共抽象：public abstract
    void add(String str);
    void delete(String str);
    void update(String str);
    void query(String str);
}

public interface TimeService {
    void timer();
}

特性

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

实现

/**
 * 抽象类用继承：extends
 * 接口用实现：implements
 * 类可以实现接口,需要现实所有方法！
 * 利用接口实现伪多继承~
 */
public class UserServiceImpl implements UserService,TimeService {
    @Override
    public void add(String str) {

    }

    @Override
    public void delete(String str) {

    }

    @Override
    public void update(String str) {

    }

    @Override
    public void query(String str) {

    }

    @Override
    public void timer() {

    }
}

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

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

在实现接口的时候，也要注意一些规则：

一个类只能继承一个类，但是能实现多个接口。
一个接口能继承另一个接口，这和类之间的继承比较相似。

继承

一个接口能继承另一个接口，和类之间的继承方式比较相似。接口的继承使用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);
}

多继承

在Java中

类不允许多继承
接口允许多继承。

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

public interface Hockey extends Sports, Event

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

标记接口

最常用的继承接口是没有包含任何方法的接口。

标记接口是没有任何方法和属性的接口。它仅仅表明它的类属于一个特定的类型，供其他代码来测试允许做一些事情。

标记接口作用：简单形象的说就是给某个对象打个标（盖个戳），使对象拥有某个或某些特权。

例如：java.awt.event 包中的 MouseListener 接口继承的 java.util.EventListener 接口定义如下：

package java.util;
public interface EventListener
{}

标记接口主要用于以下两种目的：

建立一个公共的父接口：

正如EventListener接口，这是由几十个其他接口扩展的Java API，你可以使用一个标记接口来建立一组接口的父接口。

例如：当一个接口继承了EventListener接口，Java虚拟机(JVM)就知道该接口将要被用于一个事件的代理方案。
向一个类添加数据类型：

这种情况是标记接口最初的目的，实现标记接口的类不需要定义任何接口方法(因为标记接口根本就没有方法)，

但是该类通过多态性变成一个接口类型。