How old are you, Java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
char charAt(int index)        //不怎么推荐使用吧，除非你保证你知道底层原理，不会出现···
boolean isEmpty()
boolean isBlank()
boolean equals(Object other)
boolean equalsignoreCase(String other)
boolean startWith(String prefix)
boolean endWith(String suffix)
int indexOf()  //这个方法有很多变种
String replace(CharSequence oldstr,CharSequence newstr)
String substring(int begin)
String substring(int begin,int end)
String toLowerCase()
String toUpperCase()
String strip()   //这个函数要记住，不要使用trim()
String join(CharSequence dolimiter, CharSequence elements) 
String repeat(int count)  //java11 才加  

String greeting = """
He\
llo
World""";
//这个转义符可以和下一行连接

1
2
3
4
5
6
7
8
9
StringBuilder builder = new StringBuilder()
builder.append(ch)
builder.append(str)
String resultstr = builder.toString()

builder.appendCodePoint(int cp) //追加一个码点, 我是新我不用
builder.insert(int offset,char c)
builder.delete(int startindex,int endindex)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//初学者OI套
import java.util.*

Scanner in = new Scanner(System.in);
String str = in.nextLine();   //提取一行，以换行符结束
String word = in.next();   //遇见空格就停止
int age = in.nextInteger();

System.out.print()

// Console类
Console cons = System.Console()
String username = cons.readLine("User name:")
//不过这个玩意，你在IDEA里面一定是null，只有在控制台里面才能正常执行

//Scanner 的api
Scanner(InputStream in)
String nextLine()
String next()
int nextInt()
double nextDouble()

new Scanner(Path.of(""),StandardCharsets.UTF-8)
//sout
System.out.print();
System.out.printf();
System.out.println();

System.out.printf() //沿用c风格

1
2
3
System.out.println(System.getProperty("user.dir"));
Scanner file = new Scanner(Path.of("statics/a.txt"), StandardCharsets.UTF_8);
System.out.println(file.nextLine());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
if - else if - else;
while();
do{}while();
for();
switch (){};
//这里我们说说switch
switch (choice) {
	case 1 -> ...
	case 0 -> ...
	case 2 -> ...
	case 3 -> ...
	default -> 
}
switch (choice) {
	case 1 : ... break;
}

//下面我们来看看优美的switch
//无直通行为
int num = switch (choice) {
	case 1,2 -> {
		System.out.print("我赢");
		yield 6;
	} 
	case 3 -> yield 7;
	default -> yield 8;
}
switch (choice) {
	case 1,2 -> {
		System.out.print("我赢");
		num = 6;
	} 
	case 3 -> num = 7;
	default -> num = 8;
}

//把上面箭头换成冒号，就有直通了，你需要加break,不加就死，但是yield自动返回
int num = switch (choice) {
	case 1,2 : {
		System.out.print("我赢");
		yield 6;
	} 
	case 3 : yield 7;
	default : yield 8;
}
switch (choice) {
	case 1,2 : {
		System.out.print("我赢");
		num = 6;
		break;
	} 
	case 3 : num = 7;break;
	default : num = 8;
}
//注意，在switch中不能使用return break continue ，有需求就用yield
//当你复习到这里，能够理解这里的四种switch，其实就很强了
//对于加注解， 这个不做要求

1
2
3
4
5
6
7
8
9
10
11
import java.math.BigInteger,BigDecimal;

BigInteger a = BigInteger.valueOf(100);
BigInteger reallybig = BigInteger.valueOf("222222222222222222222222222222222222222222222222222222");
a.add(a);
a.multiply(a);
a.sqrt();
a.mod(a);
a.divide(a);
a.compareTo(a); //比较返回结果是int 的 0 或者正负数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//java对你的数组很宽限
int[] a = {
	1001,
	1111,
}//你多了一个逗号，java是允许的
//匿名函数优化
smallPrimes = new int[] {17,16,15};
//等价于
int[] temp = {17,16,15};
Primes = temp;
//java允许长度为0的数组
new ele[0]
new ele[] {}
//以上都是length为0 的数组，但不是null

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//for each 拯救遍历
for(n : num) {}


//Java中一般的赋值都是浅拷贝
//如果要深拷贝
newarr = Arrays.copy(oldarr,2*oldarr.length)

//排序
import java.util.Arrays

Arrays.sort(num);  //底层是优化了的快速排序
Arrays.binarySearch(T[] t,T t1);
Arrays.binart

1
2
3
4
5
6
LocalDate now = LocalDate.now();
LocalDate date = LocalDate.of(2020, 1, 1);
int year = date.getYear();
int month = date.getMonthValue();
date = now.plusDays(1000);
System.out.println(date);

1
2
3
4
5
6
//在构造器里面，我极其推荐你去使用null引用
public ClassName(Type1 param1,Type2 param2){
	this.field1 = Objects.requireNonNullElse(param1,"unknow");
	this.field2 = Objects.requireNonNull(param2," field2 can be null ");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//在c++中，很多程序员诟病总是需要同时维护.h 和 .cxx 
// 在java中，你也被强制写 new 类名()
AcomplexClassName acomplexclassexample = new AcomplexClassName(param1,param2);
//这种感觉和C++程序员一样头大
//在臃肿的c++中，都支持下面写法
AcomplexClassName example(param1,param2);
//但是java不支持

//在jdk 10 中，java添加了var关键字，算是省了一半力气吧
var example = new AcomplexClassName(param1,param2);

//所以，无论如何，我都推荐你写var
//但是，我建议你不要乱用,尤其对于数值型
var  intnum = 1000L
var tinynum = 1000.3f
//你要是写出上面的代码，你就等死吧

//此外，var只允许生命局部变量

1
2
3
4
//对于初学者，可能对于setters和getters感到莫名奇妙，不过，大家都是从新手过来的。
//对于类的一切field，都建议你设置为  private
//想要查值或者想要重新赋值，都必须通过一个暴露的方法
//禁止对field直接进行操作

1
2
3
4
5
6
private final StringBuilder evaluations;
evaluations = new StringBuilder;

evaluations.append()
//上面这个final仅仅用来修饰StringBuilder的指针，所以，
//对于一些可变类型要   慎 用！！！ 

1
2
3
4
5
6
7
8
//有一些人认为，静态字段应该被叫为“类字段”
class Employee{
	static int All_id = 1;
}
//声明之后，这个方法属于整个类，在类创建的时候就已经确定了


//之前说，不建议有公共字段，但被final的字段可以是公共的，因为已经不可改了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Manager extends Employee{

}

//阻止继承
public final class Massager{

}
//阻止覆写
public final String getName(){

}

//向上转型（Upcasting）：一定安全，不需要强转
Animal a = new Dog();

//向下转型（Downcasting）：必须满足“真实类型是目标类或其子类”
Animal dog = new Dog();
Dog a = dog;
if(dog instanceof Animal)  //true

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//最标准的步骤

//判断二者是否相同 
if(this == otherobj ) return true;
//判断是否非空
if(otherobj ==  null) return false;
//判断是否有相同语义来进行选择getClass和instanceof
	//相同语义
	if(!otherobj instanceof ThisClss obj) return false;
	//这句可能有点不理解,JDK16+,比较otherobj是否是thisClass,是的话,把otherobj转为obj(ThisClass类)
		// 执行对字段的判断
	//不同语义
	if(!this.getClass() == otherobj.getClass())  return false;
	otherobj = (ThisClass) otherobj;
		// 执行对字段的判断


//Object的equals方法十分简单
public Object equals(Object obj){
	return this == obj;
}
//所以,必须自己重新equals方法,不然和==没什么区别

1
2
3
4
5
6
7
8
9
//hashCode定义在Object类
//也就是说,所有对象都有hashcode,对于一些对象,底层重写了此方法
//比如String
String s = "sb" ;
String b = "sb" ;
Sout(s.hashCode() == b.hashCode())

//对于有多个字段
return Objects.hashCode(obj1,obj2);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Override
    public String toString() {
        return "Student{" +
                "value=" + value +
                ", age=" + age +
                '}';
    }

//在我们调用toString方法的时候
//建议写法
sout(""+ x);
//而不是
sout(x.toString())

//这样写的好处是，如果x是一个基本类型，这个语法仍然不报错""+x
//其实也可以
sout(x)


System.out.println(student);
System.out.println(student+"");
System.out.println(student.toString());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        if (!super.equals(o)) return false; //这个的作用是什么？为了比较公有字段
        Student student = (Student) o;
        return age == student.age;
    }

    @Override
    public int hashCode() {
        return Objects.hashCode(age);
    }

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

1
2
3
public  void  add(Integer i){
	i++;
}

1
2
3
4
5
6
7
8
9
10
11
//底层实现 i++
	//自动拆箱
	int i = i.intValue();
	i++;
	//自动装箱
	Integer new_i = Integer.valueOf(tmp);
	i = new_i;
//由于java总是值拷贝，我们传参i，在函数内部其实是i_copy
//也就是，在函数内部：
	i_copy = new_i ;
	//与我们的i没有任何关系，所以······

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//常用方法
int a = Integer.parseInt("10086");
int a_2 = Integer.parseInt("100010",2);

Integer c = Integer.valueOf("10086");
Integer c_2 = Integer.valueOf("100110",2);

//如果你不够熟悉方法，就可能不知道下面这几个是什么类型的
var a = Integer.parseInt("10086");
var a_2 = Integer.parseInt("100010",2);

var c = Integer.valueOf("10086");
var c_2 = Integer.valueOf("100110",2);

//toString()方法默认使用10进制，想使用其他进制和上面的方法一样，给一个radix

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Test
public void try2(){
	deal_int(1,2,3,4,5);
	deal_int2(new int[]{1, 2, 3, 4, 5} );
}


public void deal_int(int... vales){
	int temp = Integer.MIN_VALUE;
	for(int i : vales){
		temp = (i > temp) ? i : temp;
	}
	System.out.println(temp);
}
public void deal_int2(int[] vales){
	int temp = Integer.MIN_VALUE;
	for(int i : vales){
		temp = (i > temp) ? i : temp;
	}
	System.out.println(temp);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public abstract sealed class Test2 permits Json1,Json2 {
    
}

    final class Json1 extends  Test2{
    
}

    sealed  class  Json2 extends  Test2{
        
    }
    
    final   class  Json22 extends  Json2{
    
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Test
public void stage1() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
	Person p = new Person();
	Student s = new Student();
	System.out.println(s.getClass()); //class aaa.Student
	System.out.println(Student.class); //class aaa.Student
	System.out.println(s.getClass() == Student.class); //true
	String s1 = "aaa.Person";


	Class cl = Student.class;
	Class cl2 = Class.forName(s1);
	Constructor perBuilder = cl2.getConstructor();

	Object po = perBuilder.newInstance();
	Person p2 = (Person) perBuilder.newInstance();

	System.out.println(po.hashCode() + " " + p2.hashCode()); //226170135 381707837
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Resource {
    public static void main(String[] args) {
        Class cl = Resource.class;
        URL url = cl.getResource("img/1.jpg");
        //使用类.getResource()，会从类的位置找资源，非常方便
        var img = new ImageIcon(url);

        System.out.println(url); //会输出路径
        System.out.println(img);
    }
}

//我们还可以用resource目录，将其设置为Resource Root
//然后直接
getResource("/...")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import javax.swing.*;
import java.net.URL;

public final class Resources {

    public static final ImageIcon PLAYER_ICON;
    public static final ImageIcon BACKGROUND_ICON;
    public static final ImageIcon LOGO_ICON;

    static {
        PLAYER_ICON = load("/img/player.png");
        BACKGROUND_ICON = load("/img/background.jpg");
        LOGO_ICON = load("/img/logo.png");
    }

    private Resources() {
        //禁止 new，真正的工具类
		//如果你想问，final类不是不能new吗，为什么还要给构造器
		//如果你不给构造器，默认有public无参构造器，实际上是可以new Resource()，只不过会报错
		//但是我们给一个private的无参构造器，甚至没有字段提示，所以就不可能不小心写出new的代码了
    }

    private static ImageIcon load(String path) {
        URL url = Resources.class.getResource(path);
        if (url == null) {
            throw new IllegalArgumentException("资源未找到: " + path);
        }
        return new ImageIcon(url);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Field[] getFields();   // 拿到公共字段，包括超类字段
Field[] getDeclaredField(); // 拿到所有字段，不包括超类的，
//反射类里面所有类似的方法都是这样 

Method[] getMethods();
Method[] getDeclaredMethods();

Constructor[] getConstructors();
Constructor[] getDeclaredConstructors();

isInterface();
isEnum();
isRecord();
RecordComponent[] getRecordComponents();
String getPackageName();

1
2
3
4
5
6
Class getDeclaringClass(); //返回定义这个FMC(上面那三个)的Class类
Class getExceptionTypes(); //返回异常类的数组
int getModifiers();  //得到修饰符，用数字表示
String getName(); 
Class getParameterTypes();  //拿到参数类型数组
Class getReturnType(); //返回值类型

1
2
3
String getName();
Class<?> getType();
Method getAccessor();

1
2
3
4
5
6
7
8
9
10
11
12
static String toString(int modifiers);
static boolean isAbstract(int modifiers);
static boolean isFinal(int modifiers);
static boolean isInterface(int modifiers);
static boolean isNative(int modifiers);
static boolean isPrivete(int modifiers);
static boolean isProtected(int modifiers);
static boolean isPublic(int modifiers);
static boolean isStatic(int modifiers);
static boolean isStrict(int modifiers);
static boolean isSynchronized(int modifiers);
static boolean isVolatile(int modifiers);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        Student stu = new Student();
        stu.age = 10;
        Class cl = stu.getClass();
        Field f1 = cl.getDeclaredField("age");
        f1.setAccessible(true);
        f1.set(stu,11);
        System.out.println(stu.age);
		
		//
        MethodHandles.Lookup lookup = MethodHandles.lookup(); //创建一个观察者
        lookup.in(cl);  //把视角移到class
        VarHandle vh = lookup.findVarHandle(cl, "age", int.class);
        vh.set(stu,100);
        System.out.println(stu.age);
    }

//在java9 以后，出现了Field的上位替代
//VarHandle  Lookup
class A {
    int x;
}

VarHandle vh = MethodHandles.lookup()
        .in(A.class)
        .findVarHandle(A.class, "x", int.class);

A obj = new A();
vh.set(obj, 42);
System.out.println(vh.get(obj)); // 42

1
2
3
4
void setAccessible(boolean flag);  
boolean trySetAccessible();    
boolean canAccess(Object obj);
static void setAccessible(AccessibleObject[] array, boolean flag);

1
2
3
4
Field getField(String name);
Field[] getFields();
Field getDeclaredField(String name);
Field[] getDeclaredFields();

1
2
Object get(Object obj);
void set(Object obj,Object newValue);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//java.lang.Class
boolean isArray();
Class<?> getComponentType();
Class<?> componentType();
Class<?> arrayType(); //返回数组被描述的类

//java.lang.reflect.Array  //区分 java.utils.Array
static Object get(Object array,int index);

static void set(Object array,int index, Object newVal);

static int getLength(Object array);
static Object newInstance(Class componentType, int length);
static Object newInstance(Class componentType[], int length);

1
2
3
4
5
//java.lang.reflect.Method
public Object invoke(Object implicitParamter,Object[] explicitParameters);
//第一个参数，如果是非静态方法，直接不管
//如果是静态方法，传入一个 null
//返回值是基本类型的会自动装包