Java 接口与模块设计模式

一、JDK1.8前的接口

1.狭义的定义：interface（关键字） 接口名 {}

2.广义的定义：接口就相当于定义了，一个规则，我们要想使用这个接口，就必须遵守这个规则
注：定义的是jdk1.8以前的规则
 1）.接口中只能声明抽象方法
 2）.如果你声明一个方法，没有写abstract,系统会默认帮你加上--abstract
 3）.接口没有构造方法，不能直接实例化对象
 4）.接口中定义的成员变量，默认的修饰词是 public static finall是常量，并且直接用接口名去调用
 使用接口的关键字，implements(实现）---实现这个接口
注：接口的实现类，都有后缀的Impl
3.
1）类和类的关系
 类和类 继承关系 只能单继承，可以多层继承
2）类和接口的关系
 类和接口 实现的关系 可以单实现，也可以多实现（接口可以有很多个)
3）接口和接口的关系
是继承关系，可以单继承，也可以多继承
例题
动物：吃，叫  
猫：猫吃鱼，喵喵
跳高猫
训练动物：训练跳高
训练猫：会跳高的猫
4）代码
例题1：
public class Demo02 {
public static void main(String[] args) {

}
}
abstract class Animal{
    //抽象方法
    public abstract void eat() ;
    public abstract void speak();
}
//测试接口多实现
interface InterB{
    public abstract void fun1();

}
interface InterC{
    public abstract void fun2();
}
//实现多接口的实现类
class InterImpl implements InterD{

    @Override
    public void fun1() {
        // TODO Auto-generated method stub  
    }
    @Override
    public void fun2() {
        // TODO Auto-generated method stub  
    }
    @Override
    public void fun3() {
        // TODO Auto-generated method stub      
    }
}
//单继承 多继承
interface InterD extends InterB,InterC{
    public abstract  void fun3();
}

//写个接口 训练
interface CatJumpInter {    
    //训练猫
    public abstract void jump();
}
//猫类继承 实现接口
class Cat extends Animal {
//重写抽象类里的方法
    @Override
    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("猫吃鱼");
    }
    @Override
    public void speak() {
        // TODO Auto-generated method stub
        System.out.println("猫叫 喵喵喵");
    }
}
//跳高猫
class JumpCat extends Cat implements CatJumpInter{
//实现接口中的方法
    @Override
    public void jump() {
        System.out.println("拿棒子 怼屁股跳高");
    }

}

例题2
package com.lanou3g.test;
需求：经过国际主板研究协会讨论 
最终要求 主板生产商 要按规则生产可插卡的主板
所有的卡都要有 开始和停止的方法
设计完成 生产 大力牌主板
public class Demo03 {
public static void main(String[] args) {
    //父类引用只想子类空间
    //多态---向上转型
    MainBoardInter mainBoardInter = new DLMainBoardInter ();
    //向上转型
      DLMainBoardInter dlMainBoardInter = (DLMainBoardInter)mainBoardInter;
      dlMainBoardInter.run();
      //添加一张网卡
      Card card = new NetCard();
      dlMainBoardInter.addCard(card);
      //只需要传入一个卡类的子类对象就行，
      dlMainBoardInter.addCard(new NetCard());

}
}
//抽象卡类 开始和停止
//声卡继承 抽象类
//大力牌实现接口

//大力牌实现接口

//主板接口
interface MainBoardInter {
    //插卡方法 new Card = new  NetCard;
    //定义主板的规则
    public abstract void addCard(Card card);
}
//大力牌主板
 class DLMainBoardInter implements MainBoardInter{
//实现主板的规则
    @Override
    public void addCard(Card card) {
        card.start();
        card.stop();

    }
    //主板启动
    public void run() {
        System.out.println("主板启动");
    }

 }

  //抽象卡类 开始和停止
abstract  class Card{
    public abstract void start();
    public  abstract void stop();
}
//声卡继承 抽象类
  class SayCard extends Card{

    @Override
    public void start() {
        // TODO Auto-generated method stub

    }

    @Override
    public void stop() {
        // TODO Auto-generated method stub

    }

  }
  //网卡
  class NetCard extends Card{
//重写网卡方法
    @Override
    public void start() {
        // TODO Auto-generated method stub
        System.out.println("开始上网");
    }

    @Override
    public void stop() {
        // TODO Auto-generated method stub
    System.out.println("中断上网");
    }

  }

二、JDK1.8后的接口

package com.lanou3g.test;
JDK1.8后 接口的新特性(暂时没有什么应用场景）
 接口中可以声明
 1.抽象方法
 2.静态方法
 使用 static 关键词修饰的方法
 3.默认方法 
 使用default关键词
 分析思路：
 * 1.明确写法
 * 2.明确如何在接口和实现类中调用
 * 3.明确如何在对象中去调用
 * 4.最后总结要注意什么
 抽象类和接口的区别
 * 1.成员变量
 * 抽象类:可以是变量也可以是常量
 * 接口:  只能是常量
 * 2.成员方法
 * 抽象类: 可以是抽象方法，也可以是普通的成员方法
 * 接口:只能是抽象方法 静态方法 默认发方法
 * 3.构造方法（抽象类和接口都不能实例化对象）
 *抽象类：可以有构造方法 可以被继承
 *接口：没有构造方法 只能被实现
 代码：
public class Demo04 {
//接口中，直接接口名调用
    public static void main(String[] args) {
        InterX.staticFun();
        //创建一个接口的实现类的对象
        InterX interX = new InterXImpl();
        //调用接口中默认的方法
        interX.defaultFun();
        //调用接口中被重写的抽象的方法
        //interX.print();
        System.out.println();

        //调用实现类中的特有方法
        InterXImpl impl = (InterXImpl)interX;
        impl.fun();

        System.out.println();
        //调用接口类中的静态方法
        InterX.staticFun();
        //调用实现类中的静态方法
        InterXImpl.staticFun();

    }
}
//定义一个接口
interface InterX{
    //声明一个抽象方法
    public abstract void print();
    //声明一个静态的方法
    public static void staticFun() {
        System.out.println("我是接口中的静态方法 staticFun");
    }
    //声明一个默认方法  
    public default void defaultFun() {
        System.out.println("我是接口的默认方法 defaultFun");
    }
}
 //如何调用接口中 静态方法 和 默认方法 
//接口的实现类
//实现类中，可以不用去实现接口中的 静态方法和 默认方法
class InterXImpl implements InterX{
//实现接口中的抽象方法
    @Override
    public void print() {
        // TODO Auto-generated method stub
        System.out.println("我是实现类中的抽象方法");
    }
    //重写接口中的默认方法
    //实现类中 如果想调用接口中默认的方法 可以使用 接口名 点 super 点 方法名（）；
    @Override
        public void defaultFun() {
        //没有对象，所以要加上接口名--作为标识（一种形式)
        InterX.super.defaultFun();
            System.out.println("我是实现类中 重写接口里的默认方法");
        }
    //实现类中特有的方法
    public  void fun() {
        //调用接口中的 默认方法
        InterX.super.defaultFun();
        System.out.println("我是实现类中的特有的方法 fun");
    }
    //静态方法 又叫类方法 
    public static void staticFun() {
        System.out.println("我是实现类中的静态方法 staticFun");
    }
}

三、 模板设计模式（设计思想）

通过例题理解：例题1
 需求：
 * 学习类 来蓝鸥学习 报名缴费
 * 选择学习进行学科学习（JAVA H5 VR)
 * 毕业找工作

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

    FenJian fenJian = new FenJian();
    fenJian.lanOuStudy();

    System.out.println();

    Study study = new FenJian();
    study.lanOuStudy();
}
}
//学习类(相当于一个模板，可以适应选择不同学科的学生）
//想让这个学习类 适应于来蓝鸥学习的每一个学生
abstract class Study 
{
    //来蓝鸥学习的方法
    public void lanOuStudy() {
        //第一步 和 最后一步 只有中间一部分不确定
        System.out.println("报名缴费");
        //调用抽象方法
        chooseSubject();
        System.out.println("毕业找工作");
    }
  //声明一个抽象的方法
    public abstract void chooseSubject();
}
class FenJian extends Study{
  //重写抽象方法
    @Override
    public void chooseSubject() {
        // TODO Auto-generated method stub
        System.out.println("选择JAVA学科");
    }

}
例题2：
package com.lanou3g.test;
 * 需求：
 * 计算一个程序的 运行时间
public class Demo06 {
public static void main(String[] args) {
    //获取1970.1.1日 和 当前系统时间的差值
    //以毫秒为单位 1秒 == 1000毫秒
    //当前 - 运行后的当前时间 
    GetTime getTime = new Test();
    getTime.getTime();
}
}
abstract class GetTime{
        public void getTime() {
     long start = System.currentTimeMillis();
     fun();         
     long stop = System.currentTimeMillis();
     //执行程序 计算时间差
     System.out.println((stop - start)+"毫秒");
}
 //声明成抽象方法 ，把执行的程序声明成抽象方法
        public abstract void fun();
}
class Test extends GetTime{
    //重写抽象方法 方法中就写 要计算的 执行时间的方法
    @Override
    public void fun() {
        for(int i = 0;i<40000;i++) {
            System.out.println(i);
            }
        }

}