课程笔记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(); //滴滴滴滴...
}
}
架构设计器
打开方式
界面说明
第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());
}
}
}
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());
}
}
}