JAVA 接口全攻略

接口

狭义的定义:关键字: interface 接口名{ }
广义的定义: 接口相当于定义一个规则 要想使用这个接口 就必须遵循这个规则

注意:

1.接口中只能声明抽象方法
2.如果你声明一个方法 没写 abstract 系统会默认帮你加上
3.接口没有构造方法 不能直接实例化对象
4.接口中定义的成员变量默认的修饰词 public static final 是常量 直接使用接口名去调用

接口和类之间的关系

类和类的关系 :类和类是继承关系 只能单继承 可以多层继承
接口和类的关系 :类和接口实现关系 可以单实现 也可以多实现
接口和接口的关系:接口和接口是继承关系 可以单继承也可以多继承

代码举例:

/*
 * 经过国际主板研究协会讨论 
 * 最终要求 主板生产商 要按规则生产可插卡的主板
 * 所有的卡都要有 开始和停止的方法
 * 设计完成 生产 大力牌主板
 * 
 * 主板接口(插卡方法)
 * 抽象卡类(开始和停止方法)
 * 声卡 继承抽象类
 * 大力牌 实现接口
 */
public class Demo03 {
    public static void main(String[] args) {        
        DaLi daLi = new DaLi(); 
        daLi.run();
        daLi.ChaKa(new NetCard());
    }
}
//主板类
abstract class Card {
    public abstract void start();
    public abstract void close();
}

//主板接口
interface CardInter {
    //插卡方法
    public abstract void ChaKa(Card card);
}
//网卡 继承主板
class NetCard extends Card{
    //重新主板类中的抽象方法
    @Override
    public void start() {
        System.out.println("开始上网"); 
    }

    @Override
    public void close() {
        System.out.println("上网结束"); 
    }   
}
// 主板品牌类 实现接口方法
class DaLi implements CardInter {
    //重新接口中的方法
    @Override
    public void ChaKa(Card card) {
        card.start();
        card.close();       
    }
    //主板启动
    public void run() {
        System.out.println("主板启动");
    }
}

上面例子中既有抽象类又有接口 那它们俩有什么区别呢?

1. 成员变量
   抽象类:可以是变量 可以是常量
   接口: 只能是常量
2. 成员方法
   抽象类:可以是抽象方法 可以是普通方法
   接口:只能是抽象方法 静态方法和默认方法
3. 构造方法(抽象类和接口都不能实例化对象)
   抽象类:有构造方法 可以被继承
   接口: 没有构造方法 只能被实现

在JDK1.8中 接口又引入了几个新特性 这里我们一起来梳理一下

接口中可以声明:
1.抽象方法
2.静态方法
3.默认方法

代码举例:

public class Demo04 {
    public static void main(String[] args) {
        InterX.staticFun(); //接口名直接调用静态方法
        // 创建一个接口实现类的对象
        InterX iX = new InterXImp();
        //调用接口中的默认方法
        iX.defaultFun();
        //向下转型
        InterXImp imp = (InterXImp)iX;
        imp.fun();
        //调用实现类的静态方法
        InterXImp.staticFun();

    }
}

interface InterX{
    //抽象方法
    public abstract void print();
    //静态方法
    public static void staticFun() {
        System.out.println("我是接口中静态方法 staticFun()");
    };
    //默认方法(使用 default关键词)
    public default void defaultFun() {
        System.out.println("我是接口中默认方法 defaultFun()");
    }
}

//接口的实现类
//实现类中 可以不去重写 实现接口中的静态方法 和 默认方法
class InterXImp implements InterX{
    //抽象方法
    @Override
    public void print() {
        System.out.println("我是实现类中的抽象方法");  
    }

    // 重写接口中默认方法
    @Override
    public void defaultFun() {
        // 实现类中如果想调用接口类中的默认方法可以使用  
        //接口名.super.方法名();
        InterX.super.defaultFun();
        System.out.println("我是实现类中的默认方法");
    }
    //实现类中的也有方法
    public void fun() {
        //调用接口中的 默认方法
        InterX.super.defaultFun();
        System.out.println("我是实现类中的特有方法");
    }

    //重写接口里的 静态方法 又叫 类方法
    public static void staticFun() {
        System.out.println("我是实现类的静态方法");
    }

}

模板设计模式 —-(设计思想)

代码举例:

/*
 * 模板设计模式 ----(设计思想)
 * 
 * 学习类 来学校学习 
 * 报名 
 * 缴费 
 * 学习学科(java H5 VR) 
 * 毕业 找工作
 */

public class Demo05 {
    public static void main(String[] args) {

        Study study = new Stu1();
        study.schoolStudy();
        Study study2 = new stu2();
        study2.schoolStudy();   
    }
}

//学习类(相当于一个模板 可以适用选择不同学科的人)
//目的 适用于每一个来学校学习的人
abstract class Study{
    //来学校学习的方法
    public void schoolStudy() {
        //第一步和最后一步已经确定
        //只有中间一部分不确定
        System.out.println("报名缴费");
        chooseSubject();
        System.out.println("毕业找工作");

    }
    //声明一个抽象方法
    public abstract void chooseSubject();
}

class Stu1 extends Study{
    @Override
    public void chooseSubject() {
        System.out.println("我选择 JAVA 学习");      
    }   
}

class stu2 extends Study{
    @Override
    public void chooseSubject() {
        System.out.println("我选择 H5 学习");                
    }   
}