抽象类与接口

Posted 2020-12-20 1101-

抽象类

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)就知道该接口将要被用于一个事件的代理方案。

• 向一个类添加数据类型：

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

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

接口与类相似点：

• 一个接口可以有多个方法。

• 接口文件保存在 .java 结尾的文件中，文件名使用接口名。

• 接口的字节码文件保存在 .class 结尾的文件中。

• 接口相应的字节码文件必须在与包名称相匹配的目录结构中。

接口与类的区别：

• 接口不能用于实例化对象。

• 接口没有构造方法。

• 接口中所有的方法必须是抽象方法。

• 接口不能包含成员变量，除了 static 和 final 变量。

• 接口不是被类继承了，而是要被类实现。

• 接口支持多继承。

抽象类和接口的区别

• 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
• 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
• 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
• 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

抽象类和接口的相同点和不同点吧。

1. 在java中，抽象类和接口都不能直接进行实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。
2. 抽象类要被子类继承，接口要被类实现。
3. 接口只能做方法申明，抽象类既可以做方法申明，还可以做方法实现。
4. 接口中的变量只能是静态的公共变量，抽象类中的变量是普通的变量，即常量。
5. 抽象类中可以没有抽象方法
6. 如果一个类中有抽象方法，那么这个类是一个抽象类
7. 接口可以继承接口，并且可以多继承，但是类只能单继承。

在实际开发中，我们很少去主动定义一个抽象类，我们每天写代码，更多的是创建一个接口，然后定义接口实现类，在实现类中做对应的业务逻辑处理。