抽象类与接口（二）

最新推荐文章于 2023-08-27 09:36:51 发布

为什么暴躁

最新推荐文章于 2023-08-27 09:36:51 发布

阅读量117

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/chenguoao1999/article/details/119043115

版权

java基础专栏收录该内容

42 篇文章 2 订阅

订阅专栏

课程笔记Day10

抽象
接口
比较器

第一章抽象

第01节基础理论

抽象的由来

在我们编写代码，采用继承关系的时候。继承是【向上抽取共性】的过程。
例如:
	猫
		成员变量: name age
		成员方法: 撸猫、吃
	狗
		成员变量：name age
		成员方法：遛狗、吃
我们向上抽取共性，形成父类 动物 对于成员方法而言，都应该具备有 吃的功能。
但是站在动物的角度来说，动物吃什么? 我们不清楚

生活实例：

在这里插入图片描述

说明：

站在父类的角度考虑问题，父类当中一定是存在这个功能的，但是这个功能说不清楚具体的实现方式。

这种情况下，这个功能就是抽象的。（例如上述案例当中的形状的面积和动物的吃）

第02节快速入门

效果图

在这里插入图片描述

案例代码

动物类

//动物类【抽象类】
public abstract class Animal {

    //动物睡觉的方式是一样的
    public void sleep(){
        System.out.println("动物睡觉..");
    }

    //动物吃的方式是不一样的
    //抽象方法所在的类，必须是抽象类
    public abstract void eat();
}

猫类

//猫类【子类】  Alt + Enter
public class Cat extends Animal{

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

测试类

//测试类
public class Test {

    public static void main(String[] args) {

        //创建对象
        //这里出错，抽象类不能创建对象（不能实例化）
        //Animal aa = new Animal();

        //创建对象
        Cat c = new Cat();
        //调用方法
        c.eat();   //猫吃鱼
        c.sleep(); //动物睡觉..
    }
}

第03节注意事项

抽象类和抽象方法需要注意哪些问题

1. 两者关系
	抽象方法所在的类，必须是抽象类。
	抽象类当中，不一定有抽象方法，还可以有其他方法。

2. 对象和构造
	抽象类不能创建对象，也就是不能被实例化。
	抽象类有构造方法，给成员变量初始化数据。

3. 使用方式
	如果一个类，继承了抽象类，那么他有两个选择。
	选择一：把自己变成抽象类
	选择二：重写父类当中，所有的抽象方法

4. abstract 和 final 不能共存。为什么呢?
	A.抽象类是要求被继承的，有子类的。 而final修饰的类，是不能被继承。
	B.抽象方法是要求被重写的，而 final 修饰的方法，是不能被重写的。

演示：抽象类当中，包含有构造方法。不包含抽象方法的情况

在这里插入图片描述

第04节模板方法

基础理论

设计模式：共计有 23种。
他是程序员经过多年长期的积累，累计出来的 23种 编写代码的方式。设计代码的方式。

生活实例

《司机的故事》

司机分为两种：新手司机和老司机。开车的方式很像。

新手司机:
	1. 系上安全带，点火，启动
	2. 双手紧握方向盘，刹车当油门，猛地轰
	3. 熄火，停车

老司机:
	1. 系上安全带，点火，启动
	2. 三挡起步，一只手握方向盘，一只手抠脚
	3. 熄火，停车

小结操作步骤

1. 将共性的内容，写在父类当中，定义成为 final 修饰的方法。
2. 将不同的内容，定义在父类，作为抽象方法，交给各自的子类去实现。
3. 在父类的 final 方法当中去调用父类的抽象方法。

案例代码

司机类

//司机类【抽象类】
public abstract class Driver {

    //存在开车的方法
    public final void byCar(){
        System.out.println("1.系上安全带，点火，启动");
        useCar();
        System.out.println("3.熄火，停车");
    }

    //定义一个方法，表示不同的操作
    public abstract void useCar();
}

新手司机

//新手司机【子类】
public class NewDriver extends Driver {
    @Override
    public void useCar() {
        System.out.println("2.双手紧握方向盘，刹车当油门，猛地轰");
    }
}

老司机

//老司机【子类】
public class OldDriver extends Driver {
    @Override
    public void useCar() {
        System.out.println("2.三挡起步，一只手握方向盘，一只手抠脚");
    }
}

测试类

//测试类
public class Test {

    public static void main(String[] args) {

        //创建新手司机的对象
        NewDriver nd = new NewDriver();
        nd.byCar();
        System.out.println("-----");
        //创建老司机的对象
        OldDriver od = new OldDriver();
        od.byCar();
    }
}

//1.系上安全带，点火，启动
//2.双手紧握方向盘，刹车当油门，猛地轰
//3.熄火，停车
//-----
//1.系上安全带，点火，启动
//2.三挡起步，一只手握方向盘，一只手抠脚
//3.熄火，停车

第二章接口

第01节基础理论

生活实例

在这里插入图片描述

Java的接口

接口在 Java 当中就是一套规则。必须要遵循规则，才能连接上接口。
类似于: 电脑和设备必须要遵循 USB的规则，才能共通使用。

所谓的规则：指的就是 抽象方法。
在抽象方法当中，我们指的了 方法的名称、方法的参数、方法的返回值类型。具体连接的内容，不操心，有千万种连接方式。

第02节快速入门

使用格式

定义格式

interface  接口名称{
    //常量
    //抽象方法
    //JDK8版本当中可以定义 默认方法和静态方法
    //JDK9版本当中可以定义 私有方法
}

使用格式

class 实现类名称 implements 接口名称{
    //重写抽象方法...
}

案例代码

接口

//定义接口
//1. 任何JDK版本  常量和抽象方法
//2. JDK8版本以上 默认方法和静态方法
//3. JDK9版本以上 私有方法
public interface JieKou {

    //1.常量. 默认修饰符  public static final
    public static final String ADDRESS = "www.baidu.com";

    //2.抽象方法.【重点】 默认修饰符 public abstract
    public abstract void methodAbstract();

    //3.默认方法. 默认修饰符 public
    public default void methodDefault(){
        System.out.println("接口当中的默认方法");
    }

    //4.静态方法. 默认修饰符 public
    public static void methodStatic(){
        System.out.println("接口当中的静态方法");
    }
}

实现类

//实现类 implements 实现的意思  Alt + Enter
public class ShiXian implements JieKou {
    @Override
    public void methodAbstract() {
        System.out.println("实现类，【必须重写】抽象方法");
    }
    @Override
    public void methodDefault() {
        System.out.println("实现类，【选择重写】默认方法");
    }
}

测试类

//测试类
public class Test {

    public static void main(String[] args) {
        //创建对象, 错误！接口不能被创建对象 实例化
        //JieKou kou = new JieKou();
        //创建实现类的对象
        ShiXian sx = new ShiXian();
        //调用成员信息
        System.out.println(JieKou.ADDRESS); //www.baidu.com
        sx.methodAbstract();  //实现类，【必须重写】抽象方法
        sx.methodDefault();  //实现类，【选择重写】默认方法
        JieKou.methodStatic();  //接口当中的静态方法
    }
}

效果图

在这里插入图片描述

第03节冲突问题

如果同时实现多个接口，而且还去继承其他的类，就会出现冲突情况，那么出现冲突之后怎么办呢?

1. 多个接口，拥有相同的抽象方法，实现类怎么办?
	只需要实现1个抽象方法即可。

2. 多个接口，拥有相同的默认方法，实现类怎么办?
	强制要求重写 相同的默认方法

3. 多个接口，拥有相同的静态方法，实现类怎么办?
	静态方法，调用方式是接口名称打点调用，与实现类没有关系，不存在冲突的情况

4. 接口的默认方法和父类的普通方法冲突，实现类怎么办?
	听父类的方法，但是如果自己重写了，就以自己重写的方法为准。

第04节类和接口关系

了解一下，彼此之间的关系

1. 类和类的关系?
	继承关系: extends
	特点: 单一继承，多层继承
	代码: public class ZiLei extends FuLei{ ... }

2. 类和接口的关系?
	实现关系：implements
	特点: 多实现
	代码: public class ShiXian implements JieKou { ... }

3. 接口和接口的关系?
	继承关系： extends
	特点： 多继承，可以同时继承多个接口
	代码:  public interface JieKou4  extends JieKou1,JieKou2,JieKou3{ ... }

一句话总结一下：

相同是继承 extends，不同是实现 implements 。

设计层面分析选择类和接口

需求说明

生活实例：门具备有基础功能（开门操作和关门的操作）额外的附加功能（防盗报警）
如果说，我们现在这里存在两个门，分别表示的是 旧门和新门。
旧门的功能：开门和关门的操作
新门的功能：开门和关门 以及防盗报警的功能。
如果采用前面学习过的知识点，应该如何设计门的功能呢？

案例设计

在这里插入图片描述

代码

门类

//门类
public class Door {

    //开门操作
    public void open(){
        System.out.println("开门...");
    }

    //关门操作
    public void close(){
        System.out.println("关门...");
    }
}

防盗接口

//防盗的接口
public interface FangDao {

    //定义抽象方法
    public abstract void alarm();

}

旧门

//旧门（只有开门和关门的操作）
public class OldDoor extends Door{

}

新门

//新门（具备有开门和关门的操作 同时具备防盗的操作）
public class NewDoor extends Door implements FangDao{
    @Override
    public void alarm() {
        System.out.println("滴滴滴滴...");
    }
}

测试类

//测试类
public class Test {

    public static void main(String[] args) {
        //创建旧门的对象
        OldDoor od = new OldDoor();
        od.open();   //开门...
        od.close();  //关门...
        System.out.println("------");
        //创建新门的对象
        NewDoor nd = new NewDoor();
        nd.open();  //开门...
        nd.close(); //关门...
        nd.alarm(); //滴滴滴滴...
    }
}

架构设计器

打开方式

在这里插入图片描述

界面说明

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-I6sL3Sk8-1627040358369)(%E8%AF%BE%E7%A8%8B%E7%AC%94%E8%AE%B0Day10.assets/image-20210723143030022.png)]
在这里插入图片描述

第05节运动员案例

需求说明

1. 有四个角色，分别是 篮球运动员、篮球教练、乒乓球运动员、乒乓球教练
2. 现在运动员需要有学习的功能，教练需要有教的功能
3. 打篮球的需要出国访问，学习英语
请根据前面学习的内容，分析哪些是类，哪些是接口，哪些是抽象类？

英语单词:
	运动员 Player
	教练   Coach
	篮球   basketball
	乒乓球 pingpang
	教    teach
	学    study
	英语  english

体系结构

在这里插入图片描述

第三章比较器

第01节基础理论

比较器有什么作用？

在我们后期学完面向对象之后，所有的操作，都是针对于对象。
而比较器，就是用来对 对象进行比较排序的操作。

例如：商品排序规则（价格排序、评论排序、销量排序....）

比较器的分类

1. 内部比较器 ： 直接在类里面去进行比较规则
2. 外部比较器 ： 类已经定义完毕了，在使用的时候，才会去指的规则

第02节内部比较器

学生类

//学生类【内部比较器】
public class Student implements Comparable<Student>{

    //核心就是：比较规则，告诉JVM 我应该怎么比较啊?
    // o 和 this
    // 升序： this-o
    // 降序： o-this
    @Override
    public int compareTo(Student o) {
        //例如: 我们按照学生的年龄比较，降序。从大到小
        int result = o.age - this.age;
        //如果说，两个年龄是相同的，则按照姓名首字母降序排列
        result = (result == 0)? o.name.compareTo(this.name):result;
        return result;
    }

    String name;
    int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

测试类

import java.util.Arrays;

//测试类
public class Test {

    public static void main(String[] args) {

        Student one = new Student("zhangsan", 23);
        Student two = new Student("lisi", 24);
        Student three = new Student("wangwu", 25);
        Student four = new Student("zhaoliu", 24);

        //我们将对象，存放到对象数组当中。
        //int[] array = new int[3];
        Student[] array = new Student[4];
        array[0] = one;
        array[1] = two;
        array[2] = three;
        array[3] = four;

        //数组是可以排序操作的。怎么排呢? Arrays.sort();
        Arrays.sort(array);

        //展示结果
        for (int i = 0; i < array.length; i++) {
            Student stu = array[i];
            System.out.println(stu.getName() + "," + stu.getAge());
        }
    }
}

为什么暴躁

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
抽象类与接口（二）

课程笔记Day10抽象接口比较器第一章抽象第01节基础理论抽象的由来在我们编写代码，采用继承关系的时候。继承是【向上抽取共性】的过程。例如: 猫成员变量: name age 成员方法: 撸猫、吃狗成员变量：name age 成员方法：遛狗、吃我们向上抽取共性，形成父类动物对于成员方法而言，都应该具备有吃的功能。但是站在动物的角度来说，动物吃什么? 我们不清楚生活实例：说明：站在父类的角度考虑问题，父类当中一定是存在这个功能的，但是这个功能
复制链接

扫一扫