学习java的第二十一天，使用Pci接口完成显卡、声卡的输出

一、前言

转眼间又是两天过去了，这两天我都是在做书本上的练习题，也就是抽象类以及接口的练习题，相当于复习了一下之前所学习的内容吧，但是情况不容乐观，接口以及抽象类使用得还是没有那么得心顺手，下面也做了一个简单的例子，让这个接口被调用起来！

首先再来回顾一下接口，方便一会进行使用

• 定义接口的关键字是interface
• 使用接口的关键字是implements
• 接口不能用来实现方法，只能定义方法
• 接口中所有的方法都是以public abstract 来进行定义的
• 接口中所有的属性都是以public static final 来进行定义的 常量 必须有值！
• 接口中不存在构造方法，因为她本身就不是一个class类，不能被调用！

然后再来回顾一下抽象类，一会也会使用到

• 定义抽象类的关键字是 abstract
• 继承抽象类的关键字是 extends
• 抽象类可以有自己的方法
• 抽象类定义的抽象方法必须由子类来实现，或者由子子类来实现！
• 抽象方法必须存在抽象类中！
• 抽象类不能被new，也就是不能被实例化！

二、项目

1、创建接口PciInterface

package com.actual.eighth.five2;
//PCI接口
public interface PciInterface {
    void start();   //开始工作的方法，让使用接口的类来实现！
    void stop();   //结束工作的方法，让使用接口的类来实现！

}

以上就是接口，分别是开始跟结束工作的方法，等待使用接口的类来进行实现！

2、创建显卡类

package com.actual.eighth.five2;

//显卡类 继承父类以及调用接口
public class GraphicsCard extends Assembling implements PciInterface {

    @Override
    public void start() {  //这里实现了接口中开始工作的方法！
        System.out.println("开始工作啦！");
    }
    @Override
    public void stop() {   //这里实现了接口中结束工作的方法！
        System.out.println("停止工作啦！");
    }
    public GraphicsCard(String name){
        super(name);   //有参构造器，继承父类的返回值name 在new这个对象 的时候需要填入name
    }

}

以上就是创建的显卡类，这个类继承了抽象类以及使用了接口！所以需要完成上面所说的要求，但是这边没有做一个复杂的调用方法，只是实现了接口的开始与结束工作的方法！

3、创建声卡类

package com.actual.eighth.five2;

//声卡类
public class Soundcard extends Assembling implements PciInterface {

    @Override
    public void start() {
        System.out.println("开始工作啦！");
    }
    @Override
    public void stop() {
        System.out.println("停止工作啦！");
    }
    public Soundcard(String name){
        super(name);
    }

}

以上就是声卡类，继承内容以及使用接口情况跟显卡类相同！

4、创建网卡类

package com.actual.eighth.five2;

//网卡类！
public class NetworkCard extends Assembling implements PciInterface {

    @Override
    public void start() {
        System.out.println("开始工作啦！");
    }

    @Override
    public void stop() {
        System.out.println("停止工作啦！");
    }

    public NetworkCard(String name){
        super(name);
    }

}

以上就是网卡类，继承内容以及使用接口情况跟显卡类相同！

5、创建装配类

package com.actual.eighth.five2;

import java.util.Scanner;

//装配类
public abstract class Assembling {
    //这里定义了一个开始工作的方法，但并不是接口类所使用的！因为考虑到抽象类的内容！
    //其实也可以在这里直接调用接口，再给到其他类去继承，这也能实现的！但是我分开了，使用硬件类去连接接口
    public  void work(PciInterface pic){   //使用接口类的属性
        pic.start();   //开始工作  调用接口类开始工作的方法
    }
    public  void work2(PciInterface pic){//使用接口类的属性
        pic.stop();   //结束工作   调用接口类开始工作的方法
    }
    public Assembling(String name) {   //硬件的名字
        System.out.println("我是"+name);
    }

    public void qidong(){   //这个是启动程序！

        Scanner scanner = new Scanner(System.in);  //创建扫描器
        boolean flog = false;  //用来判断是否全部启动
        boolean sotpnoe = false;  //用来判断是否全部停止
        boolean qi1 = false;  //用来判断显卡是否在工作
        boolean qi2 = false;//用来判断声卡是否在工作
        boolean qi3 = false;//用来判断网卡是否在工作
        do {
            System.out.println("请问您需要启动什么设备：1、显卡 2、声卡 3、网卡 4、全部启动");
            int kai = scanner.nextInt();
                if (kai == 1&&qi1 == false) {
                        GraphicsCard xk = new GraphicsCard("显卡");
                        work(xk);
                        qi1 = true;
                } else if (kai == 2&&qi2 == false) {
                    Soundcard sk = new Soundcard("声卡");
                    work(sk);
                    qi2 = true;

                } else if (kai == 3&&qi3 == false) {
                    NetworkCard wk = new NetworkCard("网卡");
                    work(wk);
                    qi3 = true;
                }else if (kai == 4){
                    NetworkCard wk = new NetworkCard("网卡");
                    Soundcard sk = new Soundcard("声卡");
                    GraphicsCard xk = new GraphicsCard("显卡");
                    work(wk);
                    qi1 = true;
                    qi2 = true;
                    qi3 = true;
                }else {
                    System.out.println("该设备已启动！");
                    System.out.println("***********************************");
                }
                if (qi1==true&&qi2==true&&qi3==true){
                    System.out.println("所有设备已启动完毕咯~ ");
                    flog = true;
                }
        } while (!flog) ;   //如设备全部开始，则停止本次循环，开始以下的循环！
        if (flog==true){
            do {
                System.out.println("请问您需要停止什么设备：1、显卡 2、声卡 3、网卡 4、全部停止");
                int sotp = scanner.nextInt();
                if (sotp == 1&&qi1 == true) {
                    GraphicsCard xk = new GraphicsCard("显卡");
                    work2(xk);
                    qi1 = false;
                } else if (sotp == 2&&qi2 == true) {
                    Soundcard sk = new Soundcard("声卡");
                    work2(sk);
                    qi2 = false;

                } else if (sotp == 3&&qi3 == true) {
                    NetworkCard wk = new NetworkCard("网卡");
                    work2(wk);
                    qi3 = false;
                }else if (sotp == 4){
                    NetworkCard wk = new NetworkCard("网卡");
                    Soundcard sk = new Soundcard("声卡");
                    GraphicsCard xk = new GraphicsCard("显卡");
                    work2(wk);
                    qi1 = false;
                    qi2 = false;
                    qi3 = false;
                }else {
                    System.out.println("该设备未启动！");
                    System.out.println("***********************************");
                }
                if (qi1==false&&qi2==false&&qi3==false){
                    System.out.println("所有设备已经关闭咯~ bye~ ");
                    sotpnoe = true;
                    flog =true;
                }
            } while (!sotpnoe) ;  //如果设备全部关闭，则停止循环！
        }
    }

}

以上就是装配类，也是一个抽象类，包括三个接口也有继承它，相对于说它就是一个容器，用来调度各个接口的使用情况！但是并没有定义抽象方法，所以子类未重写抽象方法！装配类中的qidong方法，主要是用来执行接口的自定义启动以及关闭！

6、创建测试类

package com.actual.eighth.five2;

//测试类
public class Test {
    public static void main(String[] args) {
        //父类的引用指向了子类，用子类的构造器来暂时描述出一个装配器
        Assembling assembling = new GraphicsCard("装配器");
        //运行模块已经在装配类的qidong方法里了！
        assembling.qidong();
    }
}

这是一个测试类，因为抽象方法无法被实例化，所以这里指向的是子类的一个显卡对象，然后通过显卡对象中的有参构造，给这个引用类型进行了赋值，也就是“装配器”，然后这个这个属性去调用了父类中的qidong的方法，所以才能运行起来！

以下是效果图：

---