2023.4.4-CSDN博客

本文链接：https://blog.csdn.net/SCR1209/article/details/129962833

@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 test
    public 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 test
    public 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 test
    public 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 test
    public 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 test
    public 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.val
    public 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;
    }
}