@24：final关键字

final修饰变量：

（1）final修饰一个基本类型的变量，变量的值不可以改变，这个变量也变成了一个字符常量，规定：名字大写。

（2）final修饰一个引用类型的变量，final Dog d = new Dog( )，那么地址值就不可以改变

final Dog d = new Dog();
// wrong，地址值不可以改变
d = new Dog();
// d对象的属性仍然可以改变
d.age = 10;
d.weight = 100.33;

(3)：情况三：

public static void method() {// 地址值不可以改变final Dog d = new Dog();a(d);
}
//这种写法是可以的，a方法中的d是一个新建的形参
public static void a(Dog d){d = new Dog();}

（4）：情况四：

public static void method() {// 地址值不可以改变final Dog d = new Dog();a(d);
}
//这种写法是错的，a方法中的d是一个新建的形参，但是其地址值不可以改变
public static void a(final Dog d){d = new Dog();}

final修饰方法

final修饰方法，那么这个方法不可以被该类的子类重写：

final修饰类

final修饰类，代表没有子类，该类不可以被继承：

一旦一个类被final修饰，那么里面的方法也没有必要用final修饰了（final可以省略不写）

注意：java.lang包下的Math类中的构造方法被private修饰—> 导致Math这个类不可以创建对象

在这里插入图片描述

@25：抽象类与抽象方法

1：简单的介绍抽象类：

抽象类相当于是在普通的类中加上了抽象方法，但是抽象类不可以创建对象。

2：抽象类的作用：

在抽象类中定义抽象方法，目的是为了为子类提供一个通用的模板，子类可以在模板的基础上进行开发，先重写父类的抽象方法，然后可以扩展子类自己的内容。抽象类设计避免了子类设计的随意性，通过抽象类，子类的设计变得更加严格，进行某些程度上的限制。使子类更加的通用。

3：注意事项：

1：一个类中如果有方法是抽象方法，那么这个类必定是一个抽象类。
2：在一个类中，会有一类方法，子类对这个方法永远不满意，会对这个方法进行重写，这个方法直接写成抽象方法，类变成抽象类。
3：一个方法的方法体去掉，然后被abstract修饰，那么这个方法就变成了一个抽象方法
4：抽象类可以被其他类继承
5：一个类继承一个抽象类，那么这个类要么变成抽象类（不用重写 / 重写部分抽象方法）要么把继承的抽象类中的抽象方法全部重写。
6：一般子类不会加abstract修饰，一般会让子类重写父类中的抽象方法
7：子类继承抽象类，就必须重写全部的抽象方法
8：子类如果没有重写父类全部的抽象方法，那么子类就要变成一个抽象类。
9：抽象类不可以创建对象
10：多态的写法：父类引用只想子类对象：

4：面试题：

（1）抽象类不能创建对象，那么抽象类中是否有构造器？

抽象类中一定有构造器。构造器的作用给子类初始化对象的时候要先super调用父类的构造器。

（2）抽象类是否可以被final修饰？

不能被final修饰，因为抽象类设计的初衷就是给子类继承用的。要是被final修饰了这个抽象类了，就不存在继承了，就没有子类。

@26：接口

1：类是类，接口是接口，它们是同一层次的概念。

2：接口中没有构造器

3：接口如何声明：interface

4：在JDK1.8之前，接口中只有两部分内容：
（1）常量：固定修饰符：public static final
（2）抽象方法：固定修饰符：public abstract
注意：修饰符可以省略不写，IDE会帮你自动补全

5：类和接口的关系是什么？实现关系类实现接口

6：一旦实现一个接口，那么实现类要重写接口中的全部的抽象方法

7：如果没有全部重写抽象方法，那么这个类可以变成一个抽象类。

8：java只有单继承，java还有多实现

9：写法：先继承再实现：class P extends Person implements Interface01,Interface02 { }

10：接口不能创建对象。

11：接口中常量如何访问。
// 直接调用接口中的常量（static修饰）
System.out.println(TestInterface01.NUM);
// 通过接口的实现类调用
System.out.println(Student.NUM);
Student s = new Student();
System.out.println(s.NUM);
TestInterface01 t2 = new Student();
// 多态
System.out.println(t2.NUM);
12：继承与实现的区别

继承：子类对父类的继承

实现：实现类对接口的实现

手机是不是照相机

继承：手机 extends 照相机 “is-a”的关系，手机是一个照相机

上面的写法不好：

实现：手机 implements 拍照功能 “has-a”的关系，手机具备照相的能力

“实现” 更加的轻量，注重实现那些功能

归并排序：

package Novice_class;import java.util.Arrays;// 归并排序
public class MergeSort {// 递归方法实现public static void mergeSort2(int[] arr) {if (arr == null || arr.length < 2) {return;}process(arr, 0, arr.length - 1);}// 将数组arr[L , R]范围上排有序public static void process(int[] arr, int L, int R) {if (L == R) {return;}int mid = L + ((R - L) >> 1);process(arr, L, mid);process(arr, mid + 1, R);merge(arr, L, mid, R);}public static void merge(int[] arr, int L, int mid, int R) {int[] help = new int[R - L + 1];int p1 = L;int p2 = mid + 1;int i = 0;while (p1 <= mid && p2 <= R) {help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];}while (p1 <= mid) {help[i++] = arr[p1++];}while (p2 <= R) {help[i++] = arr[p2++];}for (int j = 0; j < help.length; j++) {//非常的重要arr[L + j] = help[j];}}// for testpublic static int[] generateRandomArray(int maxSize, int maxValue) {int[] arr = new int[(int) ((maxSize + 1) * Math.random())];for (int i = 0; i < arr.length; i++) {arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());}return arr;}// for testpublic static int[] copyArray(int[] arr) {if (arr == null) {return null;}int[] res = new int[arr.length];for (int i = 0; i < arr.length; i++) {res[i] = arr[i];}return res;}// for testpublic static boolean isEqual(int[] arr1, int[] arr2) {if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {return false;}if (arr1 == null && arr2 == null) {return true;}if (arr1.length != arr2.length) {return false;}for (int i = 0; i < arr1.length; i++) {if (arr1[i] != arr2[i]) {return false;}}return true;}// for testpublic static void printArray(int[] arr) {if (arr == null) {return;}for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + " ");}System.out.println();}// for testpublic static void main(String[] args) {int testTime = 500000;int maxSize = 100;int maxValue = 100;System.out.println("测试开始");for (int i = 0; i < testTime; i++) {int[] arr1 = generateRandomArray(maxSize, maxValue);int[] arr2 = copyArray(arr1);//mergeSort1(arr1);Arrays.sort(arr1);mergeSort2(arr2);if (!isEqual(arr1, arr2)) {System.out.println("出错了！");printArray(arr1);printArray(arr2);break;}}System.out.println("测试结束");}}

最小路径

package Novice_class;// 路径总和
public class PathSum {public static class TreeNode {public int val;public TreeNode left;public TreeNode right;TreeNode(int val) {this.val = val;}}// 返回左子树有没有总和 == targetSum - root.val//  返回右子树有没有总和 == targetSum - root.valpublic static Boolean hasPathSum(TreeNode root, int targetSum) {if (root == null) {return false;}// 叶节点if (root.left == null && root.right == null) {return root.val == targetSum;}Boolean leftTree = hasPathSum(root.left, targetSum - root.val);Boolean rightTree = hasPathSum(root.right, targetSum - root.val);if (leftTree || rightTree) {return true;}return false;}
}

最小路径和2

package Novice_class;import javax.swing.*;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;public class PathSumII {public static class TreeNode {public int val;public TreeNode left;public TreeNode right;TreeNode(int val) {this.val = val;}}public static List<List<Integer>> pathSum(TreeNode root, int sum) {List<List<Integer>> ans = new ArrayList<>();if (root == null) {return ans;}List<Integer> path = new ArrayList<>();process(root, sum, 0, path, ans);return ans;}// 左子树中有没有这个路径，右子树中有没有这个路径public static void process(TreeNode x, int sum, int preSum, List<Integer> path, List<List<Integer>> ans) {if (x == null) {return;}// 来到叶子节点if (x.left == null && x.right == null) {if (x.val + preSum == sum) {path.add(x.val);// 返回一个新的地址ans.add(copyList(path));path.remove(path.size() - 1);}return;}preSum = preSum + x.val;path.add(x.val);process(x.left, sum, preSum, path, ans);process(x.right, sum, preSum, path, ans);path.remove(path.size() - 1);return;}public static List<Integer> copyList(List<Integer> path) {List<Integer> cur = new ArrayList<>();for (int i = 0; i < path.size(); i++) {cur.add(i, path.get(i));}return cur;}
}