20220718_第七小组_张红睿_学习笔记

Java基础第六天

概述：Java面向对象！

1. 了解

1.1 面向过程与面向对象

Java是一门面向对象的编程语言。在Java中，万事万物皆对象（在Linux中，万事万物皆文件）

面向过程：分析出实现需求需要的步骤，通过一些方法一步一步进行。

面向对象（行为化）：把整个需求的按照特点、功能划分，将这些存在共性的部分封装成类。

2. 掌握

2.1 不定长数组

// ... arr 本质上是个数组
// JVM在解析时，会将传入的一序列数的参数组装成数组进行计算
public static int sum(int ... arr){
    int result = 0;
    for(int i : arr)
        result += i;
    return result;
}

2.2 递归

2.2.1 基本概念

定义：递归函数即自调用函数，在函数体内直接或间接的调用自己，即函数的嵌套是函数本身。如：

求阶乘: f(n) = nf(n-1)

为什么要用递归：递归的目的是简化程序，使程序更加简单。
递归的弊端：递归函数较难编程，可读性较差，添加了系统开销，也就是说每递归一次，栈内存就多占用一截。
递归的条件：需要有使函数执行结束的条件语句，需满足递归的要求。

2.2.2 实例

1. 斐波那契数列

private static int fibonacci(int n){
    if(n <= 0)
        return -1;
    else if (n == 1 || n == 2)
        return 1;
    return fibonacci(n - 1) + fibonacci(n - 2);
}
public static void main(String[] args) {
    System.out.println("斐波那契数列中第5个值为: " + fibonacci(5));
}

2. 著名递归——汉诺塔

/**
 * 目标 将A柱上的n个盘子移到C上
 * @param n 盘子个数  
 * @param initial 起始柱子
 * @param depend  依赖柱子
 * @param target 	 目标柱子
 */
private static void hanoi(int n, char initial, char depend, char target){
    if(n == 1) {
        System.out.println(initial + " -> " + target);
        return;
    }
    hanoi(n - 1, initial, target, depend);
    System.out.println(initial + " -> " + target);
    hanoi(n - 1, depend, initial, target);
}
public static void main(String[] args) {
    hanoi(3, 'A', 'B', 'C');
}

测试结果，移动过程如下:

2.3 Java内存空间

栈：存放基本类型的数据和对象的引用，但对象本身不存放在栈中，而是存放堆中。
堆：存放用new产生的数据。
静态域：存放在对象中用static定义的静态成员。
常量池：存放常量。

3. 重点

3.1 访问权限修饰符

public：公有的，在任何类中可见。

protected：受保护的，在子类中或同一个包中可见。

default：默认的（什么都不写），在同一个包中可见，子类不在一个包中也不可见。

private：私有的，只在本类中可见，子类中也不可见。

3.2 成员变量

定义：成员变量是指类的一些属性定义，标志类的静态特征。

语法：【访问修饰符】【修饰符】【类型】【属性名称】=【初始值】；

访问修饰符：public（公共的）；protected（受保护的）；无修饰符和private（私有的）。

修饰符：对属性特征的描述：如static、final等。

类型：属性的数据类型，可以使任意类型。

属性名称：任何合法标识符，命名格式要求小驼峰式。

初始值：赋值给属性的初始值。

举例：public static int index = 0；

public class Car{
    // 成员变量 定义了一个私有的字符串
    private String name;
}

3.3 成员方法

定义：成员方法就是对象所具有的动态功能。

语法：【访问修饰符】【修饰符】【返回值类型】【方法名称】【参数】【异常】【方法体】

访问修饰符：public（公共的）；protected（受保护的）；无修饰符和private（私有的）。

修饰符：对方法特征的描述：如static、final、abstract等。

返回值类型：方法返回数据的类型。

方法名称：任何合法标识符，小驼峰式命名。

参数：可以有多个，使用逗号分隔。

异常：关键字：throws【具体异常】

方法体：该方法具体实现功能的地方。

public class Car{
    // 成员变量 定义了一个私有的字符串
    private String name;
    
    // 成员方法 定义了一个公有的、返回值类型为String的成员方法
    public String getName(){
        return this.name;
    }
}

3.4 构造方法

定义：是特殊的成员方法，它的作用是创建对象并初始化成员变量。

语法：【访问权限修饰符】【类名】【参数】【构造方法体】

规则：构造方法的方法名必须和类名一致。

特点：

1.如果没有构造方法，则无法创建对象。

2.每个类都会有一个默认的无参构造函数。

3.在对象被实例化时，调用了构造函数。

4.如果一个类中显示的声明了一个构造函数，原来默认的无参构造函数就不存在了。

5.构造函数也是特殊的函数重载。

public class Car{
    // 成员变量 定义了一个私有的字符串
    private String name;
    
    // 构造函数
    // 定义了一个无参构造函数
    public Car(){}
    // 定义了一个含有一个参数类型为String的构造函数
    public Car(String name){
        this.name = name;
    }

    // 成员方法 定义了一个公有的、返回值类型为String的成员方法
    public String getName(){
        return this.name;
    }

}

*3.5 析构方法

析构函数：finalize()；

在Java的Object类中还提供了一个protected类型的finalize()方法，因此任何Java类都可以覆盖该方法，在这个方法进行释放对象所占有的相关资源的操作。

特点：

垃圾回收器是否会执行该方法以及何时执行该方法，都是不确定的。
finalize()方法有可能使用对象复活，使对象恢复到可触及状态。
垃圾回收器在执行finalize()方法时，如果出现异常，垃圾回收器不会报告异常，程序继续正常运行。

技巧：由于finalize()方法的不确定性，所以在程序中可以调用System.gc()和Runtime.gc()方法提示垃圾回收器尽快执行该垃圾回收操作。

3.6 函数重载

3.6.1 特点

方法名必须相同
参数列表必须不同
- 参数类型不同
- 参数个数不同
- 参数顺序不同
与返回值类型无关
与访问权限修饰符无关

3.6.2 测试实例

public static int sum(int num1, int num2) {
    System.out.print("调用了int sum(int num1, int num2): ");
    return (num1 + num2);
}
public static int sum(int num1, int num2, int num3) {
    System.out.print("调用了int sum(int num1, int num2, int num3): ");
    return (num1 + num2 + num3);
}
public static double sum(int num1, double num2) {
    System.out.print("调用了double sum(int num1, double num2): ");
    return (num1 + num2);
}
public static double sum(double num1, int num2) {
    System.out.print("调用了double sum(double num1, int num2): ");
    return (num1 + num2);
}
public static void main(String[] args) {
    System.out.println(sum(1, 2));
    System.out.println(sum(1, 2, 3));
    System.out.println(sum(1, 2.0));
    System.out.println(sum(1.0, 2));
}

测试结果：

4. 注意

4.1 成员方法不能重名

4.2 不需显式导入

java.lang 包下含有String类。但是在测试时不导入：

// java.lang包下的所有类不需要显式的导入（language）
// import java.lang.String
public static void main(String[] args) {
    String str = "我是java.lang下的String类对象";
    System.out.println(str);
}