Java-10接口与抽象类

Java-10接口与抽象类

抽象方法

abstract method机制

这是一个不完整的方法，它只有一个声明，没有方法体

abstract void f();

包含抽象方法的类被称为抽象类：如果一个类包含一个或多个抽象方法，则该类必须被定义为抽象类

public abstract class Basic {
    /**
     * 1、抽象类不能够被实例化
     * 2、包含抽象方法的类称为抽象类
     * 3、如果一个类包含一个或多个抽象方法，则该类必须被定义为抽象类
     */
    abstract void unimplemented();
    abstract void f();
}

抽象类不能够被实例化

public class AbstractTest {
    public static void main(String[] args) {
//        java: org.example.onjava.example10.abstract_class.Basic是抽象的; 无法实例化
//        Basic basic = new Basic();
    }
}

如果一个新类型继承了抽象类，并希望能生成自己的对象，那它必须为基类中的所有抽象方法提供方法定义，也就是说必须重写抽象类中所有抽象方法

public abstract class Basic {
    /**
     * 1、抽象类不能够被实例化
     * 2、包含抽象方法的类称为抽象类
     * 3、如果一个类包含一个或多个抽象方法，则该类必须被定义为抽象类
     */
    public abstract void unimplemented();
    public abstract void f();
}

public class Basic2 extends Basic {
  	// 【注意】继承抽象类后，需要为所有的抽象方法提供定义
 
    @Override
    public void unimplemented() {
        System.out.println("Basic2.unimplemented");
    }
    @Override
    public void f() {
        System.out.println("Basic2.f");
    }
}

一个抽象类可以不包含任何抽象方法。

如果一个类并不需要包含抽象方法，但同时还想阻止对它任何实例化，这时将其定义为抽象类就好了

public abstract class Basic3 {
    int f(){
        return 666;
    }
    // 没有抽象方法......
 
    public static void main(String[] args) {
        Basic3 basic3 = new Basic3();
        //Basic3是抽象的; 无法实例化
    }
}

接口

⚠️接口中只允许有public 方法，默认的访问权限修饰符就是public

我们使用关键字interface来定义接口

接口如果不加上public关键字，将获得包访问权限，这样的话该接口就只能在同一个包内使用

public interface AnInterface {
    /**
     * "所有实现了这个特定接口的类看起来都像这样" -> 任何使用了特定接口的代码都知道可以为该接口调用哪些方法
     * 接口是用来在类之间建立"协议"
     * 接口通常暗示 "类的类型"
     * 1、interface关键字创建了一个完全抽象的类，它不代表任何实现
     * 2、接口描述了一个类应该是什么样子的和做什么的，而不是应该怎么做
     * 3、它确定了方法名、参数列表和返回类型，但不提供方法主体
     * 4、接口只提供一种形式，并且除了某些受限制的情况外，它通常不提供实现
     *
     */
    int method01();
    void method02();
    double method03();
    boolean method04(int a, int b);
 
}

接口也可以包含字段，但这些字段是隐式的static和final

要创建一个符合特定接口的类，使用implements【支持多实现】

/**
 * @Author Coder_Pans
 * @Date 2022/11/16 10:05
 * @PackageName:org.example.onjava.example10.interface_demo.impl
 * @ClassName: Implementation
 * @Description: TODO Concept接口的实现类
 * @Version 1.0
 */
public class Implementation implements Concept, AnInterface {// 实现多个接口用逗号隔开
    @Override
    public int method01() {
        return Concept.i;// 接口中的字段：默认是static和final的
    }
 
    @Override
    public void method02() {
        System.out.println("我实现了Concept接口......");
    }
 
    @Override
    public double method03() {
        return 0;
    }
    @Override
    public boolean method04(int a, int b) {
        return a > b;
    }
}

默认方法

当在接口中使用default时，default会允许方法创建一个方法体，实现了该接口的类可以在不定义方法[不实现该方法]的情况下直接替换方法体

/**
*
* 带有默认方法的接口
*/
public interface InterfaceWithDefault {
    void firstMethod();
    void secondMethod();
    // 默认方法
    default void newMethod(){
        System.out.println("default会允许接口中的方法创建一个方法体，" +
                "实现了该接口的类可以在不定义方法的情况下直接替换方法体.!>?" +
                "Java8之前不可以default" +
                "实现类可以不实现default方法，但也可以直接调用");
    }
}

/**
 * @Author Coder_Pans
 * @Date 2022/11/16 10:14
 * @PackageName:org.example.onjava.example10.interface_demo.impl
 * @ClassName: DefaultMethodImpl
 * @Description: TODO 实现带有默认方法的接口
 * @Version 1.0
 */
public class DefaultMethodImpl implements InterfaceWithDefault {
    @Override
    public void firstMethod() {
        System.out.println("DefaultMethodImpl.firstMethod()");
    }
 
    @Override
    public void secondMethod() {
        System.out.println("DefaultMethodImpl.secondMethod()");
    }
    // 该实现类没有实现InterfaceWithDefault中的default方法
 
    public static void main(String[] args) {
        DefaultMethodImpl defaultMethod = new DefaultMethodImpl();
        defaultMethod.firstMethod();
        defaultMethod.secondMethod();
        defaultMethod.newMethod();// 没有实现也可以直接调用
    }
}

⚠️返回值类型不是方法签名的一部分，不能够用来区分两个方法

接口中的静态方法

定义模版方法(Template Method)

/**
 * @Author Coder_Pans
 * @Date 2022/11/16 10:22
 * @PackageName:org.example.onjava.example10.interface_demo.interfaces
 * @ClassName: Operation
 * @Description: TODO 接口中 的 静态方法
 * @Version 1.0
 */
public interface Operation {
    void execute();
 
    // 设计模式 -> 模版方法(Template Method)
    // 根据需要传递任意数量的Operation参数，按顺序运行
    static void runOps(Operation... ops){
        for (Operation op : ops){
            op.execute();
        }
    }
    // 接口中 的 静态方法
    static void show(String msg){
        System.out.println(msg);
    }
}
 

runOps()使用可变参数列表，可以根据需要传递任意数量的参数，并且顺序运行.....

/**
 * @Author Coder_Pans
 * @Date 2022/11/16 10:27
 * @PackageName:org.example.onjava.example10.interface_demo.impl
 * @ClassName: MetalWork
 * @Description: TODO
 * @Version 1.0
 */
class Heat implements Operation {
    @Override
    public void execute() {
        Operation.show("Heat......");
    }
}
public class MetalWork {
    public static void main(String[] args) {
        Operation twist = new Operation() {
            @Override
            public void execute() {
                Operation.show("Twist......");
            }
        };
        Operation.runOps(
                new Heat(), // 常规类
                new Operation() {// 匿名类
                    @Override
                    public void execute() {
                        Operation.show("Hammer......");
                    }
                },
                twist :: execute,// 方法引用
                () -> Operation.show("Lambda......")// lambda表达式
 
        );
    }
}

抽象类和接口

二者之间的区别

抽象类仍然是一个类，在创建新类时只能继承它一个。而创建类的过程中可以实现 多个接口。【爱是抽象且唯一的！】

组合多个接口

需要将所 有的接口名称置于 implements 关键字之后且用逗号分隔。可以有任意多个接口，并可以向上转型为每个接口，因为每个接口都是独立的类型。

/**
 * @Author Coder_Pans
 * @Date 2022/11/16 10:44
 * @PackageName:org.example.onjava.example10.interface_demo.impl
 * @ClassName: Adventure
 * @Description: TODO 组合多个接口，接口的多继承
 * @Version 1.0
 */
 
public class Adventure {
    public static void main(String[] args) {
 
    }
}
 
/**
 * 需要将所 有的接口名称置于 implements 关键字之后且用逗号分隔。
 * 可以有任意多个接口，并可以向上转型为每个接口，因为每个接口都是独立的类型。
 */
class Hero extends D
        implements A, B, C{
 
    @Override
    public void aMethod() {
 
    }
 
    @Override
    public void bMethod() {
 
    }
 
    @Override
    public void cMethod() {
 
    }
}
interface A{
    void aMethod();
}
interface B{
    void bMethod();
}
interface C{
    void cMethod();
}
class D{
    public void dMethod(){
        System.out.println("dMethod......");
    }
}