1
public class VarFinalScope {
2
    //常量，必须初始化
3
    static final double MY_AGE = 18;
4
    //类变量，从属于类
5
    static double monthSalary = 700000;
6
    //实例变量，从属于对象，如果不自行初始化，为默认值
7
    /* (String 默认值为 null，
8
    int 默认值为 0,
9
    boolean 默认值为 false,
10
    char 默认值为 '\u0000')*/
11
    String name;
12
    int age;
13
    char gender;
14
    public static void main(String[] args) {
15
        //局部变量，从属于方法，如果不自行初始化，则不能使用
16
        int number = 10;
17
        System.out.println(number);
18
        // 在堆里创建一个对象、返回引用
19
        VarFinalScope varfinalscope = new VarFinalScope();//
20
        System.out.println(varfinalscope.name);
21
        System.out.println(varfinalscope.age);
22
        System.out.println(varfinalscope.gender);
23
        System.out.println(MY_AGE);
24
    }
25

26
    public void aTest() {
27
    // LOL this is a empty Method :)
28
    }
29
}

1
import java.nio.file.SimpleFileVisitor;
2
import java.util.Scanner;
3

4
public class Method {
5
    public static void main(String[] args) {
6
        // 1. 调用普通方法
7
        int result = add(10, 20);
8
        System.out.println("整数和: " + result);
9

10
        // 2. 调用重载方法（根据参数类型自动匹配）
11
        double result2 = add(10.5, 20.5);
12
        System.out.println("小数和: " + result2);
13

14
        // 3. 调用可变参数方法
15
        printNames("Alice", "Bob", "Charlie");
16

17
        // 4. 递归计算阶乘 5! = 120        System.out.println("5的阶乘: " + factorial(5));
18

19
        //命令行传参
20
        for (int i = 0; i < args.length; i++) {
21
            System.out.println("args[" + i + "]" +args[i]);
22

23
        }
24
    }
25

26
    // 方法定义
27
    public static int add(int a, int b) {
28
        int result = a + b;
29
        return result;
30
    }
31

32
    // 方法重载 (Overloading)    public static double add(double a, double b) {
33
        return a + b;
34
    }
35

36
    // 可变参数 (VARARGS)，必须放在最后
37
    public static void printNames(String... names) {
38
        for (String name : names) {
39
            System.out.print(name + " ");
40
        }
41
        System.out.println();
42
    }
43

44
    // 递归 (Recursion)    public static int factorial(int n) {
45
        if (n == 1) {
46
            return 1; // 递归头：程序停止调用的条件
47
        } else {
48
            return n * factorial(n - 1); // 递归体
49
        }
50
    }
51
}

1
public class CommandLine {
2
    public static void main(String[] args) {
3
        for (int i = 0; i < args.length; i++) {
4
            System.out.println("args[" + i + "]=" + args[i]);
5
        }
6
    }
7
}

1
public class VariableArgs {
2
    public static void main(String[] args) {
3
        PrintMax(new double[]{1.2, 3.4, 5.6});
4
    }
5
    public static void PrintMax(double... numbers){
6
        if (numbers.length ==0){
7
            System.out.println("No argument passed");
8
            return ;
9
        }
10
        double max = numbers[0];
11
        for (int i=1;i < numbers.length;i++){
12
            if (numbers[i]>max){
13
                max = numbers[i];
14
            }
15
        }
16
        System.out.println("最大值是：" + max);
17
    }
18
}

1
public class ArrayDemo {
2
    public static void main(String[] args) {
3
        int[] numbers;
4
        numbers = new int[5];
5
        int l = numbers.length;
6
        System.out.println("数组的长度是：" + l);
7
        numbers[0] = 1;
8
        numbers[1] = 2;
9
        numbers[2] = 3;
10
        numbers[3] = 4;
11
        numbers[4] = 5;
12
        int sum = 0;
13
        for (int i = 0; i < numbers.length; i++) {
14
            sum += numbers[i];
15
        }
16
        System.out.println("数组的和是：" + sum);
17
    }
18
}

1
int[] arr = new int[5];

1
int[] arr = new int[]{1, 2, 3};

1
import java.util.Arrays;
2

3
public class ArraysClass {
4

5
    public static void main(String[] args) {
6
        int[] arr = {1, 3, 4, 55, 3, 3, 21, 6, 7, 8, 9};
7

8
        // 1. 打印数组内容 Arrays.toString()        System.out.println("Original (hashcode): " + arr);
9
        System.out.println("Arrays.toString(): " + Arrays.toString(arr));
10

11
        // 2. 排序 Arrays.sort()        Arrays.sort(arr);
12
        System.out.println("Sorted: " + Arrays.toString(arr));
13

14
        // 3. 二分查找 Arrays.binarySearch() (必须先排序)
15
        // 返回索引，如果没找到返回 (-(插入点) - 1)
16
        int index = Arrays.binarySearch(arr, 55);
17
        System.out.println("Index of 55: " + index);
18

19
        // 4. 填充数组 Arrays.fill()        int[] arr2 = new int[5];
20
        Arrays.fill(arr2, 10);
21
        System.out.println("Filled arr2: " + Arrays.toString(arr2));
22
        Arrays.fill(arr2, 1, 4, 20); // 填充部分区间 [1, 4)        System.out.println("Partially filled arr2: " + Arrays.toString(arr2));
23
        // 5. 比较数组 Arrays.equals()        int[] arr3 = {10, 10, 10, 10, 10};
24
        System.out.println("arr2 equals arr3: " + Arrays.equals(arr2, arr3));
25

26
        // 6. 复制数组 Arrays.copyOf()        // 扩容或截断时常用
27
        int[] copy = Arrays.copyOf(arr, 3);
28
        System.out.println("Copy of first 3: " + Arrays.toString(copy));
29
    }
30
}

1
package com.n1n3bird.oop.override;
2

3
public class ExampleA extends ExampleB {
4

5
    public static void test(){
6
        System.out.println("A test");
7
    }
8
    @Override
9
    public void test2(){
10
        System.out.println("A test2");
11
    }
12
}

1
/*
2
instanceof 关键字简单笔记:
3
1. 作用：测试左边的对象是否是右边类的实例（或者是其子类的实例）。
4
2. 返回值：boolean 类型 (true/false)。
5
3. 编译通过条件：X instanceof Y，X 的引用类型与 Y 之间必须有父子关系，否则编译报错。
6
4. 运行结果：看 X 实际指向的对象是不是 Y 类型的子类/实现类。
7
*/
8

9
// System.out.println(X instanceof Y); // 能不能编译通过？ -> X的引用类型 与 Y 是否有父子关系
10
// 结果是 true 还是 false？ -> X实际指向的对象 是不是 Y 的子类型
11

12
// Object > Person > Hacker
13
// Object > String
14
// Teacher (假设有)
15

16
System.out.println(klare instanceof Hacker); // true
17
System.out.println(klare instanceof Person); // true
18
System.out.println(klare instanceof Object); // true
19
System.out.println(klare instanceof String); // false
20

21
System.out.println(n1n3bird instanceof Hacker); // true
22
System.out.println(n1n3bird instanceof Person); // true
23
System.out.println(n1n3bird instanceof Object); // true
24
// System.out.println(n1n3bird instanceof String); // 编译报错！Person 和 String 没关系
25

26
System.out.println(shyler instanceof Hacker); // true
27
System.out.println(shyler instanceof Person); // true
28
System.out.println(shyler instanceof Object); // true
29
// System.out.println(shyler instanceof String); // 编译报错！Hacker 和 String 没关系

1
public abstract class Action {
2

3
    // 抽象方法，只有方法名字，没有方法的实现！
4
    public abstract void doSomething();
5

6
    // 1. 不能new这个抽象类，只能靠子类去实现它：约束！
7
    // 2. 抽象类中可以写普通的方法~
8
    // 3. 抽象方法必须在抽象类中~
9
    // 抽象的抽象：约束~
10
    public void sayHello() {
11
        System.out.println("Hello");
12
    }
13
}

1
public class A extends Action {
2
    @Override
3
    public void doSomething() {
4
        System.out.println("A doSomething");
5
    }
6
}

1
package com.n1n3bird.oop.jiekou;
2

3
public interface UserService {
4
    // 定义方法都是 public abstract 的
5
    void addUser();
6
    void deleteUser();
7
    void updateUser();
8
    void queryUser();
9
    // 定义变量则都是 public static final    public static final String name = "n1n3bird";
10
}

1
package com.n1n3bird.oop.jiekou;
2
// Ctrl + i 实现接口的快捷键
3
// 接口可以实现多继承，类只能单继承~
4
public class UserServiceImpl implements  UserService,TimeService {
5
    @Override
6
    public void deleteUser() {
7

8
    }
9
    @Override
10
    public void updateUser() {
11

12
    }
13
    @Override
14
    public void queryUser() {
15

16
    }
17
    @Override
18
    public void addUser() {
19
        System.out.println("添加用户");
20
    }
21
}

1
package com.n1n3bird.oop.InsiderClass;
2

3
public class OuterClass {
4

5
    private int id = 10;
6
    public void out() {
7
        System.out.println("这是外部类的方法");
8
    }
9

10
    // 1. 成员内部类
11
    public class Inner {
12
        public void in() {
13
            System.out.println("这是内部类的方法");
14
        }
15

16
        // 获得外部类的私有属性
17
        public void getID() {
18
            System.out.println(id);
19
        }
20
    }
21

22
    // 2. 静态内部类
23
    public static class StaticInner {
24
        public void in() {
25
            System.out.println("这是静态内部类的方法");
26
        }
27
    }
28

29
    // 3. 局部内部类
30
    public void method() {
31
        class LocalInner {
32
            public void in() {
33
                System.out.println("这是局部内部类的方法");
34
            }
35
        }
36
    }
37

38
}
39
// 4. 匿名内部类（没有名字初始化类，不用将实例保存到变量中）
40
class Test {
41
    public static void main(String[] args) {
42
        // 成员内部类实例化
43
        OuterClass outer = new OuterClass();
44
        // 通过外部类对象来实例化内部类
45
        OuterClass.Inner inner = outer.new Inner();
46
        inner.in();
47
        inner.getID();
48
        // 静态内部类实例化
49
        // 静态内部类可以直接实例化，不需要外部类对象
50
        // 注意：静态内部类无法直接访问外部类的非静态属性
51
        OuterClass.StaticInner staticInner = new OuterClass.StaticInner();
52
        staticInner.in();
53
        // 匿名内部类
54
        // 没有名字初始化类, 不用实例保存到变量中
55
        new Apple().eat();
56
        // 也可以实现接口
57
        new UserService() {
58
            @Override
59
            public void hello() {
60
                System.out.println("Hello from Anonymous Inner Class");
61
            }
62
        };
63
    }
64
}
65

66
class Apple {
67
    public void eat() {
68
        System.out.println("1");
69
    }
70
}
71

72
interface UserService {
73
    void hello();
74
}

1
package com.n1n3bird.yichang;
2

3
public class Demo {
4
    // 异常笔记：
5
    // 1) Throwable 是所有异常/错误的父类：Error(程序通常不处理) vs Exception(可处理)。
6
    // 2) Exception 分为编译期异常(必须处理/throws)与运行时异常(可不处理，但会崩)。
7
    // 3) 处理方式：try-catch-finally；也可在方法上用 throws 抛给上层。
8
    // 4) throw 用于主动抛出异常；自定义异常继承 Exception 或 RuntimeException。
9

10
    public static void main(String[] args) {
11
        System.out.println("=== try-catch-finally ===");
12
        int result = safeDivide("10", "0");
13
        System.out.println("result = " + result);
14

15
        System.out.println("\n=== throws / throw / 自定义异常 ===");
16
        try {
17
            registerUser(" ");
18
        } catch (UserInputException e) {
19
            System.out.println("caught: " + e.getMessage());
20
        }
21

22
        System.out.println("\n=== 受检异常示例 ===");
23
        try {
24
            parsePositiveInt("-3");
25
        } catch (Exception e) {
26
            System.out.println("caught: " + e.getMessage());
27
        }
28
    }
29

30
    // 运行时异常示例：被 0 除会抛 ArithmeticException    private static int safeDivide(String a, String b) {
31
        try {
32
            int x = Integer.parseInt(a);
33
            int y = Integer.parseInt(b);
34
            return x / y;
35
        } catch (NumberFormatException e) {
36
            System.out.println("输入不是数字: " + e.getMessage());
37
            return 0;
38
        } catch (ArithmeticException e) {
39
            System.out.println("除数不能为 0: " + e.getMessage());
40
            return 0;
41
        } finally {
42
            System.out.println("finally 一定会执行");
43
        }
44
    }
45

46
    // throws：把异常交给调用者处理
47
    private static int parsePositiveInt(String s) throws Exception {
48
        int v = Integer.parseInt(s);
49
        if (v <= 0) {
50
            throw new Exception("必须是正整数");
51
        }
52
        return v;
53
    }
54

55
    // throw：主动抛出自定义异常
56
    private static void registerUser(String name) {
57
        if (name == null || name.trim().isEmpty()) {
58
            throw new UserInputException("用户名不能为空");
59
        }
60
        System.out.println("注册成功: " + name);
61
    }
62
}
63

64
class UserInputException extends RuntimeException {
65
    public UserInputException(String message) {
66
        super(message);
67
    }
68
}