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