java--抽象类(abstract)和接口(interface)

一.抽象类(abstract)

1.概念:

当父类中的一些方法不能确定实现的具体功能时,可以用abstract关键字来修饰该方法,此时,该方法就是抽象方法,该方法不需要实现方法体.可由其子类实现父类的抽象方法,

abstruct不能用来修饰属性,

用abstract修饰的类叫做抽象类

// 抽象类：被abstract修饰的类
public abstract class Test {
    // 抽象方法：被abstract修饰的方法，没有方法体
    abstract public void func1();
    abstract void func2();
 
    // 抽象类也是类，也可以增加普通方法和属性
    public double getArea(){
        return area;
   }
 
    protected double area;    // 面积
}

2.抽象类,抽象方法使用注意事项:

1.抽象类不能被实例化(创建对象)

2.抽象类可以没有抽象方法,但当一个类中有抽象方法时,该类必须为抽象类

3.abstract关键字只能修饰类和方法,不能修饰属性或其他

4.抽象类可以有任意成员


abstract class Abstract {
     int n;//普通属性
    static int m;//静态属性
    public Abstract(int n) {//构造方法
        this.n = n;
    }
    {
        int a=10;
    }
    abstract void fun1();
}

5.当一个类继承抽象类时,该类必须实现抽象类的所有抽象方法,除非该类也声明为抽象类


abstract class Abstract {
   
    abstract void fun1();
}
class A extends Abstract {//实现父类的所有抽象方法

    @Override
    void fun1() {
        System.out.println("A的fun1()方法");
    }
}
abstract class B extends Abstract {//子类也声明为抽象方法,就无需再实现父类的抽象方法
    
}

6.抽象方法不能用private,final,static修饰,因为这些都与重写相违背

二.接口

1.概念:接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口

语法:interface 接口名{}

定义一个接口AA,

3.使用:

接口不能直接使用，必须要有一个"实现类"来"实现"该接口，实现接口中的所有抽象方法,用implements 来实现接口

语法:class 类名 implements 接口名

定义一个类BB来实现接口AA,BB必须要实现AA中的所有方法,(否则会编译失败)

注意：子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系。

4.接口的特性

1.1. 接口类型是一种引用类型，但是不能直接new接口的对象

2. 接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错)

3. 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现

4. 接口中不能有静态代码块和构造方法

5.在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口。

6.一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类

1>.实现接口中的方法

2>.声明为抽象类

7.接口与接口之间可以多继承，一个接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字.即：用接口可以达到多继承的目的。

语法:interface 接口A extends 接口B{}

接口总代码:

interface AA {//定义一个接口
    public static int a=10;//接口中的属性,方法默认都是public static 的,可省略不写
    public int b=20;
    static int c=10;
    void func();//推荐这种简便写法
//    public AA{};//
//    static {};
//    protected void func2();//接口中的属性,方法默认都是public static
                            //不能用其他修饰
//    final void func3();
}
interface A4 extends AA{}
//interface A3 extends AA {
//    void func(){//接口中的方法只能在类中实现,不能在接口中实现
//        System.out.println("aa");
//    }
//}
interface A2{
    void func3();

}
abstract class B2 implements A2{

}
class BB implements AA,A2{//一个类可以实现多个接口
//一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类
    @Override
    public void func() {
        System.out.println("AA的func()");
    }
    @Override
    public void func3() {//
        System.out.println("A2.func3()");
    }

    public static void main(String[] args) {
        //AA a=new AA();//接口不能被直接引用
    }

}

class CC{ }
//class DD extends BB,CC{//一个类只能有一个父类,不能实现多继承
//
//}

三.接口和抽象类的区别

抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法.

	抽象类abstract	接口interface
组成	普通属性+抽象方法	抽象方法+全局常量
权限	各种权限	默认public static修饰
使用方式	子类使用entends继承	子类使用implements实现
关系	一个抽象类可以实现多个接口	接口可以通过extends关键字继承多个接口
子类限制	一个子类只能继承一个抽象类	一个子类可以实现多个接口