面向对象高级,学习记录2

最新推荐文章于 2024-06-24 00:36:46 发布

令人费解.

最新推荐文章于 2024-06-24 00:36:46 发布

阅读量164

点赞数

文章标签：学习 java 开发语言

本文链接：https://blog.csdn.net/m0_56950238/article/details/126622894

版权

day02-面向对象高级

今日内容

多态
抽象类
接口

今日目标

能够知道多态的前提
能够理解多态的好处和弊端
能够理解多态中的转型
能够知道抽象类的特点
能够知道抽象类的成员特点
能够知道接口的特点
能够知道接口的成员特点
能够理解抽象类和接口的区别

1.多态

1.1 多态概述

【什么是多态】

指的是同一个对象，在不同时刻表现出来的多种形态
我们可以说猫是猫：猫 cat = new 猫();
我们也可以说猫是动物：动物 animal = new 猫();
这里猫在不同的时刻表现出来了多种形态，这就是多态

【前提】

有继承/实现关系
有方法重写
有父类引用指向子类对象

【代码】

public class Animal {

    public void eat() {
        System.out.println("动物吃东西");
    }

}

public class Cat extends Animal {

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

}

/*
    多态的前提
        有继承/实现关系
        有方法重写
        有父类引用指向子类对象
 */
public class Test {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal a = new Cat();
    }
}

1.2 多态中成员访问特点

【特点】

Fu f = new Zi();
成员变量： f.成员变量
编译看左边: 成员变量在父类中是否存在
存在,编译通过
不存在,编译错误

执行看左边: 访问Fu类的成员变量

成员方法: f.成员方法()
编译看左边:成员方法在父类中是否存在
存在: 编译通过
不存在:编译失败

执行看右边: 调用的子类的方法(最主要的特点)

【代码】

public class Fu {
    public int age = 50;

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

public class Zi extends Fu{
    public int age = 20;
    public int height = 180;

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

    public void show(){
        System.out.println("子类中的show方法");
    }
}

public class Test {
    /*
        练习: 多态的前提,多态前提下成员的访问特点

        成员变量: 编译看左边,运行看左边(访问父类的成员变量)
        成员方法: 编译看左边,运行看右边(调用子类的成员方法)
     */
    public static void main(String[] args) {
        Fu f = new Zi();
        System.out.println(f.age);
//        f.height

        f.eat();
//        f.show();
    }
}

1.3 多态的好处和弊端

【好处】

提高了程序的扩展性
- 父类的引用记录的是哪一个子类的对象,调用方法是,执行就是那个子类的方法

//        Animal a = new Cat();
//        Animal a = new Dog();
		Animal a = new Pig();
		a.eat();

【代码】

public class Animal {
    public void eat(){
        System.out.println("动物吃东西");
    }
}

public class Horse extends Animal{
    @Override
    public void eat() {
        System.out.println("马吃草");
    }
}

public class Test {
    /*
        多态的好处 : 提高程序的扩展性

        调用方法时,传递不同的对象就能实现不同的效果
     */
    public static void main(String[] args) {
//        Animal a = new Cat();
//        Animal a = new Dog();
//        Animal a = new Pig();
//        a.eat();
        show(new Horse());
    }

    // 定义一个方法看看每种动物都吃什么
    public static void show(Animal a){
        // 数据类型 名字
        // Animal a 引用数据类型的变量
        // Animal a = new Horse(); // 父类引用指向子类的对象
        a.eat();
    }


}

【弊端】

不能使用子类的特有功能
- 多态的使用更多就是为了看不同子类的表现,调用的重写的方法
- 就想调用子类特有的方法???

Animal a = new Cat();
a.eat()  // 重写方法 可以正常执行
a.work() // 编译错误 没有办法调用子类特有的方法

1.4 多态中的转型

【向上转型】

父类引用指向子类对象

Animal a = new Cat();

【向下转型】

父类引用转为子类对象
- 解决访问子类特有方法的弊端

Cat c = (Cat) a;

【ClassCastException】

向下转型是,有可能会出现类型转换异常
原因: 变量类型和记录的地址无关的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9Ga5OC9O-1661926258214)(assets/image-20220827095746038.png)]

【instanceof】

变量/地址值 instanceof 类名
示例: a1 instanceof Dog a1 是不是狗
- 如果是返回结果就是true
- 不是返回结果就是false
作用: 避免类型转换异常

if (a1 instanceof Dog){
    // 向下转型
    Dog d = (Dog) a1;
}

1.5 案例：猫和狗(多态版)

【步骤】

① 定义动物类(Animal)

成员变量：姓名，年龄
构造方法：无参，带参
成员方法：get/set，吃(){}

② 定义猫类(Cat)，继承动物类，重写吃的方法

构造方法：无参，带参
成员方法：吃(){}
成员方法：工作(){} 抓老鼠

③ 定义狗类(Dog)，继承动物类，重写吃的方法

构造方法：无参，带参
成员方法：吃(){}

④ 定义测试类(AnimalDemo)，写代码测试

【代码】

2.抽象类

2.1 抽象类概述

【抽象方法】

Java中，一个没有方法体的方法为抽象方法

示例: public abstract void show();

【抽象类】

一个类中如果有抽象方法，该类必须是抽象类

【为什么要定义抽象方法】

在多态的前提下: Fu f = new Zi();
调用方法时: f.show(); 执行的一定是子类的方法
父类中的方法永远执行不到的

【代码】

2.2 抽象类特点

【特点】

抽象类抽象方法必须使用abstract修饰
- public abstract class 类名{}
- public abstract void eat();
抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
抽象类不能实例化
- 抽象类如何实例化呢？使用多态的方式实例化子类
抽象类的子类
- 要么重写抽象类中的所有抽象方法
- 要么是抽象类

【代码】

/*
    抽象类
 */
public abstract class Animal {
    //抽象方法
    public abstract void eat();

    public void sleep() {
        System.out.println("睡觉");
    }

}

public class Cat extends Animal {

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

public abstract class Dog extends Animal {

}

/*
    测试类
 */
public class AnimalDemo {
    public static void main(String[] args) {
//        Animal a = new Animal();
        Animal a = new Cat();
        a.eat();
        a.sleep();
    }
}

2.3 抽象类的成员特点

literals: 字面量(常量) : “”,‘’,10,12.5,true,false null
constant: 常量: 不能被修改的变量称值为常量
final修饰的变量

【成员变量】

可以是变量
也可以是常量(final修饰的)

【成员方法】

可以有抽象方法：限定子类必须完成某些动作
也可以有非抽象方法：提高代码复用性,非私有成员方法,子类可以直接使用的

【构造方法】

有构造方法，但是不能实例化
那么，构造方法的作用是什么呢？用于子类访问父类数据的初始化(给成员变量赋值)

【代码】

/*
    抽象类
 */
public abstract class Animal {

    private int age = 20;
    private final String name = "动物";

    public Animal() {
    }

    public Animal(int age) {
        this.age = age;
    }


    public void show() {
        age = 40;
        System.out.println(age);
//        name = "老虎";
        System.out.println(name);
    }

    public abstract void eat();

}

public class Cat extends Animal {

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

/*
    测试类
 */
public class AnimalDemo {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.eat();
        a.show();
    }
}

2.4 案例：猫和狗(抽象类版)

需求：请采用抽象类的思想实现猫和狗的案例，并在测试类中进行测试

看完需求后，我们先简单的说一下思路：

思路：

① 定义动物类(Animal)

成员变量：姓名，年龄
构造方法：无参，带参
成员方法：get/set，吃();

② 定义猫类(Cat)，继承动物类，重写吃的方法

构造方法：无参，带参
成员方法：吃(){…}
成员方法：工作(){} 抓老鼠

③ 定义狗类(Dog)，继承动物类，重写吃的方法

构造方法：无参，带参
成员方法：吃(){…}

④ 定义测试类(AnimalDemo)，写代码测试

3.接口

3.1 接口概述

【生活中的接口】

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZketYNNS-1661926258215)(imgs/1640785171549.png)]

这是我们房间中比较常见的五孔插线面板，我们再来一个五孔插线面板。

大家认真看一下啊，这是两种不同类型的插线面板，对插线面板有了解的同学，应该能够看出来。

左边这个是公牛的，右边这个是西门子的。

为什么不同厂商生成的插线面板装到你家里，你都可以使用呢？

原因很简单，因为这些面板是这些厂商遵循同样的规范生产的。

所以说，接口啊，就是一种公共的规范，只要符合规范，大家都可以使用。

这是我们生活当中的，其实与计算机相关的接口也随处可见：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tS3ZqOVy-1661926258216)(imgs/1640785329296.png)]

这是笔记本，有两个USB插口，可以用来连接外接设备。

我们在使用笔记本的时候，有些操作我们发现使用键盘不方便，这里呢，我们就可以提供一个鼠标，插入到这个USB插口里面就可以使用了。

再比如说，笔记本上的键盘用起来我感觉不是很方便，而且我担心给他敲坏了，怎么本？我们就可以提供一个外置的键盘，插入到这个USB插口里面也就可以使用了。

再比如说，我电脑上有一些学习资料，我要给你。如果有网络，我们可以通过一些网络软件发送给你，如果没有网络，怎么办呢？这个时候，我们就可以通过这样的一个小工具：U盘来拷贝资料。

插入到这个USB插口里面也就可以使用了。

看到这里，我们思考一下，这些产品是由不同的厂商生产的，但是它们却都可以通过这个USB插口接到这个电脑上，这是为什么呢？

原因很简单，因为它们参照的是同样的USB插口规范来实现的。无论是尺寸，厚度等都是有标准参数的。所以，虽然它们是不同的厂商生产的，但是却可以通过这个USB插口来使用。

【什么是接口】

接口就是一种公共的规范标准，只有符合规范标准（具备这个功能），大家都可以通用
Java中的接口更多的体现在对行为（方法）的抽象

3.2 接口特点

【特点】

接口用关键字interface修饰
- public interface 接口名 {}
类实现接口用implements表示
- public class 类名 implements 接口名 {}
接口不能实例化
- 接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫接口多态
- 多态的形式：具体类多态，抽象类多态，接口多态
- 多态的前提：有继承或者实现关系；有方法重写；有父(类/接口)引用指向(子/实现)类对象
接口的实现类
- 要么重写接口中的所有抽象方法
- 要么是抽象类

【代码】

/*
    定义了一个接口
 */
public interface Inter {
    public abstract void show();
}

public class InterImpl implements Inter {
    @Override
    public void show() {
        System.out.println("show...");
    }
}

public abstract class InterImpl2 implements Inter{

}

/*
    测试类
 */
public class InterDemo {
    public static void main(String[] args) {
//        Inter i = new Inter();
        Inter i = new InterImpl();
        i.show();
    }
}

3.3 接口的成员特点

【成员变量】

只能是常量
默认修饰符：public static final

【构造方法】

没有，因为接口主要是扩展功能的，而没有具体存在
一个类如果没有父类，默认继承自Object类

【成员方法】

只能是抽象方法
默认修饰符：public abstract
关于接口中的方法，JDK8和JDK9中有一些新特性，后面再讲解

public interface Inter {
    public int num = 10;
    public final int num2 = 20;
//    public static final int num3 = 30;
    int num3 = 30;

//    public Inter() {}

//    public void show() {}

    public abstract void method();
    void show();

}

//public class InterImpl implements Inter {

public class InterImpl extends Object implements Inter {
    public InterImpl() {
        super();
    }

    @Override
    public void method() {
        System.out.println("method");
    }

    @Override
    public void show() {
        System.out.println("show");
    }
}

/*
    测试类
 */
public class InterfaceDemo {
    public static void main(String[] args) {
        Inter i = new InterImpl();
//        i.num = 20;
        System.out.println(i.num);
//        i.num2 = 40;
        System.out.println(i.num2);
        System.out.println(Inter.num);
    }
}

3.4 类和接口的关系

类和类的关系
- 继承关系，只能单继承，但是可以多层继承
类和接口的关系
- 实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
接口和接口的关系
- 继承关系，可以单继承，也可以多继承,也可以多层继承

public interface Inter1 {
    
}

public interface Inter2 {

}

public interface Inter3 extends Inter1,Inter2 {

}

public class InterImpl extends Object implements Inter1,Inter2,Inter3 {

}

3.5 抽象类和接口的区别

来，继续啊，下面我们来学习抽象类和接口的区别。

我们一起来说一下：

成员区别
- 抽象类变量,常量；有构造方法；有抽象方法,也有非抽象方法
- 接口常量；没有构造方法;抽象方法
关系区别
- 类与类继承，单继承
- 类与接口实现，可以单实现，也可以多实现
- 接口与接口继承，单继承，多继承
设计理念区别
- 抽象类对类抽象，包括属性、行为???
- 接口主要是行为抽象???

3.6 案例：木门和电动报警门

需求：请采用面向对象的思想实现木门和电动报警门的案例，并在测试类中进行测试

看完需求后，我们先简单的分析一下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pgm3bO2z-1661926258216)(imgs/1641276207662.png)]

分析：

①木门

成员变量：宽，高，品牌
成员方法：开门，关门

②电动报警门：

成员变量：宽，高，品牌
成员方法：开门，关门，报警

图解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kyebABhr-1661926258217)(assets/image-20220827123638168.png)]

思路：

①定义报警 (Alarm)接口

成员方法：报警

②定义门 (Door)抽象类

成员变量：宽，高，品牌
构造方法：无参，带参
成员方法：get/set方法，开门，关门

③定义木门类(WoodDoor)，继承门类

构造方法：无参，带参
成员方法：开门，关门

④定义电动报警门类(ElectricAlarmDoor),继承门类,实现报警接口

构造方法：无参，带参
成员方法：开门，关门，报警

⑤定义测试类(DoorDemo)，创建对象进行测试

知道了实现思路后，下面我们一起到IDEA中去实现一下：

/*
    报警接口
 */
public interface Alarm {
    void alarm();
}

/*
    抽象门类
 */
public abstract class Door {
    //宽
    private double width;
    //高
    private double height;
    //品牌
    private String brand;

    public Door() {
    }

    public Door(double width, double height, String brand) {
        this.width = width;
        this.height = height;
        this.brand = brand;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    //开门
    public abstract void open();

    //关门
    public abstract void close();
}

/*
    木门
 */
public class WoodDoor extends Door {

    public WoodDoor() {
    }

    public WoodDoor(double width, double height, String brand) {
        super(width, height, brand);
    }

    @Override
    public void open() {
        System.out.println("手动开门");
    }

    @Override
    public void close() {
        System.out.println("手动关门");
    }
}

/*
    电动报警门
 */
public class ElectricAlarmDoor extends Door implements Alarm {
    public ElectricAlarmDoor() {
    }

    public ElectricAlarmDoor(double width, double height, String brand) {
        super(width, height, brand);
    }

    @Override
    public void open() {
        System.out.println("自动开门");
    }

    @Override
    public void close() {
        System.out.println("自动关门");
    }


    @Override
    public void alarm() {
        System.out.println("具有报警功能");
    }
}

/*
    测试类
 */
public class DoorDemo {
    public static void main(String[] args) {
        //木门
        WoodDoor wd = new WoodDoor();
        wd.open();
        wd.close();
//        wd.alarm();
        System.out.println("--------");

        //电动报警门
        ElectricAlarmDoor ed = new ElectricAlarmDoor();
        ed.open();
        ed.close();
        ed.alarm();
        System.out.println("--------");

        //多态用法
        Door d = new WoodDoor();
        d.open();
        d.close();
        System.out.println("--------");

        d = new ElectricAlarmDoor();
        d.open();
        d.close();
//        d.alarm();
        System.out.println("--------");

        Alarm a = new ElectricAlarmDoor();
//        a.open();
//        a.close();
        a.alarm();
    }
}

3.7 接口新增的方法

【接口组成】

常量
- public static final
抽象方法
- public abstract
默认方法(Java 8)
静态方法(Java 8)
私有方法(Java 9)

【默认方法】

接口中默认方法的定义格式
- 格式：public default 返回值类型方法名(参数列表) { }
- 范例：public default void show1() { }
接口中默认方法的注意事项
- public可以省略，default不能省略

【静态方法】

接口中静态方法的定义格式
- 格式：public static 返回值类型方法名(参数列表) { }
- 范例：public static void show2() { }
接口中静态方法的注意事项
- 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
- public可以省略，static不能省略

【私有方法】

接口中私有方法的定义格式
- 格式1：private 返回值类型方法名(参数列表) { }
- 范例1：private void show3() { }
- 格式2：private static 返回值类型方法名(参数列表) { }
- 范例2：private static void show4() { }
接口中私有方法的注意事项
- 默认方法可以调用私有的静态方法和非静态方法
- 静态方法只能调用私有的静态方法

【代码】

public interface Inter {
//    public default void show1() {
//        System.out.println("默认方法被调用");
//    }

    default void show1() {
        System.out.println("默认方法被调用");
        show3();
        show4();
    }

//    public static void show2() {
//        System.out.println("静态方法被调用");
//    }

    static void show2() {
        System.out.println("静态方法被调用");
//        show3();
        show4();
    }

    private void show3() {
        System.out.println("私有方法");
    }

    private static void show4() {
        System.out.println("静态私有方法");
    }

}

public class InterImpl implements Inter {
    
}

/*
    测试类
 */
public class InterDemo {
    public static void main(String[] args) {
        Inter i = new InterImpl();
        i.show1();
//        i.show2();
//        InterImpl.show2();
        Inter.show2();
    }
}