// 注释信息

/* 注释信息 */

/** 注释信息 **/

public class HelloWorld{

    public static void main(String[] args) {
        // 补上5个空格
        System.out.println("abc" + '\t');
    }
}

// 数据类型 变量名 = 数据值;

// 定义变量
// 数据类型 变量名 = 数据值;
int a = 10;
System.out.println(a); // 10
// 变量参与计算
int b = 20;
System.out.println(a + b); // 30
// 修改记录的值
a = -10;
System.out.println(a); // -10

public class data{
public static void main(String[] args) {
System.out.println(15); // 十进制
System.out.println(015); // 八进制
System.out.println(0b1101); // 二进制
System.out.println(0x19f); // 十六进制
}
}

long num01 = 99999L；

float num02 = 10.1F;

import java.util.Scanner;

Scanner sc = new Scanner(System.in)

int i = sc.nextInt();

int a = 10;
int b = 20;
int c = a + b;

double a = 12.3
int b = (int) a;

byte a = 10;
byte b = 20;
byte result = (byte)(a + b);

System.out.println(10 + 10 + "岁"); // 20岁

System.out.println(1 + 'a'); // 98
System.out.println('a' + "a"); // aa

int a = 5;
a++;
System.out.println(a); // 6
++a;
System.out.println(a); // 7
a--;
System.out.println(a); // 6
--a;
System.out.println(a); // 5

int a = 10;
int b = a++;// b=10,a=11

int a = 10;
int b = ++a;// b=11,a=11

int result = a > b ? a : b;// 把三元运算符的结果赋值给一个变量
System.out.println(a > b ? a : b);// 把三元运算符的结果直接打印

if (关系表达式) {
语句体;
}

if (关系表达式) {
语句体1;
} else {
语句体2;
}

if (关系表达式1) {
语句体1;
} else if (关系表达式2) {
语句体2;
} ... else {
语句体n;
}

switch (表达式) {
case 值1:
语句体1;
break;
case 值2:
    语句体2;
    break;
    case 值3:
    语句体3
    break;
    ...
    default:
    语句体n;
    break;
}

int dayOfWeek = 2;
String dayType;

switch (dayOfWeek) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
        dayType = "Weekday";
        break;
    case 6:
    case 7:
        dayType = "Weekend";
        break;
    default:
        dayType = "Invalid day";
        break;
}

System.out.println("The day is: " + dayType);

int num = 1;
switch (num) {
case 1 -> System.out.println("一")
case 2 -> System.out.println("二")
case 3 -> System.out.println("三")
    default -> System.out.println("None")
}

int number = 10;

String result = switch (number) {
    case 1, 2, 3 -> "Number is 1, 2, or 3";
    case 4 + 6 -> "Number is 10";
    case (int) Math.PI -> "Number is approximately 3";
    default -> "Number is not recognized";
};

System.out.println(result);

int a = 5;

String result = switch (a) {
    case 1, 2 -> "a is 1 or 2";
    case x if x < 10 -> "a is less than 10";
    default -> "a is neither 1 nor less than 10";
};

System.out.println(result);

for (初始化语句;条件判断语句;条件控制语句){
循环语句体;
}

for (int i = 1;i <= 10;i++) {
System.out.println("HelloWorld");
}

while (条件判断语句) {
循环体语句;
条件控制语句;
}

int i = 1;
while (i <= 100) {
System.out.println(i);
i++;
}

do {
    // 循环体代码
} while (条件);

int sum = 0;
int i = 1;

do {
    sum += i;
    i++;
} while (i <= 10);

System.out.println("Sum: " + sum);

for(;;) {
System.out.println("Hello");
}

while(true) {
System.out.println("Hello");
}

do {
System.out.println("Hello");
} while(true);

for (int i = 0; i < 5; i++) {
if (i == 3) {
// 结束本次循环，继续下次循环
continue;
}

 System.out.println(i); // 输出结果：0,1,2,4
}

for (int i = 0; i < 5; i++) {
    if (i == 3) {
    // 结束本次循环，继续下次循环
        break;
    }
    System.out.println(i);// 输出结果：0,1,2
}

int [] array

int array[]

int[] array = new int[]{11,22,33};

int[] array = {11,22,33};

int[] arr = new int[3];

// 存50个人的姓名
String[] arrName = new String[50];
// 添加数据
arrName[0] = "张三";
arrName[1] = "李四";

// 定义三个身高
double[] height = {160.2,151.5,170.6};
// 定义三个年龄
int[] age = {18,20,19};
// 定义五个姓名
String[] name = {"张三","李四","王五","赵六","孙七"};
System.out.println(height[1]);  // 151.1
System.out.println(age[2]);     // 19
System.out.println(name[4]);    // 孙七

int[] num = {1,2,3,4,5,6,7,8,9,10};
for (int i = 0; i < num.length; i++) {
System.out.println(num[i]);
}

int[] num = {1,2,3,4,5,6,7,8};
System.out.println(num[10]);// 索引越界

// 求最值
int[] arr = {95,77,81,90,69,121,55,17,31};
int max = 0;
for (int i = 0; i < arr.length; i++) {
    if (max < arr[i]) {max = arr[i];}
}
System.out.println(max);
// 求和
int sum = 0;
for (int i = 0; i < arr.length; i++) {
    sum += arr[i];
}
System.out.println(sum);
// 交换数据
System.out.println("beforeChange：" + arr[1] + '|' + arr[3]);
int box = 0;
box = arr[1];
arr[1] = arr[3];
arr[3] = box;
System.out.println("afterChange：" + arr[1] + '|' + arr[3]);

int[][] arr = new int[][] {{1,2,3},{4,5,6}}

int[][] arr = {{1,2,3},{4,5,6}}

int[][] twoDimensionalArray = new int[3][3];

int[][] irregularArray = new int[3][];
irregularArray[0] = new int[2];
irregularArray[1] = new int[4];
irregularArray[2] = new int[3];

// 动态初始化一个 3x3 的二维数组
int[][] twoDimensionalArray = new int[3][3];

// 给二维数组赋值
twoDimensionalArray[0][0] = 1;
twoDimensionalArray[0][1] = 2;
twoDimensionalArray[0][2] = 3;
twoDimensionalArray[1][0] = 4;
twoDimensionalArray[1][1] = 5;
twoDimensionalArray[1][2] = 6;
twoDimensionalArray[2][0] = 7;
twoDimensionalArray[2][1] = 8;
twoDimensionalArray[2][2] = 9;

// 打印二维数组的内容
for (int i = 0; i < twoDimensionalArray.length; i++) {
  for (int j = 0; j < twoDimensionalArray[i].length; j++) {
    System.out.print(twoDimensionalArray[i][j] + " ");
  }
  System.out.println();
}

// 创建一个 3x3 的二维数组
int[][] twoDimensionalArray = {
  {1, 2, 3},
  {4, 5, 6},
  {7, 8, 9}
};

// 访问二维数组的元素
System.out.println(twoDimensionalArray[0][0]); // 输出: 1
System.out.println(twoDimensionalArray[1][2]); // 输出: 6
System.out.println(twoDimensionalArray[2][1]); // 输出: 8

// 修改二维数组的元素
twoDimensionalArray[1][1] = 10;
System.out.println(twoDimensionalArray[1][1]); // 输出: 10

public static void 方法名() {
方法体(打包起来的代码);
}

public static void sout() {
    System.out.println("你好世界");
    System.out.println("Hello World");
    System.out.println("Hi World");
}

public static void 方法名(形参1,形参2,...) {
方法体(打包起来的代码);
}

public static void sum(int num1,int num2) {
    int result = num1 + num2;
    System.out.println(result);
}

public static 返回值类型 calc(int hours) {
方法体(打包起来的代码);
    return 返回值;
}

public static int calc(int hours) {
    int minutes = hours * 60;
    return minutes;
}

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

public static void main(String[] args) {
    sum(50,50);
}

public static void main(String[] args) {
    int hours = calc(5);
    System.out.println(hours);
}

public static int sum(int a, int b) {
return a+b;
}
public static int sum(int a, int b,int c) {
return a+b+c;
}

// 基本数据类型
int num = 10;
double pi = 3.14;
char letter = 'A';
boolean flag = true;

// 引用数据类型
String name = "John";
int[] numbers = {1, 2, 3, 4};
Object obj = new Object();

public class 类名 {
1. 成员变量
2. 成员方法
}

public class Phone {
// 属性（成员变量）
String brand;

// 行为(方法)
public void call() {
...
}

public void playGame() {
...
}
}

类名 对象名 = new 类名();

Phone p = new Phone();

对象名.成员变量

对象名.方法名()

修饰符 数据类型 变量名称 = 初始化值;

public class Phone {
private String picture;
String brand;
double price;
}

public class Person {
private int age;// 成员变量（全局变量）
public void age() {
int age = 18;// 局部变量
System.out.println(age);// 这里的age会优先获取局部变量的age（就近原则）
}
}

public class Person {
private int age;// 成员变量（全局变量）
public void age() {
int age = 18;// 局部变量
System.out.println(this.age);// 这里的age会获取全部变量的age
}
}

   public void setName(String name) {
       this.name = name;
   }

   public void add(int num) {
       this.result += num;
   }

   public void subtract(int num) {
       this.result -= num;
   }

   public Rectangle() {
       this(0, 0); // 调用带参数的构造方法
   }

   public Rectangle(int width, int height) {
       this.width = width;
       this.height = height;
   }

public class Peson {
修饰符 类名(参数) {
方法体;
}
}

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

public Student() {// 空参构造方法
...
}

public Student(String name,int age) {// 带全部参数构造方法
...
}
}

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

public Student() {// 空参构造方法

}

public Student(String name,int age) {// 带全部参数构造方法
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public int getAge() {
return age;
}
}

// 传递以及获取类的值
public class StudentTest {
public static void main(String[] args) {
Student s = new Student("张三",18)

System.out.println(s.getName());
System.out.println(s.getAge());
}
}

class Person {
    String name;
    int age;

    // 无参构造方法，默认提供，可以省略显式定义
    public Person() {
        // 对象初始化
        name = "Unknown";
        age = 0;
    }

    // 带参构造方法，重载构造方法
    public Person(String name, int age) {
        // 对象初始化
        this.name = name;
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        // 使用无参构造方法创建对象
        Person person1 = new Person();
        System.out.println(person1.name); // Output: "Unknown"
        System.out.println(person1.age); // Output: 0

        // 使用带参构造方法创建对象
        Person person2 = new Person("Alice", 30);
        System.out.println(person2.name); // Output: "Alice"
        System.out.println(person2.age); // Output: 30
    }
}

String name = "张三"

String s1 = new String();
System.out.println(s1);// ""即空字符串

String s2 = new String("abc");
System.out.println(s2);// "abc"

char[] chs = {'h','e','l','l','o'};
String s3 = new String(chs);
System.out.println(s3);// "hello"

byte[] bytes = {97,98,99,100};
String s4 = new String(bytes);
System.out.println(s4)// "abcd" ASCII码

String s1 = "abc";
String s2 = "abc";// s1 s2执行的是同一个内存地址

基本数据类型：比较数据值
引用数据类型：比较地址值

String s1 = new String("abc");
String s2 = "abc";

boolean res = s1.equals(s2);
System.out.println(res);// true

String s1 = "abc";
for (int i=0;i < s1.length;i++) {
char c = str.charAt(i)
System.out.println(c);// 依次打印：a b c
}

StringBuilder sb1 = new StringBuilder("abc");// 有参
StringBuilder sb2 = new StringBuilder();// 无参

// 1. 创建对象
StringBuilder sb = new StringBuilder();
sb.append(123);
sb.append(2.3);
sb.append(true);
// 打印
// Java对这个类进行了特殊处理
// 打印对象不是地址值而是属性值
System.out.println(sb); // 1232.3true

// 反转
sb.reverse();
// 获取对象字符串长度
int len = sb.length();
System.out.println(sb); // eurt3.2321
System.out.println(len); // 10

// 转换为字符串类型
String str = sb.toString();
System.out.println(str); // eurt3.2321

sb.append(123).reverse();
System.out.println("321");

// 1.创建集合的对象
// 泛型(e)：限定集合中存储数据的类型
ArrayList<String> list = new ArrayList<>();
// 这个类在底层做了一些处理，打印对象不是地址值，而是具体的数据
// 在展示的时候会拿[]把所有的数据进行包裹
System.out.println(list);   // 打印结果：[]

// 添加元素
list.add("你好");
list.add("Hello");
System.out.println(list);   // 打印结果：[你好, Hello]

// 删除元素
list.remove("你好");
System.out.println(list);   // 打印结果：[Hello]
// 以上两个都有返回值，且为布尔值
boolean res1 = list.add("test");
boolean res2 = list.remove("test");
boolean res3 = list.remove("???");  // 删除集合中不存在的元素返回值为false
System.out.println(res1 + "-" + res2 + "-" + res3); // 打印结果：true-tr

// 按照索引删除元素
String delete = list.remove(0);
System.out.println(delete); // 打印结果：Hello
System.out.println(list);   // 打印结果：[]

// 修改元素
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
String change = list.set(0,"first");
System.out.println(change); // aaa
System.out.println(list);   // [first, bbb, ccc, ddd]

// 查询元素
String find = list.get(3);
System.out.println(find);   // ddd

// 获取集合的长度
int size = list.size();
System.out.println(size);   // 4

// 1. 创建集合
ArrayList<Integer> intArr = new ArrayList<>();
ArrayList<Character> charArr = new ArrayList<>();

intArr.add(1);
intArr.add(2);
intArr.add(3);
intArr.add(4);
intArr.add(5);
// 遍历数字集合
for (int i = 0; i < intArr.size(); i++) {
    System.out.println(intArr.get(i));
}

charArr.add('a');
charArr.add('b');
charArr.add('c');
charArr.add('d');
charArr.add('e');
charArr.add('f');
// 遍历字符集合
for (int i = 0; i < charArr.size(); i++) {
    System.out.println(charArr.get(i));
}

 // 属性：学生姓名 年龄 性别 老师姓名
 private String name;
 private int age;
 private String gender;

// 所有的对象都共享一个老师姓名
 public static String teacherName;

// 所有的对象都共享一个老师姓名
Student.teacherName = "Bob";

Student s1 = new Student();
s1.setName("张三");
s1.setGender("男");
s1.setAge(23);
s1.study();
s1.show();
Student s2 = new Student();
s2.setName("李四");
s2.setGender("女");
s2.setAge(22);
s2.study();
s2.show();

public class MyClass {
    private int value;

    public static void staticMethod() {
        // 静态方法无法使用 this 关键字
        // this.value = 10; // 编译错误：Cannot use this in a static context
    }

    public void instanceMethod() {
        // 实例方法可以使用 this 关键字
        this.value = 10;
    }
}

public class Student extends Person {}

// 父类
class Animal {
    void eat() {
        System.out.println("Animal is eating.");
    }
}

// 子类继承自Animal类
class Dog extends Animal {
    void bark() {
        System.out.println("Dog is barking.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat(); // 继承自Animal类的方法
        dog.bark(); // 子类独有的方法
    }
}

class Parent {
    int age;

    Parent(int age) {
        this.age = age;
    }
}

class Child extends Parent {
    String name;

    Child(String name, int age) {
        super(age); // 调用父类的构造方法进行初始化
        this.name = name;
    }
}

class Parent {
    public int publicVar;
    protected int protectedVar;
    int defaultVar; // 默认访问修饰符，包级私有
    private int privateVar;

    public Parent() {
        publicVar = 1;
        protectedVar = 2;
        defaultVar = 3;
        privateVar = 4;
    }
}

class Child extends Parent {
    void printVariables() {
        System.out.println(publicVar); // 可以访问继承的公共成员变量
        System.out.println(protectedVar); // 可以访问继承的受保护成员变量
        System.out.println(defaultVar); // 可以访问继承的默认成员变量
        // System.out.println(privateVar); // 编译错误，无法访问继承的私有成员变量
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.printVariables();
    }
}

public class Fu {
String name = "Fu";
}

public class Zi extends Fu{
String name = "Zi";// 删除这行，打印结果为：Fu
public void ziShow(){
String name = "ziShow";// 删除这行，打印结果为：Zi
System.out.println(name);// 结果：ziShow
}
}

public class Fu {
    int Id = 10;

    public void doThings() {
        System.out.println("I am Fu");
    }
}

public class Zi extends Fu{
    int Id = 20;
    public void idShow() {
        System.out.println("Zi:" + this.Id);
        System.out.println("Fu:" + super.Id);
    }

    public void doThings() {
        System.out.println("I am Zi");
    }

    public void ziShow() {
        this.doThings();
    }

    public void fuShow() {
        super.doThings();
    }
}

public class Test {
    public static void main(String[] args) {
        Zi z1 = new Zi();
        z1.idShow();    // Zi: 20 Fu:10
        z1.ziShow();
        z1.fuShow();
    }
}

public class Person {
    public void eat() {
        System.out.println("吃米饭");
    }
    public void drink() {
        System.out.println("喝开水");
    }
}

public class Student extends Person{
    @Override
    public void eat() {
        System.out.println("吃菜");
    }
    @Override
    public void drink() {
        System.out.println("喝饮料");
    }
}

public class Fu{
int Age;
String Name;
public Fu() {
Age = 10;
Name = "张三";
}
public Fu(int Age,String Name) {
this.Age = Age;
this.Name = Name;
}
}

public class Zi extends Fu{
public Zi() {
// 子类构造方法中隐藏的super()去访问父类的无参构造
super();
}

    public Zi(String Name,int Age) {
        // 访问父类的有参构造
        super(Name,Age);
    }
}

父类类型 对象名称 = 子类对象;

Fu f = new Zi();

package duotai;

public class Test {
    public static void main(String[] args) {
        Animal a = new Dog();
        // 变量为父，方法为子
        System.out.println(a.name); // 动物
        a.show();   // Dog----show
    }
}

class Animal {
    String name = "动物";

    public void show() {
        System.out.println("Animal----show");
    }
}

class Dog extends Animal {
    String name = "狗";

    @Override
    public void show() {
        System.out.println("Dog----show");
    }
}

Person p = new Student();
p.work();
// 如果需要变成teacher的work方法，不需要修改其他地方，只需要把new Student() 改为 new Teacher()

package duotai;

public class Test {
    public static void main(String[] args) {
        Animal a = new Dog();
        // 变量为父，方法为子
        System.out.println(a.name); // 动物
        a.show();   // Dog----show
        // a.watchDoor(); 父类里面没有这个方法，会报错
    }
}

class Animal {
    String name = "动物";

    public void show() {
        System.out.println("Animal----show");
    }
}

class Dog extends Animal {
    String name = "狗";

    @Override
    public void show() {
        System.out.println("Dog----show");
    }

    public void watchDoor() {
        System.out.printf("看门");
    }
}

public class Test {
public static void main(String[] args) {
com.zhaojiale.domain.Student s = new com.zhaojiale.domain.Student()
}
}

import com.zhaojiale.domain.Student;
public class Test {
public static void main(String[] args) {
Student s = new Student()
}
}

static{}

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

static {
System.out.println("静态代码块执行了");
}

...
}

public abstract 返回值类型 方法名(参数列表);

public abstract class 类名{}

package abstractDemo;

abstract class Person {
    public abstract void work();
}

public class Test {
    public static void main(String[] args) {
        // Person p = new Person(); java: abstractDemo.Person是抽象的; 无法实例化
    }
}

public interface 接口名 {}

public class 类名 implements 接口名 {}

public class 类名 implements 接口名1,接口名2 {}

public class 类名 extends 父类 implements 接口名1,接口名2 {}

public class Outer {// 外部类
public class Inner {// 内部类

}
}

public class Outer {// 外部类
static class Inner {// 内部类

}
}

外部类名.内部类名 对象名 = new 外部类名.内部类名();

package InnerClass;

public class Outer {
    int a = 10;
    static int b = 20;
    static class Inner {
        public void show1() {
            Outer o = new Outer();
            System.out.println(o.a);
            System.out.println(b);
        }

        public static void show2() {
            Outer o = new Outer();
            System.out.println(o.a);
            System.out.println(b);
        }
    }
}

package InnerClass;

public class Test {
    public static void main(String[] args) {
        Outer.Inner oi = new Outer.Inner();
        oi.show1();
        // oi.show2(); 不会报错且可以使用
        Outer.Inner.show2();
    }
}

package InnerClass02;

public class Outer {
    int b = 20;
    public void show() {
        int a = 10;
        class Inner{
            String name;
            int age;

            public void method1() {
                System.out.println("局部内部类中的method1方法");
            }

            public static void method2() {
                System.out.printf("局部内部类中的method2静态方法");
            }
        }

        // 创建局部内部类的对象
        Inner i = new Inner();
        System.out.println(i.name);
        System.out.println(i.age);
        i.method1();
        Inner.method2();
    }
}

new 类名或接口名() {
重写方法;
}

new Inter() {
public void show() {

}
}

package InnerClass03;

public class Test2 {
    public static void main(String[] args) {
        // 在测试类中调用下面的method方法？
        // 以前的方式如何调用？
        // 要自己写一个子类继承Animal类
        // 再创建子类的对象
        // Dog d = new Dog();
        // method(d);
        // 以上的方法过于繁琐，需要自己定义
        // 使用匿名类就会方便很多
        method(
                new Animal() {
                    @Override
                    public void eat() {
                        System.out.println("狗吃骨头");
                    }
                }
        );
    }

    public static void method(Animal a) {
        a.eat();
    };
}

package InnerClass03;

public class Test3 {
    public static void main(String[] args) {
        new Swim() {

            @Override
            public void swim() {
                System.out.println("重写之后的游泳方法");
            }
        }.swim();
    }
}

1. 创建一个宽603像素，高680像素的游戏主界面
2. 创建一个宽488像素，高430像素的登陆界面
3. 创建一个宽488像素，高500像素的注册界面

JFrame GameJFrame = new JFrame();

JFrame.setSize(int width,int height);// 设置窗口宽高
JFrame.setVisible(Boolean b);// 显示窗口，建议放到最后
JFrame.setTitle(String s);// 设置标题
JFrame.setAlwaysOnTop(Boolean b);// 设置窗口置顶
JFrame.setDefaultCloseOperation();// 设置窗口关闭方式 参数可以填入 0-3 范围

package Ui;

import javax.swing.*;

public class GameJFrame extends JFrame {
    // JFrame表示界面、窗体
    // 同理它的子类也是代表界面、窗体
    // GameJFrame 自定义类，表示主界面窗体
    public GameJFrame(int width,int height,Boolean vb) {
        this.setSize(width,height);
        this.setVisible(vb);

        this.setTitle("拼图单机版 v1.0"); // 设置窗口标题
        this.setAlwaysOnTop(true);  // 设置窗口置顶

        this.setLocationRelativeTo(null); // 设置窗口居中
        this.setDefaultCloseOperation(3);
    }

}

JMenuBar jMenuBar = new JMenuBar();
JMenu functionJMenu = new JMenu(String s);
JMenuItem replayItem = new JMenuItem(String s);

// 初始化菜单
// 创建整个的菜单对象
JMenuBar jMenuBar = new JMenuBar();

JMenu functionJMenu = new JMenu("功能");
JMenu aboutJMenu = new JMenu("关于我们");

// 创建选项下面的条目对象
JMenuItem replayItem = new JMenuItem("重新游戏");
JMenuItem reLoginItem = new JMenuItem("重写登录");
JMenuItem closeItem = new JMenuItem("关闭游戏");
JMenuItem accountItem = new JMenuItem("公众号");

// 将条目添加到选项中
functionJMenu.add(replayItem);
functionJMenu.add(reLoginItem);
functionJMenu.add(closeItem);

aboutJMenu.add(accountItem);

// 将菜单里面的两个选项添加到菜单当中
jMenuBar.add(functionJMenu);
jMenuBar.add(aboutJMenu);

// 将整个页面设置菜单
this.setJMenuBar(jMenuBar);

JLabel jLabel = new JLabel();

ImageIcon icon = new ImageIcon(String s);// s 填入图片路径

jLabel.add(icon);

jLabel.setBounds(int x,int y,int width,int height);

this.getContentPane().add(jLabel);

// 取消默认的居中放置，只有取消了才会按照XY轴的形式添加组件
this.setLayout(null);

private void initImage() {
    for (int j = 0; j < 4; j++) {
        for (int i = 0; i < 4; i++) {
            // 获取当前要加载的图片序号
            int num = data[i][j];
            // 创建一个JLabel的对象（管理容器）
            JLabel jLabel = new JLabel(new ImageIcon("C://" + num + ".jpg"));
            // 指定图片位置
            jLabel.setBounds(105 * i,105*j,105,105);
            // 将容器添加到界面中
            // this.add(jLabel);
            this.getContentPane().add(jLabel);
        }
    }

键盘监听：KeyListener
鼠标监听：MouseListener
动作监听：ActionListener

JButton jbtn = new JButton(String s);// 按钮内的文字

jbtn.setBounds(int x,int y,int width,int height);

public class MyActionLisntener implements ActionListener {
    public  void actionPerformed(ActionEvent e) {
        System.out.println("按钮被点击了");
    }
}

jbtn.addActionListener(new MyActionLisntener());

jbtn.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("匿名内部类哦");
    }
});

public class JframeButton extends JFrame implements ActionListener {
JButton btn1 = new JButton("AButton");
    JButton btn2 = new JButton("BButton");

public JframeButton() {
...
        btn1.setBounds(0,0,100,50);
        // 这里的this代表传入本类对象，即btn1
        btn1.addActionListener(this);

        btn2.setBounds(200,0,100,50);
        // 这里的this代表传入本类对象，即btn2
        btn2.addActionListener(this);

        this.getContentPane().add(btn1);
        this.getContentPane().add(btn2);
        ...
}

public void actionPerformed(ActionEvent e) {
        Object source = e.getSource();

        if (source == btn1) {
            System.out.println("我是第一个按钮");
        } else if (source == btn2) {
            System.out.println("我是第二个按钮");
        }
    }

}

public class MyMouseListener extends JFrame implements MouseListener {
    JButton btn1 = new JButton("1");

    public MyMouseListener() {
        JFrame jfm = new JFrame();
        jfm.setSize(600,500);
        jfm.setAlwaysOnTop(true);
        jfm.setDefaultCloseOperation(3);
        jfm.setLayout(null);
        jfm.setLocationRelativeTo(null);

        btn1.setBounds(10,0,100,100);
        btn1.addMouseListener(this);

        jfm.getContentPane().add(btn1);

        jfm.setVisible(true);
    }

    @Override
    public void mouseClicked(MouseEvent e) {
        Object source = e.getSource();
        if (source == btn1) {
            System.out.println("按下");
        }
    }

    @Override
    public void mousePressed(MouseEvent e) {
        System.out.println("按住");
    }

    @Override
    public void mouseReleased(MouseEvent e) {
        System.out.println("松开");
    }

    @Override
    public void mouseEntered(MouseEvent e) {
        System.out.println("鼠标划入");
    }

    @Override
    public void mouseExited(MouseEvent e) {
        System.out.println("鼠标离开");
    }
}

public class MyKeyListener extends JFrame implements KeyListener {

    public MyKeyListener() {
        this.setSize(603,680);
        this.setTitle("测试按键");
        this.setAlwaysOnTop(true);
        this.setLocationRelativeTo(null);
        this.setAlwaysOnTop(true);
        this.setDefaultCloseOperation(3);
        this.setLayout(null);

        this.addKeyListener(this);

        this.setVisible(true);
    }

    @Override
    public void keyTyped(KeyEvent e) {

    }

    @Override
    public void keyPressed(KeyEvent e) {
        System.out.println("按下不松");
    }

    @Override
    public void keyReleased(KeyEvent e) {
        System.out.println("按下且释放");

        // 获取按键编号
        int code = e.getKeyCode();
        System.out.println(code);
    }
}

public static boolean primeNum(int number) {
    int index = 0;
    for (int i = 2; i < number; i++) {
        index++;
        if (number % i == 0) {
            return false;
        }
    }
    System.out.println(index);
    return true;
}

public static boolean primeNum(int number) {
    int index = 0;
    for (int i = 2; i <= Math.sqrt(number); i++) {
        index++;
        if (number % i == 0) {
            return false;
        }
    }
    System.out.println(index);
    return true;
}

for (int i = 100; i <= 999; i++) {
    int ge = i % 10;
    int shi = i / 10 % 10;
    int bai = i / 100 % 10;

    double sum = Math.pow(ge,3) + Math.pow(shi,3) + Math.pow(bai,3);
    if (sum == i) {
        System.out.println(i);
    }
}

System.exit(0) // 虚拟机正常终止
System.out.println("我不会被打印出来");

long l = System.currentTimeMillies();
System.out.println(l)

int[] arr1 = {1,2,3,4,5,6,7,8,9,10};
int[] arr2 = new int[10];

// 从 arr1 数组的0索引上开始复制到 arr2 数组的0索引中，总共复制 10 个数
System.arraycopy(arr1,0,arr2,0,10);

/*
Runtime r1 = Runtime.getRuntime();
Runtime r2 = Runtime.getRuntime();
System.out.println(r1 == r2);
*/

// 停止虚拟机
/*
Runtime.getRuntime().exit(0);
System.out.println("我不会被打印");
*/

// CPU线程数
System.out.println(Runtime.getRuntime().availableProcessors());

// 总内存大小
System.out.println(Runtime.getRuntime().maxMemory() / 1024 / 1024);

// 已经获取的总内存大小
System.out.println(Runtime.getRuntime().totalMemory() / 1024 / 1024);

// 剩余内存大小
System.out.println(Runtime.getRuntime().freeMemory() / 1024 / 1024);

// 执行 cmd 命令
System.out.println(Runtime.getRuntime().exec("notepad"));

Object obj = new Object();
Boolean flag = false;
String sflag = obj.toString();
System.out.println(flag.getClass());    // class java.lang.Boolean
System.out.println(sflag.getClass());   // class java.lang.String

// OpenJDK7 java.lang.Object类toString()源码
public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

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

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

    ...

    // 重写equals，使对象的属性之间做对比
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}

Student s1 = new Student("张三",18);
Student s2 = new Student("张三",18);
Boolean result = s1.equals(s2);
System.out.println(result); // 直接输出为 false，这是因为对比的是地址值，正确的对比需要重写equals

public class User implements Cloneable{
    private int id;
    private String username;
    private String password;

    private int[] data;

...

    // 

    public String toString() {
        return "角色编号为：" + id + "，用户名：" + username + "，密码：" + password + "，data：" + ArrtoString(data);
    }

    public String ArrtoString(int[] data) {
        StringJoiner sj = new StringJoiner("，","[","]");
        for (int i = 0; i < data.length; i++) {
            sj.add(data[i] + "");
        }
        return sj.toString();
    }

    // 由于clone在Object中是受保护的，需要重写才可以使用

    @Override
    protected Object clone() throws CloneNotSupportedException {
        // 调用父类的clone方法
        // 相当于让Java帮我们克隆一个对象，并把克隆之后的对象返回出去
        return super.clone();
    }
}

int[] data = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,0};
// 创建对象
User u1 = new User(1,"zhangsan","qwe123456",data);
// 克隆对象
User u2 = (User) u1.clone();
System.out.println(u1);
System.out.println(u2);

[abc] 只能是a,b,c
[^abc] 除了a,b,c之外的任何字符
[a-zA-Z] a到z A到Z，包括（范围）
[a-d[m-p]] a到d，或m到p
[a-z&&[def]] a-z到def的交集。即：d，e，f
[a-z&&[^bc]] a-z和非bc的交集。即：[ad-z]
[a-z&&[^m-p]] a到z和除了m到p的交集。即：[a-lq-z]

. 任意字符
\d 一个数字：[0-9]
\D 非数字：[^0-9]
\s 一个空白字符：[\t\n\x0B\f\r]
\S 非空字符：[^\s]
\w 英文、数字、下划线：[a-zA-z_0-9]
\W [^\w] 一个非单词字符

x?x，一次或0次
x*x，零次或多次
x+x，一次或多次
x{n} x，正好n次
x{n,} x,至少n次
x{n,m} x,至少n但不超过m次

/*
有如下文本，请按照要求爬取数据
Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是 Java8 和 Java11，
因为这两个是长期支持版本，下一个长期支持版本是 Java17，相信在未来不久 Java17 也会逐渐登上历史舞台

要求：找出里面所有的 JavaXX
*/
String str = "Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，" +
        "因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17 也会逐渐登上历史舞台";

// Pattern 表示正则表达式
// Matcher 文本匹配器，作用按照正则表达式的规则去读取字符串，从头开始读取

// 获取正则表达式的对象
// Pattern p = Pattern.compile("Java\\d{0,2}");
// Matcher m = p.matcher(str);
// 代码解释：m要在str中查找符合p规则的字符小串

// boolean b = m.find();
// 拿着文本匹配器从头开始读取，寻找是否有满足规则的字串
// 如果没有，返回false，如果有返回true，在底层记录子串的 起始索引 和 结束索引+1

// 方法底层会根据find方法记录的索引进行字符串的截取
// subString(起始索引, 结束索引); 包头不包尾，所以结束索引会+1
// String s1 = m.group();
// System.out.println(s1);

// 第二次在调用find的时候，会继续读取后面的内容
// 读取到第二个满足要求的子串，方法会继续返回true
// 并把第二个字串的起始索引和结束索引+1，进行记录
// b = m.find();
// String s2 = m.group();
// System.out.println(s2);

// 规范写法：
// 1. 获取正则表达式的对象
Pattern p = Pattern.compile("Java\\d{0,2}");
// 2. 获取文本匹配器的对象
Matcher m = p.matcher(str);

// 3. 利用循环获取
while (m.find()) {
    String res = m.group();
    System.out.println(res);
}

    public static void main(String[] args) {
        String str = "Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，" +
                "因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17 也会逐渐登上历史舞台";

        // 1. 不显示版本号,只要java
        // ? 理解为前面的数据 Java
        // = 表示在Java后面要跟随的数据
        // 但是在获取的时候，只获取前半部分
//        String regex = "Java(?=8|11|17)";
//        Pattern p = Pattern.compile(regex);
//        Matcher m = p.matcher(str);
//        while (m.find()) {
//            System.out.println(m.group());
//        }

        // 2. 显示版本号
//        String regex = "Java(8|11|17)";
//        Pattern p = Pattern.compile(regex);
//        Matcher m = p.matcher(str);
//        while (m.find()) {
//            System.out.println(m.group());
//        }

        // 3. 爬取版本号位 8,11,17 的Java
//        String regex = "Java(8|11|17)";
//        Pattern p = Pattern.compile(regex);
//        Matcher m = p.matcher(str);
//        while (m.find()) {
//            System.out.println(m.group());
//        }

String str = "Java自从95年问世以来，abbbbbbbbbbbaaaaaaaaaaaaa经历了很多版本，目前企业中用的最多的是Java8和Java11，" + "因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17 也会逐渐登上历史舞台";

// 只写+和*表示贪婪匹配，
// +? 非贪婪匹配
// *? 非贪婪匹配
// Java中默认的是贪婪爬取

// 1. 按照ab+的方式爬取ab，b尽可能多获取
// String regex = "ab+";
// Pattern p = Pattern.compile(regex);
// Matcher m = p.matcher(str);
//
// while (m.find()) {
// System.out.println( m.group());
// }

// 2. 按照ab+的方式爬取ab，b尽可能少获取
String regex = "ab+?";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(str);

while (m.find()) {
System.out.println( m.group());
}

String s = "张三三qweasdzxc123李四四poilkjmnb098王五五";
String res = s.replaceAll("[\\w&&[^_]]+","vs");
System.out.println(res);

String[] arr = s.split("[\\w&&[^_]]+");
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

String regex1 = "\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3})"

// 判断一个字符串的开始字符和结束字符是否一致
String regex = "(.).+\\1";
System.out.println("a123a".matches(regex));
System.out.println("a121a".matches(regex));
System.out.println("b121a".matches(regex));
System.out.println("a123b".matches(regex));
System.out.println("------------");

// 将重复内容替换为单个
String s = "我要学学编编编编程程程程程程";
String res = s.replaceAll("(.)\\1+","$1");
System.out.println(res);

Date d1 = new Date();
System.out.println(d1);

Date d2 = new Date(0L);
System.out.println(d2);

d2.setTime(1000L);
System.out.println(d2);

long time = d2.getTime();
System.out.println(time);

y 年M 月 d 日
H 时 m 分 s 秒

2025-06-15 23:42:10
yyyy-MM-dd HH:mm:ss

2025年06月15日 23:42:10
yyyy年MM月dd日 HH:mm:ss

// 利用构造方法获取Integer（JDK5以前的方式）
Integer i1 = new Integer(1);

// 利用静态方法获取Integer（JDK5以前的方式）
Integer i2 = Integer.valueOf(2);
Integer i3 = Integer.valueOf("525",16);

System.out.println(i2);
System.out.println(i3);

// 这两种方式获取对象的区别
// 和之前学习到的BigInteger一样，内部进行优化，127~-128 提前创建对象，不会重复创建新的对象
Integer i4 = Integer.valueOf(127);
Integer i5 = Integer.valueOf(127);
System.out.println(i4 == i5);   // true

Integer i6 = Integer.valueOf(128);
Integer i7 = Integer.valueOf(128);
System.out.println(i6 == i7);   // true

// 因为有new关键字，在Java中，每一次new都是创建了一个新的对象
// 所以下面的两个对象都是new出来的，地址值不一样
Integer i8 = new Integer(127);
Integer i9 = new Integer(127);
System.out.println(i8 == i9);   // true

Integer i10 = new Integer(128);
Integer i11 = new Integer(128);
System.out.println(i10 == i11); // true

// 在以前包装类的计算方式
Integer i1 = new Integer(1);
Integer i2 = new Integer(2);

// 对 i1 与 i2 进行相加操作
// 1. 把对象进行拆箱，变成基本数据类型
// 2. 相加
// 3. 把得到的结果再次进行装箱（再变回包装类）
// int res = i1.intValue() + i2.intValue();
// Integer i3 = new Integer(res);
// System.out.println(i3);

// 在JDK5的时候提出了一个机制，自动装箱和自动拆箱
// 自动装箱：把基本数据类型会自动的变成其对应的包装类
// 自动拆箱：把包装类自动的变成其对象的基本数据类型

// 自动装箱动作
Integer i5 = 10;
Integer i6 = new Integer(20);

// 自动拆箱动作
int i = i2;

// 在JDK5以后，int和Integer可以看作是同一个东西，因为在内部可以自动转化

flowchart TB  Start["Collection"]  Start -->List  Start -->Set    List --> id1[(ArrayList)]  List --> id2[(LinkedList)]  List --> id3[(Vector)]    Set --> id4[(HashSet)]  Set --> id5[(TreeSet)]    id4[(HashSet)] --> id6[(LinkedHashSet)]    接口  id7[(实现类)]

Collection<String> coll = new ArrayList<>();
coll.add("aaa");
coll.add("bbb");
coll.add("ccc");
coll.add("ddd");
coll.add("eee");
coll.add("eee");

Iterator<String> it = coll.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

for (元素的数据类型 变量名:数组或者集合) {

}

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

// 1. 创建集合并添加元素
Collection<String> coll = new ArrayList<>();
coll.add("zhangsan");
coll.add("lisi");
coll.add("wangwu");
coll.add("zhaoliu");

// 利用增强for循环
for (String s : coll) {
    System.out.println(s);
}

for (String s : coll) {
s = "qqq"; // 并不会修改值
}

// 1. 创建集合并添加元素
Collection<String> coll = new ArrayList<>();
coll.add("zhangsan");
coll.add("lisi");
coll.add("wangwu");
coll.add("zhaoliu");

// 2. 利用匿名内部类的形式
// forEach底层原理：
// 也会自己遍历集合，依次得到每一个元素
// s依次表示集合中的每一个数据
coll.forEach(new Consumer<String>() {
    @Override
    // s 依次表示集合中的每一个数据
    public void accept(String s) {
        System.out.println(s);
    }
});

// lambda表达式
coll.forEach(s -> System.out.println(s));

List<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");

// 1. 迭代器
// Iterator<String> it = list.iterator();
// while (it.hasNext()) {
//     System.out.println(it.next());
// }

// 2. 增强for
// for (String s : list) {
//     System.out.println(s);
// }

// 3. lambda
// list.forEach(s -> System.out.println(s));

// 4. 普通for循环
// for (int i = 0; i < list.size(); i++) {
//     System.out.println(list.get(i));
// }

// 5. 列表迭代器
// 获取一个列表迭代器的对象，里面的指针默认指向0索引
ListIterator<String> it = list.listIterator();
while (it.hasNext()) {
    // 迭代器可以添加元素
    String s = it.next();
    if("bbb".equals(s)) {
        it.add("qqq");
    }
}

System.out.println(list);
while (it.hasPrevious()) {
    System.out.println(it.previous());
}

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.function.Consumer;

public class A13_SetDemo1 {
    public static void main(String[] args) {
        // 1. 创建一个set对象
        Set<String> s = new HashSet<>();

        // 2. 添加元素
        // 如果添加的元素集合中不存在，返回值为true
        // 如果添加的元素集合中存在，返回值为false
        s.add("张三");
        s.add("李四");
        s.add("王五");

        System.out.println(s);

        // 迭代器遍历
        System.out.println("----迭代器----");
        Iterator<String> it = s.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }

        // 增强for遍历
        System.out.println("----增强for----");
        for (String s1 : s) {
            System.out.println(s1);
        }

        // lambda表达式
        // forEach遍历
        System.out.println("----forEach----");
        s.forEach(s1 -> {
            System.out.println(s1);
        });
    }
}

int index = (数组长度 - 1) & 哈希值;

package mySet;

import java.util.Iterator;
import java.util.TreeSet;

public class A16_TreeSetDemo1 {
    public static void main(String[] args) {
        /*
            需求：利用 TreeSet 存储整数并排序
        */

        TreeSet<Integer> ts = new TreeSet<>();
        ts.add(1);
        ts.add(3);
        ts.add(5);
        ts.add(2);
        ts.add(4);
        ts.add(6);

        System.out.println(ts);

        // 迭代器遍历
        System.out.println("迭代器遍历：");
        Iterator<Integer> it = ts.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }

        // 增强for遍历
        System.out.println("增强for遍历：");
        for (Integer t : ts) {
            System.out.println(t);
        }

        // forEach遍历
        System.out.println("forEach遍历：");
        ts.forEach(v -> {
            System.out.println(v);
        });
    }
}

flowchart TD    Map[Map]    Map --> HashMap[HashMap]    Map --> Hashtable[Hashtable]    Hashtable --> Properties[Properties]    HashMap --> LinkedHashMap[LinkedHashMap]    Map --> TreeMap[TreeMap]

import java.util.HashMap;
import java.util.Map;

public class A01_MapDemo1 {
    public static void main(String[] args) {
        // 1. 创建Map集合的对象
        Map<String,String> m = new HashMap<>();

        // 2. 添加元素
        // 添加数据时，键不存在，则会把键值对添加到Map中，返回值为null
        // 添加数据时，键存在，则会覆盖原来的键值对，返回值为被覆盖的值
        m.put("张三","13岁");
        m.put("李四","14岁");
        m.put("王五","13岁");

        String val = m.put("张三","14岁");

        System.out.println(val);    // 13岁
        System.out.println(m);

        // 3. 删除元素
        String res = m.remove("张三");
        System.out.println(res);    // 14岁

        // 4. 清空集合
        // m.clear();

        // 5. 判断包含内容
        System.out.println(m);
        if (m.containsKey("张三")) {
            System.out.println("有一个叫张三的人");
        } else if (m.containsKey("李四")) {
            System.out.println("有一个叫李四的人");
        }

        if (m.containsValue("14岁")) {
            System.out.println("有一个14岁的人");
        }

        // 6. 判断集合是否为空
        // m.clear();
        if (m.isEmpty()) {
            System.out.println("集合为空");
        } else {
            System.out.println("集合不为空");
        }

        // 7. 查看集合的大小
        System.out.println("集合中元素的个数为：" + m.size());
    }
}

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class A02_MapDemo2 {
    public static void main(String[] args) {
        // 遍历Map集合
        Map<String, String> hs = new HashMap<>();
        hs.put("张三", "18");
        hs.put("李四", "13");
        hs.put("王五", "15");
        hs.put("赵六", "20");
        hs.put("路人甲", "17");
        hs.put("路人乙", "16");
        hs.put("路人丙", "21");
        hs.put("路人丁", "18");

        // 1. 通过键找值
        // 1.1 获取所有的键，把这些键放到一个单列集合中
        Set<String> keys = hs.keySet();

        // 1.2 遍历单列集合，得到每一个键
        for (String key : keys) {
            // 1.3 利用键获取对应的值
            System.out.println(key + "=" + hs.get(key));
        }
    }
}

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class A03_MapDemo3 {
    public static void main(String[] args) {
        // 遍历Map集合
        Map<String, String> hs = new HashMap<>();
        hs.put("张三", "18");
        hs.put("李四", "13");
        hs.put("王五", "15");
        hs.put("赵六", "20");
        hs.put("路人甲", "17");
        hs.put("路人乙", "16");
        hs.put("路人丙", "21");
        hs.put("路人丁", "18");

        // 1. 通过键值对对象进行遍历
        // 1.1 通过entrySet()方法，获取所有的键值对对象，方法会返回一个Set集合,Set集合中存放的是键值对对象
        Set<Map.Entry<String, String>> entries = hs.entrySet();

        // 1.2 遍历entries集合，获取每一个键值对对象
        for (Map.Entry<String, String> entry : entries) {
            // System.out.println(entry);   // 直接打印
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "=" + value);
        }

    }
}

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;

public class A04_MapDemo4 {
    public static void main(String[] args) {
        // 遍历Map集合
        Map<String, String> hs = new HashMap<>();
        hs.put("张三", "18");
        hs.put("李四", "13");
        hs.put("王五", "15");
        hs.put("赵六", "20");
        hs.put("路人甲", "17");
        hs.put("路人乙", "16");
        hs.put("路人丙", "21");
        hs.put("路人丁", "18");

        // 1. 利用lambda遍历
        /*
        * hs.forEach(new BiConsumer<String, String>() {
        *     @Override
        *     public void accept(String key, String value) {
        *         System.out.println(key + "=" + value);
        *     }
        * });
        */

        hs.forEach((key,value) -> {
            System.out.println(key + "=" + value);
        });
    }
}

public class A07_GenericsDemo1 {
    public static void main(String[] args) {
        // 当集合没有指定数据类型时，默认所有的元素都是Object
        // 此时可以往集合添加任意的数据类型
        // 带来一个坏处：我们在获取数据的时候，无法使用他的特有行为
        ArrayList list = new ArrayList();
        list.add(123);
        list.add("abc");
        list.add(new Student(18,"张三"));

    }
}

class Student{
    public int age;
    public String name;

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

修饰符 class 类名<类型> {

}

public class ArrayList<E> {

}

import java.util.Arrays;

public class A08_GenericsDemo2 {
    public static void main(String[] args) {
        MyArrayList<Integer> list = new MyArrayList<>();

        list.add(111);
        list.add(222);
        list.add(333);

        System.out.println(list.get(0));
        System.out.println(list.get(1));
        System.out.println(list.get(2));

        System.out.println("-------------");
        System.out.println(list.toString());
    }
}

class MyArrayList<E> {
    Object[] obj = new Object[10];
    int size;

    /*
    E : 表示不确定的类型
    e : 表示形参名，变量名
    */
    public boolean add(E e) {
        obj[size] = e;
        size++;
        return true;
    }

    public E get(int index) {
        return (E)obj[index];
    }

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

class MyArrayList<E> {
    public boolean add(E e) {
        obj[size] = e;
        size++;
        return true;
    }
}

public <E> boolean add(E e) {    obj[size] = e;    size++;    return true;}

修饰符 <类型> 返回值类型 方法名(类型 变量名) {

}

修饰符 interface 接口名<类型> {

}

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class A09_GenericsDemo3 {
    public static void main(String[] args) {
        MyArrayList2 list = new MyArrayList2();
        list.add("abc");
        // list.add(123); // 报错，因为添加的是整数类型，而该对象只能添加字符串类型
    }
}

class MyArrayList2 implements List<String> {

    @Override
    public int size() {
        return 0;
    }

    @Override
    public boolean isEmpty() {
        return false;
    }

    @Override
    public boolean contains(Object o) {
        return false;
    }

    @Override
    public Iterator<String> iterator() {
        return null;
    }

    @Override
    public Object[] toArray() {
        return new Object[0];
    }

    @Override
    public <T> T[] toArray(T[] a) {
        return null;
    }

    @Override
    public boolean add(String s) {
        return false;
    }

    @Override
    public boolean remove(Object o) {
        return false;
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean addAll(Collection<? extends String> c) {
        return false;
    }

    @Override
    public boolean addAll(int index, Collection<? extends String> c) {
        return false;
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        return false;
    }

    @Override
    public void clear() {

    }

    @Override
    public String get(int index) {
        return null;
    }

    @Override
    public String set(int index, String element) {
        return null;
    }

    @Override
    public void add(int index, String element) {

    }

    @Override
    public String remove(int index) {
        return null;
    }

    @Override
    public int indexOf(Object o) {
        return 0;
    }

    @Override
    public int lastIndexOf(Object o) {
        return 0;
    }

    @Override
    public ListIterator<String> listIterator() {
        return null;
    }

    @Override
    public ListIterator<String> listIterator(int index) {
        return null;
    }

    @Override
    public List<String> subList(int fromIndex, int toIndex) {
        return null;
    }
}

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class A10_GenericsDemo4 {
    public static void main(String[] args) {
        MyArrayList3<Integer> list = new MyArrayList3<>();
        list.add(123);

        MyArrayList<String> slist = new MyArrayList<>();
        slist.add("abc");
    }
}

class MyArrayList3<E> implements List<E> {

    @Override
    public int size() {
        return 0;
    }

    @Override
    public boolean isEmpty() {
        return false;
    }

    @Override
    public boolean contains(Object o) {
        return false;
    }

    @Override
    public Iterator<E> iterator() {
        return null;
    }

    @Override
    public Object[] toArray() {
        return new Object[0];
    }

    @Override
    public <T> T[] toArray(T[] a) {
        return null;
    }

    @Override
    public boolean add(E e) {
        return false;
    }

    @Override
    public boolean remove(Object o) {
        return false;
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        return false;
    }

    @Override
    public boolean addAll(int index, Collection<? extends E> c) {
        return false;
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        return false;
    }

    @Override
    public void clear() {

    }

    @Override
    public E get(int index) {
        return null;
    }

    @Override
    public E set(int index, E element) {
        return null;
    }

    @Override
    public void add(int index, E element) {

    }

    @Override
    public E remove(int index) {
        return null;
    }

    @Override
    public int indexOf(Object o) {
        return 0;
    }

    @Override
    public int lastIndexOf(Object o) {
        return 0;
    }

    @Override
    public ListIterator<E> listIterator() {
        return null;
    }

    @Override
    public ListIterator<E> listIterator(int index) {
        return null;
    }

    @Override
    public List<E> subList(int fromIndex, int toIndex) {
        return null;
    }
}

import java.util.ArrayList;

public class A11_GenericsDemo5{
    public static void main(String[] args) {
        // 泛型不具备继承性，但是数据具备继承性
        ArrayList<Fu> list1 = new ArrayList<>();
        ArrayList<Zi> list2 = new ArrayList<>();

        // method(list1); // 集合的数据类型为Fu，所以调用method方法时，和形参的数据类型匹配，不会报错
        // method(list2); // 集合的数据类型为Zi，所以调用method方法时，和形参的数据类型不匹配，会报错

        // 数据可以具备继承性
        list1.add(new Fu());
        list1.add(new Zi());
    }

    public static void method(ArrayList<Fu> list) {

    }
}

class Fu{};

class Zi extends Fu{};

public static <E> void method(ArrayList<E> list) {

}

import java.util.ArrayList;

public class A12_GenericsDemo6{
    public static void main(String[] args) {
        // 泛型不具备继承性，但是数据具备继承性
        ArrayList<Fu> list1 = new ArrayList<>();
        ArrayList<Zi> list2 = new ArrayList<>();

        method(list1);
        method(list2);
    }

    public static void method(ArrayList<? extends Fu> list) {

    }
}

class Fu{};

class Zi extends Fu{};

int...args

public class ArgsDemo1 {
    public static void main(String[] args) {
        // 创建一个方法，可以计算两个数的和
        // 创建一个方法，可以计算三个数的和
        // 创建一个方法，可以计算四个数的和
        // 创建一个方法，可以计算n个数的和

        // 第一种：
        // 此时如果要计算n个数的和，就需要有n个参数的方法
        System.out.println(getSum(10,20));
        System.out.println(getSum(10,20,30));
        System.out.println(getSum(10,20,30,40));
    }
    public static int getSum(int a,int b) {
        return a + b;
    }

    public static int getSum(int a,int b,int c) {
        return a + b + c;
    }

    public static int getSum(int a,int b,int c,int d) {
        return a + b + c + d;
    }
}

public class ArgsDemo2 {
    public static void main(String[] args) {
        // 创建一个方法，可以计算两个数的和
        // 创建一个方法，可以计算三个数的和
        // 创建一个方法，可以计算四个数的和
        // 创建一个方法，可以计算n个数的和

        // 第二种：
        // 虽然这种方法可以计算n个数的和，但是使用起来相对复杂
        int[] arr = {10,20,30,40,50};
        int sum = getSum(arr);
        System.out.println(sum);
    }
    public static int getSum(int[] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }
}

public class ArgsDemo3 {
    public static void main(String[] args) {
        // 创建一个方法，可以计算两个数的和
        // 创建一个方法，可以计算三个数的和
        // 创建一个方法，可以计算四个数的和
        // 创建一个方法，可以计算n个数的和

        // 从JDK5开始，有了可变参数
        // 可变参数：方法形参的个数是个发生变化的
        // 格式：属性类型...形参名
        // int...args

        System.out.println(getSum(10,20,30,40,50));
    }

    // 底层：
    // 可变参数底层就是一个数组
    // 只不过不需要使用者自己创建
    public static int getSum(int...args) {
        int sum = 0;
        for (int i = 0; i < args.length; i++) {
            sum += args[i];
        }
        return sum;
    }
}

public class StreamDemo3 {
    public static void main(String[] args) {
        // 1. 单列集合获取stream流
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"a","b","c","d","e");
        list.stream().forEach(s -> System.out.println(s));

        // 2. 双列集合
        HashMap<String,Integer> hm = new HashMap<>();
        hm.put("aaa",111);
        hm.put("bbb",222);
        hm.put("ccc",333);
        hm.put("ddd",444);

        // 第一种： ketSet方法获取stream流
        hm.keySet().stream().forEach(s -> System.out.println(s + "=" + hm.get(s)));

        // 第二种：entrySet方法获取stream流
        hm.entrySet().stream().forEach(s-> System.out.println(s));

        // 3. 数组获取Stream流
        int[] arr1 = {1,2,3,4,5,6};
        String[] arr2 = {"abc","bcd","a","b","c"};
        Arrays.stream(arr1).forEach(s -> System.out.println(s));
        Arrays.stream(arr2).forEach(s -> System.out.println(s));

        // 4. 零散数据
        Stream.of("a","b",3,4,5).forEach(s -> System.out.println(s));
    }
}

public class StreamDemo5 {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();
        Collections.addAll(list1,"bob-15","alan-20","john-10","bob-15","bob-15","alan-20");
        Collections.addAll(list2,"aaa","bbb","aaa","ccc","ddd","eee");

        // distinct 去重
        // list1.stream().distinct().forEach(s -> System.out.println(s));

        // concat 合并流
        // Stream.concat(list1.stream(),list2.stream()).forEach(s -> System.out.println(s));

        // map 转换流中的数据类型
        // s 表示转换后的数据
        /*
        list1.stream().map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                // 获取字符串中的数字
                String[] arr = s.split("-");
                String ageString = arr[1];
                int age = Integer.parseInt(ageString);
                return age;
            }
        }).forEach(s -> System.out.println(s));
        **/

        list1.stream().map(s -> Integer.parseInt(s.split("-")[1])).forEach(s -> System.out.println(s));
    }
}

public class StreamDemo6 {
    public static void main(String[] args) {
        // 遍历
        Stream.of("1","2","3","4","5","6","7").forEach(s -> System.out.println(s));

        // 统计
        long count = Stream.of("1", "2", "3", "4", "5", "6", "7").count();
        System.out.println("count:" + count);

        // toArray：创造一个指定类型的数组
        // 第一种使用方法：
        Object[] objects = Stream.of("1", "2", "3", "4", "5", "6", "7").toArray();
        System.out.println(Arrays.toString(objects));

        // 第二种使用方法：
        String[] str = Stream.of("1", "2", "3", "4", "5", "6", "7").toArray(new IntFunction<String[]>() {
            @Override
            public String[] apply(int value) {
                return new String[value];
            }
        });

        System.out.println(Arrays.toString(str));

        // 第三种使用方法：
        String[] strings = Stream.of("1", "2", "3", "4", "5", "6", "7").toArray(value -> new String[value]);
        System.out.println(Arrays.toString(strings));
    }
}

public class StreamDemo7 {
    public static void main(String[] args) {
        // collect：收集流中的数据，放到集合中（List、Set、Map）
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张三-男-15","李四-男-14","王五-男-16","王若男-女-14","赵丽-女-15","张强-男-14","刘莉莉-女-13","陈念-男-15","龚月月-女-14");

        // 收集到List集合当中
        // 需求：
        // 把所有的男性收集起来
        List<String> newlist = list.stream().filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toList());
        System.out.println(newlist);

        // 收集到Set集合当中
        // 需求：
        // 把所有的男性收集起来
        Set<String> newset = list.stream().filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toSet());
        System.out.println(newset);

        // 收集Map集合当中
        // 需求：
        // 键：名字，值：年龄
        // toMap方法中有两个参数，都是方法接口
        // 第一个参数是键的值，方法中泛型的第一个类型是流里的数据类型，第二个类型是Map集合键的数据类型
        // 第二个参数是值的值，用法和第一个一样
        list.stream().filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toMap(s -> s.split("-")[0],s -> s.split("-")[2])).entrySet().stream().forEach(s -> System.out.println(s));
    }
}

Arrays,sort(arr,new Comparator<Integer>() {
@override
public int compare(Integer o1,Integer o2) {
return o1 - o2;
}
})

public int subtraction(int n1,int n2) {
return n1 - n2;
}

Arrays.sort(arr,FunctionDemo::subtraction);
// FunctionDemo::subtraction：表示在FunctionDemo中有一个方法叫subtraction

Integer::parseInt

public class FunctionDemo1 {
    public static void main(String[] args) {
        // 集合中有以下数字，要求把它们都变成int类型
        // "1","2","3","4","5"

        // 1. 创建集合
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"1","2","3","4","5");

        /*list.stream().map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                int num = Integer.parseInt(s);
                return num;
            }
        }).forEach(s -> System.out.println(s));*/

        list.stream().map(Integer::parseInt).forEach(System.out::println);

    }
}

flowchart TD    top[Java.lang.Throwable]    top --> midleft[Error]    top --> midright[Exception]    midright --> bottomleft[RuntimeException]    midright --> bottomright[其他异常]    bottomleft --> other["。。。"]

flowchart TD    top[Java文件]    top -- Javac命令 --> mid[字节码文件]    mid -- Java命令 --> bottom[运行结果]

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ExceptionDemo1 {
    public static void main(String[] args) throws ParseException {
        // 编译时异常（在编译阶段，必须要手动处理，否则代码报错）
        /*String time = "2030年1月1日";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
        Date date = sdf.parse(time);
        System.out.println(date);*/

        // 运行时异常
        int[] arr = {1,2,3,4,5};
        System.out.println(arr[10]); // ArrayIndexOutOfBoundsException
    }
}

public class ExceptionDemo2 {
    public static void main(String[] args){
        // 作用一：异常是用来查询bug的关键参考信息
        // 案例一：
        // Student[] students = new Student[3];
        // String name = students[0].getName();
        // System.out.println(name); // NullPointerException

        // 案例二：
        // Student zs = new Student("张三,23");
        // System.out.println(zs);

        // 作用二：异常可以作为方法内部的一种特殊返回值，以便通知调用者底层的执行情况
        // 年龄范围（18 - 40）
        Student s1 = new Student();
        s1.setAge(50);
    }
}

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

    public  Student() {};

    public  Student(String str) {
        String[] arr = str.split("-");
        this.name = arr[0];
        this.age = Integer.parseInt(arr[1]);
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age < 18 || age > 40) {
            throw new RuntimeException();
        } else {
            this.age = age;
        }
    }
}

try {
可能出现异常的代码;
} catch {
异常的处理代码
}

package myexception;

public class ExceptionDemo4 {
    public static void main(String[] args){
        /*自己处理（捕获异常）
        格式：
        try {
            可能出现异常的代码;
        } catch {
            异常的处理代码
        }*/

        int[] arr = {1,2,3,4,5};
        try{
            // 可能出现异常的代码
            System.out.println(arr[10]); 
            // 如果此处出现了异常，程序就会在这里创建一个ArrayIndexOutOfBoundsException对象
            // new ArrayIndexOutOfBoundsException();
            // 拿着这个对象到catch的小括号中对比，看括号中的变量是否可以接收这个对象
            // 如果能被接收，就表示该异常被捕获（抓住），执行catch里面的内容
        } catch(ArrayIndexOutOfBoundsException e) {
            // 如果出现了ArrayIndexOutOfBoundsException该如何处理
            System.out.println("索引越界了");
        }

        System.out.println("我会被执行");
    }
}

public class ExceptionDemo5 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};

        // 如果try中没有遇到问题，怎么执行？
        try{
            System.out.println(arr[0]); // 执行该行代码
        }catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("索引越界了");
        }

        System.out.println("我被执行了"); // 执行该行代码

    }
}

public class ExceptionDemo6 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};

        // 如果try中可能遇到多个问题，怎么执行？
        // 写多个catch与之对应
        // 细节：如果要捕获多个异常，如果这些异常存在父子关系的话，那么父类一定要写在下面
        // 在JDK之后，可以在catch中同时捕获多个异常，中间用 | 进行隔开
        /*try{
            System.out.println(arr[10]);
            System.out.println(2/0);
            String s = null;
            System.out.println(s.equals("abc"));
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("索引越界了");    // 执行改行代码
        } catch (ArithmeticException e) {
            System.out.println("除数不能为0");
        } catch (NullPointerException e) {
            System.out.println("空指针异常");
        } catch (Exception e) {
            System.out.println("Exception");
        }*/
        try{
            System.out.println(arr[10]);
            System.out.println(2/0);
            String s = null;
            System.out.println(s.equals("abc"));
        } catch (ArrayIndexOutOfBoundsException | ArithmeticException | NullPointerException e) {

        }

        System.out.println("我被执行了"); // 执行该行代码

    }
}

public class ExceptionDemo7 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        // 如果try中遇到的问题没有被捕获，怎么执行？
        // 如果try中遇到的问题没有捕获（没有匹配到异常），就相当于try...catch的代码白写了
        // 最终会交给虚拟机进行处理
        try{
            System.out.println(arr[10]);
        }catch (NullPointerException e) {
            System.out.println("空指针异常");
        }

        System.out.println("我不会被执行");
    }
}

public class ExceptionDemo8 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        // 如果try中遇到了问题，那么try下面的其他代码还会执行吗？
        try{
            System.out.println(arr[10]);
            System.out.println("我不会被执行");
        }catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("空指针异常");
        }

        System.out.println("我会被执行");
    }
}

package myexception;
public class ExceptionDemo9 {
    public static void main(String[] args) {
        /*| public String getMessage()    | 返回此throwable的详细消息字符串 |
          | public String toString()      | 返回此可抛出的简短描述          |
          | public void printStackTrace() | 把异常的错误信息输出在控制台    |*/

        int[] arr = {1,2,3,4,5};
        try {
            System.out.println(arr[10]);
        } catch (ArrayIndexOutOfBoundsException e) {
            // String message = e.getMessage();
            // System.out.println(message); // Index 10 out of bounds for length 5

            // String s = e.toString();
            // System.out.println(s);  // java.lang.ArrayIndexOutOfBoundsException: Index 10 out of bounds for length 5

            e.printStackTrace();    // 类似与JVM的默认处理方式（红色字体打印异常），但是不会结束虚拟机
        }

        System.out.println("我是否被执行了？");
    }
}

public void 方法()throws 异常类名1,异常类名2... {
...
}

public void 方法() {
throw new NullPointerException();
}

package myexception;
public class ExceptionDemo10 {
    public static void main(String[] args) {
        // 需求：定义一个方法求数组最大值
        int[] arr = null;
        int max = 0;
        try {
            max = getMax(arr);
        } catch (NullPointerException e) {
            System.out.println("空指针异常");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("数组超出索引");
        }
        System.out.println("我还是会打印");
    }

    public static int getMax(int[] arr)/* throws NullPointerException,ArrayIndexOutOfBoundsException `RuntimeException的子类` */ {
        if (arr == null) {
            // 手动创建一个异常对象，并把这个异常交给方法的调用者处理
            // 此时方法就会结束，下面的代码就不会再执行了
            throw new NullPointerException();
        }

        if (arr.length == 0) {
            throw new ArrayIndexOutOfBoundsException();
        }

        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
            }
        }
        return max;
    }
}

package myexception;

import java.util.InputMismatchException;
import java.util.Scanner;

public class ExceptionPractice2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        while (true) {
            try {
                System.out.println("请输入长度在3-10之间的姓名：");
                String name = sc.nextLine();
                if (name.length() < 3 || name.length() > 10) {
                    throw new NameFormatException(name + "格式有误，长度应为：3~10");
                }

                System.out.println("请输入18-40之间的年龄：");
                int age = sc.nextInt();
                sc.nextLine();  // 清除输入流中的换行符

                if (age < 18 || age > 40) {
                    throw new AgeFormatException(age + "格式有误，范围应为：18~40");
                }

                break;  // 如果姓名和年龄都合法，就跳出循环
            } catch (InputMismatchException e) {
                System.out.println("年龄异常，请输入一个整数");
                sc.nextLine();  // 清除输入流中的错误数据
            } catch (NameFormatException e) {
                e.printStackTrace();
                sc.nextLine();
            } catch (AgeFormatException e) {
                e.printStackTrace();
                sc.nextLine();
            }
        }
    }
}

package myexception;

import javax.naming.Name;

public class NameFormatException extends RuntimeException{
    // 技巧：
    // NameFormat：当前异常的名字，表示姓名格式化问题
    // Exception：表示当前类是一个异常类

    // 运行时：RuntimeException 核心 就表示由于参数错误而导致的
    // 编译时：Exception 核心 提醒程序员检查本地信息

    public NameFormatException() {};

    public NameFormatException(String message) {
        super(message);
    }
}

package myexception;

public class AgeFormatException extends RuntimeException{
    // 技巧：
    // NameFormat：当前异常的名字，表示姓名格式化问题
    // Exception：表示当前类是一个异常类

    // 运行时：RuntimeException 核心 就表示由于参数错误而导致的
    // 编译时：Exception 核心 提醒程序员检查本地信息

    public AgeFormatException() {};

    public AgeFormatException(String message) {
        super(message);
    }
}

import java.io.File;

public class FileDemo1 {
    public static void main(String[] args) {
        // 1. public File(String pathname)
        // 根据文件路径创建文件对象
        String str = "C:\\Users\\Zhao\\Desktop\\a.txt";
        File f1 = new File(str);
        System.out.println(f1); // C:\Users\Zhao\Desktop\a.txt

        // 2. public File(String parent,String child)
        // 父路径：C:\Users\Zhao\Desktop
        // 子路径：a.txt
        String parent = "C:\\Users\\Zhao\\Desktop";
        String child = "a.txt";
        File f2 = new File(parent,child);
        System.out.println(f2); // C:\Users\Zhao\Desktop\a.txt

        // 3. public File(File parent,String child)
        // 把一个File表示的路径和String表示的路径进行拼接
        File parent2 = new File("C:\\Users\\Zhao\\Desktop");
        String child2 = "a.txt";
        File f3 = new File(parent2,child);
        System.out.println(f3); // C:\Users\Zhao\Desktop\a.txt
    }
}

import java.io.File;

public class FileDemo2 {
    public static void main(String[] args) {
        /*
        | 方法名称                     | 说明                               |
        | ---------------------------- | ---------------------------------- |
        | public boolean isDirectory() | 判断此路径名表示的File是否为文件夹 |
        | public boolean isFile()      | 判断此路径名表示的File是否为文件   |
        | public boolean exists()      | 判断此路径名表示的File是否存在     |
        * */

        // 1. 对一个文件的路径进行判断
        File f1 = new File("E:\\data\\a.txt");
        System.out.println(f1.isDirectory());   // false
        System.out.println(f1.isFile());        // true
        System.out.println(f1.exists());        // true
        System.out.println("-------------");

        // 2. 对一个文件夹的路径进行判断
        File f2 = new File("E:\\data\\bbb");
        System.out.println(f2.isDirectory());   // true
        System.out.println(f2.isFile());        // false
        System.out.println(f2.exists());        // true
        System.out.println("-------------");

        // 3. 对一个不存在的路径进行判断
        File f3 = new File("E:\\data\\c.txt");
        System.out.println(f3.isDirectory());   // false
        System.out.println(f3.isFile());        // false
        System.out.println(f3.exists());        // false
        System.out.println("-------------");
    }
}

import java.io.File;

public class FileDemo3 {
    public static void main(String[] args) {
        /*
        | 方法名称                        | 说明                                 |
        | ------------------------------- | ------------------------------------ |
        | public long length()            | 返回文件的大小（字节数量）           |
        | public String getAbsolutePath() | 返回文件的绝对路径                   |
        | public String getPath()         | 返回定义文件时使用的路径             |
        | public String getName()         | 返回文件的名称，带后缀               |
        | public long lastModified()      | 返回文件的最后修改时间（时间毫秒值） |
        * */

        // 1. length 返回文件的大小（字节数量）
        // 无法获取文件夹的大小，只能获取文件的大小，单位：字节
        File f1 = new File("E:\\data\\a.txt");
        File f2 = new File("E:\\data\\bbb");
        long length1 = f1.length();
        long length2 = f2.length();
        System.out.println(length1);
        System.out.println(length2);

        // 2. getAbsolutePath 文件绝对路径
        File f3 = new File("a.txt");
        File absoluteFile1 = f1.getAbsoluteFile();
        File absoluteFile2 = f3.getAbsoluteFile();
        System.out.println(absoluteFile1);
        System.out.println(absoluteFile2);

        // 3. getPath
        String path1 = f1.getPath();
        String path2 = f3.getPath();
        System.out.println(path1);
        System.out.println(path2);

        // 4. getName
        // 如果路径是文件的路径，返回 文件名 + 后缀名
        // 如果路径是文件夹，返回文件夹名
        String name1 = f1.getName();
        String name2 = f3.getName();
        System.out.println(name1);
        System.out.println(name2);

        // 5. lastModified
        long l = f3.lastModified();
        System.out.println(l);
    }
}

import java.io.File;
import java.io.IOException;

public class FileDemo4 {
    public static void main(String[] args) throws IOException {
        /*
        | 方法名称                       | 说明                 |
        | ------------------------------ | -------------------- |
        | public boolean createNewFile() | 创建一个新的空的文件 |
        | public boolean mkdir()         | 创建单级文件夹       |
        | public boolean mkdirs()        | 创建多级文件夹       |
        | public boolean delete()        | 删除文件、空文件夹   |
        * */

        // 1. createNewFile
        // 当前路径表示的文件不存在，则创建成功，方法返回 true
        // 当前路径表示的文件存在，则创建失败，方法返回 false
        // 如果父级路径不存在，方法会有异常(IOException)
        // 该方法创建的一定是文件，如果路径中不包含后缀名，则创建一个没有后缀的文件
        File f1 = new File("E:\\test\\a.txt"); // 假设该文件不存在
        boolean newFile = f1.createNewFile();
        System.out.println(newFile); // true

        // 2. mkdir
        // windows当中路径是唯一的，如果当前路径已经存在，则创建失败，返回 false
        // 该方法只能创建单级文件夹，无法创建多级文件夹
        File f2 = new File("E:\\test\\aaa"); // 假设该文件夹不存在
        File f3 = new File("E:\\test\\bbb\\bbb\\bbb"); // 假设该文件夹不存在
        boolean mkdir1 = f2.mkdir();
        boolean mkdir2 = f3.mkdir();
        System.out.println(mkdir1); // true
        System.out.println(mkdir2); // false

        // 3. mkdirs
        // 既可以创建单级文件夹，也可以创建多级文件夹
        File f4 = new File("E:\\test\\bbb\\bbb\\bbb"); // 假设该文件夹不存在
        File f5 = new File("E:\\test\\ccc"); // 假设该文件夹不存在
        boolean mkdirs1 = f4.mkdirs();
        boolean mkdirs2 = f5.mkdirs();
        System.out.println(mkdirs1); // true
        System.out.println(mkdirs2); // true

        // 4. delete
        File f6 = new File("E:\\test\\a.txt"); // 存在
        File f7 = new File("E:\\test\\aaa"); // 空文件夹
        File f8 = new File("E:\\test\\bbb\\bbb\\bbb"); // 多级文件夹
        boolean delete1 = f6.delete();
        boolean delete2 = f7.delete();
        boolean delete3 = f8.delete();
        System.out.println(delete1); // true
        System.out.println(delete2); // true
        System.out.println(delete3); // false
    }
}

package myFile;

import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.util.Arrays;

public class FileDemo5 {
    public static void main(String[] args) throws IOException {
        /*
        | 方法名称                                       | 说明                                     |
        | ---------------------------------------------- | ---------------------------------------- |
        | public static File[] listRoots()               | 列出可用的文件系统根                     |
        | public String[] list()                         | 获取当前该路径下所有内容                 |
        | public String[] list(FilenameFilter filter)    | 利用文件名过滤器获取当前该路径下所有内容 |
        | public File[] listFiles()                      | 获取当前该路径下所有内容                 |
        | public File[] listFiles(FileFilter filter)     | 利用文件名过滤器获取当前该路径下所有内容 |
        | public File[] listFiles(FilenameFilter filter) | 利用文件名过滤器获取当前该路径下所有内容 |
        * */

        // 1. listFiles 获取指定路径下所有文件和文件夹的路径
        File f1 = new File("E:\\");

        File[] files = f1.listFiles();
        for (File file : files) {
            System.out.println(file);
        }

        // 2. listRoots
        File[] filesRoots = File.listRoots();
        System.out.println(Arrays.toString(filesRoots)); // [C:\, E:\]，表示系统存在C盘和E盘

        // 3. list 获取指定路径下所有内容（仅能获取名字）
        File f2 = new File("E:\\");
        String[] list = f2.list();
        for (String s : list) {
            System.out.println(s);
        }

        // 4. list(FilenameFilter filter) 利用文件名过滤器获取当前该路径下所有内容
        // 获取 E:\\data 文件夹里面所有 txt 文件
        // accept方法的形参，依次表示aaa文件夹里面每一个文件或者文件夹的路径
        // 参数一：父级路径
        // 参数二：子级路径
        // 如果返回值为true，就表示当前路径保留
        // 如果返回值为false，就表示当前路径舍弃
        File f3 = new File("E:\\data");
        String[] list1 = f3.list(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                File src = new File(dir, name);
                return src.isFile() && name.endsWith(".txt");
            }
        });
        System.out.println(Arrays.toString(list1));
    }
}

flowchart TD    top[IO流]    top --> mid1[输入流]    top --> mid2[输出流]    mid1 --> bottom1[读取]    mid2 --> bottom2[写出]

flowchart TD    top[IO流]    top --> mid1[字节流]    top --> mid2[字符流]    mid1 --> bottom1[所有类型的文件]    mid2 --> bottom2[纯文本文件]

flowchart TD    top[IO流体系]    top --> midleft[字节流]    top --> midright[字符流]    midleft --> bottom1left[InputStream--字节输入流]    midleft --> bottom1right[OutputStream--字节输出流]    midright --> bottom2left[Reader--字节输入流]    midright --> bottom2right[Writer--字符输出流]

// 细节1：参数是字符串表示的路径或者是File对象都是可以的
// 细节2：如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的
// 细节3：如果文件已经存在，则会清空文件（覆盖）
FileOutputStream fos = new FileOutputStream("a.txt");

// 细节：write方法的参数是整数，但是实际上写到本地文件的是整数在ASCII上对应的字符
fos.write(97);

// 每次使用完流之后都要释放资源
fos.close();

import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo2 {
    public static void main(String[] args) throws IOException {
        /*
        | 方法名称                             | 说明                         |
        | ------------------------------------ | ---------------------------- |
        | void write(int b)                    | 一次写一个字节数据           |
        | void write(byte[] b)                 | 一次写一个字节数组数据       |
        | void write(byte[] b,int off,int len) | 一次写一个字节数组的部分数据 |*/
        // 1.创建对象
        FileOutputStream fos = new FileOutputStream("a.txt");

        // 2. 写出数据
        fos.write(97); // a
        fos.write(98); // b

        byte[] bytes = {97,98,99,100,101}; // abcde
        fos.write(bytes);

        fos.write(bytes,1,3); // 索引 1~3，即 98、99、100
        // 3. 释放资源
        fos.close();

    }
}

import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo3 {
    public static void main(String[] args) throws IOException {
        /*
        * 换行写：
        * 再次写出一个换行符就可以了
        *   windows：\r\n
        *   linux:   \n
        *   max:     \r
        * 细节：在windows操作系统中，java对回车换行进行了优化
        *      虽然完整的是 \r\n ，但是只需要写其中一个 \r 或者 \n，
        *      java也可以实现换行，因为java会在底层补全。
        *      但是还是建议写全
        *
        * 续写：
        * 如果想要续写，打开续写开关即可
        * 开关位置：创建对象的第二个参数
        * 默认false，表示关闭续写，此时创建对象会清空文件
        * 手动传递true，表示打开续写，此时创建对象不会清空文件
        * */

        // 1. 创建对象
        FileOutputStream fos = new FileOutputStream("a.txt",true);

        // 2. 写出数据
        String str = "zheshiyiduanceshiwenzi";
        byte[] bytes = str.getBytes();
        fos.write(bytes);

        // 写出一个换行符就可以实现换行效果
        String warp = "\r\n";
        byte[] warpbytes = warp.getBytes();
        fos.write(warpbytes);

        String str2 = "huanhang";
        fos.write(str2.getBytes());
        // 3. 释放资源
        fos.close();
    }
}

package mybytestream;

import java.io.FileInputStream;
import java.io.IOException;

public class ByteStreamDemo4 {
    public static void main(String[] args) throws IOException {
        /*
        * 操作本地文件的字节输入流，可以把本地文件中的数据读取到程序中来
        * 书写步骤
        *    1. 创建字节输入流对象
        *       细节1：如果文件不存在，就直接报错
        *       这和字节输出流不一样，输出流遇到不存在的文件，会自动创建
        *
        *    2. 读数据
        *       细节2：一次读一个字节，读出来的是数据在ASCII上对应的数字
        *       细节3：读到文件末尾了，read方法返回-1
        *
        *    3. 释放资源
        **/

        // 1. 创建对象
        FileInputStream fis = new FileInputStream("b.txt");

        // 2. 读取数据
        int b1 = fis.read();    // 一次只能读取一个字节
        System.out.println(b1 + ":" + (char)b1);

        int b2 = fis.read();    // 一次只能读取一个字节
        System.out.println(b2 + ":" + (char)b2);

        int b3 = fis.read();    // 一次只能读取一个字节
        System.out.println(b3 + ":" + (char)b3);

        int b4 = fis.read();    // 一次只能读取一个字节
        System.out.println(b4 + ":" + (char)b4);

        int b5 = fis.read();    // 一次只能读取一个字节
        System.out.println(b5 + ":" + (char)b5);

        int b6 = fis.read();    // 读取不到数据了，结果为 -1
        System.out.println(b6);

        // 3. 释放资源
        fis.close();
    }
}

package mybytestream;

import java.io.FileInputStream;
import java.io.IOException;

public class ByteStreamDemo5 {
    public static void main(String[] args) throws IOException {
        // 字节输入流循环读取

        // 1. 创建对象
        FileInputStream fis = new FileInputStream("b.txt");

        // 2. 循环读取
        int b;
        while ((b = fis.read()) != -1) {
            System.out.println((char)b);
        }

        // 3. 释放资源
        fis.close();
    }
}

// 如果写成这种形式，read方法在循环中会执行两次，导致结果错误
while ((fis.read()) != -1) {
System.out.println((fis.read());
}

package mybytestream;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo6 {
    public static void main(String[] args) throws IOException {
        // 拷贝文件

        // 1. 创建对象
        FileInputStream fis = new FileInputStream("E:\\copy\\1.jpg");
        FileOutputStream fos = new FileOutputStream("E:\\copy\\bak.jpg");

        // 2. 拷贝
        // 核心思想：边读边写
        int b;
        while ((b = fis.read()) != -1) {
            fos.write(b);
        }

        // 3. 释放资源
        // 规则：先开的最后关闭
        fos.close();
        fis.close();
    }
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Date;

public class ByteStreamDemo7 {
    public static void main(String[] args) throws IOException {
        // public int read(byte[] buffer) 一次读一个字节数组数据

        // 1. 创建对象
        FileInputStream fis = new FileInputStream("E:\\copy\\1.jpg");
        FileOutputStream fos = new FileOutputStream("E:\\copy\\bak.jpg");

        // 2. 拷贝
        /*
        // 一次读一个字节数据;
        long timeBefore = System.currentTimeMillis();
        int b;
        while ((b = fis.read()) != -1) {
            fos.write(b);
        }
        long timeAfter = System.currentTimeMillis();
        System.out.println("拷贝文件花费了" + (timeAfter - timeBefore));   // 78
        **/

        // 一次读一个字节数组数据
        long timeBefore = System.currentTimeMillis();
        byte[] bytes = new byte[1024 * 1024 * 5];
        int len;    // 这个变量用于记录读取到了几个数据
        while ((len = fis.read(bytes)) != -1) {
            fos.write(bytes,0,len);
        }
        long timeAfter = System.currentTimeMillis();
        System.out.println("拷贝文件花费了" + (timeAfter - timeBefore));   // 9
        // 3. 释放资源
        // 规则：先开的最后关闭
        fos.close();
        fis.close();
    }
}

try {
...
} catch() {
...
} finally {
...
}

try{
FileOutputStream fos = new FileOutputStream("a.txt")'
fos.write(97);
} catch (IOException e) {
e.printStackTrace();
} finally {
fos.close();
}

package mybytestream;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo8 {
    public static void main(String[] args){
        // 1. 创建对象
        FileInputStream fis = null;
        FileOutputStream fos = null;

        try {
            fis = new FileInputStream("E:\\copy\\1.jpg");
            fos = new FileOutputStream("E:\\copy\\bak.jpg");

            // 2. 拷贝
            byte[] bytes = new byte[1024 * 1024 * 5];
            int len;
            while ((len = fis.read(bytes)) != -1) {
                fos.write(bytes,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3. 释放资源
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

try(创建流对象1,创建流对象2) {
可能出现异常的代码;
} catch(异常类名 变量名) {
异常的处理代码;
}

创建流对象1;
创建流对象2;

try(流1,流2) {
可能出现异常的代码;
} catch(异常类名 变量名) {
异常的处理代码;
}

flowchart TD    id1["a[要查询的英文]"]    id1 --查询ASCII--> id2["97(110 0001)[对应的数字]"]    id2 --编码--> id3["0110 0001"]    id3 --解码--> id4[97]    id4 --查询ASCII--> id5["a[读取到的英文]"]

flowchart TD    id1["a[要查询的英文]"]    id1 --查询GBK--> id2["97(110 0001)[对应的数字]"]    id2 --编码--> id3["0110 0001"]    id3 --解码--> id4[97]    id4 --查询GBK--> id5["a[读取到的英文]"]

flowchart TD    id1["汉[要查询的汉字]"]    id1 --查询GBK--> id2["47802(10111010 10111010)[对应的数字]"]    id2 --编码--> id3["10111010 10111010"]    id3 --解码--> id4[47802]    id4 --查询GBK--> id5["汉[读取到的汉字]"]

flowchart TD    id1["a[要查询的英文]"]    id1 --查询Unicode--> id2["97[对应的数字]"]    id2 --编码--> id3["00000000 01100001"]    id3 --解码--> id4[97]    id4 --查询Unicode--> id5["a[读取到的英文]"]

flowchart TD    id1["汉[要查询的中文]"]    id1 --查询Unicode--> id2["27721(01101100 01001001)[对应的数字]"]    id2 --编码--> id3["11100110 10110001 10001001"]

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class charsetDemo1 {
    public static void main(String[] args) throws UnsupportedEncodingException {
        /*
        * Java编码方法
        * | String类中的方法                           | 说明                 |
        * | ------------------------------------------ | -------------------- |
        * | public byte[] getBytes()                   | 使用默认方式进行编码 |
        * | public byte[] getBytes(String charsetName) | 使用指定方式进行编码 |
        *
        * Java解码方法
        * | String类中的方法                        | 说明                 |
        * | --------------------------------------- | -------------------- |
        * | String(byte[] bytes)                    | 使用默认方式进行解码 |
        * | String(byte[] bytes,String charsetName) | 使用指定方式进行解码 |
        * */

        // 1. 编码
        // 默认方式
        String str = "Hello世界";
        byte[] bytes1 = str.getBytes();
        System.out.println(Arrays.toString(bytes1));

        // 指定编码方式
        byte[] bytes2 = str.getBytes("GBK");
        System.out.println(Arrays.toString(bytes2));

        // 2. 解码
        String str2 = new String(bytes1);
        System.out.println(str2);
        String str3 = new String(bytes2);   // 如果使用默认解码方式，会有乱码，因为编码时采用的是GBK
        System.out.println(str3);
        String str4 = new String(bytes2,"GBK");
        System.out.println(str4);
    }
}

import java.io.FileReader;
import java.io.IOException;

public class CharStreamDemo1 {
    public static void main(String[] args) throws IOException {
        // 1. 创建对象
        FileReader fr = new FileReader("c.txt");

        // 2. 读取数据
        int ch;
        while ((ch = fr.read()) != -1) {
            System.out.print((char)ch);
        }

        // 3. 释放资源
        fr.close();
    }
}

import java.io.FileReader;
import java.io.IOException;

public class CharStreamDemo2 {
    public static void main(String[] args) throws IOException {
        // 1. 创建对象
        FileReader fr = new FileReader("c.txt");

        // 2. 读取数据
        char[] chars = new char[2];
        int len;
        while ((len = fr.read(chars)) != -1) {
            System.out.println(new String(chars,0,len));
        }

        // 3. 释放资源
        fr.close();
    }
}

import java.io.FileWriter;
import java.io.IOException;

public class CharStreamDemo3 {
    public static void main(String[] args) throws IOException {
        // 1. 创建对象
        FileWriter fw = new FileWriter("d.txt");

        // 2. 写出数据
        // fw.write(25105);
        fw.write("我是写出的数据");

        fw.write("\r\n");

        char[] chars = {'h','i','张','三'};
        fw.write(chars);

        // 3. 释放资源
        fw.close();
    }
}

           3. 缓冲区有数据：就从缓冲区中读取

import java.io.*;

public class BufferedStreamDemo1 {
    public static void main(String[] args) throws IOException {
        // 利用字节缓冲流拷贝文件
        // 一次读写一个字节

        // 1. 创建缓冲流的对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("test.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.txt"));

        // 2. 循环读取并写到目的地
        int b;
        while ((b = bis.read()) != -1) {
            bos.write(b);
        }

        // 3. 释放资源
        bos.close();
        bis.close();
    }
}

import java.io.*;

public class BufferedStreamDemo2 {
    public static void main(String[] args) throws IOException {
        // 利用字节缓冲流拷贝文件
        // 一次读写多个字节

        // 1. 创建缓冲流的对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("test.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.txt"));

        // 2. 循环读取并写到目的地
        byte[] bytes = new byte[1024];
        int len;
        while ((len = bis.read(bytes)) != -1) {
            bos.write(bytes,0,len);
        }

        // 3. 释放资源
        bos.close();
        bis.close();
    }
}

import java.io.*;

public class BufferedStreamDemo3 {
    public static void main(String[] args) throws IOException {
        // 字符缓冲输入流

        // 1. 创建字符缓冲输入流的对象
        BufferedReader br = new BufferedReader(new FileReader("test.txt"));

        // 2. 读取数据
        // 细节：
        // readLine方法在读取的时候，一次读一整行，遇到回车换行结束
        // 但是并不会把回车换行读到内存当中
        // String line = br.readLine();
        // System.out.println(line);

        // 读取所有文本内容
        String line;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }

        // 3. 释放资源
        br.close();
    }
}

import java.io.*;

public class BufferedStreamDemo4 {
    public static void main(String[] args) throws IOException {
        // 字符缓冲输出流

        // 1. 创建字符缓冲输入流的对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("e.txt"));

        // 2. 写出数据
        bw.write("这是一段写入缓冲区流的测试文字");
        bw.newLine();
        bw.write("这也是一段字符写入缓冲流的测试文字");

        // 3. 释放资源
        bw.close();

    }
}

import java.io.*;
import java.nio.charset.Charset;

public class ConvertStreamDemo1 {
    public static void main(String[] args) throws IOException {
        // 利用转换流按照指定字符编码读取
        // 该方法已经被JDK11淘汰了

        /*// 1. 创建对象并指定字符编码
        InputStreamReader isr = new InputStreamReader(new FileInputStream("gbkFile.txt"),"GBK");

        // 2. 读取数据
        int ch;
        while ((ch = isr.read()) != -1) {
            System.out.print((char) ch);
        }

        // 3. 释放资源
        isr.close();*/

        // 替代方案
        // 1. 创建对象
        FileReader fr = new FileReader("gbkFile.txt", Charset.forName("GBK"));

        // 2. 读取数据
        char[] chars = new char[1024];
        int len;
        while ((len = fr.read(chars)) != -1) {
            System.out.println(new String(chars,0,len));
        }

        // 3. 释放资源
        fr.close();
    }
}

import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.nio.charset.Charset;

public class ConvertStreamDemo2 {
    public static void main(String[] args) throws IOException {
        // 利用转换流按照指定字符编码写出
        // 以下方法同样也是被被淘汰了

        /*
        // 1. 创建转换流对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("OutPutGBKFile.txt"),"GBK");

        // 2. 写出数据
        osw.write("Hello，世界");

        // 3. 释放资源
        osw.close();*/

        // 替代方案
        // 1. 创建对象
        FileWriter fw = new FileWriter("OutPutGBKFile.txt", Charset.forName("GBK"));

        // 2. 写出数据
        fw.write("你好，世界");

        // 3. 释放资源
        fw.close();
    }
}

import java.io.*;

public class ConvertStreamDemo3 {
    public static void main(String[] args) throws IOException {
        // 将本地GBK文件转换为UTF-8

        // JDK11之前的方案
        // 1. 创建对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream("gbkFile.txt"),"GBK");
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("OldOutPutUTF.txt"),"UTF-8");

        // 2. 循环读取/写出
        int b;
        while ((b = isr.read()) != -1) {
            osw.write(b);
        }

        // 3. 释放资源
        osw.close();
        isr.close();

    }
}

import java.io.*;
import java.nio.charset.Charset;

public class ConvertStreamDemo4 {
    public static void main(String[] args) throws IOException {
        // 将本地GBK文件转换为UTF-8

        // JDK11之后的方案
        // 1. 创建对象
        FileReader fr = new FileReader("gbkFile.txt", Charset.forName("GBK"));
        FileWriter fw = new FileWriter("NewOutPutGBKFile.txt",Charset.forName("UTF-8"));

        // 2. 写出数据
        int b;
        while ((b = fr.read()) != -1) {
            fw.write(b);
        }

        // 3. 释放资源
        fw.close();
        fr.close();
    }
}

import java.io.*;
import java.nio.charset.Charset;

public class ConvertStreamDemo5 {
    public static void main(String[] args) throws IOException {
        // 利用字节流读取文件中的数据，每次读取一整行，而且不能出现乱码
        // 字节流在读取中文时，会出现乱码，这时需要字符流
        // 字节流里面是没有读取一整行的方法的，这时需要缓冲流

        // 1. 创建对象
        /*FileInputStream fis = new FileInputStream("gbkFile.txt");
        InputStreamReader isr = new InputStreamReader(fis,Charset.forName("GBK"));
        BufferedReader br = new BufferedReader(isr);*/

        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("gbkFile.txt"),"GBK"));

        String s;
        while ((s = br.readLine()) != null) {
            System.out.println(s);
        }

        // 3. 释放资源
        br.close();
    }
}

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class ObjectStreamDemo1 {
    public static void main(String[] args) throws IOException {
        // 需求：利用序列化流/对象操作输出流，把一个对象写到本地文件中

        // 1. 创建对象
        Student stu = new Student("张三",18,"男");

        // 2. 创建序列化流对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("zhangsan.txt"));

        // 3. 写出数据
        oos.writeObject(stu);

        // 4. 释放资源
        oos.close();
    }
}

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class ObjectStreamDemo2 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {

        // 1. 创建反序列化流
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("zhangsan.txt"));

        // 2. 读取数据
        Object o = ois.readObject();
        // 要打印对象值而不是地址值，需要在Javabean中重写toString方法
        System.out.println(o.toString());

        // 3. 释放资源
        ois.close();
    }
}

import java.io.Serializable;

/*
* Serializable接口里面是没有抽象方法的，所以也叫这种接口为标记型接口
* 一旦实现了这个接口，那么就表示当前的Student类可以被序列化
* */
public class Student implements Serializable {
    private String name;
    private int age;
    private String gender;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

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

import java.io.Serializable;

/*
* Serializable接口里面是没有抽象方法的，所以也叫这种接口为标记型接口
* 一旦实现了这个接口，那么就表示当前的Student类可以被序列化
* */
public class Student implements Serializable {
    private String name;
    private int age;
    private String gender;
    private String[] hobby;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String[] getHobby() {
        return hobby;
    }

    public void setHobby(String[] hobby) {
        this.hobby = hobby;
    }

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

private static final long serialVersionUID = 1L;

import mytest.Student;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class test1 {
    public static void main(String[] args) throws IOException {
        /*
        * 需求：将多个自定义对象序列化到文件中，但是对象的个数不确定
        * */

        // 1. 创建对象
        Student s1 = new Student("张三",18,"苏州");
        Student s2 = new Student("李四",19,"南京");
        Student s3 = new Student("王五",17,"无锡");

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("objectsFile.txt"));

        // 2. 序列化多个对象
        oos.writeObject(s1);
        oos.writeObject(s2);
        oos.writeObject(s3);

        // 3. 释放资源
        oos.close();
    }
}

import java.io.EOFException;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class test2 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 1. 创建反序列化流的对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("objectsFile.txt"));

        // 2. 读取数据
        // 执行一次方法返回一个对象
        try {
            while (true) {
                Object o = ois.readObject();
                System.out.println(o.toString());
            }
        } catch (EOFException e) {
            System.out.println("执行完毕");
        }

        // 3. 释放资源
        ois.close();
    }
}

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.io.UnsupportedEncodingException;

public class PrintStreamDemo1 {
    public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {
        // 1. 创建字节打印流对象
        PrintStream ps = new PrintStream(new FileOutputStream("PrintStreamFile1.txt"),true,"UTF-8");

        // 2. 写出数据
        ps.println(97);
        ps.print(true);
        ps.println();
        ps.printf("%s 一段 %s","这是","文字");

        // 3. 释放资源
        ps.close();
    }
}

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class PrintStreamDemo2 {
    public static void main(String[] args) throws IOException {
        // 1. 创建字符打印流对象
        PrintWriter pw = new PrintWriter(new FileWriter("PrintWriterFile.txt"),true);

        // 2. 写出数据
        pw.println("PrintWriter方法很好用");

        // 3. 释放资源
        pw.close();
    }
}

import java.io.PrintStream;

public class PrintStreamDemo3 {
    public static void main(String[] args) {
        /*
        * 打印流的应用场景
        * */

        // 获取打印流的对象，此打印流在虚拟机启动的时候，由虚拟机创建，默认指向控制台
        // 特殊的打印流，系统中的标准输出流，不能关闭，在系统中是唯一的（如果误关，需要重启虚拟机）
        PrintStream ps = System.out;

        // 调用打印流中的方法println
        ps.println("test");
    }
}

import java.io.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

public class ZipStreamDemo1 {
    public static void main(String[] args) throws IOException {
        // 1. 创建一个File表示要解压的压缩包
        File src = new File("E:\\test.zip");

        // 2. 创建一个File表示解压的目的地
        File dest = new File("C:\\Users\\Zhao\\Desktop");

        unzip(src,dest);
    }

    // 定义一个方法用来解压
    public static void unzip(File src,File dest) throws IOException {
        // 解压的本质：把压缩包里面的每一个文件或者文件夹读取出来，按照层级拷贝到目的地当中

        // 创建一个解压缩流用来读取压缩包中的数据
        ZipInputStream zip = new ZipInputStream(new FileInputStream(src));

        // 要先获取到压缩包里面的每一个zipEntry对象
        /*for (int i = 0; i < 100; i++) {
            ZipEntry entry = zip.getNextEntry();
            System.out.println(entry);  // 会遍历压缩包里的所有文件，遍历完所有后继续遍历会返回null
        }*/

        ZipEntry entry;
        while ((entry = zip.getNextEntry()) != null) {
            System.out.println(entry);
            if (entry.isDirectory()) {
                // 文件夹：需要在目的地dest处创建一个同样的文件夹
                File file = new File(dest,entry.toString());
                file.mkdirs();
            } else {
                // 文件：需要读取到压缩包中的文件，并把他存放到目的地dest文件夹中（按照层级目录进行存放）
                FileOutputStream fos = new FileOutputStream(new File(dest,entry.toString()));
                int b;
                while ((b = zip.read()) != -1) {
                    // 写到目的地
                    fos.write(b);
                }
                fos.close();
                zip.closeEntry();
            }
        }

        zip.close();
    }
}

import java.io.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class ZipStreamDemo2 {
    public static void main(String[] args) throws IOException {
        /*
        * 压缩流：
        *   需求：
        *       把E:\\test.txt打包成一个压缩包
        *
        * 该示例只支持单文件压缩
        * */

        // 1. 创建File对象表示要压缩的文件
        File src = new File("E:\\test.txt");

        // 2. 创建File对象表示压缩包的位置
        File dest = new File("C:\\Users\\Zhao\\Desktop");

        // 3. 调用方法用来压缩
        toZip(src,dest);
    }
    /*
    * 作用：
    * 参数一：表示要压缩的文件
    * 参数二：表示压缩包的位置
    * */
    public static void toZip(File src,File dest) throws IOException {
        // 1. 创建压缩流关联压缩包
        ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(new File(dest,"a.zip")));

        // 2. 创建ZipEntry对象，表示压缩包里面的每一个文件和文件夹
        ZipEntry entry = new ZipEntry("a.txt");

        // 3. 把ZipEntry对象放到压缩包当中
        zos.putNextEntry(entry);

        // 4. 把src中的数据写到压缩包中
        FileInputStream fis = new FileInputStream(src);
        int b;
        while ((b = fis.read()) != -1) {
            zos.write(b);
        }

        // 5. 释放资源
        zos.closeEntry();
        zos.close();
    }
}

import java.io.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class ZipStreamDemo3 {
    public static void main(String[] args) throws IOException {
        /*
        * 多文件压缩
        * */

        // 1. 创建File对象表示要压缩的文件夹
        File src = new File("E:\\ziptest");

        // 2. 创建File对象表示压缩包的父级路径
        File destParent = src.getParentFile();

        // 3. 创建File对象表示压缩包的路径
        File dest = new File(destParent,src.getName() + ".zip");

        // 4. 创建压缩流关联压缩包
        ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(dest));

        // 5. 获取src里面的每一个文件，变成ZipEntry对象，放入到压缩包当中
        toZip(src,zos, src.getName());

        // 6. 释放资源
        zos.close();
    }

    /*
    * 作用：获取src里面的每一个文件，变成ZipEntry对象，放入到压缩包当中
    * 参数一：数据源
    * 参数二：压缩流
    * 参数三：压缩包内部的路径
    * */
    public static void toZip(File src,ZipOutputStream zos,String name) throws IOException {
        // 1. 进入src文件夹
        File[] files = src.listFiles();

        // 2. 遍历数组
        for (File file : files) {
            if (file.isFile()) {
                // 3. 判断-文件，变成ZipEntry对象，放入到压缩包当中
                ZipEntry entry = new ZipEntry(name + "\\" + file.getName());
                zos.putNextEntry(entry);

                // 读取文件中的数据，写到压缩包
                FileInputStream fis = new FileInputStream(file);
                int b;
                while ((b = fis.read()) != -1) {
                    zos.write(b);
                }
                fis.close();
                zos.closeEntry();
            } else {
                // 4. 判断-文件夹，递归
                toZip(file,zos,name + "\\" + file.getName());
            }
        }
    }
}

public class MyThread extends Thread{
    @Override
    public void run() {
        // 1. 书写线程要执行代码
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "：Hello World!");
        }
    }
}

public class ThreadDemo1 {
    public static void main(String[] args) {
        /*
        * 多线程的第一种启动方式：
        *   1. 自己定义一个类继承Thread
        *   2. 重写run方法
        *   3. 创建子类对象，并启动线程
        * */

        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

        t1.setName("线程1");
        t2.setName("线程2");

        // 1. 开启线程
        t1.start();
        t2.start();
    }
}

package threadcase2;

public class MyRun implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            // 获取到当前线程的对象
            Thread thread = Thread.currentThread();
            System.out.println(thread.getName() +  "：Hello World!");
        }
    }
}

package threadcase2;

public class ThreadDemo1 {
    public static void main(String[] args) {
        /*
        * 多线程的第二种启动方式：
        *   1. 自己定义一个类实现Runnable接口
        *   2. 重写里面的run方法
        *   3. 创建自己的类的对象
        *   4. 创建一个Thread类的对象，并开启线程
        * */

        // 1. 创建自己的类的对象
        // 表示多线程要执行的任务
        MyRun mr = new MyRun();

        // 创建线程对象
        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);

        // 给线程设置名字
        t1.setName("线程1：");
        t2.setName("线程2：");

        // 开启线程
        t1.start();
        t2.start();
    }
}

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        // 求 1~100之间的和
        int sum = 0;

        for (int i = 0; i <= 100; i++) {
            sum += i;
        }

        return sum;
    }
}

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadDemo1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /*
        * 多线程的第三种实现方式：
        *   特点：可以获取到多线程运行的结果
        *
        *   1. 创建一个类MyCallable实现Callable接口
        *   2. 重写call方法（是有返回值的，表示多线程运行的结果）
        *   3. 创建MyCallable的对象（表示多线程要执行的任务）
        *   4. 创建FutureTask的对象（作用：管理多线程运行的结果）
        *   5. 创建Thread类的对象，并启动（表示线程）
        * */

        // 创建自己的类的对象
        MyCallable mc = new MyCallable();

        // 创建FutureTask的对象
        FutureTask<Integer> ft = new FutureTask<>(mc);

        // 创建线程的对象
        Thread t1 = new Thread(ft);

        // 启动线程
        t1.start();

        // 获取多线程的结果
        Integer res = ft.get();

        System.out.println(res);
    }
}

package threadmethod2;

public class ThreadDemo {
    public static void main(String[] args) {
        /*
         * setPriority(int newPriority)  设置线程优先级
         * final int getPriority()       获取线程优先级
         * */

        // 创建线程要执行的参数对象
        MyRunnable mr = new MyRunnable();

        // 创建线程对象
        Thread t1 = new Thread(mr,"Thread01");
        Thread t2 = new Thread(mr,"Thread02");

        System.out.println(t1.getPriority());   // 不设置的情况下，优先级默认为5
        System.out.println(t2.getPriority());   // 不设置的情况下，优先级默认为5

        t1.setPriority(1);
        t2.setPriority(10);

        t1.start();
        t2.start();

        /*
            虽然t2优先级比t1高，但是不代表执行的时候会先完全执行完t2再执行t1
            只不过t2优先执行的概率更高
        */
    }
}

flowchart LR    START["创建线程对象"] -- "start()" --> THEN1["有执行资格  
没有执行权"]    THEN1 -- 抢到CPU的执行权 --> THEN2["有执行资格  
有执行权"]    THEN2 -- 其他线程抢走CPU的执行权 --> THEN1    THEN2 --> THEN3["没有执行资格  
没有执行权"]    THEN3 -- sleep或者其他阻塞方法 --> THEN1    THEN2 --> END["线程死亡  
变成垃圾"]

package threadsafe1;

public class MyThread extends Thread{
    static int ticket = 0;

    @Override
    public void run() {
        while (true) {
            if (ticket < 100) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                ticket++;
                System.out.println(getName() + "正在卖第" + ticket + "张票");
            } else {
                break;
            }
        }
    }
}

synchronized(锁){
操作共享数据的代码
}

package threadsafe1;

public class MyThread extends Thread{
    static int ticket = 0;

    // 锁对象，一定要是唯一的
    static Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (obj) {
                if (ticket < 100) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    ticket++;
                    System.out.println(getName() + "正在卖第" + ticket + "张票");
                } else {
                    break;
                }
            }
        }
    }
}

修饰符synchronized 返回值类型 方法名(方法参数) {...}

package threadsafe3;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyThread extends Thread {
    static int ticket = 0;

    // 加上static，是防止该类的实现方法创建多个锁
    static Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            lock.lock();
            try {
                if (ticket < 100) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    ticket++;
                    System.out.println(getName() + "正在卖第" + ticket + "张票");
                } else {
                    break;
                }
            } catch (RuntimeException e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();
            }
        }
    }
}

package waitandnotify;

public class Creater extends Thread{
    @Override
    public void run() {
        /*
            生产者
        */

        /*
            1. 循环
            2. 同步代码块（后期可以改同步方法或lock锁）
            3. 判断共享数据是否到了末尾（是）
            4. 判断共享数据是否到了末尾（否）
        */

        while (true) {
            synchronized (Middle.lock) {
                if (Middle.count == 0) {
                    break;
                } else {
                    // 判断中间体状态
                    if (Middle.flag == 1) {
                        // 如果为1，表示停止生产，等待消费者消费
                        try {
                            Middle.lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    } else {
                        // 如果为0，表示需要生产者生产
                        System.out.println("生产者生产了一个物品");

                        // 修改中间体状态
                        Middle.flag = 1;

                        // 唤醒消费者
                        Middle.lock.notifyAll();
                    }
                }
            }
        }
    }
}

package waitandnotify;

public class User extends Thread{
    @Override
    public void run() {
        /*
            消费者
        */

        /*
            1. 循环
            2. 同步代码块（后期可以改同步方法或lock锁）
            3. 判断共享数据是否到了末尾（是）
            4. 判断共享数据是否到了末尾（否）
        */

        while (true) {
            synchronized (Middle.lock){
                if (Middle.count == 0) {
                    break;
                } else {
                    // 先判断中间体是否存放了生产者的生成物
                    if (Middle.flag == 0) {
                        // 如果没有，就等待
                        try {
                            Middle.lock.wait();// 让当前线程跟锁进行绑定
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    } else {
                        // 把消费的次数-1
                        Middle.count--;

                        // 如果有，就由消费者消费
                        System.out.println("消费者在消费，还能消费" + Middle.count + "次");

                        // 消费完后，唤醒生产者继续生产
                        Middle.lock.notifyAll();

                        // 修改中间体状态
                        Middle.flag = 0;
                    }
                }
            }
        }
    }
}

package waitandnotify;

public class Middle extends Thread{
    /*
        作用：控制生产者和消费者的执行
    * */

    // 生产者是否产出，有：1，没有：0
    public static int flag=0;

    // 总个数
    public static int count = 10;

    // 锁对象
    public static Object lock = new Object();

}

package waitandnotify;

public class ThreadDemo {
    public static void main(String[] args) {
        /*
            需求：完成生产者和消费者（等待唤醒机制）的代码
            实现线程轮流交替执行的效果
        */

        // 创建线程对象
        Creater c = new Creater();
        User u = new User();

        // 给线程设置名称
        c.setName("生产者");
        u.setName("消费者");

        // 开启线程
        c.start();
        u.start();
    }
}

package waitandnotify2;

import java.util.concurrent.ArrayBlockingQueue;

public class Creater extends Thread{

    ArrayBlockingQueue<String> queue;

    public Creater(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while (true) {
            // 不断的将产物放到阻塞队列当中
            try {
                queue.put("产物");    // 底层已经创建了锁对象，不需要写同步代码块
                System.out.println("生产者生产了一个产物");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

package waitandnotify2;

import java.util.concurrent.ArrayBlockingQueue;

public class User extends Thread{
    ArrayBlockingQueue<String> queue;

    public User(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while (true) {
            // 不断的将产物放到阻塞队列当中
            try {
                String take = queue.take(); // 底层已经创建了锁对象，不需要写同步代码块
                System.out.println(take);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

package waitandnotify2;

import java.util.concurrent.ArrayBlockingQueue;

public class ThreadDemo {
    public static void main(String[] args) {
        /*
            需求：利用阻塞队列完成生产者和消费者（等待唤醒机制）的代码
            细节：生产者和消费者必须使用同一个阻塞队列
        */

        // 1. 创建阻塞队列的对象
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(1);

        // 2. 创建线程对象，并把阻塞队列传递到对象中去
        Creater c = new Creater(queue);
        User u = new User(queue);

        c.setName("生产者");
        u.setName("消费者");

        c.start();
        u.start();

    }
}

class MyThread extends Thread{
@override
public void run() {
多线程执行的一些代码
}
}

MyThread t1 = new MyThread();
MyThread t2 = new MyThread();

t1.start();
t2.start();

package Y0threadpool1;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MyThreadPoolDemo {
    public static void main(String[] args) throws InterruptedException {
        /*
            public static ExecutorService newCachedThreadPool() 创建一个没有上限的线程池
            public static ExecutorService newFixedThreadPool(int nThreads) 创建一个有上限的线程池
        */

        // 1. 获取线程池
        ExecutorService pool1 = Executors.newCachedThreadPool();

        // 2. 提交任务（线程复用）
        pool1.submit(new MyRunnable());
        Thread.sleep(1000);
        pool1.submit(new MyRunnable());
        Thread.sleep(1000);
        pool1.submit(new MyRunnable());
        Thread.sleep(1000);
        pool1.submit(new MyRunnable());
        Thread.sleep(1000);
        pool1.submit(new MyRunnable());

        // 3. 销毁线程池
        // pool1.shutdown();
    }
}

package Y0threadpool1;

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
    }
}

package Y0threadpool1;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MyThreadPoolDemo {
    public static void main(String[] args) throws InterruptedException {
        /*
            public static ExecutorService newCachedThreadPool() 创建一个没有上限的线程池
            public static ExecutorService newFixedThreadPool(int nThreads) 创建一个有上限的线程池
        */

        // 1. 获取线程池
        ExecutorService pool1 = Executors.newFixedThreadPool(3);

        // 2. 提交任务
        pool1.submit(new MyRunnable());
        pool1.submit(new MyRunnable());
        pool1.submit(new MyRunnable());
        pool1.submit(new MyRunnable());
        pool1.submit(new MyRunnable());// 最多只会出现pool-1-thread-3

        // 3. 销毁线程池
        // pool1.shutdown();
    }
}

int count = Runtime.getRuntime().availableProcessors();
System.out.println(count)

package udpdemo;

import java.io.IOException;
import java.net.*;

public class SendMessageDemo {
    public static void main(String[] args) throws IOException {
        // 1. 发送数据
        // 创建DatagramSocket对象
        // 细节：
        // 空参：所有可用的端口中随机一个进行使用
        // 有参：指定端口进行绑定
        DatagramSocket ds = new DatagramSocket();

        // 2. 打包数据
        String str = "你好啊！！！";
        byte[] bytes = str.getBytes();
        InetAddress address = InetAddress.getByName("127.0.0.1");
        int port = 10086;
        DatagramPacket dp = new DatagramPacket(bytes,bytes.length,address,port);

        // 3. 发送数据
        ds.send(dp);

        // 4. 释放资源
        ds.close();
    }
}

package udpdemo;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class ReceiveMessageDemo {
    public static void main(String[] args) throws IOException {
        // 1. 接收数据
        // 创建DatagramSocket对象
        // 细节：
        // 在接收的时候，一定要绑定端口
        // 并且绑定的端口一定要和发送的端口保持一致
        DatagramSocket ds = new DatagramSocket(10086);

        // 2. 接收数据包
        byte[] bytes = new byte[1024];
        DatagramPacket dp = new DatagramPacket(bytes, bytes.length);
        // 该方法是阻塞的
        // 程序执行到这一步的时候，会在这里等待
        // 等发送端发送消息
        ds.receive(dp);

        // 3. 解析数据包
        byte[] data = dp.getData();
        int length = dp.getLength();
        InetAddress address = dp.getAddress();
        int port = dp.getPort();

        System.out.println("接收到的数据为：" + new String(data,0, length));
        System.out.println("该数据是从" + address + "这台电脑的" + port + "端口发出的");

        // 释放资源
        ds.close();
    }
}

package udpdemo2;

import java.io.IOException;
import java.net.*;
import java.util.Scanner;

public class SendMessageDemo {
    public static void main(String[] args) throws IOException {
        /*
        按照下面的要求实现程序
        UDP发送数据：数据来自于键盘录入，直到输入的数据为886，发送数据结束
        UDP接收数据：因为接收端不知道发送端什么时候停止发送，故采用死循环接收
        */

        // 1. 创建对象
        DatagramSocket ds = new DatagramSocket();

        // 2. 打包数据
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请输入：");
            String str = sc.nextLine();
            if ("886".equals(str)) break;
            byte[] bytes = str.getBytes();

            InetAddress address = InetAddress.getByName("127.0.0.1");
            int port = 10086;
            DatagramPacket dp = new DatagramPacket(bytes, bytes.length,address,port);

            // 3. 发送数据
            ds.send(dp);
        }

        // 4. 释放资源
        ds.close();
    }
}

package udpdemo2;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class ReceiveMessageDemo {
    public static void main(String[] args) throws IOException {
        // 1. 接收数据
        // 创建DatagramSocket对象
        DatagramSocket ds = new DatagramSocket(10086);

        // 2. 接收数据包
        byte[] bytes = new byte[1024];
        DatagramPacket dp = new DatagramPacket(bytes, bytes.length);
        while (true) {
            ds.receive(dp);

            // 3. 解析数据包
            byte[] data = dp.getData();
            int length = dp.getLength();
            InetAddress address = dp.getAddress();
            int port = dp.getPort();

            System.out.println("接收到的数据为：" + new String(data,0, length));
            System.out.println("该数据是从" + address + "这台电脑的" + port + "端口发出的");
        }
    }
}

       // 1. 创建对象
       MulticastSocket ms = new MulticastSocket();

       // 2. 打包数据
       Scanner sc = new Scanner(System.in);
       while (true) {
           System.out.println("请输入：");
           String str = sc.nextLine();
           if ("886".equals(str)) break;
           byte[] bytes = str.getBytes();

           InetAddress address = InetAddress.getByName("224.0.0.1");
           int port = 10000;
           DatagramPacket dp = new DatagramPacket(bytes, bytes.length,address,port);

           // 3. 发送数据
           ms.send(dp);
       }

       // 4. 释放资源
       ms.close();
   }

       // 将当前本机，添加到224.0.0.1的这一组当中
       InetAddress address = InetAddress.getByName("224.0.0.1");
       ms.joinGroup(address);

       // 2. 接收数据包
       byte[] bytes = new byte[1024];
       DatagramPacket dp = new DatagramPacket(bytes, bytes.length);

       ms.receive(dp);

       // 3. 解析数据
       byte[] data = dp.getData();
       int len = dp.getLength();
       String ip = dp.getAddress().getHostAddress();
       String name = dp.getAddress().getHostName();

       System.out.println("ip为：" + ip +"主机名为：" + name + "的人，发送了数据" + new String(data,0,len));

       // 释放资源
       ms.close();
   }

       // 将当前本机，添加到224.0.0.1的这一组当中
       InetAddress address = InetAddress.getByName("224.0.0.1");
       ms.joinGroup(address);

       // 2. 接收数据包
       byte[] bytes = new byte[1024];
       DatagramPacket dp = new DatagramPacket(bytes, bytes.length);

       ms.receive(dp);

       // 3. 解析数据
       byte[] data = dp.getData();
       int len = dp.getLength();
       String ip = dp.getAddress().getHostAddress();
       String name = dp.getAddress().getHostName();

       System.out.println("ip为：" + ip +"主机名为：" + name + "的人，发送了数据" + new String(data,0,len));

       // 释放资源
       ms.close();
   }

       // 1. 创建对象
       DatagramSocket ds = new DatagramSocket();

       // 2. 打包数据
       Scanner sc = new Scanner(System.in);
       while (true) {
           System.out.println("请输入：");
           String str = sc.nextLine();
           if ("886".equals(str)) break;
           byte[] bytes = str.getBytes();

           InetAddress address = InetAddress.getByName("255.255.255.255");
           int port = 10086;
           DatagramPacket dp = new DatagramPacket(bytes, bytes.length,address,port);

           // 3. 发送数据
           ds.send(dp);
       }

       // 4. 释放资源
       ds.close();
   }

package tcpdemo1;

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;

public class Client {
    public static void main(String[] args) throws IOException {
        // TCP协议，发送数据

        // 1. 创建Socket对象
        // 细节：在创建对象的同时会连接服务端
        //      如果连接不上，代码会报错
        Socket socket = new Socket("127.0.0.1",10000);

        // 2. 可以从连接通道中获取输出流
        OutputStream os = socket.getOutputStream();
        // 写出数据
        os.write("你好".getBytes());

        // 3. 释放资源
        os.close();
        socket.close();
    }
}

package tcpdemo1;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args) throws IOException {
        // TCP协议，接收数据

        // 1. 创建对象ServerSocket
        ServerSocket ss = new ServerSocket(10000);

        // 2. 监听客户端的连接
        Socket socket = ss.accept();

        // 3. 从连接通道中获取输入流读取数据
        InputStream is = socket.getInputStream();
        InputStreamReader isr = new InputStreamReader(is);
        int b;
        while ((b = isr.read()) != -1) {
            System.out.println((char)b);
        }

        // 4. 释放资源
        socket.close();
        ss.close();
    }
}

package tcppractice1;

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;

public class Client {
    public static void main(String[] args) {
        // 需求：
        // 客户端多次发送数据
        // 服务器多次接收数据

        while (true) {
            try {
                Socket socket = new Socket("127.0.0.1", 9999);
                OutputStream os = socket.getOutputStream();
                Scanner sc = new Scanner(System.in);

                while (true) {
                    System.out.println("请输入：");
                    String str = sc.nextLine();
                    os.write((str + "\n").getBytes());
                    os.flush(); // 确保数据立即发送

                    if ("关闭".equals(str)) {
                        break;
                    }
                }

                os.close();
                socket.close();
                break; // 退出外层循环
            } catch (IOException e) {
                System.out.println("连接失败，重新连接中...");
                try {
                    Thread.sleep(2000); // 等待2秒后重试
                } catch (InterruptedException ie) {
                    ie.printStackTrace();
                }
            }
        }
    }
}

package tcppractice1;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocket ss = new ServerSocket(9999);
        while (true) {
            Socket socket = ss.accept();
            InputStream is = socket.getInputStream();
            InputStreamReader isr = new InputStreamReader(is);

            int b;
            StringBuilder sb = new StringBuilder();
            while ((b = isr.read()) != -1) {
                System.out.print((char)b);
                sb = sb.append((char)b);
            }
            System.out.println("");
            if (sb.toString().equals("关闭")) {
                socket.close();
                ss.close();
                break;
            } else {
                socket.close();
            }
        }

    }
}

package tcppractice2;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;

public class Client {
    public static void main(String[] args) {
        // 需求：
        // 客户端发送数据，并将服务端的响应数据打印出来
        // 服务端接收数据，并给客户端发送响应数据

        while (true) {
            try {
                Socket socket = new Socket("127.0.0.1", 10001);
                OutputStream os = socket.getOutputStream();
                InputStream is = socket.getInputStream();
                InputStreamReader isr = new InputStreamReader(is);
                Scanner sc = new Scanner(System.in);

                while (true) {
                    System.out.println("请输入：");
                    String str = sc.nextLine();
                    os.write((str + "\n").getBytes());
                    os.flush(); // 确保数据立即发送

                    int b;
                    StringBuilder sb = new StringBuilder();
                    while ((b = isr.read()) != -1) {
                        char c = (char) b;
                        if (c == '\n') break; // 读取到换行符时结束
                        sb.append(c);
                    }
                    System.out.println("服务器响应：" + sb.toString());

                    if ("关闭".equals(str)) {
                        break;
                    }
                }

                os.close();
                socket.close();
                break; // 退出外层循环
            } catch (IOException e) {
                System.out.println("连接失败，重新连接中...");
                try {
                    Thread.sleep(2000); // 等待2秒后重试
                } catch (InterruptedException ie) {
                    ie.printStackTrace();
                }
            }
        }
    }
}

package tcppractice2;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocket ss = new ServerSocket(10001);
        while (true) {
            Socket socket = ss.accept();
            InputStream is = socket.getInputStream();
            InputStreamReader isr = new InputStreamReader(is);
            OutputStream os = socket.getOutputStream();

            while (true) {
                // 解析数据
                int b;
                StringBuilder sb = new StringBuilder();
                while ((b = isr.read()) != -1) {
                    char c = (char) b;
                    System.out.print(c);
                    sb.append(c);
                    if (c == '\n') break; // 读取到换行符时结束
                }
                System.out.println("");

                // 响应数据
                os.write("收到\n".getBytes());
                os.flush();

                // 关闭连接
                if (sb.toString().trim().equals("关闭")) {
                    socket.close();
                    ss.close();
                    break;
                }
            }
        }
    }
}

package tcppractice3;

import java.io.*;
import java.net.*;

public class Server {
    public static void main(String[] args) {
        try (ServerSocket ss = new ServerSocket(10002)) {
            Socket socket = ss.accept();
            try (InputStream fis = socket.getInputStream();
                 OutputStream os = socket.getOutputStream();
                 FileOutputStream fos = new FileOutputStream("A_test.txt")) {
                int b;
                while ((b = fis.read()) != -1) {
                    char c = (char) b;
                    fos.write(b);
                    if (c == '\n') {
                        os.write("接收完毕".getBytes());
                        break;
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                socket.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

package tcppractice3;

import java.io.*;
import java.net.*;

public class Client {
    public static void main(String[] args) {
        try (Socket socket = new Socket("127.0.0.1", 10002);
             FileInputStream fis = new FileInputStream("test.txt");
             OutputStream os = socket.getOutputStream();
             InputStream is = socket.getInputStream();
             InputStreamReader isr = new InputStreamReader(is)) {

            byte[] bytes = new byte[1024 * 1024 * 5];
            int len;
            while ((len = fis.read(bytes)) != -1) {
                os.write(bytes, 0, len);
            }
            os.write("\n".getBytes());
            os.flush(); // 确保数据被发送

            int b;
            while ((b = isr.read()) != -1) {
                System.out.print((char) b);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// 1. 第一种方式
// Class.forName("全类名")
// 全类名：包名+类名
// 最常用
Class clazz1 = Class.forName("MyReflectDemo1.Student");

// 2. 第二种方式
// 一般当作参数进行传递，如多线程的锁
Class clazz2 = Student.class;

// 3. 第三种方式
// 当有类的对象时才可以使用
Student s = new Student();
Class clazz3 = s.getClass();
System.out.println(clazz1 == clazz2);   // true
System.out.println(clazz2 == clazz3);   // true

package MyReflectDemo2;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Parameter;

public class myreflectdemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        // 1. 获取class字节码文件对象
        Class clazz = Class.forName("MyReflectDemo2.Student");

        // 2. 获取构造方法
        Constructor[] cons1 = clazz.getConstructors();

        for (Constructor con : cons1) {
            // public MyReflectDemo2.Student()
            // public MyReflectDemo2.Student(java.lang.String,int)
            System.out.println(con);
        }

        Constructor[] cons2 = clazz.getDeclaredConstructors();
        for (Constructor con : cons2) {
            // public MyReflectDemo2.Student()
            // public MyReflectDemo2.Student(java.lang.String,int)
            // protected MyReflectDemo2.Student(java.lang.String)
            // private MyReflectDemo2.Student(int)
            System.out.println(con);
        }

        Constructor decon1 = clazz.getDeclaredConstructor();
        // public MyReflectDemo2.Student()
        System.out.println(decon1);

        Constructor decon2 = clazz.getDeclaredConstructor(String.class);
        // protected MyReflectDemo2.Student(java.lang.String)
        System.out.println(decon2);

        Constructor decon3 = clazz.getDeclaredConstructor(String.class,int.class);
        // public MyReflectDemo2.Student(java.lang.String,int)
        System.out.println(decon3);

        // 获取权限修饰符
        int modifiers = decon3.getModifiers();  // public == 1 | protected == 4 | private == 2
        System.out.println(modifiers);

        // 获取参数
        Parameter[] parameters = decon3.getParameters();
        for (Parameter parameter : parameters) {
            // java.lang.String arg0
            // int arg1
            System.out.println(parameter);
        }

        // 创建对象
        Student stu = (Student) decon3.newInstance("张三", 23);
        // Student{name='张三', age=23}
        System.out.println(stu);

        // 暴力反射：表示临时取消权限校验
        Constructor decon4 = clazz.getDeclaredConstructor(int.class);
        decon4.setAccessible(true);
        Student student = (Student) decon4.newInstance(13);
        // Student{name='null', age=13}
        System.out.println(student);
    }
}

package MyReflectDemo2;

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

    public Student(){};

    private Student(int age) {
        this.age = age;
    }

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

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

package MyReflectDemo3;

import MyReflectDemo3.Student;

import java.lang.reflect.Field;

public class myreflectdemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
        // 1. 获取class字节码文件的对象
        Class clazz = Class.forName("MyReflectDemo3.Student");

        // 2. 获取成员变量
        Field[] fields1 = clazz.getFields();
        for (Field field : fields1) {
            // public java.lang.String MyReflectDemo3.Student.gender
            System.out.println(field);
        }

        Field[] fields2 = clazz.getDeclaredFields();
        for (Field field : fields2) {
            // private java.lang.String MyReflectDemo3.Student.name
            // private int MyReflectDemo3.Student.age
            // public java.lang.String MyReflectDemo3.Student.gender
            System.out.println(field);
        }

        // 3. 获取单个成员变量
        Field gender = clazz.getField("gender");
        // public java.lang.String MyReflectDemo3.Student.gender
        System.out.println(gender);

        Field name = clazz.getDeclaredField("name");
        // private java.lang.String MyReflectDemo3.Student.name
        System.out.println(name);

        // 获取权限修饰符
        int modifiers = name.getModifiers();
        System.out.println(modifiers);

        // 获取数据类型
        Class type = name.getType();
        System.out.println(type);   // class java.lang.String

        // 获取成员变量记录的值
        Student s = new Student("张三",18,"男");
        name.setAccessible(true);
        System.out.println(name.get(s));    // 张三

        // 修改成员变量记录的值
        name.set(s,"李四");
        // Student{name='李四', age=18}
        System.out.println(s);
    }
}

package MyReflectDemo3;

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

    public String gender;

    public Student() {}

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

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

package MyReflectDemo4;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;

public class myflectdemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        // 1. 获取
        Class clazz = Class.forName("MyReflectDemo4.Student");

        // 2. 获取里面所有的方法对象
        Method[] methods1 = clazz.getMethods();
        for (Method method : methods1) {
            System.out.println(method); // 会打印所有的公共方法，包括继承的（如Object类）
        }

        Method[] methods2 = clazz.getDeclaredMethods();
        for (Method method : methods2) {
            System.out.println(method); // 会打印所有的方法，包括继承的（如Object类）
        }

        // 3. 获取单个方法
        Method eat = clazz.getDeclaredMethod("eat", String.class);
        System.out.println(eat);

        // 4. 获取方法的形参
        Parameter[] parameters = eat.getParameters();
        for (Parameter parameter : parameters) {
            System.out.println(parameter);  // java.lang.String arg0
        }

        // 获取方法的修饰符
        int modifiers = eat.getModifiers();
        System.out.println(modifiers);

        // 获取方法的抛出的异常
        Class[] exceptionTypes = eat.getExceptionTypes();
        for (Class exceptionType : exceptionTypes) {
            // class java.io.IOException
            // class java.lang.NullPointerException
            // class java.lang.ClassCastException
            System.out.println(exceptionType);
        }

        // 方法运行
        Student s = new Student();
        eat.setAccessible(true);
        Object res = eat.invoke(s, "炒饭");
        System.out.println(res);    // 吃完啦

    }
}

package MyReflectDemo4;

import java.io.IOException;

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

    public Student(){};

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void sleep() {
        System.out.println("睡觉");
    }

    private String eat(String something) throws IOException,NullPointerException,ClassCastException {
        System.out.println("在吃" + something);
        return "吃完啦";
    }

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

package MyReflectDemo5;

import java.io.*;
import java.lang.reflect.Field;

public class myreflectdemo {
    public static void main(String[] args) throws IllegalAccessException, IOException {
        /*
            将任意一个对象的所有字段名和值保存到文件中去
        */
        Student s= new Student("张三",23,"男",177,"睡觉");
        Teacher t= new Teacher("小王",10000);
        saveObject(s);

    }

    public static void saveObject(Object obj) throws IllegalAccessException, IOException {
        // 1. 获取字节码文件的对象
        Class clazz = obj.getClass();

        // 创建IO流
        BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));

        // 2. 获取所有的成员变量
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            String name = field.getName();
            Object val = field.get(obj);

            // 写出数据
            bw.write(name + "=" + val);
            bw.newLine();
        }

        bw.close();
    }
}

flowchart TB    A[调用者] --> B[代理]    B --> C[对象]

package mydynamicproxydemo1;

public class User implements Helper{
    private String name;

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

    public String getName() {
        return name;
    }

    // 唱歌
    @Override
    public String sing(String name) {
        System.out.println(this.name + "正在唱" + name);
        return "谢谢";
    }

    // 跳舞
    @Override
    public void dance() {
        System.out.println(this.name + "正在跳舞");
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

package mydynamicproxydemo1;

public interface Helper {
    // 可以把所有想要被代理的方法定义在接口中
    // 唱歌
    public abstract String sing(String name);

    // 跳舞
    public abstract void dance();
}

package mydynamicproxydemo1;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyUtil {
    // 方法作用：给对象创建一个代理
    // 形参：被代理的对象
    // 返回值：给对象创建的代理

    // 需求：
    // 需要用户唱歌
    // 1. 获取代理的对象
    // 代理对象 = ProxyUtil.createProxy()
    // 2. 再调用代理的唱歌方法
    // 代理对象.唱歌的方法()
    public static Helper createProxy(User u) {
        /*
        public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)

        参数一：用于指定用哪个类加载器，去加载生成的代理类
        参数二：指定接口，这些接口用于指定生成的代理长什么样子，也就是有哪些方法
        参数三：用来指定生成的代理对象要干什么事情
        */

        Helper helper = (Helper) Proxy.newProxyInstance(
                ProxyUtil.class.getClassLoader(),   // 参数一：用于指定用哪个类加载器，去加载生成的代理类
                new Class[]{Helper.class},  // 参数二：指定接口，这些接口用于指定生成的代理长什么样子，也就是有哪些方法
                new InvocationHandler() {   // 参数三：用来指定生成的代理对象要干什么事情
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        // 参数一：代理的对象
                        // 参数二：要运行的方法
                        // 参数三：调用方法时，传递的实参
                        if("sing".equals(method.getName())) {
                            System.out.println("准备话筒，收钱");
                        } else if ("dance".equals(method.getName())) {
                            System.out.println("准备场地，收钱");
                        }

                        return method.invoke(u,args);
                    }
                }
        );
        return helper;
    }
}

package mydynamicproxydemo1;

public class Test {
    public static void main(String[] args) {
        // 1. 获取代理的对象
        User u = new User("张三");
        Helper proxy = ProxyUtil.createProxy(u);

        // 2. 调用唱歌的方法
        String res = proxy.sing("乱唱");
        System.out.println(res);

        // 3. 调用跳舞的方法
        proxy.dance();
    }
}

package demo01;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Scanner;

public class LoggerDemo1 {
    // 获取日志对象
    public static final Logger LOGGER = LoggerFactory.getLogger(LoggerDemo1.class);
    public static void main(String[] args) {
        // 记录用户的操作日志

        // 登录操作
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名");
        String username = sc.nextLine();
        System.out.println("请输入密码");
        String password = sc.nextLine();

        if ("zhangsan".equals(username) && "123".equals(password)) {
            System.out.println("登陆成功");
            LOGGER.info("用户于 xxxx年xx月xx日 xx:xx:xx 登录成功，用户名为：" + username + "，密码为：" + password);
        } else {
            System.out.println("登陆失败");
            LOGGER.info("用户于 xxxx年xx月xx日 xx:xx:xx 登录失败，用户名为：" + username + "，密码为：" + password);
        }
    }
}

<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">

<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">

<root level="INFO">
<appender-ref ref="CONSOLE"/>
<appender-ref ref="FILE"/>
</root>

flowchart LR    A[加载] --> B[验证]    B --> C[准备]    C --> D[解析]    D --> E[初始化]

public @interface 注解名称{
public 属性类型 属性名() default 默认值;
}

@注解名(属性名1=值1,属性名2=值2)