Java基礎二十三（interface）

skylineII發表於2020-11-15

介面的使用

1.介面的使用interface來定義
2.Java中，介面和類是並列的兩個結構
3.如何定義介面：定義介面中的成員
3.1 JDK7及以前：只能定義全域性常量和抽象方法
>全域性常量：public static final。可以省略不寫
>抽象方法：public abstract

3.2 JDK8：除了定義全域性變數和抽象方法之外，還可以定義靜態方法、預設方法

4.介面中不能定義構造器，意味著介面不可以例項化
5.Java開發中，介面都通過類去實現（implements）的方式來使用。
如果實現類覆蓋率介面中所有抽象法，則此實現類就可以例項化
如果沒有覆蓋，則此實現類仍為一個抽象類
6.java類可以實現多個介面 -->彌補了java類單繼承性的侷限性
格式：class AA extends BB implements CC,DD
7.介面與介面之間可以繼承，而且可以多繼承
8.介面具體使用，體現多型性
面試題：抽象類與介面有哪些異同

public class InterfaceTest {

    public static void main(String[] args) {
        System.out.println(Flyable.MAX_SPEED);
        System.out.println(Flyable.MIN_SPEED);
//        Flyable.MIN_SPEED = 2;//不可修改

        Plane plane = new Plane();
        plane.fly();
    }
}

interface AttackAble{

    void attack();
}

interface Flyable{

    //全域性常量
    public static final int MAX_SPEED = 7900;//第一宇宙速度
    int MIN_SPEED = 1;//省略 public static final

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

    //省略public abstract
    void stop();

    //不能定義構造器
//    public Flyable(){
//
//    }
}

class Plane implements Flyable{

    @Override
    public void fly() {
        System.out.println("通過引擎起飛");
    }

    @Override
    public void stop() {
        System.out.println("駕駛員減速停止");
    }
}

//沒有覆蓋所有方法，需加上abstract，不能例項化
abstract class Kite implements Flyable{

    @Override
    public void fly() {

    }

}

class Bullet extends Object implements Flyable, AttackAble, CC{

    @Override
    public void attack() {

    }

    @Override
    public void fly() {

    }

    @Override
    public void stop() {

    }

    @Override
    public void method1() {

    }

    @Override
    public void method2() {

    }
}

//****************************************************

interface AA{
    void method1();
}

interface BB{
    void method2();
}

interface CC extends AA,BB{

}

/*
*
* 介面的使用
* 1.介面使用上也滿足多型性
* 2.介面，實際上定義了一種規範
*
* */
public class USBTest {
    public static void main(String[] args) {

        Computer computer = new Computer();
        //1.建立了介面的非匿名實現類的非匿名物件
        Flash flash = new Flash();
//        computer.transferData(usb);//介面不能例項化
        computer.transferData(flash);

        //2.建立了介面的非匿名實現類的匿名物件
        computer.transferData(new Printer());

        //3.建立介面的匿名實現類的非匿名物件
        USB phone = new USB(){

            @Override
            public void start() {
                System.out.println("手機開始工作");
            }

            @Override
            public void stop() {
                System.out.println("手機結束工作");
            }
        };
        computer.transferData(phone);

        //4.建立介面的匿名實現類的匿名物件
        computer.transferData(new USB() {
            @Override
            public void start() {
                System.out.println("mp3開始工作");
            }

            @Override
            public void stop() {
                System.out.println("mp3結束工作");
            }
        });
    }
}

class Computer{

    public void transferData(USB usb){//USB usb = new Flash();
        usb.start();
        System.out.println("具體傳輸資料細節");

        usb.stop();
    }
}

interface USB{
    //定義了長、寬、最大最小的傳輸速度

    void start();

    void stop();
}

class Flash implements USB{

    @Override
    public void start() {
        System.out.println("U盤開啟工作");
    }

    @Override
    public void stop() {
        System.out.println("U盤結束工作");
    }
}

class Printer implements USB{

    @Override
    public void start() {
        System.out.println("印表機開始工作");
    }

    @Override
    public void stop() {
        System.out.println("印表機結束工作");
    }
}

代理模式

public class NetWorkTest {

    public static void main(String[] args) {
        Server server = new Server();
//        server.browse();
        ProxyServer proxyServer = new ProxyServer(server);

        proxyServer.browse();
    }
}

interface NetWork{

    public void browse();
}



//被代理類
class Server implements NetWork{

    @Override
    public void browse() {
        System.out.println("真實的伺服器訪問網路");
    }
}

//代理類
class ProxyServer implements NetWork{

    private NetWork work;
    public ProxyServer(NetWork work){
        this.work = work;
    }

    public void check(){
        System.out.println("聯網前的檢查工作");

    }
    @Override
    public void browse() {
        check();
        work.browse();
    }


}

代理模式舉例

public class StaticProxyTest {
    public static void main(String[] args) {
//        Star s = new Proxy(new RealStar());
        Proxy s = new Proxy(new RealStar());
        s.confer();
        s.signContract();
        s.bookTicket();
        s.sing();
        s.collectMoney();
    }
}

interface Star{
    void confer();//面談

    void signContract();//籤合同

    void bookTicket();//訂票

    void sing();//唱歌

    void collectMoney();//收錢
}

//被代理類
class RealStar implements Star{

    @Override
    public void confer() {

    }

    @Override
    public void signContract() {

    }

    @Override
    public void bookTicket() {

    }

    @Override
    public void sing() {
        System.out.println("明星：唱歌~~");
    }

    @Override
    public void collectMoney() {

    }
}

//代理類
class Proxy implements Star{

    private Star real;

    public Proxy(Star real){
        this.real = real;
    }

    @Override
    public void confer() {
        System.out.println("經紀人面談");
    }

    @Override
    public void signContract() {
        System.out.println("經紀人籤合同");
    }

    @Override
    public void bookTicket() {
        System.out.println("經紀人買票");
    }

    @Override
    public void sing() {
        real.sing();
    }

    @Override
    public void collectMoney() {
        System.out.println("經紀人收錢");
    }
}

舉例

定義一個ComparableCircle類，繼承Circle類並且實現CompareObject介面。
在ComparableCircle類中給出介面中方法compareTo的實現題，用來比較兩個圓的半徑大小.

public class ComparableCircle extends Circle implements CompareObject{

    public ComparableCircle(double radius){
        super(radius);
    }
    @Override
    public int compareTo(Object o) {
        if(this == o){
            return 0;
        }
        if(o instanceof ComparableCircle){
            ComparableCircle c = (ComparableCircle)o;
//            return (int)(this.getRadius() - c.getRadius());
            //方式一
//            if(this.getRadius() > c.getRadius()){
//                return 1;
//            }else if(this.getRadius() < c.getRadius()){
//                return -1;
//            }else{
//                return 0;
//            }

            //方式二
            // 當屬性radius宣告為Double型別時，可以呼叫包裝類的方法
            return this.getRadius().compareTo(c.getRadius());
        }else{
            return 0;
        }
    }
}

public interface CompareObject {
    //若返回值是0，代表相等；若為正數，代表當前物件大；負數代表當前物件小
    public int compareTo(Object o);

}

/*
* 定義一個Circle類，宣告radius屬性，提供getter和setter方法
* */
public class Circle {

//    private double radius;
    //改成包裝類，下同
    private Double radius;

    public Double getRadius() {
        return radius;
    }

    public void setRadius(Double radius) {
        this.radius = radius;
    }

    public Circle() {
    }

    public Circle(Double radius) {
        this.radius = radius;
    }
}

public class ComparableCircleTest {
    public static void main(String[] args) {
        ComparableCircle c1 = new ComparableCircle(3.4);
        ComparableCircle c2 = new ComparableCircle(3.6);

        int compareValue = c1.compareTo(c2);
        if (compareValue > 0){
            System.out.println("c1物件大");
        }else if(compareValue < 0){
            System.out.println("c2物件大");
        }else {
            System.out.println("一樣大");
        }

        int compareValue1 = c1.compareTo(new String("AA"));
        System.out.println(compareValue1);//0

    }
}

JDK8：除了定義全域性變數和抽象方法之外，還可以定義靜態方法、預設方法

public class SubClassTest {

    public static void main(String[] args) {
        SubClass s = new SubClass();

        //1.介面中定義的靜態方法只能通過介面呼叫
//        s.method1();
//        SubClass.method1();
        CompareA.method1();
        //2.通過實現類的物件，可以呼叫介面中的方法
        //如果實現類重寫了介面中的預設方法，呼叫時仍然呼叫的是重寫以後的方法
        s.method2();
        //3.如果子類（或實現類）繼承的父類和實現的介面中宣告瞭同名同引數的方法
        //那麼子類在沒有重寫次方法的情況下，預設的是呼叫的是父類中的同名同引數的方法。-->類優先原則
        s.method3();

        s.myMethod();
    }
}

class SubClass extends SuperClass implements CompareA,CompareB{
    @Override
    public void method2() {
        System.out.println("SubClass：上海");
    }

    public void method3(){
        System.out.println("SubClass：深圳");
    }

    public void myMethod(){
        method3();//呼叫自己定義的重寫方法
        super.method3();//呼叫父類中宣告的
        //5.如估計在子類（或者實現類）的方法中呼叫父類、介面中被重寫的方法
        CompareB.super.method3();
        CompareA.super.method3();
    }
}


//4.如果實現類實現了多個介面，而這多個介面中定義了同名同引數的預設方法
//那麼在實現類沒有重寫次方法的情況下，報錯。-->介面衝突
//這就需要在實現類中重寫此方法
//class SubClass implements CompareA,CompareB{
//    @Override
//    public void method2() {
//        System.out.println("SubClass：上海");
//    }
//
//    public void method3(){
//        System.out.println("SubClass：深圳");
//    }
//}

在這裡插入圖片描述

public class SuperClass {
    public void method3(){
        System.out.println("SuperClass：上海");
    }
}

public interface CompareA {

    //靜態方法
    public static void method1(){
        System.out.println("CompareA：北京");
    }

    //預設方法
    public default void method2(){
        System.out.println("CompareA：上海");
    }

    default void method3(){
        System.out.println("CompareA：上海");
    }
}

public interface CompareB {

    default void method3(){
        System.out.println("CompareB：上海");
    }
}

java基礎：interface
2015-02-01
Java
Java-介面（interface）
2020-09-25
Java
java之介面interface
2014-10-20
Java
Java基礎-語法基礎
2020-07-27
Java
JAVA 基礎
2019-01-07
Java
【Java基礎】
2014-05-29
Java
java基礎
2024-03-17
Java
Java 基礎02Java程式設計基礎
2019-03-03
Java程式設計
java基礎-java NIO
2017-08-10
Java
Java基礎-物件導向基礎
2018-05-12
Java物件
Python零基礎學習筆記（二十三）——迭代器
2019-01-23
Python筆記
javascript基礎（包裝類和字串相關的方法）（二十三）
2017-02-08
JavaScript字串
java中的interface(介面)
2022-02-23
Java
【Java基礎】--深入剖析基礎語法
2015-08-26
Java
Scanner——Java基礎
2020-07-21
Java
Java 反射基礎
2019-03-30
Java反射
【Java基礎】Servlet
2019-07-12
JavaServlet
java基礎（四）
2020-12-19
Java
Java基礎篇
2020-11-15
Java
Java基礎（1）
2020-10-31
Java
java基礎1
2020-10-23
Java
java基礎部分
2020-09-01
Java
java基礎-介面
2020-12-23
Java
java基礎——反射
2016-12-23
Java反射
Java基礎題
2018-06-13
Java
Javase—java基礎
2017-11-26
Java
【Java基礎】方法
2016-06-28
Java
java基礎：abstract
2015-02-01
Java
【Java基礎】集合
2014-04-27
Java
java 基礎深入
2009-10-28
Java
Java基礎 --- 方法
2024-03-07
Java
Java基礎類庫【Java】
2018-10-13
Java
Java基礎系列—Java反射
2018-05-03
Java反射
【java基礎】--Java列舉
2016-03-03
Java
《java程式設計基礎》java的基礎知識（三）
2020-12-23
Java程式設計
?Java基礎之Java列舉
2020-02-13
Java
【Java反射】Java 泛型基礎
2019-01-19
Java反射泛型
JAVA學習--JAVA基礎（一）
2020-12-19
Java

Java基礎二十三（interface）

介面的使用

相關文章