java学习第三周周记

java学习第三周周记

***day1*类的组成和static修饰符
***day2***继承
day3 final关键字和多态
day4 抽象类
day5 接口

day1.
1.一个类的成员组成
一个类的组成:
成员变量 ：在类中方法外
成员方法： 去掉了static
构造方法也是方法:
1)方法名和类名相同
2)没有具体的返回值类型
3)连void都没有
2.构造方法
构造方法的注意事项:
1)无参的构造方法,我们不给出,系统会默认提供
2)如果我们提供了有参构造方法,那么系统就不会再提供无参构造方法了!
一旦我们创建的对象的时候使用的无参构造方法创建对象,直接报错了!(建议永远给出无参构造方法)
3)构造方法是可以重载的
方法重载:overLoad
方法名相同,参数列表不同,与返回值!
参数列表不同:
1)参数个数不同
2)参数类型不同
4)构造的方法作用:
其实为了给类中属性进行赋值! (数据初始化–构造方法初始化)
给成员变量赋值有几种方式?
两种方式:
1)通过setXXX(xxx)公共的访问方法赋值
2)通过构造方法进行赋值
3.成员方法和成员变量的注意事项
成员方法:
1)是否有返回值类型
2)是否携带形式参数
有返回值,无参/带参的
没有返回值 无参/带参
总结:
成员方法都是去掉了static(非静态的),以后编程题中,除非有强制性要求,定义静态的功能,其他都是非静态!
有具体的返回值类型的成员方法,根据返回值类型去接收:数据类型 变量名= 使用对象名.成员方法名() ; 赋值调用
如果没有具体返回值类型,使用对象名.成员方法名() --单独调用
成员变量的问题:
访问问题:
1)当局部变量和成员变量名称不一致的情况:分别访问即可!
2)当局部变量和成员变量名称一致的情况:
遵循就近原则:
先在局部位置找(方法定义中或者方法声明上),如果有这个变量,直接使用;
如果局部位置找不到,没有这个变量,然后在成员位置中找,有就使用!
4.静态修饰以及静态修饰的注意事项：
static(静态修饰符)的特点什么:
1)被静态修饰的变量,方法-----静态变量/静态方法随着类的加载而加载
2)被静态修饰的优先于对象存在，staitc和this是不能共存的
加载类---- xxx.class ----先执行的
类名 对象名 = new 类名() ; 创建对象 — 后执行的
3)被静态修饰:有共享,共用的意思
4)被静态修饰的变量/方法,可以被类名直接访问! (推荐)
格式: 类名.静态变量名;
类名.静态方法名();
关于静态的注意事项
1)定义静态的变量----成员位置----成员变量 —加入static
2)非静态的成员方法能不能访问静态的成员变量
既可以访问非静态的成员变量,也可以访问静态的变量!
非静态的成员方法能不能调用静态的成员方法呢?
既可用于调用非静态的成员方法,也可以调用静态的成员方法呢

3)静态的成员方法,能不能访问非静态的成员变量呢?
不能, 只能访问静态的成员变量
静态的成员方法,能不能调用非静态的成员方法呢?
不能,只能调用静态的成员方法
总结:
非静态的成员方法,既可以访问静态的成员变量/非静态的成员变量
既可以访问静态的成员方法/非静态的成员方法
静态只能访问静态!------回想:之前学习Java中的"方法"的时候,
不管是有没有具体返回值类型方法,都是static定义,这些方法最终都是在main方法的
因为main方法是静态!
静态变量和成员变量(非静态的)的区别:
1)在类中位置相同的,成员位置(类中,方法外),写法格式不同的
静态变量: static修饰 数据类型 变量名;
成员变量 : 数据类型 变量;
2)内存中位置不一样:
静态成员变量:方法区中—静态区域中
成员变量:堆内存中
3)生命周期不同 (静态的变量优先于对象存在的)
静态成员变量:随着类的加载而加载, 类就加载一次,static变量加载一次,随着类的加载完毕,在方法区中不会立即消失
成员变量:随着对象的创建而存在, 随着对象的创建完毕,等待垃圾回收器回收!
4)初始化时机不同
静态成员变量:类加载的时候可以直接初始化!
成员变量:对象创建完毕,才进行初始化!
5.代码实现
写一个Worker 类，并创建多个Worker 对象。

1. 为Worker 类添加三个属性，1）String 类型的name，表示工人的姓名；
   2）int 类型的age，表示工人的年龄；3）double 类型的salary，表示工人
   的工资。
2. 为Worker 类添加两个构造方法，1）公开无参构造方法；2）接受三个参
   数的构造方法，三个参数分别为字符串、int 和double 类型。
3. 为Worker 类添加两个work 方法，一个无参，另一个带整数参数，表示
   工人工作的时间（为多少小时）。
   Worker如下的属性的类型以及构造方法相关的参数
   name:String
   age:int
   salary:double
   Worker()
   Worker(name:String,age:int,salary:double)
   work();
   work(hours:int)

class Worker {
    String name;
    int age;
    double salary;
    public Worker() {
    }
    public Worker(String name, int age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
    public void work(){
        System.out.println("工人正在工作");
    }
    public int work(int hours){
        return hours;
    }

}
public class WorkTest {
    public static void main(String[] args) {
        Worker worker=new Worker("小明",22,123112);
        System.out.println("工人的名字："+worker.name+" 工人的年龄："+worker.age+" 工人的工资"+worker.salary);
        worker.work();
        worker.work(16);
        System.out.println("工人一天工作："+worker.work(16)+"个小时");
    }
}

day2
1.代码块
代码块:在Java中,使用{} 括起来的内容
分类:
局部代码块:
在局部位置,方法定义中书写{},作用:限定局部变量的生命周期
构造代码块:
在类的成员位置,使用{}—构造代码块
特点:每次执行构造方法之前,先执行构造代码块, 作用:将构造方法中的相同的内容放在构造代码块中
静态代码块:在类的成员位置,使用static{…}
作用:在加载类的时候,随着类加载而加载,优先于对象存在…
类就加载一次,静态代码块执行一次!
优先级:
静态代码块 > 构造代码块 > 构造方法
2.继承
（1）什么是继承?
将多个类的共性内容,抽取到一个独立的类中,让这独立的类和其他类产生一种关系
继承关系!
关键字:extends
格式
class 子类名 extends 父类名{}

    继承的好处:
       1)提高了代码的复用性
       2)提高了代码维护性
       3)类与类产生的关系---是多态的前提条件!
    类与类之间的关系:也是弊端
       Java中 设计原则----所有的设计原则:开闭原则,接口分离原则...必须都遵循下面的原则!
               遵循: 低耦合,高内聚
               耦合:指的是类与类之前的关联度(越小越好)               ------- 第三阶段:Spring框架 (IOC容器)
               内聚:执行某一件事情的能力 (一个类中能完成的,不要使用多个类共同完成!)

（2）继承的特点:
1)仅仅是在Java中,只支持单继承 (类与类之间的关系) class 子类名 extends 父类名{}
在有的编程语言中,支持多继承 ----- class 子类名 extensd 父类名1,父类名2{…}
2)虽然Java中类与类之间的关系,不支持多继承,但是可以多层继承
Java中:任何类(自定义的类还是jdk提供的类)都继承自java.lang.Object----代表所有类的父类(超类)
（3）继承关系中成员变量的访问问题:
类的成员
成员变量
构造方法
成员方法
继承关系中:
子类继承父类,如果子类中的成员变量名称和父类的成员变量名称不一致的情况,分别访问即可!
子类继承父类,如果子类中的成员变量名称和父类的成员变量名称一致的情况:
遵循 “就近原则”
1)先在子类的局部位置中找,如果存在,就使用
2)如果子类的局部位置找不到,就在本类的成员位置中找,如果存在,就使用
3)如果本类的成员位置中都找不到,就在父类的成员位置中找,如果存在,就使用
4)如果父类的成员位置中找不到,就报错
（4）继承中的注意事项:
1)在继承关系中,子类继承父类,只能继承父类非私有的成员,私有的成员要访问,间接通过公共访问方法间接访问!
2)子类继承父类,构造方法是不能被继承的,通过子类访
（5）继承关系中 构造方法的访问问题
1)子类继承父类,子类的所有的构造方法都有默认的访问父类的无参构造方法,通过super() ; 可以省略不写
2)super():在子类中构造方法中第一句话:可以省略
为什么在创建子类对象的时候,为什么要去访问父类的无参构造方法?
因为存在继承关系,创建子类对象的时候,可能需要用到父类的数据;
子类的所有构造方法必须有一个让父类初始化即可!(分层初始化:先让父类初始化,然后在是子类) 默认的访问方式:super(),但是也可以间接访问父类的有参构造方法
3.面试题
如果父类中没有无参方法,子类的构造方法会有什么问题?如何解决
子类的所有构造方法都会报错!
子类的所有的构造方法:
默认要访问父类的无参构造方法 (子类构造方法中隐藏super())
解决方案:
1)手动给出父类的无参构造方法
2)可以让子类的构造方法显示的访问父类的有参构造方法
子类的构造方法的第一句:super(xxx)
3)第三种方案: 只需要让子类的一个构造方法让父类初始化即可
可以在当前子类的有参构造方法中:通过this()—访问本类的无参构造方法
然后在子类的无参构造方法中,间接的访问父类的有参构造方法
super: 代表的父类的空间标识 (代表父类的对象的地址值引用)
this:代表的本类对象的地址值引用
区别:
this.变量名; 访问的本类的成员变量
super.变量名; 访问的是父类的成员变量
this.方法名(); 访问的是本类的成员方法
super.方法名(); 访问的父类的成员方法
this(): 访问的本类的无参构造
this(xxx): 访问的是本类的有参构造
super() :访问的父类的无参构造
super(xx):访问的父类的有参构造方法
4.代码实现
假如我们在开发一个系统时需要对员工类类进行设计，程序员是员工，包含3个属性：姓名、工号以及工资。
经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。
请使用继承的思想设计出程序员类和经理类。要求类中提供必要的方法进行属性访问。

public class Person {
    private String name;
    private String gonghao;
    private double money;
    public Person() {
    }
    public Person(String name, String gonghao, double money) {
        this.name = name;
        this.gonghao = gonghao;
        this.money = money;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGonghao() {
        return gonghao;
    }

    public void setGonghao(String gonghao) {
        this.gonghao = gonghao;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}
============================================
public class Emyee extends Person {
    public Emyee() {
    }

    public Emyee(String name, String gonghao, double money) {
        super(name, gonghao, money);
    }
}
===========================================
public class Boss extends Person{
    public Boss() {
    }
    public Boss(String name, String gonghao, double money) {
        super(name, gonghao, money);
    }
    public int jiangJin(int a){
        return a;

    }
}
============================================
public class Test {
    public static void main(String[] args) {
        Emyee emyee=new Emyee();
        emyee.setName("小明");
        emyee.setGonghao("123456");
        emyee.setMoney(9999);
        System.out.println(emyee.getName()+"==="+emyee.getGonghao()+"===="+emyee.getMoney());
        Emyee emyee1=new Emyee("小明","123456",9999);
        System.out.println(emyee1.getName()+"==="+emyee1.getGonghao()+"===="+emyee1.getMoney());
        Boss boss=new Boss();
        boss.setName("小红");
        boss.setGonghao("65431");
        boss.setMoney(99999);
        System.out.println(boss.getName()+"==="+boss.getGonghao()+"===="+boss.getMoney());
        System.out.println("经理奖金；"+boss.jiangJin(1000));
        Boss boss1=new Boss("小红","65431",99999);
        System.out.println(boss1.getName()+"==="+boss1.getGonghao()+"===="+boss1.getMoney());
        System.out.println("经理奖金；"+boss1.jiangJin(1000));
    }
}	

day3
1.继承中成员方法的访问问题
子类继承父类,如果子类的方法名和父类的方法名不一致,分别访问即可!
如果子类继承父类,子类的出现的方法和父类的方法相同,如何访问呢?
先在子类的成员位置找,如果存在,就调用!
如果不存在,在父类中找,如果处在,就调用!,否则 报错
2.方法重写
（1）什么是方法重写?
子类出现了和父类一模一样的方法声明,子类将父类的功能覆盖了,复写了;
重写的目的:就是他不仅有父类的功能,还可以延用子类自己的功能!
（2）面试题:
Overload和Override的区别?
方法重载 :
定义方法的时候,方法名相同,参数列表不同,与返回值无关的方法称为"重载方法"
参数类型不同
方法重写:
继承中出现,子类要使用自己的功能,需要将父类的功能覆盖(复写)掉, 子类出现了和父类一模一 样的方法!
3.final关键字
（1）final的关键字
“最终的,无法更改的”
1)final 可以修饰类,该类不能被继承!
2)final可以修饰成员方法,该方法不能被重写
3)final可以修饰成员变量,此时变量是一个常量-----
final修饰成员变量的时候:必须给一个初始化值的,防止类加载完毕,这个变量还没有初始化!
而final修饰局部变量的时候,可以先定义,在使用之前必须初始化,而且只能赋值一次!
常量的分类
1)字面值常量
2)自定义常量:final修饰
（2）final修饰基本数据类型和引用数据类型的区别?
final修饰基本数据类型:
基本数据类型的值不能再改变了!(已经是一个常量了)
final修饰引用数据类型,引用数据类型的空间地址值不能再改变了!
4.多态
（1）多态的前提条件:
1)必须有继承关系----(类与类之间的继承关系,是多态的必须的条件!)
2)存在 方法重写
3)必须有父类引用指向子类对象 ----“向上转型”
格式:
父类名 对象名 = new 子类名() ;
多态中:父类的初始化------是通过子类创建的—存在继承关系(多态中的构造方法:分层初始化)
（2）多态的中的成员访问特点:
成员变量的访问:
格式: Fu f = new Zi() ;
编译看左边,运行看左边;
如果编译没有报错,那说明父类的存在这个成员变量,运行的时候使用的父类的变量
成员方法的访问:
格式: Fu f = new Zi() ;
编译看左边,运行看右,因为存在子类重写了父类的功能,方法重写!
静态的方法的访问:
静态修饰的都和类有关---- 不存在重写,因为类加载的时候,这些静态的功能就已经进入到方法区中
编译看左边,运行看左边! (一般不研究静态的方法)

构造方法访问:
分层初始化:
先让父类进行初始化,然后子类初始化
（3）多态的好处;
1)可以提高代码的维护性(由继承保证)
2)可以提高代码的扩展性(由多态保证的)—父类指向子类对象
（4）多态的弊端:
不能访问子类的特有功能
如何访问子类的功能
方式1:
子类 对象名 = new 子类名()
可以实现的,但是从内存角度考虑,又要创建一个新的对象----堆内存中产生新的空间地址值,内存中资源开销太大了!
方式2:
能不能使用子类的引用访问子类的功能:可以
向下转型:-----符号 强制类型转换----必须存在向上转型
子类名 变量名 = (子类名)(父类的引用) ;
5.代码实现
南方人和北方人都有姓名,年龄以及性别,都有"吃饭"的功能,但是南方人经常吃米饭,北方人经常吃面条,
南方人主要还去经商,北方人主要考学,请使用面向对象编程并且使用多态形式进行测试南方人和北方人!

public class Person {
    private String name;
    private int age;
    private String sex;
    public Person() {
    }

    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
   return name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public void eat(){
        System.out.println("人都爱吃饭");
    }
}
public class South extends Person{
    public void eat(){
        System.out.println("米饭");
    }
    public void jingShang(){
        System.out.println("经商");
    }
}
public class North extends Person{
    public void eat(){
        System.out.println("面条");
    }
    public void study(){
        System.out.println("考学");
    }
}
public class Test {
    public static void main(String[] args) {
        Person p=new South();
        p.setName("小明");
        p.setAge(22);
        p.setSex("男");
        System.out.println("南方人："+p.getName()+"===="+p.getAge()+"===="+p.getSex());
        p.eat();
       South s=(South)p;
       s.jingShang();
        Person p1=new North();
        p1.setName("小红");
        p1.setAge(23);
        p1.setSex("女");
        System.out.println("北方人："+p1.getName()+"===="+p1.getAge()+"===="+p1.getSex());
        p1.eat();
        North n=(North)p1;
         n.study();
    }
}

day4
1.关于返回值问题的研究
一个方法的返回值类型:
要么是基本数据类型
要么引用数据类型
返回值类型如果是基本数据类型: 根据返回的数据类型去接收即可!(最终具体的数据值),比较简单的

Java中研究方法的返回值—引用数据类型
如果是一个具体类 : 调用该方法的时候,需要返回的是当前这个类的具体对象!
Jdk提供的
String类:
public String substring(int beginIndex):返回值是String,需要String类的对象
2.抽象类
（1）什么是抽象类?
将一个类的成员方法给出一个声明,不给出具体实现,那么这个类必须是抽象类!
这个成员方法----称为"抽象方法"
抽象方法:跟之前的方法定义是一样,不过在方法声明省 加入一个关键字 abstract,而且这个方法没有{},
方法名后面直接是分号结束;
抽象类的格式
abstract class 类名{

       }

      有抽象方法的类一定是抽象类;但是抽象类不一定有抽象方法,也可以非抽象方法

（2）抽象类的特点:
1)不能直接实例化,但是可以间接通过子类实例化----抽象类多态!
格式:父类名 对象名= new 子类名() ; 父类----抽象类

                       如果抽象类的子类也是抽象类呢? 如何实例化,这个抽象的子类还有具体的子类,否则 没有意义!
                       一般情况:抽象类的子类---肯定最终需要有一个具体类!
         2)抽象类体现的是一种强制子类必须完成的事情:将抽象类中抽象方法,子类必须重写!

（3）抽象类中的成员特点:
1)成员变量
即可是变量也可以自定义常量
2)成员方法
可以是一个非抽象方法,也可以抽象方法(目的:不给出具体体现,具体体现交给了子类完成)
3)构造方法
可以有无参构造方法/也可以有有参构造方法:目的都得对数据进行初始化!
一般情况:abstract 关键字可以用再类上----这个类是 抽象类 (能够描述现实世界的事物—很概括的性的东西)
也可以在方法上----表示抽象方法
关于抽象中
abstract不能哪些关键字共同使用
不能final共存:本final修饰的成员方法—不能被重写
不能和private共存:本private修饰的,只能在本类中访问
不能和static共存:静态的方法算不上的方法重写,跟类相关的,抽象方法需要子类重写!
（4）注意事项:
子类继承父类,重写父类的方法的时候,访问权限不能更低,最起码应该跟父类的这个方法保持一致!
（5） 面试题:
一个类中,如果没有抽象方法,这个类可不可以定义抽象类?有什么意义呢?
可以;
意义:让当前这个类不能实例化!

           当前这个类一定有个静态的功能---它的返回值就是当前类本身!
           举例
          jdk提供
           public abstract class Calendar :日历类
           public static Calendar getInstance()
           类:
                   具体类
                   抽象类

3.代码实现
设计程序
创建一个名称为 Vehicle类并将它声明为抽象类,在Vehicle类中声明一个NoOfWheels方法,使它返回一个字符串值.
创建两个类,Car类和Motorbike类 继承自 Vehicle类,并在这两个类中实现 NoOfWheels方法.在Car类中,应该显示
"四轮车"信息;而在Motorbike类中,应当显示"双轮车"信息.创建一个带main方法的类,在该类中创建 Car和Motorbike的实例,
并在控制台显示信息!

public abstract class Vehicle {
    public String NoOfWheels(String abs){
        return abs;
    }

}
public class Car extends Vehicle{
    public String NoOfWheels(String abs){
        return abs;
    }
}
public class Motorbike extends Vehicle{
    public String NoOfWheels(String abs){
        return abs;
}
}
public class Test {
    public static void main(String[] args) {
        Vehicle v=new Car();
        v.NoOfWheels("四轮车");
        System.out.println(v.NoOfWheels("四轮车"));
        v=new Motorbike();
        v.NoOfWheels("两轮车" );
        System.out.println(v.NoOfWheels("两轮车" ));
    }
}

day5
1.接口
（1）什么是接口?
接口是针对某个具体事物提供的一种扩展功能(额外的功能)
格式:
interface 接口名{}
接口名的命名规则:和类名一致: 大驼峰命名法
（2）接口中的特点:
1)接口中的方法只能是抽象方法
2)接口的子实现类和接口之间的关系: implements 实现关系
实际开发中: 接口的子实现类的命名规则----- class 接口名+Impl implements 接口名{}
接口的子实现类必须要实现接口中的抽象方法!
3)接口不能直接实例化—不能直接new 接口名() ;
接口的实例化:通过具体的子实现类进行实例化
接口名 对象名 = new 具体的子实现类名() ; 接口多态

           接口的子实现类:如果是一个抽象类,那么它一定存在具体的子类,否则接口不能实例化了,否则没有意义!

（3）接口中的成员特点
成员变量:
此时一个常量—并且存在默认修饰符:
public static final 可以省略
成员方法:
只能是抽象方法----默认修饰符:public abstract : 可以省略
构造方法:不存在!
接口也是需要让子实现类必须重写的这些所有抽象方法;
接口没有构造方法----它只是为了提供额外的功能…
类与类 :继承关系, extends
只能单继承,不支持多继承,但是可以多层继承
类与接口:实现关系, implements
一个类继承另一个类的同时,可以实现多个接口
接口与接口:继承关系, extends
支持单继承,也支持多继承!
2.抽象类和接口的区别?
1)成员的区别
抽象类:
成员变量: 既可以是常量,也可以是变量
成员方法:既可以是抽象方法,也可以是非抽象方法
抽象方法:必须携带abstract关键字
构造方法:既可以是有参构造/也可以存在无参构造—对数据进行初始化
接口 :
成员变量:只能是常量:存在默认修饰符:public static final
成员方法:只能是抽象方法:存在默认修饰符:public abstract
构造方法:没有构造方法
2)关系的区别
类与类:继承关系, extends
只能单继承,不支持多继承,但是可以多层继承
类无非:要么具体类/抽象类
类与接口
:实现关系, implements
一个类继承另一个类的同时,可以实现多个接口
接口与接口
:继承关系, extends
支持单继承,也支持多继承!
3)设计理念的区别:
抽象类---- 抽象类—子类 由于存在"继承关系",体现一种"is a"的关系
A类是B类的一种或者B类是A类的一种…
接口---- 提供的额外的扩展功能(本身事物不存在这个功能,经过后台的学习或者种种,能够获取功能)
接口和子实现类----存在"实现关系",体现出的一种"like a"的关系
3.参数传递
（1）方法的形式参数:
基本数据类型: 形式参数的改变不会影响实际参数—传递的实际参数是具体的数值
引用数据类型: 形参的改变会直接影响实际参数(除过String:特殊的引用类型)
数组:----冒泡排序
public static void bubbleSort(int[] arr){}
类
具体类
抽象类
接口

（2）形式参数
引用数据类型: 形参的改变会直接影响实际参数(除过String:特殊的引用类型)
类
具体类:需要改具体类的对象
抽象类:实际参数传递的时候,需要传递该抽象类的子类对象!
接口
实际参数传递的时候,需要传递该接口的子实现类对象
自定义一个类 ,实现接口,重写接口中抽象方法即可!
4.方法的返回值问题研究
返回值类型是基本数据类型
需要返回该基本数类型的具体的结果
返回值类型是引用数据类型
类
具体类:需要返回该具体类型具体对象
抽象类:方法需要返回该抽象类的具体子类对象
接口
5.代码实现
笔记本电脑（laptop）通常具备使用USB设备的功能。
在生产时，笔记本都预留了可以插入USB设备的USB接口， 但具体是什么USB设备，笔记本厂商并不关心，
只要符合USB规格的设备都可以。
定义USB接口，具备最基本的开启功能和关闭功能。
鼠标和键盘要想能在电脑上使用，那么鼠标和键盘也必须遵守 USB规范，实现USB接口，
否则鼠标和键盘的生产出来也无法使用。(使用面向对象思想编程：接口，多态等)

interface Usb {
public abstract void on();
public abstract void close();
}
class Mouse implements Usb{
    @Override
    public void on() {
        System.out.println("打开鼠标");
    }
    @Override
    public void close() {
        System.out.println("关闭鼠标");
    }
}
class KeyBord implements Usb{
    @Override
    public void on() {
        System.out.println("打开键盘");
    }
    @Override
    public void close() {
        System.out.println("关闭键盘");
    }
}
class Computer {
     public void computer(Usb usb){
         usb.on();
         usb.close();

     }
}
 class Test{
    public static void main(String[] args) {
        Computer c=new Computer();
    c.computer(new Mouse());
    c.computer(new KeyBord());

    }
}