当前位置：首页 > article >正文

面向对象高级(1)

article 2026/1/27 17:03:29

文章目录

final
- 认识final关键字
- - 修饰类：
  - 修饰方法：
  - 修饰变量
  - final修饰变量的注意事项
- 常量
单例类
- 什么是设计模式？
- 单例怎么写?
- 饿汉式单例的特点是什么？
- 单例有啥应用场景，有啥好处？
- 懒汉式单例类。
枚举类
- 认识枚举类
- 枚举类的常见应用场景
抽象类
- 认识抽象类
- 使用抽象类的好处
- 模板方法设计模式
接口
- 什么是接口
- 接口语法
- 接口如何实现
- 接口的好处
- 接口的综合小案例
- - 需求
  - 分析
  - 代码
- JDK8新增的三种方法
- 接口的注意事项
- - 1
  - 2
  - 3
  - 4
抽象类和接口的区别
案例

final、单例类、枚举类、抽象类、接口

final

认识final关键字

final 关键字是最终的意思，可以修饰：类、方法、变量。
修饰类：该类被称为最终类，特点是不能被继承了。应用场景：工具类，不需要被继承。
修饰方法：该方法被称为最终方法，特点是不能被重写了。应用场景:在抽象类会讲。
修饰变量：该变量有且仅能被赋值一次。应用场景：局部变量修饰一些固定的值，比如圆周率。
成员变量，比如作为系统的配置信息。给实例变量加无意义。

修饰类：

public class FinalDemo1 {public static void main(String[] args) { }
}
// 1、final修饰类，类不能被继承。
final class A{
}
// class B extends A{} // 报错
// 应用场景 : 工具类不需要继承,所以加final
// 在比如java的内置math方法是个工具类。查看Ctrl+点击math 查看源码
// 你会发现math类使用了final:  public final class Math{...}
public final class XxxxUtil {public static void xxx(){   ......  }public static boolean xxxx(String email){  ... }  public static String xxxxx(int n){  ... }...
}

修饰方法：

public class FinalDemo1 {public static void main(String[] args) { }
}//  final修饰方法，方法不能被重写。应用场景会在抽象类中讲。
class C{public final void show(){System.out.println("show方法被执行");}
}
class D extends C{
//     @Override
//     public void show(){
//         System.out.println("show方法被执行");
//     }
}

修饰变量

我们知道变量分为很多种

成员变量:
- 静态成员变量
- 实例成员变量
局部变量
下面对每种变量都加一个final修饰。

public class FinalDemo1 {public static void main(String[] args) {// final修饰变量：变量有且仅能被赋值一次。// 修饰局部变量final double rate = 3.14;// rate = 3.16; // 第二次赋值，报错。// 局部变量应用// 比如这里打八折buy(0.8);}public static void buy(final double z){// z = 0.1;  // 第二次赋值，报错。System.out.println(z);}
}public class FinalDemo1 {// final修饰静态成员变量// final修饰静态变量，这个变量今后被称为常量，// 常量可以记住一个固定值，并且程序中不能修改了，// 应用场景: 通常这个值作为系统的配置信息。// 常量的名称，建议全部大写，多个单词用下划线链接public static final String SCHOOL_NAME = "黑马程序员";public static void main(String[] args) { }
}public class FinalDemo1 {// final修饰实例变量（一般没有意义）private final String name = "猪刚鬣";public static void main(String[] args) {FinalDemo1 f = new FinalDemo1();System.out.println(f.name);// f.name = "高翠兰"; // 第二次赋值，报错。}
}

final修饰变量的注意事项

final修饰基本类型的变量，变量存储的数据不能被改变。
final修饰引用类型的变量，变量存储的地址不能被改变，但地址所指向对象的内容是可以被改变的。

public class FinalDemo1 {public static void main(String[] args) {final int a = 20;// a = 30; // 第二次赋值，报错。final int[] arr = {11, 22, 33, 44};// arr = new int[]{33, 55, 44}; // 第二次赋值，报错。修改地址arr[2] = 90;// 不报错没有修改地址}
}

常量

使用了 static final 修饰的成员变量就被称为常量(上节已经讲过).
作用：常用于记录系统的配置信息。

public class Constant {public static final String SCHOOL_NAME  = “传智教育";
}

注意！常量名的命名规范：建议使用大写英文单词，多个单词使用下划线连接起来。

使用常量记录系统配置信息的优势、执行原理

代码可读性更好，可维护性也更好。
程序编译后，常量会被“宏替换”：出现常量的地方全部会被替换成其记住的字面量，这样可以保证使用常量和直接用字面量的性能是一样的。
运行下面代码，在out文件夹下查看编译后的代码。

public class Constant {public static final String SYSTEM_NAME = "黑马程序员智能家居AI系统";
}
public class FinalDemo2 {public static void main(String[] args) {// 目标：详解常量。System.out.println(Constant.SYSTEM_NAME);System.out.println(Constant.SYSTEM_NAME);System.out.println(Constant.SYSTEM_NAME);System.out.println(Constant.SYSTEM_NAME);System.out.println(Constant.SYSTEM_NAME);System.out.println(Constant.SYSTEM_NAME);}
}

out文件夹下查看编译后的代码如下：
常量会被“宏替换”

package com.itheima.finaldemo;public class FinalDemo2 {public FinalDemo2() {}public static void main(String[] args) {System.out.println("黑马程序员智能家居AI系统");System.out.println("黑马程序员智能家居AI系统");System.out.println("黑马程序员智能家居AI系统");System.out.println("黑马程序员智能家居AI系统");System.out.println("黑马程序员智能家居AI系统");System.out.println("黑马程序员智能家居AI系统");}
}

单例类

单例类属于设计模式这门课，设计模式架构师学的技术。
我们面试或者看底层源码可能会有一些知识涉及到设计模式。

什么是设计模式？

一个问题通常有n种解法，其中肯定有一种解法是最优的，这个最优的解法被人总结出来了，称之为设计模式。简而言之：设计模式是具体问题的最优解决方案。
设计模式有20多种，对应20多种软件开发中会遇到的问题。

关于设计模式，主要学什么？

解决什么问题。
怎么写。

单例模式解决了什么问题？或者说他是干什么的。
确保某个类只能创建一个对象。

单例怎么写?

把类的构造器私有；
定义一个静态变量存储类的一个对象；
提供一个静态方法返回对象。

// 设计成单例设计模式
public class A {// 2、定义一个静态变量，用于存储本类的一个唯一对象。// 第三步可以用下面的这个代替。// public static final A a = new A();private static A a = new A();// 1、私有化构造器: 确保单例类对外不能创建太多对象，单例才有可能性。private A() {}// 3、提供一个公开的静态方法，返回这个类的唯一对象。public static A getInstance() {return a;}
}
package com.itheima.singleinstance;public class Test {public static void main(String[] args) {// 目标：设计单例类。A a1 = A.getInstance();A a2 = A.getInstance();System.out.println(a1); // com.itheima.singleinstance.A@404b9385System.out.println(a2); // com.itheima.singleinstance.A@404b9385System.out.println(a1 == a2);// trueSystem.out.println("============================");B b1 = B.getInstance();B b2 = B.getInstance();System.out.println(b1);System.out.println(b2);System.out.println(b1 == b2);}
}

饿汉式单例的特点是什么？

在获取类的对象时，对象已经创建好了。

单例有啥应用场景，有啥好处？

任务管理器对象、获取运行时对象。
在这些业务场景下，使用单例模式，可以避免浪费内存。

懒汉式单例类。

用对象时，才开始创建对象。

懒汉单例模式怎么写?
1. 把构造器私有。
2. 定义一个类变量用于存储对象。
3. 提供一个类方法，保证返回的是同一个对象。

// 懒汉式单例类。
public class B {// 2、私有化静态变量private static B b;// 1、私有化构造器private B() { }// 3、提供静态方法返回对象： 真正需要对象的时候才开始创建对象。public static B getInstance() {if (b == null) {// 第一次拿对象时，会创建对象，给静态变量b记住。b = new B();}return b;}
}public class Test {public static void main(String[] args) {B b1 = B.getInstance();B b2 = B.getInstance();System.out.println(b1);// com.itheima.singleinstance.B@682a0b20System.out.println(b2);// com.itheima.singleinstance.B@682a0b20System.out.println(b1 == b2);//true}
}

枚举类

认识枚举类

枚举是一种特殊类。
枚举类的写法

修饰符 enum 枚举类名{  名称1 ,  名称2, ... ; 其他成员…
}

特点：
枚举类中的第一行，只能写枚举类的对象名称，且要用逗号隔开。
这些名称，本质是常量，每个常量都记住了枚举类的一个对象。

// 枚举类
public enum A {// 枚举类的第一行：只能罗列枚举对象的名称，这些名称本质是常量。X, Y, Z;
}
// 这是
public class Test {public static void main(String[] args) {// 目标：认识枚举类，搞清楚其本质特点。A a1 = A.X;System.out.println(a1);A a2 = A.Y;System.out.println(a2);// 编译器为枚举类新增了几个方法System.out.println(a1.name()); // XSystem.out.println(a2.name()); // YSystem.out.println(a1.ordinal()); // 索引  0System.out.println(a2.ordinal()); // 索引  1}
}

我们来看一下public enum A{ }的编译后的代码

Compiled from “A.java"
public final class A extends java.lang.Enum<A> {public static final A X = new A();public static final A Y = new A();public static final A Z = new A();public static A[] values();public static A valueOf(java.lang.String);
}

枚举都是最终类，不可以被继承，枚举类都是继承java.lang.Enum类的。
枚举类的第一行只能罗列一些名称，这些名称都是常量，并且每个常量会记住枚举类的一个对象。
枚举类的构造器都是私有的（写不写都只能是私有的），因此，枚举类对外不能创建对象。
编译器为枚举类新增了几个方法。

枚举类的常见应用场景

先使用变量写：

public class Constant {public static final int UP = 0; // 上public static final int DOWN = 1; // 下public static final int LEFT = 2; // 左public static final int RIGHT = 3; // 右
}public class Test2 {public static void main(String[] args) {// 需求：模拟上下左右移动图片。// 第一种是常量做信息标志和分类: 但参数值不受约束。// 参数值可以传入0,1，110。move(Constant.UP);}public static void move(int direction){// 根据这个方向做移动：上下左右。switch (direction){case Constant.UP :System.out.println("向上移动");break;case Constant.DOWN :System.out.println("向下移动");break;case Constant.LEFT :System.out.println("向左移动");break;case Constant.RIGHT :System.out.println("向右移动");break;default:System.out.println("输入有误");}}
}

使用枚举类写。

public enum Direction {UP, DOWN, LEFT, RIGHT;
}
public class Test2 {public static void main(String[] args) {// 第二种是枚举做信息标志和分类: 参数值受枚举类约束。move2(Direction.DOWN);}public static void move2(Direction direction){// 根据这个方向做移动：上下左右。switch (direction){case UP:System.out.println("向上移动");break;case DOWN :System.out.println("向下移动");break;case LEFT :System.out.println("向左移动");break;case RIGHT :System.out.println("向右移动");break;}}
}

抽象类

认识抽象类

在Java中有一个关键字叫：abstract，它就是抽象的意思，可以用它修饰类、成员方法。

abstract修饰类，这个类就是抽象类。
abstract修饰方法，这个方法就是抽象方法。

语法

修饰符 abstract class 类名{ // 抽象方法：必须abstract修饰，只有方法签名，不能有方法体修饰符 abstract 返回值类型 方法名称(形参列表)；
}

抽象类的注意事项、特点

抽象类中不一定要有抽象方法，有抽象方法的类必须是抽象类。
类有的成员：成员变量、方法、构造器，抽象类都可以有。
抽象类最主要的特点：抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现。
一个类继承抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。

// 抽象类
public abstract class A {// 抽象类中不一定要有抽象方法，有抽象方法的类必须是抽象类。// 抽象类中：成员变量、方法、构造器，抽象方法都可以有private String name;private int age;public A() { System.out.println("A的无参构造器"); }public A(String name, int age) {this.name = name;this.age = age;}// 抽象方法：必须用abstract修饰，没有方法体，只有方法声明。public abstract void show();public void show1() { System.out.println("show1方法"); }//省略getter()和setter()
}public class B extends A{
// 一个类继承抽象类，必须重写完继承的全部抽象方法，否则这个类也必须定义成抽象类@Overridepublic void show() {System.out.println("B类重写show方法");}
}
public class AbstractDemo1 {public static void main(String[] args) {// 目标：认识抽象类，抽象方法，搞清楚他们的特点。// 抽象类的核心特点：有得有失（得到了抽象方法的能力，失去了创建对象的能力）// 抽象类不能创建对象（重点）。// A a = new A();  // 报错了// 抽象类的使命就是被子类继承：就是为了生孩子。B b = new B(); // A的无参构造器b.setName("张三");b.setAge(18);System.out.println(b.getName() + "---" + b.getAge());// 张三---18b.show(); // B类重写show方法b.show1();// show1方法}
}

使用抽象类的好处

父类知道每个子类都要做某个行为，但每个子类要做的情况不一样，父类就定义成抽象方法，交给子类去重写实现，我们设计这样的抽象类，就是为了更好的支持多态。

public abstract class Animal {// 每个动物的叫声。// 如果这里不写抽象方法cry()，无法使用父类调用子类的方法。//  Animal a = new Dog();右侧不能解耦。public abstract void cry();
}
public class Dog extends Animal{@Overridepublic void cry() {System.out.println("🐕是汪汪汪的叫~~~");}
}
public class Cat extends Animal{@Overridepublic void cry() {System.out.println("🐱是喵喵喵的叫~~~");}
}
public class Test {public static void main(String[] args) {Animal a = new Dog();a.cry();// 🐕是汪汪汪的叫~~~}
}

模板方法设计模式

提供一个方法作为完成某类功能的模板，模板方法封装了每个实现步骤，但允许子类提供特定步骤的实现。
模板方法设计模式可以：提高代码的复用、并简化子类设计。

写法
1、定义一个抽象类。
2、在里面定义2个方法
- 一个是模板方法：把共同的实现步骤放里面去。
- 一个是抽象方法：不确定的实现步骤，交给具体的子类来完成。

建议使用final关键字修饰模板方法，为什么？

模板方法是给子类直接使用的，不能被子类重写。
一旦子类重写了模板方法，模板方法就失效了。

public abstract class People {// 1、模板方法设计模式。public final void write(){System.out.println("\t\t\t《我的爸爸》");System.out.println("\t我爸爸是一个好人，我特别喜欢他，他对我很好，我来介绍一下：");// 2、模板方法知道子类一定要写这个正文，但是每个子类写的信息是不同的，父类定义一个抽象方法// 具体的实现交给子类来重写正文。writeMain();System.out.println("\t我爸爸真好，你有这样的爸爸吗？");}public abstract void writeMain();
}
public class Student extends People{@Overridepublic void writeMain() {System.out.println("\t我爸爸很牛逼，是个管理者，我开车不用看红绿灯的，有这样的爸爸真好，下辈子还要做他儿子！");}
}
public class Teacher extends People {@Overridepublic void writeMain() {System.out.println("\t我爸爸经常让我站在这里别动，他要去买几斤橘子~~柚子我也吃，毕竟是亲生的！");}
}
public class Test {public static void main(String[] args) {// 抽象类的使用场景之二：模板方法设计模式。// 学生和老师都要写一篇作文：《我的爸爸》//         第一段是一样的：我爸爸是一个好人，我特别喜欢他，他对我很好，我来介绍一下：//         第二段是不一样：老师和学生各自写各自的。//         第三段是一样的：我爸爸真好，你有这样的爸爸吗？// 解决：抽出一个父类。父类中还抽取一个模板方法给子类直接用。Student s = new Student();s.write();
//        			《我的爸爸》
//	我爸爸是一个好人，我特别喜欢他，他对我很好，我来介绍一下：
//	我爸爸很牛逼，是个管理者，我开车不用看红绿灯的，有这样的爸爸真好，下辈子还要做他儿子！
// 我爸爸真好，你有这样的爸爸吗？s.writeMain();
//我爸爸很牛逼，是个管理者，我开车不用看红绿灯的，有这样的爸爸真好，下辈子还要做他儿子！}
}

接口

什么是接口

Java提供了一个关键字interface定义出接口。

接口语法

public interface 接口名 {// 成员变量（常量）// 成员方法（抽象方法）
}

注意：接口不能创建对象。

接口如何实现

接口是用来被类实现（implements）的，实现接口的类称为实现类，一个类可以同时实现多个接口。

修饰符 class 实现类类名 implements 接口1, 接口2, 接口3 , ... {// 实现类实现多个接口，必须重写完全部接口的全部抽象方法，// 否则实现类需要定义成抽象类。// JDK 8之前，接口中只能定义常量和抽象方法。
}

// 接口：使用interface关键字定义的
public interface A {// JDK 8之前，接口中只能定义常量和抽象方法。// 1、常量：接口中定义常量可以省略public static final不写，默认会加上去。String SCHOOL_NAME = "黑马程序员";// public static final String SCHOOL_NAME2 = "黑马程序员";// 2、抽象方法: 接口中定义抽象方法可以省略public abstract不写，默认会加上去。// public abstract void run();void run();String go();
}
public interface B {void play(); // 玩
}
public class Test {public static void main(String[] args) {System.out.println(A.SCHOOL_NAME);// 注意：接口不能创建对象。C c = new C();c.run();System.out.println(c.go());c.play();}
}
// C被称为实现类。同时实现了多个接口。
// 实现类实现多个接口，必须重写完全部接口的全部抽象方法，否则这个类必须定义成抽象类
class C implements  B , A{@Overridepublic void run() {System.out.println("C类重写了run方法");}@Overridepublic String go() {return "黑马找磊哥！";}@Overridepublic void play() {System.out.println("C类重写了play方法");}
}

接口的好处

+ 弥补了类单继承的不足，一个类同时可以实现多个接口，使类的角色更多，功能更强大。
+ 让程序可以面向接口编程，这样程序员就可以灵活方便的切换各种业务实现（更利于程序的解耦合）。

public class Test {public static void main(String[] args) {// 接口弥补了类单继承的不足，可以让类拥有更多角色，类的功能更强大。// 学生是个人，但是学生可能兼职代代驾。所以亲爹是人，干爹是代驾等等。People p = new Student();Driver d = new Student(); // 多态BoyFriend bf = new Student();// 接口可以实现面向接口编程，更利于解耦合。// 比如说A公司要做一个对学生增删改查的功能，A公司设计一个接口，// 这个接口要求删接口 查接口 统计作业接口 // 给学生建议接口 集成ai接口。// 现在有B，C两个公司去实现这5个接口，我们用哪个呢？// A公司 a = new B公司 // A公司 a = new C公司 // 如上A公司接口不变，只要换个公司就能接着实现功能Driver a = new Student();Driver a2 = new Teacher();BoyFriend b1 = new Student();BoyFriend b2 = new Teacher();}
}
interface Driver{}
interface BoyFriend{}
class People{}
class Student extends People implements Driver, BoyFriend{}class Teacher implements Driver, BoyFriend{}

接口的综合小案例

需求

请设计一个班级学生的信息管理模块：学生的数据有：姓名、性别、成绩
功能1：要求打印出全班学生的信息；
功能2：要求打印出全班学生的平均成绩。

注意！以上功能的业务实现是有多套方案的，比如：

第1套方案：能打印出班级全部学生的信息；能打印班级全部学生的平均分。
第2套方案：能打印出班级全部学生的信息（包含男女人数）；能打印班级全部学生的平均分（要求是去掉最高分、最低分）。
要求：系统可以支持灵活的切换这些实现方案。

分析

提供两套业务实现方案，支持灵活切换（解耦合）：面向接口编程。
– 定义一个接口（规范思想）：必须完成打印全班学生信息，打印平均分。(ClassDataInter)

定义第一套实现类，实现接口：实现打印学生信息，实现打印平均分。
定义第二套实现类，实现接口：实现打印学生信息(男女人数)，实现打印平均分（去掉最高分和最低分）。

在这里插入图片描述

代码