java相关

包

Java定义了一种名字空间，称之为包：package。一个类总是属于某个包，类名（比如Person）只是一个简写，真正的完整类名是包名.类名。

包作用域是指一个类允许访问同一个package的没有public、private修饰的class，以及没有public、protected、private修饰的字段和方法。

关键字作用域

public

• class,interface可被其他任何class访问
• class内部定义的字段必须要先有此class的访问权限才能访问

**PS:**如果不确定是否需要public，就不声明为public，即尽可能少地暴露对外的字段和方法。

private

• 无法被其他类访问

• 可以被定义private字段的class的内部class访问

protected

protected作用于继承关系。定义为protected的字段和方法可以被子类访问，以及子类的子类

final

• 作用于class阻止class被继承

• 作用于class内的方法阻止方法被子类覆写

• 作用于变量阻止被重新赋值

classpath和jar

classpath是JVM用到的一个环境变量，它用来指示JVM如何搜索class

假设classpath是.;C:\work\project1\bin;C:\shared，当JVM在加载abc.xyz.Hello这个类时，会依次查找：

• <当前目录>\abc\xyz\Hello.class
• C:\work\project1\bin\abc\xyz\Hello.class
• C:\shared\abc\xyz\Hello.class

在启动JVM时设置classpath

java -classpath .;C:\work\project1\bin;C:\shared abc.xyz.Hello

java -cp .;C:\work\project1\bin;C:\shared abc.xyz.Hello

JavaBean

在Java中，有很多class的定义都符合这样的规范：

• 若干private实例字段；
• 通过public方法来读写实例字段。

//如下面这个class
public class Person{
	private String name;
    public String getName(){
		return this.name;	
    }
}
//这种class被称为JavaBean

• 使用Introspector.getBeanInfo()可以获取属性列表。

enum枚举

为了让编译器能自动检查某个值在枚举的集合内，并且，不同用途的枚举需要不同的类型来标记，不能混用，我们可以使用enum来定义枚举类：

​ Java使用enum定义枚举类型，它被编译器编译为final class Xxx extends Enum { … }；

​ 这样定义了一个数据集合，我们可以自定义属于这个数据集合的数据

enum Weekday {
    SUN, MON, TUE, WED, THU, FRI, SAT;
}
//定义Weekday类型
public class Main {
    public static void main(String[] args) {
    Weekday day = Weekday.SUN;
    }

使用enum定义的枚举类是一种引用类型。引用类型比较，要使用equals()方法，但是enum除外，这是因为enum类型的每个常量在JVM中只有一个唯一实例，所以可以直接用==比较

• 定义的enum类型总是继承自java.lang.Enum，且无法被继承；
• 只能定义出enum的实例，而无法通过new操作符创建enum的实例；
• 定义的每个实例都是引用类型的唯一实例；
• 可以将enum类型用于switch语句。

enum的方法

• name()：返回常量名
• ordinal():返回定义常量的顺序，从0开始

为enum创建方法

可以为enum编写构造方法、字段和方法

enum的构造方法要声明为private，字段强烈建议声明为final；

enum Weekday {
    MON(1), TUE(2), WED(3), THU(4), FRI(5), SAT(6), SUN(0);

    public final int dayValue;

    private Weekday(int dayValue) {
        this.dayValue = dayValue;
    }
}

记录类

不变类

使用String、Integer等类型的时候，这些类型都是不变类，一个不变类具有以下特点：

1. 定义class时使用final，无法派生子类；
2. 每个字段使用final，保证创建实例后无法修改任何字段。

//例如
public final class Point {
    private final int x;
    private final int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int x() {
        return this.x;
    }

    public int y() {
        return this.y;
    }
}

不变类改记录类

从Java 14开始，引入了新的Record类。我们定义Record类时，使用关键字record。把上述Point类改写为Record类，代码如下：

public record Point(int x, int y) {}
//是的，就这一行
//等于
public final class Point extends Record {
    private final int x;
    private final int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int x() {
        return this.x;
    }

    public int y() {
        return this.y;
    }

    public String toString() {
        return String.format("Point[x=%s, y=%s]", x, y);
    }

    public boolean equals(Object o) {
        ...
    }
    public int hashCode() {
        ...
    }
}

除了用final修饰class以及每个字段外，编译器还自动为我们创建了构造方法，和字段名同名的方法，以及覆写toString()、equals()和hashCode()方法。

和enum类似，我们自己不能直接从Record派生，只能通过record关键字由编译器实现继承。

检查数据

既然编译器自动生成了方法，那我们要检查构造方法传入的数据要怎么办呢？

public final class Point extends Record {
    public Point(int x, int y) {
        // 这是我们编写的Compact Constructor:
        if (x < 0 || y < 0) {
            throw new IllegalArgumentException();
        }
        // 这是编译器继续生成的赋值代码:
        this.x = x;
        this.y = y;
    }
    ...
}

添加静态方法

作为record的Point仍然可以添加静态方法。一种常用的静态方法是of()方法，用来创建Point：

public record Point(int x, int y) {
    public static Point of() {
        return new Point(0, 0);
    }
    public static Point of(int x, int y) {
        return new Point(x, y);
    }
}

常用库

random

Random r = new Random();
r.nextInt(); // 2071575453,每次都不一样
r.nextInt(10); // 5,生成一个[0,10)之间的int
r.nextLong(); // 8811649292570369305,每次都不一样
r.nextFloat(); // 0.54335...生成一个[0,1)之间的float
r.nextDouble(); // 0.3716...生成一个[0,1)之间的double

Donate