1
2
3
4
5
6
7
8
9
// 单行注释

/*
 * 多行注释
 */

/**
 * 文档注释
 */

1
2
3
4
5
6
7
"hello"
1
3.14
'A'
true
false
null

1
2
3
int binary = 0b101010; // 二进制
int hex = 0xfa;        // 十六进制
int octal = 012;       // 八进制

1
2
3
4
修饰符 返回值类型 方法名(参数列表) {
    // 方法体
    return 返回值;
}

1
2
3
public static int getSum(int left, int right) {
    return left + right;
}

1
2
3
4
5
6
7
int number = 12;
byte value = (byte) number;
print(value);

public static void print(byte value) {
    System.out.println(value);
}

1
2
3
4
5
6
7
8
9
10
11
12
import java.util.Scanner;

Scanner scanner = new Scanner(System.in);

System.out.print("请输入年龄：");
int age = scanner.nextInt();

System.out.print("请输入姓名：");
String name = scanner.next();

System.out.println("年龄：" + age + "，姓名：" + name);
scanner.close();

1
2
3
byte left = 10;
byte right = 20;
left += right; // 等价于 left = (byte) (left + right)

1
String result = number % 2 == 0 ? "偶数" : "奇数";

1
2
3
4
5
6
7
if (condition) {
    // 条件成立
} else if (otherCondition) {
    // 另一个条件成立
} else {
    // 其他情况
}

1
2
3
4
5
6
7
8
9
10
switch (level) {
    case 1:
        System.out.println("普通");
        break;
    case 2:
        System.out.println("高级");
        break;
    default:
        System.out.println("未知");
}

1
2
3
4
5
6
7
8
9
10
11
for (int index = 0; index < 10; index++) {
    System.out.println(index);
}

while (condition) {
    // 循环体
}

do {
    // 至少执行一次
} while (condition);

1
2
3
4
5
6
// 静态初始化：定义时给出元素
String[] names = {"张三", "李四"};
String[] otherNames = new String[]{"王五", "赵六"};

// 动态初始化：只指定长度
double[] scores = new double[8];

1
2
3
4
5
6
int randomIndex = (int) (Math.random() * names.length);
String randomName = names[randomIndex];

for (int index = 0; index < names.length; index++) {
    System.out.println(names[index]);
}

1
2
3
4
5
6
7
for (int index = 0; index < pokers.length; index++) {
    int randomIndex = (int) (Math.random() * pokers.length);

    String temp = pokers[index];
    pokers[index] = pokers[randomIndex];
    pokers[randomIndex] = temp;
}

1
2
3
4
5
6
7
8
9
10
11
int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6}
};

for (int row = 0; row < matrix.length; row++) {
    for (int column = 0; column < matrix[row].length; column++) {
        System.out.print(matrix[row][column] + " ");
    }
    System.out.println();
}

1
2
3
4
5
6
7
8
9
10
public class Student {
    private String name;

    public Student() {
    }

    public Student(String name) {
        this.name = name;
    }
}

1
2
public class Dog extends Animal {
}

1
2
Animal animal = new Dog(); // 向上转型
animal.run();               // 调用实际对象重写后的方法

1
2
3
4
if (animal instanceof Dog) {
    Dog dog = (Dog) animal;
    dog.swim();
}

1
2
3
4
5
6
7
8
9
10
public class EagerSingleton {
    private static final EagerSingleton INSTANCE = new EagerSingleton();

    private EagerSingleton() {
    }

    public static EagerSingleton getInstance() {
        return INSTANCE;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {
    }

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

1
2
3
4
5
public enum Status {
    CREATED,
    RUNNING,
    FINISHED
}

1
2
3
4
5
6
7
8
9
10
public abstract class Writer {
    public final void write() {
        System.out.println("固定流程 1");
        System.out.println("固定流程 2");
        writeMain();
        System.out.println("固定流程 3");
    }

    protected abstract void writeMain();
}

1
2
3
4
5
6
7
8
9
10
11
public interface Runner {
    void run();

    default void prepare() {
        System.out.println("prepare");
    }

    static void printInfo() {
        System.out.println("runner");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
interface First {
    default void go() {
        System.out.println("First");
    }
}

interface Second {
    default void go() {
        System.out.println("Second");
    }
}

class Child implements First, Second {
    @Override
    public void go() {
        First.super.go();
        Second.super.go();
    }
}

1
2
3
4
5
6
7
8
9
public class Example {
    static {
        System.out.println("类加载时执行");
    }

    {
        System.out.println("创建对象时执行");
    }
}

1
Outer.Inner inner = new Outer().new Inner();

1
Outer.StaticInner inner = new Outer.StaticInner();

1
2
3
4
5
6
Animal animal = new Animal() {
    @Override
    public void cry() {
        System.out.println("匿名内部类实现");
    }
};

1
2
3
(参数列表) -> {
    // 方法体
}

1
2
3
4
5
6
String[] names = {
    "Tom", "Jerry", "Lucy", "Mary", "Alice", "曹操", "andy", "chris"
};

Arrays.sort(names, String::compareToIgnoreCase);
System.out.println(Arrays.toString(names));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
CarFactory factory = Car::new;
Car car = factory.create("奔驰");

interface CarFactory {
    Car create(String name);
}

class Car {
    private final String name;

    Car(String name) {
        this.name = name;
    }
}

1
2
String first = "hello";
String second = new String("hello");

1
2
3
4
5
6
7
String first = "hello";
String second = "hello";
String third = new String("hello");

System.out.println(first == second);    // true
System.out.println(first == third);     // false
System.out.println(first.equals(third)); // true

1
2
3
4
5
6
7
8
List<String> names = new ArrayList<>();
names.add("张三");
names.add("李四");

names.set(1, "王五");
names.remove("张三");

System.out.println(names.get(0));