10-接口；多态

最新推荐文章于 2022-05-04 21:10:21 发布
原创 最新推荐文章于 2022-05-04 21:10:21 发布 · 332 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

文章目录

1. 接口

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

接口与类相似点：

  1. 一个接口可以有多个方法。
  2. 接口文件保存在 .java 结尾的文件中，文件名使用接口名。
  3. 接口的字节码文件保存在 .class 结尾的文件中。
  4. 接口相应的字节码文件必须在与包名称相匹配的目录结构中。

接口与类的区别：

  1. 接口不能用于实例化对象。
  2. 接口没有构造方法。
  3. 接口中所有的方法必须是抽象方法。
  4. 接口不能包含成员变量，除了 static 和 final 变量。
  5. 接口不是被类继承了，而是要被类实现。
  6. 接口支持多继承。

接口特性：

  1. 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
  2. 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
  3. 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

抽象类和接口的区别：

  1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
  2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
  3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
  4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

1.1. 接口的定义基本格式

接口就是多个类的公共规范，接口是一种引用数据类型，接口最重要的就是其中的：抽象方法。

格式：

public interface 接口名称 {
    // 接口内容
}

备注：换成interface关键字之后，编译生成的字节码仍然是：.java --> .class。

如果是Java 7，那么接口中可以包含的内容有：

  1. 常量：即不能发生改变的量。
  2. 抽象方法

如果是Java 8，接口中还可以包含有：

  1. 默认方法
  2. 静态方法

如果是Java 9，还可以额外包含有：

  1. 私有方法

1.2. 接口的抽象方法定义

在任何Java的版本中，接口都能定义抽象方法。

格式：

public abstract 返回值类型 方法名称(参数列表);

注意事项：

  1. 接口当中的抽象方法，修饰符必须是两个固定的关键字：即public abstract。
  2. 这两个关键字修饰符可以选择性省略（可以省略任何一个，或者干脆全省略不写）。（刚学，不推荐这样做）
  3. 方法的三要素可以随意定义。
package cn.itcast.demo01;

public interface MyInterfaceAbstract {
    // 这是一个抽象方法：
    public abstract void methodAbs1();
    // 省略了public abstract关键字的抽象方法：
    abstract void methodAbs2();
    // 这也是抽象方法：
    public void methodAbs3();
    // 这还是抽象方法：
    void methodAbs4();
}

1.3. 接口使用的三个步骤

三个步骤：

  1. 接口不能直接使用，必须有一个“实现类”来实现该接口。

    格式：

public class 类名称 implements 接口名称 {
	......
}
  1. 接口的实现类必须覆盖重写override（实现）接口中所有的抽象方法：实现就是，去掉abstract关键字，加上方法体大括号。
  2. 创建实现类对象，进行使用。

注意事项：如果实现类并没有覆盖重写接口中的所有的抽象方法，那么这个实现类就必须是抽象类。

////// 接口：
package cn.itcast.demo01;

public interface MyInterfaceAbstract {
    // 这是一个抽象方法：
    public abstract void methodAbs1();
    // 省略了public关键字的抽象方法：
    abstract void methodAbs2();
    // 这也是抽象方法：
    public void methodAbs3();
    // 这还是抽象方法：
    void methodAbs4();
}

////// 实现类：
package cn.itcast.demo01;

public class MyInterfaceAbstractlmpl implements MyInterfaceAbstract{
    @Override
    public void methodAbs1() {
        System.out.println("这是第1个方法！");
    }

    @Override
    public void methodAbs2() {
        System.out.println("这是第2个方法！");
    }

    @Override
    public void methodAbs3() {
        System.out.println("这是第3个方法！");
    }

    @Override
    public void methodAbs4() {
        System.out.println("这是第4个方法！");
    }
}

////// 主方法：
package cn.itcast.demo01;

public class Demo01Interface {
    public static void main(String[] args) {
        // 这是错误写法！！！不能直接new接口对象使用！！！
//        MyInterfaceAbstract inter = new MyInterfaceAbstract();

        // 创建实现类的对象使用：
        MyInterfaceAbstract impl = new MyInterfaceAbstractlmpl();
        impl.methodAbs1();
        impl.methodAbs2();
    }
}

1.4. 接口的默认方法

从Java 8开始，接口里允许定义默认方法。

格式：（注意：对比抽象方法，默认方法是有方法体的！）

public default 返回值类型 方法名称(参数类型) {
    // 方法体
}

备注：接口中的默认方法可以决解接口升级的问题。

使用注意事项：

  1. 接口的默认方法，可以通过实现类对象，直接调用。
  2. 接口的默认方法，也可以被接口实现类进行覆盖重写。

默认方法的用途：

  1. 解决接口升级问题。
  2. lambda表达式和函数式编程中，接口的默认方法可以拼接函数模型。

定义接口MyInterfaceDefault：

package cn.itcast.demo01;

public interface MyInterfaceDefault {
    // 抽象方法：
    public abstract void methodAbs();

    // 新添加一个抽象方法 --> 这样做实现类会报错！
//    public abstract void methodAbs2();

    // 上面新添加的方法，改为默认方法：
    public default void methodDefault() {
        System.out.println("这是一个新添加的默认方法！");
    }
}

创建实现类MyInterfaceDefaultA：

package cn.itcast.demo01;

public class MyInterfaceDefaultA implements MyInterfaceDefault{
    @Override
    public void methodAbs() {
        System.out.println("实现了抽象方法，AAA");
    }
}

创建实现类MyInterfaceDefaultB：

package cn.itcast.demo01;

public class MyInterfaceDefaultB implements MyInterfaceDefault{
    @Override
    public void methodAbs() {
        System.out.println("实现了抽象方法，BBB");
    }
    @Override
    public void methodDefault() {
        System.out.println("实现类B覆盖重写了接口的默认方法");
    }
}

主方法：

package cn.itcast.demo01;

public class Demo02InterFace {
    public static void main(String[] args) {
        // 创建了实现类对象：
        MyInterfaceDefaultA a = new MyInterfaceDefaultA();
        a.methodAbs(); //调用抽象方法，实际运行的是右侧的实现类。

        // 调用默认方法，如果实现类中没有，则会向上找：
        a.methodDefault(); // 这是一个新添加的默认方法！
        System.out.println("===========");

        MyInterfaceDefaultB b = new MyInterfaceDefaultB();
        b.methodAbs();
        b.methodDefault(); // 实现类B覆盖重写了接口的默认方法
    }
}

1.5. 接口的静态方法

从Java 8开始，接口中运行定义静态方法。

格式：

public static 返回值类型 方法名称(参数列表) {
    // 方法体
}

提示：和接口的默认方法一样，就是将abstract或者default换成static即可，然后带上方法体。

注意事项：不能通过接口实现类的对象来调用接口当中的静态方法！

正确使用：通过接口名称，直接调用其中的静态方法。

格式：接口名称.静态方法名(参数);

定义接口MyInterfaceStatic：

package cn.itcast.demo01;

public interface MyInterfaceStatic {
    public static void methodStatic() {
        System.out.println("这是接口的静态方法！");
    }
}

实现实现类MyInterfaceStaticImpl：

package cn.itcast.demo01;

public class MyInterfaceStaticImpl implements MyInterfaceStatic{

}

主方法：

package cn.itcast.demo01;

public class Demo03Interface {
    public static void main(String[] args) {
        // 创建了实现类对象：
        MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();

        // 错误写法！不能通过实现类的对象滴调用静态方法！
//        impl.methodStatic();

        // 直接通过接口名称调用静态方法：
        MyInterfaceStatic.methodStatic();
    }
}

1.6. 接口的私有方法

问题描述：我们需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题。但是这个共有方法不应该让实现类使用，应该是私有化。

解决方案：从Java 9开始，接口当中允许定义私有方法。

私有方法分为两种：

  1. 普通私有方法：解决多个默认方法之间重复代码的问题。

    格式：

    private 返回值类型 方法名称(参数列表) {
    // 方法体
}

  2. 静态私有方法：解决多个静态方法之间重复代码的问题。

    格式：

    private static 返回值类型 方法名称(参数列表) {
    // 方法体
}

定义接口MyInterfacePrivateB：

package cn.itcast.demo01;

public interface MyInterfacePrivateB {
    public static void methodStatic1() {
        System.out.println("静态方法1");
        methodStaticCommon();
    }

    public static void methodStatic2() {
        System.out.println("静态方法2");
        methodStaticCommon();
    }
    // private的方法只有接口自己才能调用，不能被实现类或别人使用：
    private static void methodStaticCommon() {
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
}

实现实现类MyInterfacePrivateAlmpl：

package cn.itcast.demo01;

public class MyInterfacePrivateAlmpl implements MyInterfacePrivateB {
    public void methodAnother() {
        // 直接访问到了接口中的静态方法，这样是错误的！因为methodCommon是私有方法
//        methodCommon();
    }
}

主方法：

package cn.itcast.demo01;

public class Demo04Interface {
    public static void main(String[] args) {
        MyInterfacePrivateB.methodStatic1();
        MyInterfacePrivateB.methodStatic2();
        // 错误写法！因为methodStaticCommon是private的！
//        MyInterfacePrivateB.methodStaticCommon();
    }
}
/* 输出结果：
静态方法1
AAA
BBB
CCC
静态方法2
AAA
BBB
CCC
*/

1.7. 接口中的常量

接口中也可以定义”成员变量“，这个成员变量必须使用public static final三个关键字进行修饰。从效果上看，这其实就是接口的【常量】。

格式：

public static final 数据类型 常量名称 = 数据值;

备注：解释这三个关键字

  • public：大家都能随便用。
  • static：由于是静态，这样方便调用。
  • final：一旦使用了final关键字，说明不可改变。

注意事项：

  1. 几口中的常量，可以省略public static final，注意：不写也默认这三个关键字。
  2. 接口中的常量，必须进行赋值，不能不赋值。
  3. 接口中常量的名称，使用完全大写的字母，并且用下划线进行分割。

定义接口MyInterfaceConst：

package cn.itcast.demo01;

public interface MyInterfaceConst {
    // 这其实就是一个常量，一旦赋值，就不可修改了：
    public static final int NUM_OF_MY_CLASS = 99;
}

主方法：

package cn.itcast.demo01;

public class Demo05Interface {
    public static void main(String[] args) {
        // 访问接口中的常量：
        System.out.println(MyInterfaceConst.NUM_OF_MY_CLASS); // 99
    }
}

1.8. 接口的总结

在Java 9+的版本中，接口的内容可以有：

  1. 成员变量其实是常量，格式：

    [public] [static] [final] 数据类型 常量名称 = 数据值；

    注意：

    • 常量值必须进行赋值，而且一旦赋值不能改变。

    • 常量名称完全大写，用下划线进行分割。

  2. 接口中最重要的就是抽象方法，格式：

    [public] [abstract] 返回值类型 方法名称(参数列表);

    注意：

    • 实现类必须覆盖重写接口所有的抽象方法，除实现类是抽象类。

  3. 从Java 8开始，接口中允许定义默认方法，格式：

    [public] default 返回值类型 方法名称(参数列表) {方法体}

    注意：默认方法也可以被覆盖重写。

  4. 从Java 8开始，接口里允许定义静态方法，格式：

    [public] static 返回值类型 方法名称(参数列表) {方法体}

    注意：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法。

  5. 从Java 9开始，接口里允许定义私有方法，格式：

    普通私有方法：

    private 返回值类型 方法名称(参数列表) {方法体}

    静态私有方法：

    private static 返回值类型 方法名称(参数列表) {方法体}

    注意：private的方法只有接口自己才能调用，不能被实现类或别人使用。

1.9. 继承父类并实现多个接口

使用接口的时候，需要注意：

  1. 接口是没有静态代码块或者构造方法的。

  2. 一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。

    格式：

    public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB {
    // 覆盖重写所有的抽象方法
}

  3. 如果实现类所实现的多个接口中，存在重复的抽象方法，那么只需要覆盖重写一次即可。

  4. 如果实现类没有覆盖重写所有的接口中的所有抽象方法，那么实现类必须是抽象类。（在继承中提过）

  5. 如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。

  6. 优先级：一个类如果直接父类当中的方法，和接口当中的默认方法，产生冲突，优先用父类中的方法。

定义接口MyInterfaceA：

package cn.itcast.demo02;

public interface MyInterfaceA {
    // 1. 错误写法！接口不能有静态代码块！
//    static{}

    // 2. 错误写法！接口蹦年有构造方法！
//    public MyInterface{}

    public abstract void methodA();

    public abstract void methodAbs();

    public default void methodDefault() {
        System.out.println("默认方法AAA");
    }
}

定义接口MyInterfaceB：

package cn.itcast.demo02;

public interface MyInterfaceB {
    // 1. 错误写法！接口不能有静态代码块！
//    static{}

    // 2. 错误写法！接口蹦年有构造方法！
//    public MyInterface{}

    public abstract void methodB();

    // 和MyInterfaceA中重名：
    public abstract void methodAbs();

    public default void methodDefault() {
        System.out.println("默认方法BB");
    }
}

定义接口MyInterface：

package cn.itcast.demo02;

public interface MyInterface {
    public default void method() {
        System.out.println("接口的默认方法");
    }
}

实现实现类MyInterfaceImpl：

package cn.itcast.demo02;

public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB {
    @Override
    public void methodA() {
        System.out.println("覆盖重写了A方法");
    }

    @Override
    public void methodB() {
        System.out.println("覆盖重写了B方法");
    }

    @Override
    public void methodAbs() {
        System.out.println("覆盖重写了AB接口都有的抽象方法");
    }

    @Override
    public void methodDefault() {
        System.out.println("对多个接口当中冲突的默认方法进行了覆盖重写");
    }
}

实现抽象实现类MyInterfaceAbstract：

package cn.itcast.demo02;

public abstract class MyInterfaceAbstract implements MyInterfaceA, MyInterfaceB{
    @Override
    public void methodA() {

    }

    @Override
    public void methodAbs() {

    }

    @Override
    public void methodDefault() {
        System.out.println("对多个接口当中冲突的默认方法进行了覆盖重写");
    }
}

定义父类Fu：

package cn.itcast.demo02;

public class Fu {
    public void method() {
        System.out.println("父类方法");
    }
}

定义子类Zi：

package cn.itcast.demo02;

public class Zi extends Fu implements MyInterface{

主方法：

package cn.itcast.demo02;

public class Demo01Interface {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method(); //父类方法
    }
}

1.10. 接口的多继承

  1. 类与类之间是单继承的。直接父类只能有一个
  2. 类与接口直接是多实现的。一个类可以实现多个接口。
  3. 接口与接口之间是多继承的。

注意事项：

  1. 多个父接口中的抽象方法如果重复，没关系。
  2. 多个父接口中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，【而且要呆着default关键字】。

定义接口MyInterfaceA：

package cn.itcast.demo03;

public interface MyInterfaceA {

    public abstract void methodA();

    public abstract void methodCommon();

    public default void methodDefault() {
        System.out.println("AAA");
    }
}

定义接口MyInterfaceB：

package cn.itcast.demo03;

public interface MyInterfaceB {

    public abstract void methodB();

    public abstract void methodCommon();

    public default void methodDefault() {
        System.out.println("BBB");
    }
}

定义接口MyInterface：

package cn.itcast.demo03;
/*
这个子接口里有几个方法呢？答：4个。
methodA 来源于接口A
methodB 来源于接口B
methodCommon 同时来源于接口A和接口B
method 来源于我自己
*/
public interface MyInterface extends MyInterfaceA, MyInterfaceB{

    public abstract void method();

    @Override
    public default void methodDefault() {

    }
}

实现实现类MyInterfaceImpl：

package cn.itcast.demo03;

public class MyInterfaceImpl implements MyInterface{
    @Override
    public void method() {

    }

    @Override
    public void methodA() {

    }

    @Override
    public void methodB() {

    }

    @Override
    public void methodCommon() {

    }
}

主方法：

package cn.itcast.demo03;

public class Demo01Relations {
    public static void main(String[] args) {
        MyInterfaceImpl a = new MyInterfaceImpl();
        a.method();
        a.methodA();
        a.methodB();
        a.methodCommon();
    }
}

2. 多态

多态是继封装、继承之后，面向对象的第三大特性。

在这里插入图片描述

多态：是指同一行为，具有多个不同表现形式。

2.1. 多态格式与使用

代码当中体现多态性，其实就是一句话：父类引用指向子类对象。

格式：

父类名称 对象名 = new 子类名称();

或者：

接口名称 对象名 = new 实现类名称();

////// Fu类：
package cn.itcast.demo04;

public class Fu {
    public void method() {
        System.out.println("父类方法");
    }
    public void methodFu() {
        System.out.println("父类特有的方法");
    }
}

////// Zi类：
package cn.itcast.demo04;

public class Zi extends Fu {
    @Override
    public void method() {
        System.out.println("子类方法");
    }
}

////// 主方法：
package cn.itcast.demo04;

public class demo01Multi {
    public static void main(String[] args) {
        // 使用多态的写法：
        // 左侧父类的引用，指向了右侧子类的对象
        Fu obj = new Zi();

        obj.method(); //子类方法
        obj.methodFu(); //父类特有的方法
    }
}

2.2. 多态中成员变量的使用特点

多态中成员变量的使用和之前（讲继承的时候）相比，没有任何变化！

访问成员变量的两种方式：

  1. 直接通过对象名称访问成员变量：看等号左边是谁就优先用谁，没有则向上找。
  2. 间接通过成员方法访问成员变量：看该方法属于谁就优先用谁，没有则向上找。

2.3. 多态中成员方法的使用特点

多态中成员方法口诀：编译看左边，运行看右边。

对比一下：

  • 成员变量：编译看左边，运行还看左边。
  • 成员方法：编译看左边，运行看右边。
    （例如：Fu obj = new Zi()；编译看左边，看左边是Fu类，Fu类当中没有要用的成员方法，没有的话编译报错！有的话，执行的时候再看右边的Zi类，优先使用Zi类的成员方法，没有的话，再向上找。）
////// Fu类：
package cn.itcast.demo05;

public class Fu {
    int num = 10;

    public void showNum() {
        System.out.println(num);
    }

    public void method() {
        System.out.println("父类方法");
    }

    public void methodFu() {
        System.out.println("父类特有方法");
    }
}

////// Zi类：
package cn.itcast.demo05;

public class Zi extends Fu{
    int num = 20;

    @Override
    public void showNum() {
        System.out.println(num);
    }

    @Override
    public void method() {
        System.out.println("子类方法");
    }

    public void methodZi() {
        System.out.println("子类特有方法");
    }
}

////// 主方法：
package cn.itcast.demo05;

public class Demo01MultiField {
    public static void main(String[] args) {
        // 使用多态写法，父类引用指向子类对象
        Fu obj = new Zi();
        System.out.println(obj.num); //10 --> 父类成员变量
        System.out.println("========");

        obj.showNum(); //20 --> 子类覆盖重写

        obj.method(); // 父子都有，优先用子类
        obj.methodFu(); // 子类没有父类有，向上找到父类

        // 编译看左边，左边是Fu，Fu当中没有methodZi方法，所以编译会报错！
//        obj.methodZi(); // 错误写法！
    }
}

2.4. 使用多态的好处

在这里插入图片描述

2.5. 对象的向上/下转型

  • 向上转型一定是安全的，没有问题的，正确的，但是也有弊端：对象一旦向上转型为父类，那么就无法调用子类原本特有的方法。
  • 向下转型：用对象的向下转型【还原】

在这里插入图片描述

////// Animal类：
package cn.itcast.demo06;

public abstract class Animal {
    public abstract void eat();
}

////// Cat类：
package cn.itcast.demo06;

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    // 子类特有方法：
    public void catchMouse() {
        System.out.println("猫抓老鼠");
    }
}

////// Dog类：
package cn.itcast.demo06;

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃屎");
    }

    public void watchHouse() {
        System.out.println("狗看家");
    }
}

////// 主方法：
package cn.itcast.demo06;
/*
向上转型一定是安全的，没有问题的，正确的，
但是也有弊端：对象一旦向上转型为父类，那么就无法调用子类原本特有的方法。

向下转型：用对象的向下转型【还原】
 */
public class Demo01Main {
    public static void main(String[] args) {
        // 对象的向上转型就是：父类引用指向子类对象
        Animal animal = new Cat();
        animal.eat(); // 猫吃鱼

//        animal.catchMouse(); // 错误写法！对象一旦向上转型为父类，那么就无法调用子类原本特有的方法

        // 向下转型，进行“还原”动作
        Cat cat = (Cat) animal;
        cat.catchMouse(); // 猫抓老鼠

        // 下面是错误的向下转型：
        // 本来new的时候是一只猫，现在非要当作狗
        // 错误写法！编译不会报错，但是运行会出现异常
        // java.lang.ClassCastException：类转换异常
        Dog dog = (Dog) animal;
    }
}

2.6. instanceof关键字判断类型

格式：

对象 instanceof 类名称；

返回是个boolean值。

////// Animal类：
package cn.itcast.demo06;

public abstract class Animal {
    public abstract void eat();
}

////// Cat类：
package cn.itcast.demo06;

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    // 子类特有方法：
    public void catchMouse() {
        System.out.println("猫抓老鼠");
    }
}

////// Dog类：
package cn.itcast.demo06;

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃屎");
    }

    public void watchHouse() {
        System.out.println("狗看家");
    }
}

////// 主方法：
package cn.itcast.demo06;

public class Demo02Instanceof {
    public static void main(String[] args) {
        Animal animal = new Cat(); //本来是只猫
        animal.eat(); // 猫吃鱼

        giveMeAnPet(new Dog());
    }
    
    public static void giveMeAnPet(Animal animal) {
        // 如果希望调用子类特有方法，需要向下转型
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }
        if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }
    }
}

3. 实例：笔记本USB接口案例

进行描述笔记本类，实现笔记本使用USB鼠标、USB键盘

  • USB接口，包含开启功能、关闭功能
  • 笔记本类，包含运行功能、关机功能、使用USB设备功能
  • 鼠标类，要实现USB接口，并具备点击的方法
  • 键盘类，要实现USB接口，具备敲击的方法

在这里插入图片描述

定义接口USB：

package cn.itcast.demo07;

public interface USB {
    public abstract void open(); // 打开设备

    public abstract void close(); // 关系设备

}

定义Computer类：

package cn.itcast.demo07;

public class Computer {
    public void powerOn() {
        System.out.println("笔记本电脑开机");
    }

    public void powerOff() {
        System.out.println("笔记本电脑关机");
    }

    // 使用USB设备：使用接口作为方法的参数
    public void useDevices(USB usb) {
        usb.open(); // 打开设备

        if (usb instanceof Mouse) {
            Mouse mouse = (Mouse) usb; // 向下转型
            mouse.click();
        } else if (usb instanceof Keyboard) {
            Keyboard keyboard = (Keyboard) usb; // 向下转型
            keyboard.type();
        }

        usb.close(); // 关闭设备
    }
}

定义Mouse类：

package cn.itcast.demo07;

// 鼠标就是一个USB设备
public class Mouse implements USB{
    @Override
    public void open() {
        System.out.println("打开鼠标");
    }

    @Override
    public void close() {
        System.out.println("关闭鼠标");
    }

    public void click() {
        System.out.println("鼠标点击");
    }
}

定义Keyboard类：

package cn.itcast.demo07;

// 键盘就是一个USB设备
public class Keyboard implements USB{
    @Override
    public void open() {
        System.out.println("打开键盘");
    }

    @Override
    public void close() {
        System.out.println("关闭键盘");
    }

    public void type() {
        System.out.println("键盘输入");
    }
}

主方法：

package cn.itcast.demo07;

public class DemoMain {
    public static void main(String[] args) {
        // 首先创建一个笔记本电脑
        Computer computer = new Computer();
        computer.powerOn();

        // 准备一个鼠标，供电脑使用：
        Mouse mouse = new Mouse();
        // 首先进行向上转型：
        USB usbMouse = new Mouse(); // 多态写法
        // 参数是USB类型：
        computer.useDevices(usbMouse);

        // 1. 创建一个USB键盘
        Keyboard keyboard = new Keyboard(); // 没有使用多态写法
        // 2. 方法参数是USB类型，传递进去的是实现类：
        computer.useDevices(keyboard); // 正确写法！这里也发生了向上转型
        // 3. 使用子类对象，匿名对象：
//        computer.useDevices(new Keyboard()); // 也是正确写法！

        computer.powerOff();
        System.out.println("=============");

        method(10.0); // 正确写法：double --> double
        method(20); // 正确写法：int --> double
    }

    public static void method(double num) {
        System.out.println(num);
    }
}
/* 输出结果：
笔记本电脑开机
打开鼠标
鼠标点击
关闭鼠标
打开键盘
键盘输入
关闭键盘
笔记本电脑关机
=============
10.0
20.0
*/
接口、 多态
m0_48960643的博客
07-06 1264
接口、 多态
接口的多态实现
03-23
接口多态的实现，引用，对于初学者是一份比较好的课程文件
接口多态
我的标题
07-12 2436
接口多态 什么是多态 多态是指一个对外接口，多种实现方式，即一个接口使用不同实例执行不同的操作 ，它分为两种——方法重写（运行时多态） 简单来说，多态是具有表现多种形态的能力的特征 向同一父类的不同子类对象发送同一条消息，行为不同。 实现多态的步骤 1、子类重写父类的方法 2、编写方法时，参数使用父类对象，并调用父类定义的方法 3、运行时，根据实际创建的对象类型动态决定使用哪个方法 抽象类和抽象方...
接口的多态
hv102的博客
05-04 1286
1，多态参数 假设有一个方法A，方法A的形参是一个接口B引用，那么这个方法A就可以传任意一个，实现了接口B的类的对象，并可以可以用传进来的对象调用他们各自实现了的抽象类。 接口引用还可以指向实现了接口类的对象 Interface interface = new Phone();//左边为接口引用，右边为实现该接口类的对象 2 多态数组 public static void main(String[] args) { Interface_[] usb = new Interfa
Java基础：接口
david2000999的博客
09-26 164
Java接口基础接口接口概述标准格式接口的实现接口的多实现接口的多继承总结 接口 接口概述 接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么 接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法 （JDK 9）。 接口的定义： 它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并 不是类，而是另外一种引用数据类型。 引用数据类型：数组，类，接口。
接口、多态
killerhz的博客
06-11 254
Java学习的第十四天 接口 接口：主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法（JDK 9）。 接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。 注意：引用数据类型有数组、类、接口。 定义格式：public interface 接口名称 { ...
【IT十八掌徐培成】Java基础第06天-03.多态-类多态-接口多态-同名属性问题.zip
08-07
在Java中，多态分为类多态和接口多态。类多态主要体现在子类对象可以被当作父类对象来使用，这是因为子类继承了父类的特性，同时也可能扩展了自己的特性。例如，动物是父类，狗和猫是子类，那么我们可以说一个动物...
黑马程序员匠心之作 C++教程_第4阶段实战-基于多态的企业职工系统讲义.rar
03-19
《C++教程_第4阶段实战-基于多态的企业职工系统讲义》是黑马程序员精心制作的一份教学资源，特别适合C++初学者。这份讲义深入浅出地讲解了C++编程语言中的多态性，并通过实战项目——企业职工系统，让学习者能够将...
Java程序设计课程实验10-接口和多态
最新发布
12-14
在Java程序设计中，接口和多态是两个非常重要的概念，它们构成了面向对象编程的核心特性。接口（Interface）是Java中定义行为规范的一种抽象类型，它允许类之间通过定义一组公共方法来实现通信，而无需关注具体的...
java 将方法作为传参--多态的实例
08-29
在 Java 中，不能像 C/C++ 一样将函数作为指针传递，但可以使用面向对象的思想，设计一个接口，实现多态的实例。在这个实例中，我们将使用黄金搜索法（Golden Section Search）作为例子，来演示如何将方法作为参数...
【笔记式】Java快速入门77课时--多态接口内部类篇（含200条笔记+60个实例）
06-13
多态与接口 4.内部类 课程亮点： 笔记加案例详细讲解Java入门知识！！！提供详细的笔记作为辅助工具,2000多条笔记帮助学员快速掌握Java150多个知识点 课程特色： 笔记JAVA：用200条笔记串连所有知识点，让学员从...
接口 多态
wyq15004350208的博客
08-12 353
一、接口     (1)接口的定义:因为继承只能单继承，我们为了实现多继承，所以我们需要使用接口来实现多继承。                             接口实际上是一种规范，连接接口的类或接口必须满足本接口的内容。    (2)接口的特点:               ①接口使用interface关键字，而不是class。接口也是特殊的抽象类。              ...
接口和多态
Java修炼者的博客
10-07 2451
接口和多态接口接口定义接口的继承和实现接口的应用类的单继承原理多态多态的内存结构接口的多态模板模式Math类的使用Scanner扫描器类 接口 接口：当一个抽象类，如果抽象类中的所有方法都是抽象的， 那么我们就可以把它定义为一个接口，接口是对行为的抽象。类是对属性和行为的抽象。 接口定义 接口无法被直接实例化和抽象类一样。但是可以通过对象上转型来间接实例化 在接口中可以定义常量不可定义变量，这个常量默认是：final static float PI=3.14f; 它默认用fin
Java接口多态
weixin_46046653的博客
09-14 343
一、接口 接口概述 a. 接口是什么 公共的规范标准。把要做什么和怎们做进行了分离。 接口定义的基本格式 a. 接口是什么数据类型： 引用数据类型 b. 如何定义接口 public interface 接口名{} c. 接口中可以包含哪些内容 JDK7：常量、抽象方法 JDK8：常量、抽象方法、默认方法、静态方法 JDK9：常量、抽象方法、默认方法、静态方法、私有默认方法、私有静态方法 接口的抽象方法定义和使用 语法： public abstract 返回值类型 方法名(参数列表); //public a
接口 多态
weixin_42943720的博客
08-30 232
接口 接口；是Java语言的一种引用类型，是方法的集合。接口的内部主要就是封转了方 法。抽象方法1.7jdk。 静态方法和默认方法1.8jdk。私有方法1.9jkd。接口，用inerface来进行修饰，他会产生class 文件，但主要的它不是一个类，只不过是一个引用类型的方法。 引用数据类型；数据， 类，接口。 接口的使用；他不能够被用来创建对象，他可以用被实现 用implemen...
2020.10.28Java接口
weixin_45649686的博客
10-29 197
接口 1.定义：使用interface来实现接口，可以将接口理解为一个纯粹的抽象类 java中一个接口可以继承多个接口。 public interface Animal extends InterFaceA,InterFaceB,InterFaceC{ } public interface InterFaceA { void run(); } public interface InterFaceB { void play(); } public interface InterFac
Ember-Data多态hasMany关系问题分析与解决
资源摘要信息:"polymorphic_test:我在多态 hasMany 关系和 Ember-Data 1.0.0-beta.14.1 中遇到的问题的描述" 在分析这个标题和描述时，我们可以提取出与软件开发、尤其是Web应用开发相关的多个知识点。由于标题提到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值