Java中abstract和interface的概念理解

abstract

abstract：抽象的

1、可以用来修饰：类、方法

2、具体的：
 2.1、abstract修饰的类是一个抽象类，此类不能被实例化，抽象类一定有构造器，构造器便于子类实例化时调用

 2.2、开发中，都会提供抽象类的子类，让子类对象实例化，完全相关操作    ：抽象使用的前提是继承
        
 2.3、abstract修饰的方法都是抽象方法，抽象方法都没有方法体
        
 2.4、包含抽象方法的类一定是一个抽象类,抽象类不一定有抽象方法

 2.5、子类必须重写父类中的抽象方法，该子类才可以实例化，否则该子类也是一个抽象类
        
3、注意点：

    3.1、abstract不能用来修饰：构造器、属性等结构

    3.2、abstract不能用来修饰私有(private)方法,静态方法(static),final方法,final类

4、abstract的应用案例:

abstract class AA{		// 这是一个抽象类
    public void print(){    // 该方法可以不被重写
        System.out.println("这是第一个方法");
    };

    public abstract void print2();  // 这是一个抽象方法需要被子类重写
}

interface

interface:接口

1.接口使用interface定义
2.Java中接口和类是并列关系
3.如何定义接口：定义接口中的成员

3.1    JDK7及以前：只能定义全局常量和抽象方法
        全局常量:public static final，书写时可以省略不写
        抽象方法:public abstract的

3.2    JDK8：在原基础上增加了静态方法和默认方法
        静态方法:public static void print(){}
        默认方法:default void print(){}

4.接口不能定义构造器,不能定义构造器意味着不能实例化!!!

5.Java开发中，接口通过让类去实现(implements)的方式来使用
如果实现类覆盖了接口中的抽象方法，则该实现类可以实例化
    如果实现类没有覆盖接口中的抽象方法，那么该实现类扔是一个抽象类(abstract)

6.Java类可以实现多接口    --- 弥补了Java单继承的局限性(extends只能单继承)
格式：class AA extends BB implements CC,DD,EE......

7.接口和接口之间可以多继承

8.接口的具体使用，体现多态性

9.接口也可以看作是一种规范

2.举例

interface AA{
    public static final int n = 10;   // 全局常量
    public abstract void print1();  // 抽象方法，没有方法体
    public static void print2(){};  // 静态方法
    default void print(){
        System.out.println("这是一个默认方法");
    }
}

3.体会面向接口的思想

接口是一种多继承的类似类，它没有构造器，也就是说不能创建对象，但可以被其他类所实现，从而达到一个获取方法的作用，也可以作为一种接口，让实现类来实现方法，把接口隐藏起来，不对外开放，只能通过实现类来调用它的方法

4.Java8中关于接口的新规范

1、接口中定义的静态方法，只能通过接口来调用

class Test{
    public static void main(String[] args) {
        AA.print2();    // 静态方法只能被接口调用
    }
    interface AA{
        public static final int n = 10;   // 全局常量
        public abstract void print1();  // 抽象方法，没有方法体
        public static void print2(){};  // 静态方法
        default void print(){
            System.out.println("这是一个默认方法");
        }
    }
}

2、通过实现类的对象，可以调用接口中的默认方法(default)

class Test{
    public static void main(String[] args) {
        Test.BB b1 = new Test.BB();
        b1.print1();    // 抽象方法，已被重写
        b1.print();     // 默认方法,可重写也可不重写
    }
    interface AA{
        public static final int n = 10;   // 全局常量
        public abstract void print1();  // 抽象方法，没有方法体
        public static void print2(){};  // 静态方法
        default void print(){
            System.out.println("这是一个默认方法");
        }
    }
    
    static class BB implements AA{

        @Override
        public void print1() {
            
        }
    }
}

2.1如果实现类重写了接口中的默认方法，那么调用时是实现类中的重写方法
3、如果子类(或实现类)继承的父类和实现的接口声明了同名的默认方法，若子类未重写该默认方法，则优先使用父类的默认方法，类优先原则

4、如果实现类实现了多个接口，而多个接口中定义了同名同参数的默认方法，
// 若实现类未重写方法，报错 --> 接口冲突
// 需要我们在实现类中必须重写该方法

5、如何在子类(或实现类)的方法中调用父类，接口中被重写的方法

interface CC{
    default void print(){
        System.out.println("这是接口中的方法");
    }
}
class AA{   // 父类
    public void print(){
        System.out.println("这是父类中的方法");
    }
}

class BB extends AA implements CC{
    public void print2(){
        print();    // 子类调用自己的方法
        CC.super.print();   // 调用接口中的默认被重写的方法
    }

    @Override
    public void print() {
        super.print();  // 子类调用父类中的方法
    }
}

6、抽象类与接口的异同

相同点：不能实例化;都可以包含抽象方法

不同点：抽象类有构造器，接口没有构造器，抽象类是类，只能单继承，接口可以多继承多实现。