byte,short,char -> int -> long -> float -> double
		   char -> int

byte i = 1;
short j = 30;
byte i = 2 * i; // error
short k = i + j; // error
int k = i + j; // correct

byte i = 1;
byte j = (byte)2 * (byte)i; // error
byte j = (byte)(2 * i);

char random_alpha = (char)('a' + rand.nextInt(25));

int i = 5;
int j = 2;
float k = i / j; // k = 2
float k = (float)i / j; // k = 2.5
float k = 1.0 * i / j; // k = 2.5

double a = 10;
int b = 30;
a += b; // a = (double)(a + b)

long variable = 100;
switch(variable){
	// error
}

OUT:
for (int i = 0; i < 100; i++){
	for (j = i; j < 100; j++){
		if (j == 70){
			continue OUT;
		}
	}
}

int[] arr1 = new int(){1, 2, 3, 4};
int[] arr2 = {1, 2, 3, 4};
int arr3[] = new int(){1, 2, 3, 4};

int[] arr_dynamic = new int[10];

public class Father{
	private Father(){}
	public Father(String name) {}
}
public class Son extends Father{
	public Son(){
		super("Java");
	}
}

// Object.java
public class Object {
	String name;
	int cost;
}

class Object_A{

}

public class Util{
	private Util{}
	public static void PostHttp(){
	}
}

public class Util(){
	public static int count;
	static {
		count =  1;
	}
}

public class Son extends Father{
	@Override
	public void print(){}
}

People p1 = Teacher();

import com.xilyfe.pkg.util.PostHttp;
int res = PostHttp();

int res1 = PostHttp();
int res2 = com.xilyfe.pkg.http.PostHttp();

People p1 = new Student();
p1.study(); // error
Student s1 = (Student)p1;
s1.study();

public static void execute(People p){
	if (p instanceof Student) p.study();
	else if (p instanceof Teacher) p.teach();
}

public class Outer{
	private String name = "Outer";
	private static int age = 90;
	public class Inner{
		private String name = "Inner";
		private static int age = 80;

		private void test(){
			String name = "test";
			System.out.println(name);
			System.out.println(this.name);
			System.out.println(Outer.this.name);
		}
	}
}

public static void main(){
	// 方法1
	Outer.Inner inn = new Outer.new Inner();
	// 方法2
	Outer out = new Outer();  
	Outer.Inner inn = out.new Inner();
}

public class Outer{
	private String name = "Outer";
	private static int age = 90;
	public class Inner{
		private String name = "Inner";
		private static int age = 80;

		private static void test(){
			String name = "test";
			System.out.println(name);
			System.out.println(this.name);
			System.out.println(Outer.this.name);
			// System.out.println(Outer.this.age);
		}
	}
}

public static void main(){
	Outer.Inner inn = new Outer.Inner();
}

abstract class Base{
	public abstract void test();
}
public static void main(){
	Base a = new Base(){
		@Override
		public void test(){
		}
	}
}

public class Imp implements A, B, C{}

interface A {
	default void function(){
		//  可以有函数体
	}
}

public interface MyInterface {

    // public default 方法
    default void sayHello() {
        greet("Hello");
    }

    default void sayHi() {
        greet("Hi");
    }

    // private 方法只能被接口内部调用
    private void greet(String message) {
        System.out.println(message);
    }
}

interface A{
	public static void function(){
		// ...
	}
}
A.function();

@FunctionalInterface
interface MyPrinter {
    void print(String msg); // 唯一抽象方法
}

public class Demo {
    public static void main(String[] args) {
        // Lambda 实现
        MyPrinter p = msg -> System.out.println(msg);
        p.print("Hello Functional Interface!");
    }
}

interface I1{}
interface I2{}
interface I3 extends I1, I2{}

class Parent {
    public void hello() {
        System.out.println("Hello from Parent");
    }
}

interface MyInterface {
    default void hello() {
        System.out.println("Hello from Interface");
    }
}

class Child extends Parent implements MyInterface {
    // 不需要重写 hello 方法
}

public class Main {
    public static void main(String[] args) {
        new Child().hello();  // 输出：Hello from Parent
    }
}

interface a{
	default void print(){
		//...
	}
}
interface b{
	default void print(){
		//...
	}
}
class c implements a, b{
	@Override
	public void print(){
		// 可以选择调用某一个接口的默认方法：
        A.super.print();  // 或 B.super.print();
	}
}

public enum Sex{
	MALE, FEMALE
}

switch (sex){
	case Sex.MALE:
		break;
	case Sex.FEMALE:
		break;
}

public final class Sex extends Enum<Sex>{
	public static final Sex MALE = new Sex();
	public static final Sex FEMALE = new Sex();
	private Sex(){}
	public static Sex[] values(){}
	public static Sex valueof(String){}
}

public enum Animal{
	Dog(){
		@Override
		public void sing(){
			//...
		}
	}, 
	Cat(){
		@Override
		public void sing(){
			//...
		}
	}
	public abstract void sing();
}

String name = "java";
System.out.println(name[0]); // error
char[] name_arr = name.toCharArray();
System.out.println(name_arr[0]); // correct
System.out.println(name.charAt(0)); // correct

String variable1 = "java";
String variable2 = "python";
System.out.println(variable1.equals(variable2));

String name_1 = "java";
char[] name_arr = {'j', 'a', 'v', 'a'};
String name_2 = new String(name_arr);

String s1 = "ab";
String s2 = s1 + "c"; // 堆区创建2个对象
// -------------------------------------------
String s3 = "a" + "b" + "c"; // 堆区创建一个对象

public static String toString(int arr[]);
public static <T>[] copyOfRange(<T>[] arr, int sta, int end); // [sta, end)
public static <T>[] copyOf(<T>[] arr, int length); // 超出补0
Arrays.setAll(arr, new IntToDoubleFunction() {
	@Override
	public double applyAsDouble(int value){
		return prices[value] * 0.8;
	}
});
public static <T>[] sort(<T>[] arr);

class Student implements Comparable{
	public int age;
	public double score;
	public String name;

	@Override
	public int compareTo(Student o){
		if (score > o.score) return 1;
		else if (score < o.score) return -1;
		return 0;
	}
}

Arrays.sort(students, new Comparator<Student>() {
	@Override
	public int compare(Student s1, Student s2){
		return 0;
	}
});

public class Student {

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

public class Student {

	@Override
	public boolean equals(const Student& stu){
		if (this == stu) return true;
		if (stu == null || getClass() != stu.getClass()) return false;
		return Objects.equals(this.name, stu.name);
	}
}

public class User implements Cloneable {

	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
}

public class User implements Cloneable {

	@Override
	protected Object clone() throws CloneNotSupportedException {
		User u2 = (User)super.clone();
		u2.scores = us.scores.clone();
		return u2;
	}
}

double f1 = 0.1;
double f2 = 0.2;

// 方法1
BigDecimal bd1 = new BigDecimal(Double.toString(f1));
// 推荐方法
BigDecimal bd2 = BigDecimal.valueof(f1);

BigDecimal bd1 = BigDecimal.valueof(0.1);
BigDecimal bd2 = BigDecimal.valueof(0.2);

BigDecimal bd3 = bd1.add(bd2);
BigDecimal bd4 = bd1.multiply(bd2);
BigDecimal bd5 = bd1.divide(bd2);

// 获取当前日期
Date d = new Date();

// 获取毫秒数
long time = d.getTime();

// 毫米转日期
long t2 = time + 2 * 1000;
Date d2 = new Date(t2);
Date d3 = new Date();
d3.setTime(t2);

Date d = new Date();
long time = d.getTime();
SimpleDateFormate sdf = new SimpleDateFormate("yyyy-mm-dd HH-mm-ss EEE a");
System.out.println(sdf.formate(d));
System.out.println(sdf.formate(time));


// 日期转Date
String dateStr = "2002-10-26 10-24-45"
SimpleDateFormate sdf2 = new SimpleDateFormate("yyyy-mm-dd HH-mm-ss");
Date d2 = sdf2.parse(dateStr);

import java.time.LocalDate;

LocalDate today = LocalDate.now();                // 当前日期
LocalDate birthday = LocalDate.of(2000, 5, 20);   // 指定日期
LocalDate parsed = LocalDate.parse("2025-08-08"); // 字符串解析

LocalDate tomorrow = today.plusDays(1);           // 加一天
LocalDate lastWeek = today.minusWeeks(1);         // 减一周
int year = today.getYear();                       // 获取年份
int dayOfMonth = today.getDayOfMonth();           // 获取日

import java.time.LocalTime;

LocalTime now = LocalTime.now();                     // 当前时间
LocalTime lunch = LocalTime.of(12, 30);               // 指定时间
LocalTime parsed = LocalTime.parse("08:15:30");       // 字符串解析

LocalTime nextHour = now.plusHours(1);                // 加一小时
int hour = now.getHour();                             // 获取小时
int minute = now.getMinute();                         // 获取分钟

import java.time.LocalDateTime;

LocalDateTime now = LocalDateTime.now();                  // 当前日期时间
LocalDateTime meeting = LocalDateTime.of(2025, 8, 8, 14, 30); // 指定日期时间
LocalDateTime parsed = LocalDateTime.parse("2025-08-08T14:30:00");

LocalDateTime tomorrowSameTime = now.plusDays(1);         // 加一天
LocalDate datePart = now.toLocalDate();                   // 提取日期部分
LocalTime timePart = now.toLocalTime();                   // 提取时间部分

// 实例化
Integer a1 = Integer.valueof(1);

// 自动装箱
Integer a2 = 1;

// 自动拆箱
int a3 = a2;

// 泛型不支持基本类型，所以需要包装类
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1);
int a4 = list.get(1);

Integer a = 12;
String rs1 = Integer.toString(a);
String rs2 = a.toString();
String rs3 = a + "";

String ageStr = "12";
Integer a1 = Integer.ParseInt(ageStr);
Integer a2 = Integer.valueof(ageStr);
String scoreStr = "12.5";
Float f1 = Float.ParseFloat(scoreFloat);
Float f2 = Float.valueof(scoreFloat);

public class Singleton{
	private static instance = new Singleton();
	private Singleton(){}
	public GetInstance(){
		return instance;
	}
}

public class Singleton{
	private static instance;
	private Singleton(){}
	public GetInstance(){
		if (instance == null){
			instance = new Singleton();
		}
		return instance;
	}
}

public abstract class People{
	public void func(){
		// 重复任务1
		this.todo();
		// 重复任务2
	}
	public abstract void todo(){}
}
public class Student{
	@Override
	public void todo(){
		// ...
	}
}

public class ArrayList<E> {
	private object[] objs = new object[10];
	private int size = 0;
	private ArrayList();
	public void add(E e){
		objs[size++] = e;
	}
	public E get(int index){
		return objs[index];
	}
}

public static <E extends Car> go(ArrayList<E> car){
	// ...
}

public static void go(ArrayList<? extends Car> car){
	// ...
}

public interface Singer{
	public void sing();
}

Singer singer = () -> {
	System.out.println("singer interface");
};

public class compareByData {
	public static int compareTo(Student o1, Student o2){
		return o1.getAge() - o2.getAge();
	}
}

// Arrays.sort(students, (o1, o2) -> compareByData.compareTo(o1, o2));
Arrays.sort(students, compareByData::compareTo);

public class compareByData {
	public int compareTo(Student o1, Student o2){
		return o1.getAge() - o2.getAge();
	}
}

compareByData cbd = new compareByData();
// Arrays.sort(students, (o1, o2) -> cbd.compareTo(o1, o2));
Arrays.sort(students, cbd::compareTo);

String names[] = {"a", "b", "c"};
// Arrays.sort(names, (o1, o2) -> o1.compareToIgnore(o2));
Arrays.sort(names, String::compareToIgnore);