java接口详解

[可见度] interface 接口名称 [extends 其他的接口名] {
        // 声明全局变量：可以使用省略写法
        // 抽象抽象方法：可以使用省略写法
}

package com.fan.domain2;

public interface A {
    //全局常量,可以单独省略其中任何一个关键字
    public static final double PI = 3.14;

    int a = 1;

    static int b = 2;

    final int c = 3;

    public  final int d = 4;
    //等等


    //省略了public abstract ,但是默认是有的，只是隐藏了，也可以单独省略其中一个
    void eat();//抽象方法

    public void sleep();

    abstract void run();
}

// 文件名: Sports.java
public interface Sports
{
   public void setHomeTeam(String name);
   public void setVisitingTeam(String name);
}
 
// 文件名: Football.java
public interface Football extends Sports
{
   public void homeTeamScored(int points);
   public void visitingTeamScored(int points);
   public void endOfQuarter(int quarter);
}
 
// 文件名: Hockey.java
public interface Hockey extends Sports
{
   public void homeGoalScored();
   public void visitingGoalScored();
   public void endOfPeriod(int period);
   public void overtimePeriod(int ot);
}

public interface Hockey extends Sports, Event{}

package com.fan.domain2;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

//体现接口的多态性
public class USBTest {
    public static void main(String[] args) {
        Computer computer = new Computer();
        //1.创建了接口的非匿名实现类的非匿名对象
        Flash flash = new Flash();
        computer.transferData(flash);

        //2.创建了接口的非匿名实现类的匿名对象
        computer.transferData(new Printer());

        //3.创建了接口的匿名实现类的非匿名对象
        USB phone = new USB() {
            public void start() {
                System.out.println("手机开始工作");
            }

            public void stop() {
                System.out.println("手机工作结束");
            }
        };
        computer.transferData(phone);

        //4.创建了接口的匿名实现类的匿名对象
        computer.transferData(new USB() {
            public void start() {
                System.out.println("mp3开始工作");
            }

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

}

interface USB {
    //常量：定义了长，宽，最大最小的传输速度等。

    void start();

    void stop();
}

//电脑类
class Computer {
    //参数传递最能体现多态，这里体现接口的多态性
    public void transferData(USB usb){//USB usb = new Flash()
        usb.start();
        System.out.println("具体传输数据的细节");
        usb.stop();
    }
}

//优盘类
class Flash implements USB{

    public void start() {
        System.out.println("u盘开启工作");
    }

    public void stop() {
        System.out.println("u盘结束工作");
    }
}

//打印机类
class Printer implements USB {

    public void start() {
        System.out.println("打印机开启工作");
    }

    public void stop() {
        System.out.println("打印机结束工作");
    }
}

package com.fan.domain3;
/*
*jdk8:除了定义全局常量和抽象方法外，还可以定义静态方法、默认方法
*/
public interface JDK8Test  {
    public static void main(String[] args) {
        SubClass subClass = new SubClass();

        //subClass.method1();子类完全看不到父接口的静态方法
        //SubClass.method1();
        //知识点1：接口中定义的静态方法，只能通过当前接口自己去调用。(即自己设置自己用)
        JDKFather.method1();

        /*知识点2：通过实现类的对象，可以调用接口中的默认方法。
        如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写后的方法，和继承中的重写一样的*/
        subClass.method2();

       /*
       *知识点3：如果子类（或实现类）继承的父类和实现的接口（父接口）中
       * 声明了同名同参数的默认方法，那么子类在没有重写此方法的情况下，默认
       * 调用的是父类中的同名同参数的方法。-->类优先原则，针对方法来的，属性不存在谁优先。
       *
       * 知识点4：如果实现类 仅仅是 实现了多个接口，而这多个接口中定义了同名同参数的默认方法，
       * 那么在实现类没有重写此方法的情况下，报错  --->接口冲突。
       * 这时候就需要我们必须在实现类中重写此方法。
       *
       */
        subClass.method3();
        //SubClass.method2();//此方法是默认方法。
    }

}

interface JDKFather{
    //静态方法
    public static void method1(){
        System.out.println("父接口：北京1");
    }

    //默认方法
    public default void method2(){
        System.out.println("父接口：上海2");
    }

    default void method3(){
        System.out.println("父接口：上海3");
    }
}

//演示接口冲突，此时类去掉extends SuperClass关键字
interface JDKFather2{
    default void method3(){
        System.out.println("JDKFather2：上海3");
    }
}

class SuperClass {
    public void method3(){
        System.out.println("SuperClass:北京");
    }
}

class SubClass extends SuperClass implements JDKFather,JDKFather2 {
    public  void method2(){
        System.out.println("子类：上海2");
    }

    //演示接口冲突，此时类去掉extends SuperClass关键字 和去掉此方法演示
    //如果加上此方法相当于重写了，调用的是子类重写后的方法
    public  void method3(){
        System.out.println("子类：深圳");
    }

    //知识点5：如何在子类（或实现类）的方法中调用父类、接口中的被重写的方法
    public void myMethod(){
        method3();//调用自己定义的重写的方法
        super.method3();//调用的是父类中声明的

        //调用接口中的默认方法
        JDKFather.super.method3();
        JDKFather2.super.method3();
    }
}