Java 简单语法速成

public class Hello {
    public static void main(String[] args) {
        System.out.println("hello");
    }
}

定义一个 Hello 类
  -> 里面有 main 方法
  -> 程序从 main 开始执行
  -> 打印 hello

Hello.java 源码
  -> javac 编译
  -> Hello.class 字节码
  -> JVM 运行

public class Person {
}

public static void main(String[] args) {
}

System.out.println("hello");

public class Hello {
    public static void main(String[] args) {
        System.out.println("hello");
    }
}

Hello 类 {
    main 方法 {
        打印 hello
    }
}

java.io.ObjectInputStream

java 标准库
  -> io 输入输出包
  -> ObjectInputStream 类

java.io.FileInputStream fis = new java.io.FileInputStream("ser.bin");

import java.io.FileInputStream;

FileInputStream fis = new FileInputStream("ser.bin");

int age = 22;
String name = "aa";

String name = "aa";
Person p = new Person("aa", 22);

Person p = null;

p.toString();

String s = "hello";

String s = "name=" + name + ", age=" + age;

String[] args = {"aa", "bb"};
byte[] data = {1, 2, 3};

public static void main(String[] args)

Object obj = ois.readObject();
Person p = (Person) obj;

public class Person {
    String name;
    int age;
}

Person p = new Person();

Person 类：规定人有 name 和 age
Person 对象：具体某个人，比如 name=aa, age=22

public class Person {
    String name;
    int age;
}

p.name = "aa";
p.age = 22;

public void sayHello() {
    System.out.println("hello");
}

p.sayHello();

public String getName() {
    return name;
}

public void printName() {
    System.out.println(name);
}

Person p = new Person("aa", 22);

public class Person {
    private String name;
    private int age;

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

this.name = name;

public Person() {
}

public Person(String name, int age) {
}

public class Person {
    public void sayHello() {
    }
}

private String name;

p.name = "aa";

field.setAccessible(true);

public class Counter {
    public static int count = 0;
}

Counter.count;

new Counter().count;

final int x = 1;

public final void run() {
}

public final class User {
}

private static final long serialVersionUID = 1L;

这是 Person 类自己的、固定不变的、序列化版本号。

public void say(String msg) {
    System.out.println(msg);
}

say("hello");

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

int result = add(1, 2);

public void print(String msg) {
    System.out.println(msg);
}

public void exec(String command) {
}

public void exec(String[] command) {
}

exec(String command)
exec(String[] cmdarray)
exec(String command, String[] envp)
exec(String[] cmdarray, String[] envp, File dir)

public static void serialize(Object obj) throws Exception {
}

try {
    Object obj = ois.readObject();
} catch (Exception e) {
    e.printStackTrace();
}

public class Student extends Person {
}

Student 是一种 Person

public interface Runnable {
    void run();
}

public class Task implements Runnable {
    public void run() {
        System.out.println("running");
    }
}

public class Person implements Serializable {
}

这个类允许被 Java 原生序列化。

Proxy.newProxyInstance(loader, interfaces, handler)

调用代理对象的任意接口方法
  -> 都会进入 InvocationHandler.invoke(...)

Person 也是 Object
HashMap 也是 Object
URL 也是 Object

System.out.println(person);

System.out.println(person.toString());

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

a.equals(b)

int h = obj.hashCode();

HashMap.readObject()
  -> HashMap.hash()
  -> key.hashCode()
  -> URL.hashCode()
  -> DNS 查询

@Override
public String toString() {
    return "...";
}

HashMap<String, Integer> map = new HashMap<>();

List<String> names = new ArrayList<>();
names.add("aa");
names.add("bb");

0 -> aa
1 -> bb

Map<String, Integer> ages = new HashMap<>();
ages.put("aa", 22);
ages.put("bb", 23);

aa -> 22
bb -> 23

int age = ages.get("aa");

map.put(key, value)
  -> 计算 key.hashCode()
  -> 根据 hash 找位置
  -> 保存 key/value

HashMap.readObject()
  -> 读出 key/value
  -> hash(key)
  -> key.hashCode()

HashMap<String, int> // 错

HashMap<String, Integer> // 对

程序 -> 流 -> 文件

文件 -> 流 -> 程序

FileOutputStream fos = new FileOutputStream("a.bin");

FileInputStream fis = new FileInputStream("a.bin");

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
oos.writeObject(obj);
oos.close();

ObjectInputStream ois = new ObjectInputStream(new FileInputStream("ser.bin"));
Object obj = ois.readObject();
ois.close();

序列化：
Java 对象
  -> ObjectOutputStream
  -> FileOutputStream
  -> ser.bin

反序列化：
ser.bin
  -> FileInputStream
  -> ObjectInputStream
  -> Java 对象

new ObjectOutputStream(new FileOutputStream("ser.bin"))

import java.io.Serializable;

public class Person implements Serializable {
    private static final long serialVersionUID = 1L;

    private String name;
    private int age;

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

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

implements Serializable

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
oos.writeObject(new Person("aa", 22));
oos.close();

ObjectInputStream ois = new ObjectInputStream(new FileInputStream("ser.bin"));
Object obj = ois.readObject();
ois.close();

ois.readObject();

这里可能会触发对象里的代码逻辑。

p.sayHello();

Method method = p.getClass().getMethod("sayHello");
method.invoke(p);

Class<?> c1 = Person.class;
Class<?> c2 = person.getClass();
Class<?> c3 = Class.forName("Person");

Field f = Person.class.getDeclaredField("name");
f.setAccessible(true);
f.set(person, "bb");

找到 Person 的 name 字段
  -> 允许访问 private
  -> 把 person 的 name 改成 bb

Method m = Person.class.getDeclaredMethod("sayHello");
m.setAccessible(true);
m.invoke(person);

找到 sayHello 方法
  -> 允许访问
  -> 对 person 调用它

Constructor<Person> c = Person.class.getDeclaredConstructor(String.class, int.class);
Person p = c.newInstance("aa", 22);

找到 Person(String, int) 构造函数
  -> 用它创建对象

member.setAccessible(true);

.java
  -> 编译
  -> .class
  -> 类加载器加载
  -> JVM 使用这个类

public class Evil {
    static {
        System.out.println("static block");
    }
}

public class Demo {
    static {
        System.out.println("static");
    }

    {
        System.out.println("instance");
    }

    public Demo() {
        System.out.println("constructor");
    }
}

new Demo();

static
instance
constructor

Class.forName("Demo");

Class.forName("Demo", false, loader);

loader.loadClass("Demo");

只是加载类
还是加载并初始化类
还是创建对象实例