public static void swap(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
}

public static void main(String[] args) {
    int x = 10;
    int y = 20;
    swap(x, y);
    System.out.println("x = " + x + ", y = " + y); // 输出 x = 10, y = 20
}

public static void add(List<Integer> list, int value) {
    list.add(value);
}

public static void main(String[] args) {
    List<Integer> list = new ArrayList<>();
    add(list, 10);
    System.out.println(list); // 输出 [10]
}

整数类型
// 整数默认是int类型，如果数字过大，则必须在末尾加 L 否则会出错
byte 
占一个字节，数字大小为 -2^7——2^7-1，默认值为 0
short
占两个字节，数字大小为 -2^15——2^15-1，默认值为 0
int
占四个字节，数字大小为 -2^31———2^31-1，默认值为 0
long
占八个字节，数字大小为 -2^63——2^63-1，默认值为 0L

浮点型
// 实数默认是double类型，如果希望一个实数是float类型，可以在数字后加 F
float
占用四个字节，默认值为 0.0F
double
占八个字节，默认值为 0.0

// 单引号包裹
char
占两个字节，数字大小为0——2^16-1，是Unicode编码，默认值为 '\u0000'（空字符）

boolean
占一个字节，默认值为 false，只有两个值：true和false，且它们不能对应于任何整数值

如
double a = 10;

如
int a = (int)88.88;

数据类型 变量名 = 变量值
如
int a = 3;

public class demo {

    // 类变量 static
    static int password;
    
    // 实例变量 ：从属于对象
    String name;
    int age;

    // main方法
    public static void main(String[] args) {

        //局部变量
        String $_a="asd";
        System.out.println($_a);
    }
    
    // 其他方法
    void func(){
        // 局部变量
    }
}

final 常量名 = 值;
例
final int MAX = 30;

public class AAA {
    public static void  main(String[] args){
        int a = 10;
        float b = 3;
        int c = 3;
        System.out.println(a/b); //结果为 3.3333333
        System.out.println(a/b); //结果为 3
    }

}

System.out.println(1%-0.3); //结果为0.10000000000000003

"123" + "abc" 结果 "123abc"

"x" + 32 + 1 结果 "x321"
    
32 + 1 + "x" 结果 "33x"

System.out.print('a' + 1); //结果为 98
System.out.print("" + 'a' + 1);  //结果为a1

如果放在变量前，就先执行自增或自减，然后变量才参与其他操作
++a，就先执行 a = a + 1，之后再执行其他操作

如果放在变量后，变量先参与其他操作，然后执行自增或自减
a++，就先执行操作，之后再执行 a = a + 1    
例
        int a=1;
        int b = ++a;
        System.out.println(b); //结果为2

	    int a=1;
        int b = a++;
        System.out.println(b); //结果为1
		

如：a > b ? a : b;

规则：
    首先计算表达式的值
    如果值为true，表达式1的值，为运算结果
    如果值为false，表达式2的值，为运算结果

// 一般利用公司域名倒置作为包名
package 包名;
例
package sunrise;	//可以是合法标识符
package com.baidu.www;	//可以是若干标识符由`.`号分割

import 包名;
引入包中所有类，用import 包名.*;
引入包中某个类，用import 包名.类名;

public class demo {
    public static void main(String[] args) {
        // 创建 Scanner 对象
        Scanner scanner = new Scanner(System.in);
        // 判断是否输入字符串
        if (scanner.hasNext()){
            // 使用next方法接收
            String str = scanner.next();
            System.out.println(str);
        }
        // 关闭io流
        scanner.close();
    }
}

System.out.printf("Name: %s, Age: %d, Salary: %.2f%n", name, age, salary);

String formattedString = String.format("Name: %s, Age: %d, Salary: %.2f%n", name, age, salary);
System.out.print(formattedString);

System.out.print() //一般的标准输出，不换行
System.out.println() //一般的标准输出，换行    
System.out.printf() //格式化输出，不换行

System.out.print("插入 {} 条题目执行时长：{}", questionInfoVoList.size(), stopWatch.getTotalTimeMillis());

class work{
    public static void main(String[] args) {

        List<String> c = new ArrayList<String>();
        c.add("hello");
        c.add("java");
        c.add("hello");

        for (String s:c){
            System.out.println(s);
        }

//方法头
修饰符 返回值类型 方法名(参数类型 参数名){
		//方法体
    return 参数;
}

如
    
public static void test(){
		...
         ...
}

方法名()

方法声明时，在指定参数类型后加一个省略号(...)
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它
之前声明。
    
    例
    public void firstTest(char s,int ...i) { // i 就是可变参数
        if (i.length > 0) {
            System.out.println(i[0]);
        }
    }

/*
多个方法在同一个类中
多个方法具有相同的方法名
多个方法的参数不同（参数类型不同或数量不同）
只与参数列表有关，与返回值无关
*/
import java.util.*;
class a{
    int jiafa(int c,int d){
        return c + d;
    }
    int jiafa(int c,int d,int e){
        return c + d + e;
    }
}
class test {
    public static void main(String[] args) {
        a A = new a();
        
        System.out.printf("%d\n",A.jiafa(1,2));
        System.out.printf("%d\n",A.jiafa(1,2,3));

    }
}

// 声明数组变量
int[] boys;			//推荐
或
int boys[];
// 使用new来创建数组
boys = new int[10];

int[] boy = new int[]{1,2,3,4,5,6};
或
int[] boy = {1,2,3,4,5,6};

return 数组变量;

A m1,m2,m3;
//等价于
A [] m = new A[3];

package Test;

class A{
    A(int a){
        System.out.printf("%d\n",a);
    }
}
public class work {
    public static void main(String[] args) {

        A [] m = new A[3];

        m[0] = new A(2);
        m[1] = new A(3);
        m[2] = new A(4);

        for (int i=0;i<=2;i++){
            System.out.println(m[i]);
        }
    }
}

public class Car{
    //成员变量
    int high;
    // 方法
    public void run(){
        // 局部变量
        int speed = 80;
        System.out.println("hello world");
    }
}

class A{
	int i;
	int j;

	A() {}
	A(int c, int d){	//有参构造方法
		i = c;
		j = d;
	}
}

class Student{
    // 成员变量
    private String name;
    private int age;
    //无参构造方法
    public Student(){};
    //有参构造方法
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }

    //成员方法
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
    public void toString(){
        System.out.println(name + "," + age);
    }
}

class A{
int j;
int i;
}
class test{
public static void main(String[] args){
    A aa = new A(); //new A()，在堆中动态分配一块区域，被当作了A的对象实体
    				//aa本身的内存是在栈中分配的
    				//堆中内存的地址赋给了aa
    				//aa指向堆中的内存，aa代表了堆中的内存
    aa.j;    	     //aa.i代表aa这个静态指针变量所指向的动态内存中的A对象
    aa.i;
	}
}

//该例子中，b类将a类对象作为自己的成员变量
class a{
    int aa = 11;
}

class b{
    int bb = 45;
    a group = new a();		// a类对象
}

public class work {
    public static void main(String[] args){
        b li = new b();
        System.out.println(li.group.aa);
    }
}

class A{
    int x = 10;
    void num(int x){
        System.out.printf("%d\n",this.x);
        System.out.printf("%d\n",x);
    }

}

public class test{
    public static void main(String[] args){
        A a = new A();
        A b = new A();
        a.num(2);
        b.num(3);
    }
}
/**结果
10
2
10
3
*/

// 最先执行，且只执行一次
static{

}

import static java.lang.Math.random;
import static java.lang.Math.PI;

//二者等价
class Person { }

class Person extends Object { }

class family{
    int math = 1;
    String name = "张三";
}

class A extends family{	//继承于父类family
    int high = 180;
}

public  class  test {
    public static void main(String[] args) {
        A a = new A();
        System.out.printf("%d,%s\n",a.math,a.name);		//访问的是父类中的成员变量
    }
}    

class family{
    int math = 1;
    int high = 170;
    String name = "张三";
}

class A extends family{	//继承于父类family
    int math = 2;
    String name = "赵四";
}
public  class work {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(a.math  + a.name + a.high); //子类中找不到high变量，所以是父类中的high变量
    }
}
/*结果是
2赵四170
*/

package Test;

class family{
    void mc(){
        System.out.println("这是父类");
    }
}

class A extends family{	//继承于父类family
    void mb(){
        System.out.println("这是子类");
    }
}
public  class work {
    public static void main(String[] args) {
        A a = new A();
        a.mc();
    }
}
/*
结果是
这是父类
*/

子类无法直接继承父类的构造方法，只能通过super语句
如果在子类的构造方法中，显示的写出了super语句，必须保证，该语句是第一条语句，否则出错
例
class family{
    public int i;
    public int j;
    family(int i,int j){
        this.i = i;
        this.j = j;
    }
}

class A extends family{
    public int c;
    A(int i,int j,int c){
        super(i,j);	//调用父类的构造方法
        //family(i,j);	//直接调用父类的构造方法是错的
        this.c = c;
    }
}
public  class  test {
    public static void main(String[] args) {
        A a = new A(1,2,3);
        System.out.printf("%d,%d\n",a.c,a.i);
    }
}
/*结果是
3,1
*/

class family{
    int math = 1;
    int high = 170;
}
class A extends family{	//继承于父类family
    String math = "2";		//隐藏了父类的 int math
    int high = 180;			// 隐藏了父类的 int high
    void show(){
        System.out.println(this.math + " " + this.high);    // 2 180
        System.out.println(super.math + " " + super.high);	//	1 170  通过super访问被隐藏的父类变量
    }
}
public  class work {
    public static void main(String[] args) {
        A a = new A();
        a.show();
    }
}

有子类、父类的继承关系
子类只能重写父类中的非静态方法
在子类中重写父类的方法时，子类方法的权限不能低于父类，父类的私有方法不能被重写，static、final修饰的方法也不能重写
子类方法抛出的异常范围必须低于父类方法
重写的方法，必须和被重写的方法具有相同的名称、参数列表、返回值类型（即除了方法体，其余必须相同）
例
class family{
    int math = 1;
    int high = 170;
    void pou(){
        System.out.println("这是被重写的方法");
    }
}
class A extends family{	//继承于父类family
    String math = "2";
    int high = 180;
    void pou(){		 //重写父类中的pou()方法
        System.out.println("这是重写后的方法");
    }
}
public  class work {
    public static void main(String[] args) {
        A a = new A();
        a.pou();
        // 父类的引用指向子类
        // // 对象能执行哪些方法，主要看对象左边的类型
        family f = new A(); //子类重写了父类的方法
        f.pou();
    }
}

public class work {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(a instanceof A); //结果为true
    }
}

Father f1 = new Son();
// 强制转换
Son f2 = (Son) f1;

Father f1 = new Son();//编译看左边，执行看右边

public abstract void show();

//重写抽象类中的方法，通过子类对象实例化来实现抽象类实例化

public abstract class Animal{
    public abstract void eat();
    public void sleep(){
        System.out.println("睡觉");
    }
}
class Cat extends Animal{	
    public void eat(){	//重写抽象类中的方法
        System.out.println("吃鱼");
    }
}

class demo{
    public static void main(String[] args){
	//  Animal a = new Animal();  //抽象类不能实例化
        Animal a = new Cat();		//多态实现实例化
        a.eat();
    }
}

//子类是抽象类
public abstract class Animal{
    public abstract void eat();
    public void sleep(){
        System.out.println("睡觉");
    }
}
abstract class Cat extends Animal{	//子类定义为抽象类
}

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

public interface StudentService {
    public void getStudent();
    public String getStudentById(int id);
    public void setStudentName(String name);
}

public interface 接口名{}

//重写接口中的抽象方法
public interface Jumpping {     //创建一个接口
    public abstract void jump();
}

class Cat implements Jumpping{    //用类实现一个接口
    public void jump() {    //重写接口中的抽象方法
        System.out.print("猫");
    }
}
class demo{
public static void main (String[] args){
    Jumpping j = new Cat();     //编译看左边，执行看右边
    j.jump();
    }
}

//接口实现类是抽象类
public interface Jumpping {     //创建一个接口
    public abstract void jump();
}
abstract class Cat implements Jumpping{	//抽象类
}
class demo{
public static void main (String[] args){
    }
}

class Outer {
    class Inner {
        // 定义了一个Inner Class
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });
        t.start();
    }
}

// 定义一个枚举类，用来表示春、夏、秋、冬这四个固定值
public enum Season {
    SPRING,
    SUMMER,
    AUTUMN,
    WINTER;
}

public enum NodeEnum{
		// 枚举项1
        CUSTOMER(11147,"formtable_19","hcdz","xdfly"),
		// 枚举项2
        SUPPLIER(10799,"formtable20","hcdz","xdfly"),
        // 枚举项3
        SALENOTE(11107,"formtable97","hcdz","sjly");
		// 构造函数
        NodeEnum(Integer nodeId, String tableName, String backFieldName, String fromFieldName) {
            this.nodeId = nodeId;
            this.tableName = tableName;
            this.backFieldName = backFieldName;
            this.fromFieldName = fromFieldName;
        }

        /**
         * 节点id
         */
        private Integer nodeId;
        /**
         * 表名称
         */
        private String tableName;
        /**
         * 回传地址字段名
         */
        private String backFieldName;
        /**
         * 来源标志字段名
         */
        private String fromFieldName;

        public Integer getNodeId() {
            return nodeId;
        }

        public String getTableName() {
            return tableName;
        }

        public String getBackFieldName() {
            return backFieldName;
        }

        public String getFromFieldName() {
            return fromFieldName;
        }

        /**
         * 根据节点id获取对应的枚举值
         * @param nodeid
         * @return
         */
        public static Map<String,Object> nodeIdOf(int nodeid){
            Map<String,Object> map = new HashMap<String,Object>();
            for(NodeEnum nodeEnum : values()){
                if(nodeEnum.getNodeId().equals(nodeid)){
                    map.put("tableName", nodeEnum.getTableName());
                    map.put("fromFieldName", nodeEnum.getFromFieldName());
                    map.put("backFieldName", nodeEnum.getBackFieldName());
                    map.put("success", true);
                    return map;
                }
            }
            map.put("success", false);
            return map;
        }
    }

int转String
返回int参数的字符串表示形式
public static String valueOf(int i)

String转int
将数字的字符串形式转为int类型，是Integer类中的方法
public static int parseInt(String s)

isDigit(char ch)//判断数字字符
isLetter(char ch)//判断字母字符
isLetterOrDigit(char ch)//判断数字字符或字母字符
isLowerCase(char ch)//判断小写字母字符   
isUpperCase(char ch)//判断大写字母字符    
toLowerCase(char ch)//转为小写形式    
toUpperCase(char ch)//转为大写字符    
isSpaceChar(char ch)//判断空格    

Random random = new Random();
int t = random.nextInt(10);		//在范围 0 - 9 之间获取一个随机数

class work{
    public static void main(String[] args) {

        System.exit(0);		// 直接退出虚拟机
        System.out.println("123");	//该语句不执行
    }
}

class work{
    public static void main(String[] args) {

       int a [] = {4,5,2,3,1};
        System.out.println(Arrays.toString(a));		//[4, 5, 2, 3, 1]
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));		//[1, 2, 3, 4, 5]
    }
}