Java基础

编译器

项目结构

假设模块名为：a.b.c

IDEA的快捷键

Ctrl+alt+T可以生成环绕代码:if try-catch
Ctrl+alt+v可以生成函数返回值对应的变量,或者.var
ALT+/可以补全代码

项目的打开与关闭

打开项目
点:文件-打开，项目的文件图标下面有个小黑方块
新建模块：点文件-新建-新模块
导入：点文件-项目结构-模块-点加号-导入模块

正则表达式

转义字符

JAVA

方法

静态方法，如public static int function,只能调用静态变量
输入Psvm的文件a，出来的就是主类名，会生成a.class
一个文件里只能有一个类存在public，且文件必须以该类命名

方法重载

修饰符不能实现重载

数组

静态初始化
数据类型[] 名称 = new 数据类型[]{x,x,x…}
数据类型[] 名称={x,x,x…}

动态初始化
数据类型[] 名称 = new 数据类型[长度]

数组不可越界,不然会抛出异常index out of bound
数组为null，不可访问数组元素 会产生Nullpointer空指针异常
如果要创造存在泛型的数组，如下所示

二维数组

动态初始化
数据类型 数组名 [ ][ ] = new 数据类型[m][n]
数据类型 [ ][ ] 数组名 = new 数据类型[m][n]
数据类型 [ ] 数组名 [ ] = new 数据类型[m][n]

静态初始化
数据类型 [ ][ ] 数组名 = {{元素1,元素2…},{元素1,元素2…},{元素1,元素2…}…};

部分动态初始化
可能只知道二维数组的行数，而不确定每行有多少个元素。在这种情况下，可以先只指定行数，然后为每一行动态分配列数。

Comparable接口：数组自然排序

This.age-man.age：升序

class Person implements Comparable<Person> {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public int compareTo(Person other) {
        // 按照 age 进行升序排序
        return Integer.compare(this.age, other.age);
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + '}';
    }
}

public class Main {
    public static void main(String[] args) {
        Person[] people = {
            new Person("Alice", 30),
            new Person("Bob", 25),
            new Person("Charlie", 35)
        };

        // 对数组进行排序
        Arrays.sort(people);

        // 输出排序后的数组
        for (Person person : people) {
            System.out.println(person);
        }
    }
}

Comparator接口：比较器排序

内存划分

类

成员变量没有赋值，就是初始值，和堆里的规则一样
包（package）是 Java 中用来组织类和接口的一种机制。通常，包名与目录结构相对应，不同的包可以包含同名的类。

对象的内存图

Private关键字

1. 使用 private 修饰的属性

当一个属性被声明为 private 时，它只能在该类内部被访问或修改。通常，我们会通过提供 public 的 getter 和 setter 方法来间接访问这些私有属性。

public class Person {
    private String name;  // 私有属性
    private int age;      // 私有属性

    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // getter 方法
    public String getName() {
        return name;
    }

    // setter 方法
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // 私有方法
    private void displayDetails() {
        System.out.println("Name: " + name + ", Age: " + age);
    }

    // 公共方法可以调用私有方法
    public void showDetails() {
        displayDetails();  // 在类内部访问私有方法
    }
}

2. 使用 private 修饰的方法
   一个 private 方法只能在其所在的类内部调用，不能被外部类直接调用。这样可以隐藏实现细节，只暴露必要的接口给外部使用。

public class Calculator {
    private int add(int a, int b) {  // 私有方法
        return a + b;
    }

    public int calculateSum(int x, int y) {
        return add(x, y);  // 可以在类内部调用私有方法
    }
}

3. 使用 private 修饰的构造方法
   有时，你可能希望控制类的实例化方式。例如，可以使用 private 修饰构造方法来限制类的实例化，使得类只能在内部创建实例（如单例模式）。

public class Singleton {
    private static Singleton instance;  // 单例实例

    private Singleton() {  // 私有构造方法
        // 私有构造方法，防止外部实例化
    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

匿名对象

匿名对象是指没有给对象分配引用变量名的对象。它们通常在需要临时使用一个对象但不需要重复使用时使用。这种对象是在创建时直接使用的，之后就没有办法再次引用它们。

匿名对象的使用场景
匿名对象通常用于以下场景：

• 调用一次性的方法：当你只需要调用对象的一个方法，而不需要在后续代码中重复使用这个对象时，可以使用匿名对象。

public class Demo {
    public void show() {
        System.out.println("This is a demo method.");
    }

    public static void main(String[] args) {
        // 使用匿名对象调用方法
        new Demo().show();
    }
}

• 作为参数传递：在方法调用中，可以直接传递匿名对象作为参数。

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        Calculator calc = new Calculator();
        
        // 使用匿名对象作为参数
        int result = calc.add(new Calculator().add(2, 3), 4);
        System.out.println("Result: " + result);
    }
}

常用类

String

比较

获取

截取

转换


分隔