黑马程序员Java课程笔记010接口和多态

最新推荐文章于 2024-05-03 16:12:22 发布
最新推荐文章于 2024-05-03 16:12:22 发布
阅读量433 收藏 6
点赞数 6
分类专栏： Java学习 文章标签： 多态 java 接口 封装
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44005101/article/details/114960084
版权

黑马程序员Java课程笔记010


查看上一节：黑马程序员Java课程笔记009继承与抽象类

第一章 接口

1.1 接口概述与生活举例

接口就是一种公共的规范标准。
只要符合规范标准，就可以大家通用。
只要符合USB接口的规范，那么各种设备都可以使用
U盘，打印机、夜读灯、USB小风扇…

1.2 接口的定义基本格式

接口就是多个类的公共规范。
接口是一种引用数据类型，最重要的内容就是其中的，抽象方法。
如何定义一个接口的格式：

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

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

如果是Java 7，那么接口中可以包含的内容有：
1.常量
2.抽象方法

如果是Java 8，还可以额外包含有：
3.默认方法
4.静态方法

如果是Java 9， 还可以额外包含有：
5.私有方法

1.3 接口的抽象方法定义

在任何版本的Java中，接口都能定义抽象方法。
格式：
public abstract 返回值类型 方法名称（参数列表）;

注意事项：

  1. 接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
  2. 这两个关键字修饰符，可以选择性省略。（今天新学，所以不推荐）
  3. 方法的三要素，可以随意定义。
package cn.itcast.day10.demo01;
public interface MyInterfaceAbstract {

    // 这是一个抽象方法
    public abstract void methodAbs1();

    // 这也是抽象方法
    abstract void methodAbs2();

    // 这也是抽象方法
    public void methodAbs3();

    // 这也是抽象方法
    void methodAbs4();

}

1.4 接口的抽象方法使用

接口使用步骤：

  1. 接口不能直接使用，必须有一个实现类来：“实现”该接口。
    格式： public class 实现类名称 implements 接口名称{ // ... }
  2. 接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。 实现：去掉abstract关键字，加上方法体大括号。
  3. 创建实现类的对象，进行使用。

注意事项：

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

package cn.itcast.day10.demo01;
public interface MyInterfaceAbstract {

    // 这是一个抽象方法
    public abstract void methodAbs1();

    // 这也是抽象方法
    abstract void methodAbs2();

    // 这也是抽象方法
    public void methodAbs3();

    // 这也是抽象方法
    void methodAbs4();

}


package cn.itcast.day10.demo01;

public class MyInterfaceAbstractImpl implements MyInterfaceAbstract{

    @Override
    public void methodAbs1() {
        System.out.println("这里是第一个方法");
    }

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

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

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


package cn.itcast.day10.demo01;

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

//        创建实现类的对象使用
        MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
        impl.methodAbs1();
        impl.methodAbs2();
        impl.methodAbs3();

    }
}

1.5 接口的默认方法定义

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

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

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

package cn.itcast.day10.demo01;
/*
从Java 8开始，接口里允许定义默认方法。
格式：
public default 返回值类型 方法名称(参数名称){
    方法体
}

备注：接口当中的默认方法，可以解决接口升级的问题
 */
public interface MyInterfaceDefault {
//    抽象方法
    public abstract void methodAbs();

}


package cn.itcast.day10.demo01;

public class MyInterfaceDefaultA implements MyInterfaceDefault{

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


package cn.itcast.day10.demo01;

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

1.6 接口的默认方法使用

  1. 接口的默认方法，可以通过接口实现类对象，直接调用
  2. 接口的默认方法，也可以被接口实现类进行覆盖重写
package cn.itcast.day10.demo01;
public interface MyInterfaceDefault {
//    抽象方法
    public abstract void methodAbs();
//    又定义了一个抽象方法
//    public abstract void methodAbs2();

    // 新添加的方法，改成默认方法就可以解决问题
    public default void methodDefault(){
        System.out.println("这是新添加的默认方法");
    }
}


package cn.itcast.day10.demo01;

public class MyInterfaceDefaultA implements MyInterfaceDefault{

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

package cn.itcast.day10.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.day10.demo01;
/*
1. 接口的默认方法，可以通过接口实现类对象，直接调用
2. 接口的默认方法，也可以被接口实现类进行覆盖重写
 */
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();
    }
}

1.7 接口的静态方法定义

从Java 8开始，接口当中允许定义静态方法
格式：

public static 返回值类型 方法名称（参数列表）{
    方法体
}

提示：就是将abstract或者default换成static即可，带上方法体。

1.8 接口的静态方法使用

package cn.itcast.day10.demo01;
/*
注意事项：不能通过接口实现类的对象来调用接口当中的静态方法
正确用法：通过接口名称，直接调用其中的静态方法
格式：
接口名称.静态方法名(参数)：

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

        // 错误写法
//        impl.methodStatic();
        // 直接通过接口名称调用静态方法
        MyInterfaceStatic.methodStatic();

    }
}

1.9 接口的私有方法定义

问题描述：

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

。

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

  1. 普通私有方法，解决多个默认方法之间重复代码问题
    格式：
private 返回值类型 方法名称(参数列表){
    方法体
}
  1. 静态私有方法，解决多个静态方法之间重复代码问题
    格式：
private static 返回值类型 方法名称（参数列表）{
    方法体
}

package cn.itcast.day10.demo01;
public interface MyInterfacePrivateA {
    
    public default void methodDefault1(){
        System.out.println("默认方法1");
        methodCommon();
    }
    public default void methodDefault2(){
        System.out.println("默认方法2");
        methodCommon();
    }
    public default void methodCommon(){
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
    
}

1.10 接口的私有方法使用

package cn.itcast.day10.demo01;
public interface MyInterfacePrivateB {

    public static void methodStatic1(){
        System.out.println("默认方法1");
        methodStaticCommon();
    }
    public static void methodStatic2(){
        System.out.println("默认方法2");
        methodStaticCommon();
    }
    private static void methodStaticCommon(){
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }

}


package cn.itcast.day10.demo01;

public class Demo04Interface {

    public static void main(String[] args) {
        MyInterfacePrivateB.methodStatic1();
        MyInterfacePrivateB.methodStatic2();
//        错误写法！
//        MyInterfacePrivateB.methodStaticCommon();
    }
}

1.11 接口的常量定义和使用

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

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

备注：
一旦使用final关键字进行修饰，说明不可改变。
注意事项：

1. 接口当中的常量，可以省略public static final，注意：不写也照样是这样。
2. 接口当中的常量，必须进行赋值，不能不赋值。
3. 接口中常量的名称，使用完全大写的字母，用下划线进行分隔。（推荐命名规则）

package cn.itcast.day10.demo01;

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


package cn.itcast.day10.demo01;
/*
public class MyInterfaceConst {
//    这其实就是一个常量，一旦赋值，不可以修改
    public static final int NUM_OF_MY_CLASS = 10;
    

}

1.12 接口的内容小结

在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.13 继承父类并实现多个接口

使用接口时，需要注意：

  1. 接口时没有静态代码块或者构造方法的。
  2. 一个类的直接父类只有一个，但是一个类可以同时实现多个接口 格式： public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB{ // 覆盖重写所有抽象方法 }
  3. 如果实现类所实现的多个接口当中存在重复的抽象方法，呢么只需覆盖重写一个即可。
  4. 如果实现类没有覆盖重写所有接口当中的所有方法，那么实现类是抽象的
  5. 如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写
  6. 一个类如果直接父类当中的方法和接口当中的方法产生了冲突，那么优先用父类当中的方法。
package cn.itcast.day10.demo02;

public interface MyInterface {

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


package cn.itcast.day10.demo02;

public interface MyInterfaceA {
//    错误写法！接口不能有静态代码块
//    static{
//
//    }
//    错误写法！接口不能有构造方法
//    public MyInterface(){
//
//    }
    public abstract void methodA();
    public abstract void methodAbs();
    public default void methodDefault(){
        System.out.println("默认方法AAA");
    }
}


package cn.itcast.day10.demo02;

public interface MyInterfaceB {
    public abstract void methodB();
    public abstract void methodAbs();
    public default void methodDefault(){
        System.out.println("默认方法BBB");
    }
}


package cn.itcast.day10.demo02;

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

    }

    @Override
    public void methodAbs() {

    }

    @Override
    public void methodDefault() {

    }


}


package cn.itcast.day10.demo02;

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

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

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

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


}


package cn.itcast.day10.demo02;

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


package cn.itcast.day10.demo02;

public class Fu {

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


package cn.itcast.day10.demo02;
public class Demo01Interface {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();
    }
}

1.14 接口之间的多继承

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

注意事项：

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

public interface MyInterfaceA {
    public abstract void methodA();
    public abstract void methodCommon();
    public default void methodDefault(){
        System.out.println("AAA");
    }
}


package cn.itcast.day10.demo03;

public interface MyInterfaceB {
    public abstract void methodB();
    public abstract void methodCommon();
    public default void methodDefault(){
        System.out.println("BBB");
    }
}


package cn.itcast.day10.demo03;
/*
这个子接口中有几个方法？答：4个
mothodA来自于接口A
methodB来自于接口B
methodCommon来自于接口A和B
method来自于我自己
 */
public interface MyInterface extends MyInterfaceA,MyInterfaceB{
    public  abstract void method();

    @Override
    public default void methodDefault() {

    }
}


package cn.itcast.day10.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.day10.demo03;

public class Demo01Relations {
}

第二章 多态

2.1 多态的概述

面向对象三大特征：封装性、继承性、多态性。
extends继承或者implements继承，是多态性的前提。
小明是一个对象
这个对象既有学生形态，也有人类形态。
一个对象拥有多种形态，这就是：
对象的多态性。

2.2 多态的格式与使用

代码当中体现多态性，其实就是一句话：父类引用指向子类对象。
格式：
父类名称 对象名 = new 子类名称();
或者；

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

子类被当做父类看待，左父右子就是多态。

package cn.itcast.day10.demo04;

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


package cn.itcast.day10.demo04;

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

}


package cn.itcast.day10.demo04;
/*
代码当中体现多态性，其实就是一句话：父类引用指向子类对象。
格式：
父类名称 对象名 = new 子类名称();
或者；
接口名称 对象名 = new 实现类名称();
子类被当做父类看待，左父右子就是多态。
 */
public class Demo01Multi {

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

    }
}

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

访问成员变量的两种方式

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

public class Fu /*extends Object*/{
    int num = 10;
    public void showNum(){
        System.out.println(num);
    }

}


package cn.itcast.day10.demo05;

public class Zi extends Fu{
//  成员变量不能重写，只有成员方法能重写
    int num = 20;

    int age = 16;
    @Override
    public void showNum(){
        System.out.println(num);
    }

}


package cn.itcast.day10.demo05;

import org.w3c.dom.ls.LSOutput;
/*
访问成员变量的两种方式

1. 直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找
2. 直接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找
 */
public class Demo01MultiField {
    public static void main(String[] args) {
        //    使用多态写法，父类引用指向子类对象
        Fu obj = new Zi();
        System.out.println(obj.num);
//        System.out.println(obj.age); // 错误写法！
        System.out.println("=================");

        // 子类没有重写，就是父类的方法
//        子类如果重写，就是子类的方法
        obj.showNum(); 
    }

}

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

在多态的代码当中，成员方法的访问规则是：
看new的是谁，就优先用谁，没有则向上找。

成员方法：编译看左边，运行看右边。
成员变量：编译看左边，运行还看左边。

package cn.itcast.day10.demo05;

public class Fu /*extends Object*/{
    int num = 10;
    public void showNum(){
        System.out.println(num);
    }
    public void method(){
        System.out.println("父类方法");
    }
    public void methodFu(){
        System.out.println("父类特有方法");
    }
}


package cn.itcast.day10.demo05;

public class Zi extends Fu{
//  成员变量不能重写，只有成员方法能重写
    int num = 20;

    int age = 16;
    @Override
    public void showNum(){
        System.out.println(num);
    }
    @Override
    public void method(){
        System.out.println("子类方法");
    }
    public void methodZi(){
        System.out.println("子类特有方法");
    }
}


package cn.itcast.day10.demo05;
public class Demo02MultiMethod {
    public static void main(String[] args) {
        Fu obj = new Zi(); // 多态

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

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

2.5 使用多态的好处

不论右边new的时候编程哪个子类对象，等号左边调用方法都不会发生改变。

2.6 对象的向上转型

对象的向上转型，其实就是多态写法
格式：父类名称 对象名 = new 子类名();
含义：右侧创建一个子类对象，然后把它当做父类来看待使用。
注意事项：向上转型，一定是安全的。类似于自动类型转换–>从小范围转到大范围

package cn.itcast.day10.demo06;

public class Demo01Main {
//    对象的向上转型，就是：父类指向子类的对象。
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.eat();
    }


}


package cn.itcast.day10.demo06;

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


package cn.itcast.day10.demo06;

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

2.7 对象的向下转型

对象的向下转型，其实是一个【还原】的动作
格式：子类名称 对象名 = （子类名称）父类对象；
含义：将父类对象，还原成为本来的子类对象。
注意事项：
a. 必须保证对象本来创建的时候，就是猫，才能向下转型成为猫。
b. 如果对象创建的时候本来不是猫，现在非要向下转型成为猫，就会报错。

2.8 使用instanceof关键字进行类型判断

向上转型一定是安全的，正确的，但是也有一个弊端
对象一旦向上转型为父类，就无法调用子类原本特有的内容。

解决方案：用对象的向下转型【还原】

package cn.itcast.day10.demo06;

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


package cn.itcast.day10.demo06;

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

}


package cn.itcast.day10.demo06;

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


package cn.itcast.day10.demo06;
/*
向上转型一定是安全的，正确的，但是也有一个弊端
对象一旦向上转型为父类，就无法调用子类原本特有的内容。

解决方案：用对象的向下转型【还原】
 */
public class Demo01Main {
//    对象的向上转型，就是：父类指向子类的对象。
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.eat();
//        animal.catchMouse; // 错误写法！
//        向下转型，进行“还原”动作
        Cat cat = (Cat)animal;
        cat.catchMouse(); // 猫抓老鼠

//        错误的向下转型
//        Dog dog = (Dog) animal; // 错误写法，编译不会报错，但是运行会出现类转换异常。ClassCastException
//        类似于：基本数据类型中的强制类型转换
    }
}

2.9 笔记本USB接口

2.9.1 案例分析

笔记本电脑通常具有使用USB设备的功能。在生产时，笔记本都预留了可以插入USB设备的USB接口，但具体什么USB设备，笔记本厂商并不关心，只要符合USB规格的设备都可以。

定义USB接口，具备最基本的开启功能和关闭功能。鼠标和键盘要想能在电脑上使用，那么鼠标和键盘也必须遵守USB规范，实现USB接口，否则鼠标和键盘的生产出来也无法使用。

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

2.9.2 案例实现

package cn.itcast.day10.demo07;

public class Computer {
    public void powerOn(){
        System.out.println("笔记本电脑开机");
    }
    public void powerOff(){
        System.out.println("笔记本电脑关机");
    }
    // 使用USB设备的方法,使用接口作为方法的参数
    public void usedevice(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(); // 关闭设备
    }

}


package cn.itcast.day10.demo07;

public interface USB {
    public abstract void open(); // 打开设备
    public abstract void close(); // 关闭设备
}


package cn.itcast.day10.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("点击");
    }
}


package cn.itcast.day10.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.day10.demo07;

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

//        准备一个鼠标供电脑使用
//        Mouse mouse = new Mouse();

        USB usbMouse = new Mouse();
        computer.usedevice(usbMouse);
        Keyboard keyboard = new Keyboard(); // 没有使用多态写法

        // 方法参数是USB类型，传递进去的是实现类对象
        computer.usedevice(keyboard); // 正确写法!也发生了向上转型
        computer.usedevice(new Keyboard());
        computer.powerOff();
        method(10.0); // 正确方法：double --> double
        method(10); // 正确写法：int --> double
    }

    public static void method(double num){
        System.out.println(num);
    }
}

查看上一节：黑马程序员Java课程笔记009继承与抽象类

软件柠檬
关注
  • 6
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
Java程序设计课程实验10-接口和多态
12-14
Java程序设计课程实验10-接口和多态Java程序设计课程实验10-接口和多态Java程序设计课程实验10-接口和多态Java程序设计课程实验10-接口和多态Java程序设计课程实验10-接口和多态Java程序设计课程实验10-接口和多态...
《Java基础入门第2版》--黑马程序员 课后答案及其详解 第4章 面向对象(下)
热门推荐
hypertext123的博客
10-26 3万+
文章目录一、填空题二、判断题三、选择题四、简答题五、编程题六、原题及其解析 一、填空题 1、方法，抽象类 2、子类、父类、基类 3、final 4、Object 5、参数列表、“->”、表达式主体 二、判断题 1、错 2、对 3、错 4、对 5、错 三、选择题 1、B 2、ABC 3、C 4、C 5、A 四、简答题 1、在继承关系中，子类的方法与父类的某一方法具有相同的方法名、返回类型和参数列表，则称子类的该方法重写(覆盖)父类的方
Java-黑马Java学习作业-day14面向对象进阶（多态&包&权限修饰符&代码块）
Kox_233的博客
01-28 639
面向对象进阶（多态&包&权限修饰符&代码块）
2021-07-22
qq_57039493的博客
07-22 144
抽象类和接口 抽象类 什么是抽象类？ 抽象类简单理解，就是这个对象是什么。人和狗的抽象类都是动物。抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。 由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。 抽象类的规则 1 抽象类必须使用abstract修饰符来修饰，抽象方法也必须使用abstract修饰符来修饰，抽象方法不能有方法体。 2 抽象类不能被实例化，无法使用new关键字来调用抽象类的
黑马程序员：java学习笔记-接口和多态
伊斯之深の生死簿
08-29 694
----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------ 1.1. 接口 1.1.1. 概述 接口interface： 父类可以看做父亲；接口，抽象类可以看做师父；父亲只有一个，师父可以有多个 可以从师父那扩展更多的功能。 接口好
Java 多态
单飞吧的博客
04-06 90
多态的概述 什么是多态： 同一个对象，在不同时刻表现出来的不同形态 举例：猫 我们可以说猫是猫：猫 cat = new 猫(); 我们也可以说猫是动物：动物 animal = new 猫(); 这里猫在不同的时刻表现出来了不同的形态，这就是多态 多态的前提和体现 1、有继承/实现关系 2、有方法重写 3、有父类引用指向子类对象 // 测试类中 Fu a = new Zi() 多态中成员访问特点 Fu a （左边父类） = new Zi() 右边子类 成员变量：编译看左边，执行看左边 成员方法：编译
抽象类和接口
weixin_43842051的博客
11-18 749
什么是抽象类 一个类中如果有抽象方法，那么这个类就必须是一个抽象类 什么是抽象方法 抽象方法指的是没有具体的方法实现 如何定义抽象类和抽象方法 使用abstract关键字来修饰类和方法 抽象类的特点 1.抽象类和抽象方法必须使用abstract关键字修饰 public abstract class 类名{} public abstract 返回值类型 方法名(); 2.抽象类中不一定有抽象方法，但...
java用接口、多态、继承、类计算三角形和矩形周长及面积的方法
09-03
主要介绍了java用接口、多态、继承、类计算三角形和矩形周长及面积的方法,涉及java面向对象中类、接口、多态等的使用技巧,需要的朋友可以参考下
Java基础语法之接口和多态穿拖鞋的汉子上传
07-08
Java基础语法之接口和多态穿拖鞋的汉子上传
Java实验报告4接口和多态.doc
10-20
Java实验报告4接口和多态.doc
Java中使用接口实现多继承和多态的方法
01-19
这样用父类的变量去引用不同的子类，在调用这个相同的方法print()的时候得到的结果和表现形式就不一样了，这就是多态，相同的消息（也就是调用相同的方法）会有不同的结果。举例说明： 　//父类 　public class ...
链表刷题集
yajunjiao的专栏
04-30 507
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
Spring Cloud——LoadBalancer
????
05-01 1389
这里只是简单的讲解了一下LoadBalancer如何使用，因为实际上我们使用的不是很多，主要还是使用OpenFeign。
d15(136-148)-勇敢开始Java，咖啡拯救人生
m0_73459387的博客
04-28 1107
对象哈希值的特点：同一个对象调用hashCode()返回的哈希值相同；HashMap的键依赖hashCode方法和equals方法保证键的唯一，存储自定义类型的对象时，重写这两个方法。实际上，Set系列集合的底层就是基于Map实现的，只是Set集合中的元素要键数据，不要值数据。当12个位置都占满时就会扩容，大约扩容为原来的二倍，再把原数组数据转移到新数组。使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误。基于哈希表实现，每个键值对额外多了一个双链表的机制，记录元素顺序（保证。
Java解决最长公共前缀
无人罪的博客
04-28 400
编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串""。
【一步一步了解Java系列】：探索Java基本类型与C语言的区别
2302_81249757的博客
04-29 914
​​喜欢的一句话： 常常会回顾努力的自己，所以要为自己的努力留下足迹。作者：小闭。
Spring cloud原理详解
qq_33449977的博客
04-28 486
想象一下，你开了一家餐馆，一开始只卖汉堡，后来生意火了，你又增加了炸鸡、披萨、冰淇淋各种摊位，每个摊位就是一个微服务，它们各自独立工作，但又得相互配合。有时候，某个服务可能太忙了，电话老打不通，这时候Spring Cloud还有个叫Hystrix的断路器，它会说：“嘿，别打了，那边线路忙，我给你个备用方案或者告诉你稍后再试。至于餐馆运营情况，Spring Cloud Sleuth和Zipkin这些工具，就像监控摄像头，记录服务间的每一次交互，方便你查看哪里出了问题，优化服务流程。
Nacos 配置中心实例分析实践
最新发布
m0_73557631的博客
05-03 493
​ 浏览器: http://localhost:5000/nacos/config/ip。先创建e-commerce-nacos-config-client5000 模块。​ 启动e-commerce-nacos-config-client5000。​ 启动Nacos Server。
公考学习平台|基于SprinBoot+vue的公考学习平台(源码+数据库+文档)
weixin_66413741的博客
04-30 1072
本共享汽车管理系统有管理员和用户。管理员功能有个人中心，用户管理，投放地区管理，汽车信息管理，汽车投放管理，汽车入库管理，使用订单管理，汽车归还管理。用户可以在注册登录，可以对汽车进行使用产生订单，还可以归还。因而具有一定的实用性。本站是一个B/S模式系统，采用Spring Boot框架，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得共享汽车管理系统管理工作系统化、规范化。
黑马程序员java基础
05-18
黑马程序员的Java基础课程主要包括以下内容： 1. Java语言基础：Java语言的发展历史，基本语法结构、数据类型、运算符、流程控制语句等。 2. 面向对象编程：面向对象的基本概念、类与对象、封装、继承、多态等。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

软件柠檬

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值