Java 抽象类 与 接口

先说抽象类 : 抽象类也是类,内部也可以包含普通方法和属性,甚至构造方法.

我们借用abstract关键字去定义一个抽象类.

abstract class Animal {
    public int age;
    public void fun () {
        System.out.println("Animal fun()");
    }
    public abstract void walk ();
}

抽象类 和 普通类 有什么区别呢?

1. 抽象类不能实例化,普通类可以.

 2.抽象类当中,可以包含抽象方法和非抽象方法. 但是普通类只能包含非抽象方法!

抽象类的一些要求与定义 :

1.抽象类 使用abstract修饰类

2.抽象类不能被实例化

3.在抽象类当中可以有抽象方法,  或者 非抽象方法!

4.什么是抽象方法 : 一个方法被abstract修饰,没有具体的实现,只要包含抽象方法,这个类必须是抽象类!

 再次强调一下 : 抽象方法没有具体的实现.否则就会报错.

 5.当一个普通类继承了这个抽象类,那么就必须重写抽象类当中的抽象方法!!

否则就会报错!

 6.抽象类存在的最大意义就是 : 为了被继承!  因为在抽象类它自己本身不能进行实例化,而且抽象方法也没有具体的实现,所以只能是子类重写方法后,体现出抽象类的价值!

7.抽象方法不能被private,final,static修饰, 一定要满足方法的重写规则!

因为抽象方法的存在就是为了被重写,加上这些关键字后,就不能被子类重写了,所以在定义抽象方法的时候,java就会提示错误!

 8.当一个子类没有重写父类(抽象类)的抽象方法时,可以把当前的子类变为abstract修饰.

 

 

 但是重点来了  :  如果Dog还有子类的话那么它就需要重写 Dog的父类Animal的抽象方法和Dog的抽象方法.

 DollDog类继承了Dog类,因为Dog没有重写Animal类的抽象方法,所以Dog的子类DollDog类就要重写Dog类 和 Animal 类 的抽象方法.

 

9.抽象类当中 不一定包含抽象方法.

 

接着我们再来看一下接口 : 我们先来创建一个接口 通过interface关键字

interface A {
    public static final int a = 10;
    void fun();
    public abstract void fun1();
}

定义接口 :

1.使用关键字interface来定义接口

2. 接口不能被实例化

 

3.接口当中的成员 默认是public static final

在接口中不能有不是public static final 修饰的成员变量 例如 : 

只能有这一种修饰的成员变量 : 

 

4.接口当中的方法 默认是 public abstract 修饰的

灰色字体是写上去之后 自动变灰的  意思是默认是public abstract 修饰的

一般的只需要写返回类型跟方法名就可以了.

 

5.接口当中的方法  不能有具体的实现, 但是从JDK8开始  可以写一个default修饰的方法

interface A {
    default void add() {
        System.out.println("从JDK8开始  可以写一个default修饰的方法");
    }
}

6.接口当中不能有构造方法

 

7.接口需要被类实现,使用关键字implements

class B implements A {
    @Override
    public void fun() {
        System.out.println("重写A接口的fun()方法");
    }
    @Override
    public void fun1() {
        A.a();
        int b = A.a;
    }
}

8.接口当中 可以有 static 修饰的方法 ! 

interface A {
    static void a () {
        System.out.println("asdfasd");
    }
}

在java 中不支持多继承 但是 可以实现多个接口,中间需要通过 ' , '  隔开

interface C {
    void funC ();
}
interface D {
    void funD ();
}
interface E {
    void funE ();
}
class F implements C,D,E {
    @Override
    public void funC() {
        
    }
    @Override
    public void funD() {

    }
    @Override
    public void funE() {

    }
}

接口与接口之间 使用 extends 

那么R类去实现E的接口后 就还要去重写 E 继承的接口的抽象方法.

interface C {
    void funC ();
}
interface D {
    void funD ();
}
interface E extends C,D {
    void funE ();
}
class R implements E{
    @Override
    public void funC() {
    }
    @Override
    public void funD() {
    }
    @Override
    public void funE() {
    }
}

在这里给大家举一个键盘鼠标的例子 : 

package demo5;

//IUSB 接口
public interface IUSB {
    void openDevice();
    void closeDevice();
}



package demo5;
//鼠标类

public class Mouse implements IUSB{
    @Override
    public void openDevice() {
        System.out.println("打开鼠标");
    }

    @Override
    public void closeDevice() {
        System.out.println("关闭鼠标");
    }

    public void click() {
        System.out.println("点击鼠标.");
    }
}



package demo5;
//键盘类

public class KeyBoard implements IUSB {
    @Override
    public void openDevice() {
        System.out.println("打开键盘");
    }

    @Override
    public void closeDevice() {
        System.out.println("关闭键盘");
    }
    public void knock () {
        System.out.println("敲击键盘.");
    }
}


package demo5;

//电脑类
public class Computer {
    public void open () {
        System.out.println("打开电脑");
    }
    public void close () {
        System.out.println("关闭电脑");
    }

    public void useDevice (IUSB iusb) {
        iusb.openDevice();
        if (iusb instanceof Mouse) {
            ((Mouse)iusb).click();
        } else if (iusb instanceof KeyBoard) {
            ((KeyBoard)iusb).knock();
        }
        iusb.closeDevice();
    }

}



package demo5;

//测试类
public class Test {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.open();
        Mouse mouse = new Mouse();
        KeyBoard keyBoard = new KeyBoard();
        computer.useDevice(mouse);
        computer.useDevice(keyBoard);
        computer.close();
    }
}

运行结果 : 

 总结 : 抽象类与接口的区别?

1.从结构组成上 : 抽象类里面可以包含 普通成员变量,静态成员变量,普通方法,抽象方法.

                           接口里面可以包含 : 抽象方法,静态方法,还有被public static final 修饰的成员变量.

2.从权限上 : 抽象类可以使用任何权限

                   接口只可以使用public权限

3.从子类使用上: 普通类使用extends关键字继承抽象类, 使用implements关键字实现接口.

4.从关系上  :   一个抽象类可以实现若干个接口.

                      而接口不能继承抽象类,但是接口可以使用extends关键字继承多个父接口.

5.子类限制 :  一个子类只能继承一个抽象类,不能进行多继承.

                     一个子类可以实现多个接口.