一.认识final

1.含义

final关键字是最终的意思，可以修饰：类，方法，变量

修饰类：该类被称为最终类，特点是不能被继承

修饰方法：该方法被称为最终方法，特点是不能被重写了

修饰变量：该变量有且仅能被赋值一次

final修饰静态变量，这个变量今后被称为常量，可以记住一个固定值，并且程序中不能修改了，通常这个值作为系统的配置信息，作为共享值所有人都可以用

常量的名称：建议全部大写，多个单词用下划线进行连接

注：final修饰实例变量一般情况下没有意义！！！

2.final修饰变量的注意

final修饰基本类型的变量，变量存储的数据不能被改变

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

final int[] arr = {11,22,33,44}; //arr = new int[]{33,44,55}; //第二次赋值，报错 arr[2]=90;//不报错，可以修改

二.常量

1.含义

使用了static final修饰的成员变量就被称为常量

作用：常用于记录系统的配置信息

注：命名规范建议使用大写英文字母，多个单词使用下划线连接起来

2.优点

代码可读性更好，可维护性更好

程序编译后，常量会被“宏（全部）替换”：出现常量的地方全部会被替换成其记住的字面量，这样可以保证使用常量和直接用字面量的性能是一样的

三.单例类（设计模式）

注：这个属于系统架构师层面的技术

1.什么是设计模式

一个问题通常有n种解法，其中肯定有一种解法是最优的，这个最优的解法被人总结出来了，就称之为设计模式

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

解决什么问题：确保某个类只能创建一个对象

怎么写

3.单例设计模式

作用：确保某个类只能创建一个对象

写法步骤：

• 把类的构造器私有：确保单例类对外不能创建太多对象，单例才有可能性
• 定义一个静态变量：用于基本本类的一个唯一对象
• 提供一个静态方法：用于返回对象

//单例类 public class A{ //2.定义一个类变量记住类的一个变量 private static A a = new A(); //1.私有构造器 private(){ } //3.定义一个类方法返回对象 public static A getobject(){ return a; } }

public static A a = new A(); //这两句其实是相同的意思，上面的 A就是跟下面的 int一样代表数据类型 //new A()代表的是对象 public static int a1 = 20;

4.饿汉式单例的特点

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

5.单例有啥应用场景，有啥好处

任务管理器对象、获取运行时对象，避免浪费内存及无效资源浪费

6.懒汉式单例类

真正要用对象时，才开始创建对象

写法：

• 把类的构造器私有
• 定义一个静态变量用于存储对象
• 提供一个静态方法，保证返回的是同一个对象

public class B{ //2.定于一个类变量用于存储对象 private static B b;//null //1.单例必须私有构造器 private B(){ } //3.提供一个类方法返回类的的一个对象 public static B getobject(){ if(b == null){ b = new B(); } return b; } }

四.枚举类

1.枚举类的写法

修饰符enum枚举类名{ 名称1，名称2，....; 其他成员... } public enum A{ X,Y,Z; ... }

2.枚举类的特点

• 枚举类中的第一行，只能写枚举类的对象名称，且要用逗号隔开
• 这些名词，本质是常量，每个变量都记住了枚举类的一个对象
• 枚举都是最终类，不可以被继承，枚举类都是继承java.lang.Enum类的
• 枚举类的构造器都是私有的（写不写都只能时私有的），因此，枚举类对外不能创建对象
• 编译器为枚举类新增了几个方法
• 枚举是一种特殊类

public static A[] values();//将所有枚举的对象放到数组中 public static A valueOf(java.lang.String); //通过枚举对象的名字去定位某个枚举对象 a1.name()可以拿枚举对象 的名称 a1.ordinal()可以拿枚举对象 的索引

3.枚举类的常见应用场景

枚举类很适合做信息分类和标志

package com.itheima; public class Test { public static void main(String[] args) { //目标：掌握枚举类的应用场景，信息的分类和标志 //需求：模拟上下左右移动图片 move(Direction.UP); } public static void move(Direction direction){ switch (direction){ case UP://可直接写UP，因为枚举类中定义的常量值都是UP，Direction可以省略 System.out.println("向上移动"); break; case Down: System.out.println("向下移动"); break; case Left: System.out.println("向左移动"); break; case Right: System.out.println("向右移动"); break; default: System.out.println("无效指令"); } } }

package com.itheima; public enum Direction { UP,Down,Left,Right; }

五.抽象类

1.含义

在Java中有一个关键字叫：abstract（抽象），用这个可以修饰类、成员方法

abstract修饰类，这个类就是抽象类

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

2.语法

修饰符 abstract class 类名{ 修饰符 abstract 返回值类型 方法名称（形参列表）; } public abstract class A{ //抽象方法：必须abstract修饰，只有方法签名，不能有方法体,意味着不能有大括号 public abstract void test(); }

3.抽象类的注意事项、特点

抽象类中不一定要有抽象方法，有抽象方法的类必须是抽象类

类有的成员：成员变量、方法、构造器、抽象类都可以有

抽象类最主要的特点是：抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现

一个类继承抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类

注：在实际开发中，会全部重写抽象方法，而不是再定义成抽象类，这样就可以自己创建对象

方法：Alt键+回车，即可全部重写

4.使用抽象类的优点（非必须）

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

注：以后要做关于面向对象的设计时，如果所有子类都要做出功能，每个子类的功能又各不相同，即可把这个父类定义成抽象类和抽象方法

5.抽象类使用场景之一（模板方法设计模式）

提供给一个方法作为某类功能的模板，模板方法封装了每个实现步骤，但允许子类提供特定步骤的实现

模板方法设计模式：提高代码的复用、并简化子类设计

写法：

1.定义一个抽象类

2.在里面定义两个方法

• 一个是模板方法：把共同的实现步骤放里面去
• 一个是抽象方法：不确定的实现步骤，交给具体的子类来完成

注：建议使用final关键字修饰模板方法，控制方法不被重写

六.接口

1.含义

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

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

在JDK 8 之前，接口中只能定义常量和抽象方法。

在接口中定义常量可以省略public static final 不写，默认自动添加，抽象方法同理。

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

修饰符 class 实现类类名 implements 接口1，接口2，接口3，....{ //实现类实现多个接口，必须重写完全部接口的全部抽象方法，否则实现需要定义成抽象类 }

2.注意

接口不能创建对象。

3.接口的优点

弥补了类单继承的不足，一个类同时可以实现多个接口，使类的角色更多，功能更强大。

让程序可以面向接口编程，这样程序员就可以灵活方便的切换各种业务实现（更有利于程序的解耦合）。

4.接口案例：学生信息系统

package com.iteheima.interface1; public interface ClassDataInter { void printAllStudentInfos(); void printAverageScore(); }

ClassDateinter.java

package com.iteheima.interface1; public class Text {//把这个可以看作A公司提供的模板，其他两个实现类功能由另外公司完成，这就是协作开发 public static void main(String[] args) { //目标：完成接口的小案例 //1.定义学生类，创建学生对象，封装数据，才能交给别人进行调用 //2.准备学生数据，人为制造数据 Student[] allstudents = new Student[10];//创建数组allstudents并设计容量为10 allstudents[0] = new Student("小王",'男',90.5); allstudents[1] = new Student("小张",'女',80.5); allstudents[2] = new Student("小李",'男',70.5); allstudents[3] = new Student("小赵",'女',60.5); allstudents[4] = new Student("小孙",'男',50.5); allstudents[5] = new Student("小周",'女',40.5); allstudents[6] = new Student("小吴",'男',30.5); allstudents[7] = new Student("小郑",'女',20.5); allstudents[8] = new Student("小王",'男',10.5); allstudents[9] = new Student("小王",'女',90.5); //3.提供两套业务实现方案，支持灵活切换（解耦合） //——定义一个接口（规范思想）：必须完成打印全班学生信息，打印平均分 //——定义第一套实现类，实现接口：完成打印全班学生信息，实现打印平均分 //——定义第二套实现类，实现接口：实现打印学生信息（男女人数），实现打印平均分（去掉最高分和最低分） ClassDataInter cdi = new ClassDataInterImpl1(allstudents);//接口创建对象不能用new，而是用实现类 //上面这里就已经实现了解耦，如果要换实现类，只要换一个实现类，接口调用方法不变 cdi.printAllStudentInfos(); cdi.printAverageScore();

Text.java

package com.iteheima.interface1; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; @Data//构建get和set方法 @NoArgsConstructor//无参构造器 @AllArgsConstructor//有参构造器 class Student {//创建学生类，封装数据 private String name; private char sex; private double score; }

Student.java

package com.iteheima.interface1; public class ClassDataInterImpl1 implements ClassDataInter{ //类名[] 变量名（声明数组变量） private Student[] students;//创建数组记住下面送进来的全部学生信息 public ClassDataInterImpl1(Student[] students) {//用有参构造器接收学生信息 this.students = students;//将外部传入的数组赋给成员变量students } @Override public void printAllStudentInfos() { System.out.println("所有学生的信息为："); for (int i = 0; i < students.length; i++) { Student student = students[i]; System.out.println(student.getName() + " " + student.getSex() + " " + student.getScore()); } } @Override public void printAverageScore() { double sum = 0; for (int i = 0; i < students.length; i++) { Student student = students[i]; sum += student.getScore(); } System.out.println("平均分是：" + sum / students.length); } }

ClassDateInterImpl1.java

package com.iteheima.interface1; //——定义第二套实现类，实现接口：实现打印学生信息（男女人数），实现打印平均分（去掉最高分和最低分） public class ClassDataInterImpl2 implements ClassDataInter{ private Student[] students; public ClassDataInterImpl2(Student[] students) { this.students = students; } @Override public void printAllStudentInfos() { int maleCount = 0;//男生人数 for (int i = 0; i <students.length; i++) { Student student = students[i]; if (student.getSex() == '男') { maleCount++; } System.out.println(student.getName() + " " + student.getSex() + " " + student.getScore()); System.out.println("男性学生数量为：" + maleCount); System.out.println("女性学生数量为：" + (students.length - maleCount)); } } @Override public void printAverageScore() { System.out.println("平均分如下："); Student s1 = students[0]; //这边sum，max，min不能直接设计成0，万一值为0，那么后面求平均数就会出错 double sum = s1.getScore(); double max = s1.getScore(); double min = s1.getScore(); for (int i = 0; i < students.length; i++) { Student student = students[i]; sum += student.getScore(); if (student.getScore() > max) { max = student.getScore(); } else if (student.getScore() < min) { min = student.getScore(); } } System.out.println("最高分是：" + max); System.out.println("最低分是：" + min); System.out.println("平均分是：" + (sum-min-max) / (students.length-2)); } }

ClassDateInterImpl2.java

5.JDK开始，接口新增的三种方法

package com.iteheima.interface1.interface4; public interface A { //1.默认方法（普通实例方法）：必须加default关键字修饰 //默认会用public修饰 //使用接口的实现类的对象来进行调用 default void go(){ System.out.println("==go方法执行=="); run(); } //2.私有方法：必须加private关键字修饰 //使用接口中的其他实例方法来进行调用 private void run(){ System.out.println("==run方法执行=="); } //3.静态方法：必须加static关键字修饰 //只能使用当前接口名来调用 static void show(){ System.out.println("==show方法执行=="); } }

A.java

package com.iteheima.interface1.interface4; public class Text { //目标：搞清楚接口新增的三种方法，并理解其好处 public static void main(String[] args) { AImpl a = new AImpl();//创建对象 a.go();//用实现类来进行调用 } } //创建实现类AImpl class AImpl implements A{ }

Text.java

好处：

增强了接口的能力，便于项目的扩展和维护

why：新增的这些方法可以直接在接口中定义好具体的方法，新增功能时可以不用重新写方法

6.接口的注意事项

• 接口与接口可以多继承：一个接口可以同时继承多个接口
• 一个接口继承多个接口，如果多个接口中存在方法签名冲突，则此时不支持多继承，也不支持多实现
• 一个类继承了父类，又同时实现了接口，如果父类中和接口有同名的默认方法，实现类会优先用父类的
• 一个类实现了多个接口，如果多个接口中存在同名的默认方法，可以不冲突，这个类重写该方法即可

七.接口和抽象类的区别对比

1.相同点

• 多是抽象形式，都可以由抽象方法，都不能创建对象
• 都是派生子类形式：抽象类是被子类继承使用，接口是被实现类实现
• 一个类继承抽象类，或者实现接口，都必须重写抽象方法，否则自己成为抽象类
• 都能支持的多态，都能实现解耦合

2.不同点

• 抽象类中可以定义类的全部普通成员，接口只能定义常量，抽象方法（JDK8新增的三种方法）
• 抽象类只能被类单继承，接口可以被类多实现
• 一个类继承抽象类就不能再继承其他类，一个类实现了接口，还可以继承其他类或者其他接口
• 抽象类体现模板思想：更利于做父类，提高代码的复用性（最佳实践）
• 接口更适合做功能的解耦合：解耦合性更强更灵活（最佳实践）