Java中的抽象类与接口详解-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_47044513/article/details/120269598

抽象方法

如果父类当中的方法不确定如何进行{}方法的实现，那么这就应该是一个抽象方法

抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束
抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可
如果使用抽象类和抽象方法：
1 不能直接创建new抽象对象
2 必须用一个子类来继承抽象父类。
3 子类必须覆盖重写抽象父类当中所有的抽象方法
覆盖方法(实现)：子类去掉抽象方法的abstract关键字，然后补上方法体大括号。
4 创建子类对象进行使用

注意事项：

抽象类不能直接创建对象，如果创建，编译无法通过而报错，只能创建非抽象子类的对象。
抽象中，可以有构造方法，是共子类创建对象时，初始化父类成员使用的
抽象类中，不一定包含抽象方法，但是有抽象方法的类必须是抽象类
抽象类的子类必须重写抽象类父类当中的所有抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。

例：

public abstract class Animal {

    //这个是一个抽象方法，代表吃东西，但具体吃什么(大括号的内容)不确定。
    public abstract void eat();

    //这个是普通的成员方法
    public void normalMethod(){

    }
}

public class Cat extends Animal{
    
    @Override
    public  void eat(){
        System.out.println("猫吃鱼");
    }
}

public class DemoMain {

     // Animal animal = new Animal(); 错误写法

    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();
    }

注意事项的第四点：

//最高的抽象父类
public abstract class Animal {
    public abstract void sleep();
    public abstract void eat();
}

//子类也是一个抽象类
public abstract class Dog extends Animal{

    @Override
    public void eat() {
        System.out.println("狗吃肉");

    }
    //public abstract void sleep();
}  因为继承所有也会有abstract，所以也是一个抽象类

public class Dog2Ha extends Dog{
    @Override
    public void sleep() {
        System.out.println("嘿嘿嘿");
    }

public class DogGolden extends Dog{
    @Override
    public void sleep() {
        System.out.println("呼呼呼");
    }

public static void main(String[] args) {

    //Animal animal = new Animal(); //错误，抽象类不能new
    // Dog dog = new Dog(); //错误，这个也是抽象类

    Dog2Ha ha = new Dog2Ha();
    ha.sleep();
    ha.eat(); //嘿嘿嘿 狗吃肉

    DogGolden golden = new DogGolden();
    golden.sleep();
    golden.eat();

}

接口
接口就是一种公共的规范标准

接口是多个类的公共规范
接口是一种引用数据类型，最重要的内容就是其中的，抽象方法
如何定义一个接口的形式：
public interface 接口名称{
```
  //接口内容 }
```
备注：换成了关键字interface之后，编译器的字节码文件仍然是：java–> .class
如果是Java7,那么接口中可以包含的内容有：
1 常量
2 抽象方法
如果是JAVA8，还可以额外包含有：
1 默认方法
2 静态方法
如果是Java9，还可以额外包含有：
5 私有方法

例：

public interface Demo01Interface {}

使用方法

在任何版本的JAVA中，接口都能定义抽象方法
格式：
public abstract 返回值类型方法名称(参数列表)
注意事项：
1 接口当中的抽象方法，修饰符必须是两个固定的关键字，public abstract
2 这个两个关键字修饰符，可以选择性地省略
3 方法地三要素，可以随意定义
接口使用步骤：
1 接口不能直接使用，必须有一个"实现类"来"实现"该接口
格式：
public class 实现类名称 implements 接口名称{
```
  //.... }
```
2 接口地实现必须覆盖重写(实现)接口中所有的抽象方法
实现：去掉abstract关键字，加上方法体大括号
3 创建实现类对象，进行使用
注意事项：
如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类就必须是抽象类
例：

public interface MyInterfaceAbstract {

    //抽象方法
    public abstract void methodAbs();

    public void methodAbs1(); //抽象方法

    abstract void methodAbs2();//抽象方法

    void methodAbs3();  //抽象方法
}

public class MyInterfaceAbstractImpl implements MyInterfaceAbstract {

    @Override
    public void methodAbs() {
        System.out.println("这是第一个方法");
    }

    @Override
    public void methodAbs1() {
        System.out.println("这是第二个方法");
    }

    @Override
    public void methodAbs2() {
        System.out.println("这是第三个方法");
    }

    @Override
    public void methodAbs3() {
        System.out.println("这是第四个方法");
    }

public static void main(String[] args) {
        //错误写法，不能直接new接口对象使用
        //MyInterfaceAbstract inter = new MyInterfaceAbstract();

        MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
        impl.methodAbs();
        impl.methodAbs1();

    }

接口的默认方法:

从Java8 开始，接口里允许定义默认方法。
格式：

  public default 返回值类型 方法名称(参数列表){

```
  方法体 }
```
备注：接口当中的默认方法，可以解决接口升级的问题

  如果需要添加新的内容，就不需要取每一个接口的对象处添加，直接在接口添加即可

例：

/*
* 1 接口的默认方法，可以通过接口实现类对象，直接调用
* 2 接口的默认方法，也可以被接口实现类覆盖重写*/
public class Demo02Interface {

    public static void main(String[] args) {
        //创建了实现类对象
        MyInterfaceDefaultA a = new MyInterfaceDefaultA();
        //调用抽象方法，实际运行的是右侧实现的类
        a.methodAbs(); //方法AAA
        //调用默认方法，如果实现类当中没有，会向上找接口
        a.methodAbs1();//新方法

        System.out.println("==========");
        MyInterfaceDefaultB b = new MyInterfaceDefaultB();
        b.methodAbs();//方法BBB
        b.methodAbs1();//实现类B覆盖重写了默认方法
    }

public interface MyInterfaceDefault {

    //抽象方法
    public abstract void methodAbs();

    //添加新方法，改成默认方法
    public default void methodAbs1(){
        System.out.println("新方法");
    }

}

public class MyInterfaceDefaultA implements MyInterfaceDefault{
    @Override
    public void methodAbs() {
        System.out.println("方法AAA");
    }
}

public class MyInterfaceDefaultB implements MyInterfaceDefault{
    @Override
    public void methodAbs() {
        System.out.println("方法BBB");
    }

    @Override
    public void methodAbs1(){
        System.out.println("实现类B覆盖重写了默认方法");
    }
}

Static接口：

格式：
public static 返回值类型方法名称(参数列表){
```
  方法体 }
```
提示：就是将abstract或者default换成static即可，带上方法体。

如何调用：

不能通过接口实现类的对象来调用接口当中的静态方法
正确用法：通过接口名称，直接调用其中的静态方法。
格式：
接口名称：静态方法名(参数)：
例：

public interface MyInterfaceStatic {

    public static void methodStatic (){
        System.out.println("静态方法");
    }
}

public class Demo03Interface {
    public static void main(String[] args) {
        MyInterfaceStatic.methodStatic(); //直接通过接口名称调用静态方法
    }
}

接口中private关键字

问题描述：
我们需要抽取一个共有的方法，用来解决两个默认方法之间重复代码的问题。
但是这个共有方法不应该让实现类使用，应该是私有化的
解决方法：
从Java9开始，接口当中允许定义私有方法
1 普通私有方法，解决多个默认方法之间重复代码问题
格式：
private 返回值类型方法名称(参数列表){
```
  方法体
```
}
2 静态私有方法：解决多个静态方法之间重复代码问题
格式：
private static 返回值类型方法名称(参数列表){
```
  方法体
```
}

例：

public interface MyInterfacePrivateA {

    public default void methodDefault1(){
        System.out.println("默认方法1");
        methodCommon();
    }

    public default void methodDefault2(){
        System.out.println("默认方法2");
        methodCommon();
    }

     private void methodCommon(){
        System.out.println("aaa");
        System.out.println("bbb");
        System.out.println("ccc");
    }
}

这样只有method1 与 method2 能访问commen，而主方法中不能访问。静态方法也是一样，但是static方法可以直接通过类名称访问

接口中的常量：

接口当中也可以定义"成员变量"，但是必须使用public static final三个关键字进行修饰
从效果上看，这个其实就是接口的【常量】
格式：
public static final 数据类型常量名称 = 数据值；
一旦使用final关键字，说明不可以变
1 接口当中的常量，可以省略public static final，注意：不写也是一样。
2 接口当中的常量，必须赋值，不能不赋值
3 接口中常量的名称，使用完全的大写字母，用下划线进行分隔

例：

public interface MyInterfaceConst {

    public static final int NUM_OF_MY_CLASS = 10;
}

使用方法，直接类名称.就行
例：

public class Demo05Interface {

    public static void main(String[] args) {

        System.out.println(MyInterfaceConst.NUM_OF_MY_CLASS);
    }
}

小节：

成员变量其实是常量：格式： [public] [static] [final] 数据类型常量名称 = 数据值；注意：
常量必须进行赋值，而且一旦赋值不能改变。常量必须完全大写，用下划线进行分隔
接口中最重要的就是抽象方法，格式：
[public] [abstract] 返回值类型方法名称(参数列表)；
注意：实现必须覆盖重写接口所有的抽象方法，除非实现类也是抽象类
从Java 8开始，接口里允许定义默认方法，格式：
[public] default 返回值类型方法名称(参数列表) { 方法体 }
注意：默认方法也可以被覆盖重写
从Java 8开始，接口里允许定义静态方法，格式：
[public] static 返回值类型方法名称(参数列表) { 方法体 }
注意：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法
从Java 9开始，接口里允许定义私有很乏，格式：
普通私有方法：private 返回值类型方法名称(参数列表) { 方法体 }
静态私有方法：private static 返回值类型方法名称(参数列表) { 方法体 }
注意：private的方法只有接口自己才能调用，不能被实现类或别人使用。

使用接口时需要注意： Day10 demo02

1 接口是没有静态代码块或者构造方法的
2 一个类的父类是唯一的，但是一个类可以同时实现多个接口
格式：
public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB{

  //覆盖重写所有的抽象方法 }

3 如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖一次即可
4 如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类必须是一个抽象类
5 如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写
6 一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法

接口的继承

1 类与类之间是单继承的，直接父类只有一个
2 类与类之间是多实现的，一个类可以有多个接口
3 接口与接口之间是多继承的
注意事项：
1 多个父接口当中的抽象方法如果重复，没有关系
2 多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写【而且带着default关键字】

例：

public interface MyInterfaceA {

    public abstract void methodA();
    public abstract void methodCommon();

    public default void methodDefault(){
        System.out.println("AAA");
    }
}

public interface MyInterfaceB {

    public abstract void methodB();

    public abstract void methodCommon();
    public default void methodDefault(){
        System.out.println("BBB");
    }
}

* 这个子接口当中有4个方法*/

public interface MyInterface extends MyInterfaceA,MyInterfaceB{

    public abstract void method();

    @Override
    default void methodDefault() {

    }
}

public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB {
    @Override
    public void methodA() {

    }

    @Override
    public void methodB() {

    }

    @Override
    public void methodCommon() {

    }

    @Override
    public void methodDefault() {

    }
}

抽象与接口