Java学习笔记（完结）

java

快捷键

1. 修改idea的快捷键的方法：点击file》setting》keymay，去里面搜索要改的东西，然后把原来的快捷键去除，键盘输入新的你要的快捷键，就可以啦；
2. Ctrl + d 删除本行；
3. Ctrl + alt+ 向下箭头 复制本行；
4. Alt + / 补全代码；
5. Ctrl + F 对当前文本进行查找；（在代码上面，有一个小搜索的小框框，想查啥搜啥）
6. Ctrl + R 对当前文本进行替换；
7. Ctrl + Y 撤销后回退一步；
8. Ctrl + X 剪切
9. Ctrl + W 递进式选择代码块。可选中光标所在的单词或段落，连续按会在原有选中的基础上再扩展选中范围 （必备）
10. Alt + Enter 根据光标所在问题，提供快速修复选择，光标放在的位置不同提示的结果也不（必备）
11. Ctrl + Alt + L 格式化代码，可以对当前文件和整个包目录使用 （必备）
12. Ctrl + Alt + O 优化导入的类，可以对当前文件和整个包目录使用 （必备）
13. Alt + R 快速运行（如果第一次没有，就先用鼠标用一次，后面就可以用快捷键）；
14. Alt + delete 快速生成构造器；
15. Ctrl + H 查看类的层级关系；
16. 将光标放在一个方法上，输入ctrl+B，可以选位到哪个类的方法[学继承后，非常有用]
17. 快捷键自动分配变量名：如：在new Scanner（System.in）.var这样就可以自动的给你分配变量名；
18. sout可以快速打印输出语句，开发的模板，这种模板也可以自己添加；
19. fori可以快速输出for循环；
20. Main可以快速输出main()的那个语句；
21. 快速导包：alt + enter
22. 光标跳转到上一行：ctrl + enter;
23. 光标跳转到下一行：ctrl + shift + enter
24. crud只会增删改查的低级程序员
25. 用【Shift + Enter】,可以【IDEA新建一行,并且光标移到新行】
26. 向上插入空行：ctrl+alt+enter
27. 快捷键ctrl+alt+t---------->选中try-catch
28. 显示所有快捷键的快捷键 ctrl + j
29. CRUD增删改查
30. alt + 鼠标左键可以实现多行复制

中文在线文档

https://www.matools.com

java运行机制

1. 编译型：翻译成一本书、java

2. 解释型：对速度要求不高，操作系统再解释

javaDoc生成文档

无

scanner

• 如何判断用户有没有输入？/hasNextLine(); /判断整数hasNextInt()，小数hasNextFloat(）；

if(scanner.hasNext()){
    Stirng str = scanner.next();
}

• 用完scanner要关闭：scanner.close();
• 怎么接收字符串：next():不能得到带有空格的字符串 \ nextLine()：可以获得回车符之前的所有字符；

时间

//获取当前时间
Date startTime = new Date(System.currentTimeMillis());
System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));

循环

增强for循环

• 快捷键：输入iter按Tab

• for (String arg : args) {
      System.out.println(arg); 
  }
  

打印三角形

public static void m7(){
    int n = 5;
    for (int i = 1; i <= n; i++) {
        for (int j = n; j > i; j--) {
            System.out.print(" ");
        }
        for (int j = 1; j <= i; j++) {
            System.out.print("*");
        }
        for (int j = 1; j < i; j++) {
            System.out.print("*");
        }
        System.out.println();
    }
}

素数

public class zye15 {
    public static void main(String[] args) {
        for (int i=2;i<=100;i++){
            int y=2;
            while (i%y!=0){
                y++;
            }
            if (y==i){
                System.out.println(i);
            }
        }
    }
}

命令行传参

• 有时候你希望一个程序运行的时候给他传递消息，这要靠命令行参数给main()函数实现；

doc操作

可变参数\不定项参数

• 一个方法中只能指定一个可变参数，它必须是最后一个参数。
  

递归

• 能不用递归，就不用递归，越大越占用内存。（小计算用递归）
• 递归包括两个部分：递归头（什么时候不调用自身方法，如果没有头将陷入死循环）和递归体（什么时候调用自身方法）

数组

• 一般写为

  int[] a = new int[10];//动态初始化（包含默认初始化），需要后续手动赋值
  int[] b = {1,2,3};//静态初始化
  int[][] e = {{1,2},{2,3},{3,4}};
  Man[] c = {new Man(),new man()};//引用类型数组
  int[][] d = new int[2][5];//二维数组
  
  

• 若没有赋值，会自动赋值为0；

• //数组越界异常
  java.lang.ArrayIndexOutOfBoundsException
  

Array类

 System.out.println(Arrays.toString(a));//打印数组元素

 Arrays.sort(a);//数组排序
//排序后也需要下面这样输出
  System.out.println(Arrays.toString(a));

Arrays.fill(a,0);//给数组赋值；

冒泡排序

• 时间复杂度为O(n^2)；

• //冒泡排序
  public static void m11(){
      int[] arr  = {5,9,8,6,3,7,9,44,56,1,0,1};
  
      for (int i = 0; i < arr.length - 1; i++) {
          for (int j = 0; j < arr.length-1-i; j++) {
              if(arr[j + 1] > arr[j]){
                  int temp = arr[j];
                  arr[j] = arr[j + 1];
                  arr[j + 1] = temp;
              }
          }
      }
      System.out.println(Arrays.toString(arr));
  }
  

稀疏数组

• //稀疏数组
  public static void m12(){
      int[][] arr1 = new int[6][6];
      arr1[1][2] = 1;
      arr1[2][3] = 2;
      for (int i = 0; i < arr1.length; i++) {
          for (int j = 0; j < arr1.length; j++) {
              System.out.print(arr1[i][j] + "\t");
          }
          System.out.println();
      }
  
      System.out.println("===============");
      //换成稀疏数组保存
      int sum = 0;
      for (int i = 0; i < arr1.length; i++) {
          for (int j = 0; j < arr1.length; j++) {
              if(arr1[i][j] != 0){
                  sum += 1;
              }
          }
      }
      System.out.println("稀疏数组中非零元素个数为" + sum);
      int[][] arr2 = new int[sum + 1][3];
      arr2[0][0] = 6;
      arr2[0][1] = 6;
      arr2[0][2] = sum;
  
      //遍历数组，将非零的元素存入，稀疏矩阵
      int count = 0;
      for (int i = 1; i < arr1.length; i++) {
          for (int j = 0; j < arr1.length; j++) {
              if (arr1[i][j] != 0){
                  count++;
                  arr2[count][0] = i;
                  arr2[count][1] = j;
                  arr2[count][2] = arr1[i][j];
              }
          }
      }
  
      //增强for循环，遍历二维数组
      for (int[] ints : arr2) {
          for (int anInt : ints) {
              System.out.print(anInt + "\t");
          }
          System.out.println();
      }
  
  
      //再将稀疏矩阵变回去
      int[][] arr3 = new int[arr2[0][0]][arr2[0][1]];
      for (int i = 1; i < arr2.length; i++) {
          arr3[arr2[i][0]][arr2[i][1]] = arr2[i][2];
      }
  
      System.out.println("打印还原的数组");
      for (int[] ints : arr3) {
          for (int anInt : ints) {
              System.out.print(anInt + "\t");
          }
          System.out.println();
      }
  }
  

jvm内存

• 方法区：存储常量、静态变量等
• 栈内存：方法调用时进行执行，存储局部变量信息；
• 堆内存：存储new的东西，成员变量；

面向对象

构造器

• 写了有参构造器，一般要把无参构造器也写上，不然可能有些情况会报错

封装

即属性私有，get/set： 快捷键Alt + delete ，调出来就可以选择getter/setter

一个类被加载后，类的整个结构都会被封装在Class对象中

作用：

• 提高程序的安全性，保护数据
• 隐藏代码的细节
• 统一接口
• 系统的可维护性增加了

继承

• extends
• 私有的东西是无法继承的
• 所有的类都直接或者间接的继承了Object类

+++

Super

• 子类会自动调用父类的无参构造器；
• super（），要是要显示的写在子类中，必须写到第一行；只能在继承中使用，；（this也是，写需要第一行，所以这两个不能同时使用，没有继承也可以使用）
• 只能出现在子类的方法或者构造器中；

+++

方法重写

• 静态方法：调用只和左边的定义有关，即编译型

  重写：非静态的方法，调用看右边

• 关键词只能是public

• 可以扩大修饰符的范围，但是不能缩小

• 方法名和参数列表必须相同

多态

• 对象能执行哪些方法，主要看左边的类型，与右边的关系不大；
• 多态是方法的，属性没有多态；
• 存在条件，继承关系；

类型转换（instanceof）

• System.out.println(X instanceof Y);//X和Y能不能编译通过，看X和Y也没有父子关系;
  //结果为true或false，看具体分析
  

• 若父类想用子类的方法，把其强转为子类即可；

• 若子类转换为父类，可能会丢失自己原来的一些方法

static

• 静态变量可以直接用“类”来调用；
• 还可以静态导入包

代码块

• 静态代码块，加载类的时候直接加载，第一个输出，且只会执行一次
• 匿名代码块：创建对象的时候加载，在构造器前面

抽象类

• abstract
• 抽象方法，抽象类
• 继承抽象类的子类，必须实现抽象类的方法
• 不能new出来，只能子类去实现它；
• 是存在构造器的

接口

• interface
• 接口中所有的方法都是抽象的
• 可以实现多个接口
• 实现接口的类，必须实现接口中所有的方法
• 在接口中定义属性，都是静态的常量（一般不在接口中定义属性）

内部类

• 成员内部类：类中的类

• 局部内部类：方法中写的

• 匿名内部类：没有名字的new。如：

   new People().eat();
   
   new UserService(){
       public void hello(){
       
       }
   }
  

异常机制

• 检查性异常Exception
• 运行时异常Exception
• 错误ERROR：虚拟机运行错误

捕获异常：try/catch（想要捕获的异常类型），最大的类型要写在最下面/finally(去释放占用的资源)

抛出异常：throw（主动抛出异常，一般在方法中使用）/throws（在方法上使用）

自定义异常：

Object类

finalize

1、当对象被回收时，系统自动调用该对象的finalize方法。子类可以重写该方法，做一些释放资源的操作

2、什么时候被回收：当某个对象没有任何引用时，则jvm认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用finalize方法。

3、垃圾回收机制的调用，是由系统来决定，也可以通过System.gc()主动触发垃圾回收机制

一般不会自己去释放资源，但是面试的时候可能会问到你，所以还是要了解一下子；

hashcode

返回该对象的哈希码值。

支持此方法是为了提高哈希表（例如 java.util.Hashtable 提供的哈希表）的性能。

1）提高具有哈希结构的容器的效率！

2）两个引用，如果指向的是同一个对象，则哈希值肯定是一样的！

3）两个引用，如果指向的是不同对象，则哈希值是不一样的

4）哈希值主要根据地址号来的！，不能完全将哈希值等价于地址。

枚举enum

集合

例子：

package com.edu.servlet;

import java.util.ArrayList;
import java.util.Collections;

/**
 * @author 我
 * @version 1.0
 */
public class PorkerTest {
    public static void main(String[] args) {
        ArrayList<String> colors = new ArrayList<>();
        ArrayList<String> chars =  new ArrayList<>();
        ArrayList<String> porker = new ArrayList<>();


        Collections.addAll(colors, "♠", "♥", "♣", "♦");
        Collections.addAll(chars,"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K");

        for (String color : colors) {
            for (String aChar : chars) {
                String s = color.concat(aChar);
                porker.add(s);
            }
        }


        porker.add("大王");
        porker.add("小王");

        System.out.println(porker);
        Collections.shuffle(porker);
        System.out.println(porker);


        ArrayList<String> z = new ArrayList<>();
        ArrayList<String> x= new ArrayList<>();
        ArrayList<String> c = new ArrayList<>();
        ArrayList<String> hand = new ArrayList<>();

        for (int i = 0; i < porker.size(); i++) {
            String v = porker.get(i);

                if(i >= porker.size() - 3){
                    hand.add(v);
                    continue;
                }

                if(i % 3 == 0){
                    z.add(v);
                }
                if(i % 3 == 1){
                    x.add(v);
                }
                if(i % 3 == 2){
                    c.add(v);
                }
        }

        showPorkers(z,"z");
        showPorkers(x,"x");
        showPorkers(c,"c");
        showPorkers(hand,"hand");

    }

    public static void showPorkers(ArrayList<String> list,String name){
        System.out.print(name + "得到的牌为：" );
        for (String s : list) {
            System.out.print(s + " ");
        }
        System.out.println();
    }
} 

多线程

简介

• 线程是独立的执行路径
• 程序运行时，即使自己没有创建线程，其实后台也会有多个线程

线程实现（重点）

• 线程的创建：继承Thread类》》实现Runnable接口》》》实现Callable接口

• 多线程同时操纵同一个资源的情况下，线程不安全，会出现数据紊乱，如（多个人去买火车票，有些时候两人会拿到同一张火车票）

• package com.edu.thread_;
  
  //这个是继承Thread，实现多线程
  //先继承Thread，然后重写run方法，然后调用start开启多线程
  public class TestThread01 extends Thread{
      @Override
      public void run() {
          for (int i = 0; i < 20; i++) {
              System.out.println("run" + i);
          }
      }
  
  
      public static void main(String[] args) {
          TestThread01 testThread01 = new TestThread01();
          testThread01.start();//由cpu调度执行
          for (int i = 0; i < 20; i++) {
              System.out.println("main线程" + i);
          }
      }
  }
  

• package com.edu.thread_;
  
  
  //这个是通过实现Run able接口来实现多线程，推荐使用
  public class TestThread01 implements Runnable{
      @Override
      public void run() {
          for (int i = 0; i < 20; i++) {
              System.out.println("run" + i);
          }
      }
  
  
      public static void main(String[] args) {
          TestThread01 testThread01 = new TestThread01();
          new Thread(testThread01).start();
          for (int i = 0; i < 200; i++) {
              System.out.println("main线程" + i);
          }
      }
  }
  

• 
  /**
   * 模拟龟兔赛跑
   */
  
  public class Race implements Runnable{
  
      private  static String winner;
      @Override
      public void run() {
          for (int i = 0; i <= 100 ; i++) {
              if(Thread.currentThread().getName().equals("兔子") && i%10 == 0){
                  try {
                      Thread.sleep(1);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
              boolean flag = gameOver(i);
              if(flag ){
                  break;
              }
              System.out.println(Thread.currentThread().getName() + "跑了" + i + "步" );
          }
      }
  
  
      private boolean gameOver(int steps){
          if(winner != null){
              return true;
          }else {
              if (steps >= 100) {
                  winner = Thread.currentThread().getName();
                  System.out.println("winner is" + winner);
                  return true;
              }
          }
          return false;
      }
  
      public static void main(String[] args) {
          Race race = new Race();
          new Thread(race,"兔子").start();
          new Thread(race,"乌龟").start();
  
      }
  }
  

• Callable接口:

• import java.util.concurrent.*;
  
  //callable接口实现多线程
  public class TestThread02 implements Callable<Boolean> {
  
      @Override
      public Boolean call() {
          for (int i = 0; i < 10; i++) {
              System.out.println("run线程" + i );
          }
          return true;
      }
  
  
      public static void main(String[] args) throws ExecutionException, InterruptedException {
          TestThread02 t1 = new TestThread02();
          //创建执行服务,后面括号里面的表示几个线程
          ExecutorService ser = Executors.newFixedThreadPool(1);
          //提交执行
          Future<Boolean> r1 = ser.submit(t1);
          //获取结果
          boolean rs1 = r1.get();
          //关闭服务
          ser.shutdownNow();
  
          for (int i = 0; i < 200; i++) {
              System.out.println("main线程" + i);
          }
      }
  }
  

线程同步（重点）

• 形成条件，队列+锁

• synchronized关键字

  • 会很大的影响效率
  • 默认锁的是this
  • 锁的对象就是变化的量，需要增删改的对象

• 线程不安全的例子：银行卡余额、同时买票、集合等

• 
  //银行卡账户余额不安全
  public class UnsafeBank {
  
      public static void main(String[] args) {
          Account account = new Account(5000,"旅游");
          Drawing d1 = new Drawing(account,2500,"黑");
          Drawing d2 = new Drawing(account,2600,"白白");
  
          d1.start();
          d2.start();
  
      }
  }
  class Account{
       double money;
       String name;
  
      public Account(double money, String name) {
          this.money = money;
          this.name = name;
      }
  }
  
  class Drawing extends Thread{
  
      Account account;
      double drawingmoney;
      double nowmoney;
  
      public Drawing(Account account,double drawingmoney,String name){
          super(name);
          this.account = account;
          this.drawingmoney = drawingmoney;
      }
  
  
      @Override
      public void run() {
          //锁的对象就是变化的量，需要增删改的对象
  //        synchronized (account) {  //把这句打开，就不会不安全了
              if (account.money - drawingmoney < 0) {
                  System.out.println(Thread.currentThread().getName() + "卡里余额不足，取不了");
                  return;
              }
  
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
  
              account.money = account.money - drawingmoney;
              nowmoney = nowmoney + drawingmoney;
              System.out.println(account.name + "卡里面的余额为" + account.money);
              System.out.println(this.getName() + "手里的钱为：" + nowmoney);
          }
  //    }
  
  }
  

• JUC：CopyOnWriteArrayList,这个是保证线程安全的集合

静态代理

//静态代理

public class StaticProxy {
    public static void main(String[] args) {
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.happyMarry();
    }
}

interface Marry{
    public void happyMarry();
}

class You implements Marry{
    @Override
    public void happyMarry() {
        System.out.println("你要结婚啦，好啊开心");
    }
}


class WeddingCompany implements Marry{
    private Marry target;

    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void happyMarry() {
        before();
        this.target.happyMarry();
        after();
    }



    private void before() {
        System.out.println("结婚之前，布置现场");
    }
    private void after() {
        System.out.println("结婚之后，收拾定西");
    }
}

Lamda表达式

作用：

• 避免匿名内部类定义过多
• 可以让代码看起来很简洁
• 去掉了没有意义的代码，只留下核心的逻辑

函数式接口

任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口；有了函数式接口，才可以用Lambda表达式

public class Lambda_ {

    //第二种：静态内部类
    static class Love2 implements ILove{
        @Override
        public void ya() {
            System.out.println("i am lamdba2");
        }
    }

    public static void main(String[] args) {
        //第一种：new
        ILove love = new Love();
        love.ya();

//        第二种：静态内部类
         love = new Love2();
        love.ya();

        //第三种：局部内部类
        class Love3 implements ILove{
            @Override
            public void ya() {
                System.out.println("i am lamdba3");
            }
        }
        love = new Love3();
        love.ya();


        //第四种：匿名内部类
        love = new ILove(){
            @Override
            public void ya() {
                System.out.println("i am lamdba4");
            }
        };
        love.ya();

        //第五种：lamdba
        //只有一个参数的时候，括号可以省略；只有一个输出语句的时候，大括号可以省略
        love = ()->{System.out.println("i am lamdba5");};
        love.ya();


    }
}

interface ILove{
    void ya();
}

class Love implements ILove{
    @Override
    public void ya() {
        System.out.println("i am lamdba1");
    }
}

线程停止

• 推荐让线程自己停下来

• //线程的停止
  public class TestThreadStop implements Runnable{
  
      private boolean flag = true;
      @Override
      public void run() {
          int i = 0;
          while (flag){
              System.out.println("run线程" + i);
              i++;
          }
      }
  
      public void stop(){
          flag = false;
      }
  
      public static void main(String[] args) {
  
          TestThreadStop t = new TestThreadStop();
          new Thread(t).start();
  
          for (int i = 0; i < 1000; i++) {
              if(i == 900){
                  t.stop();
                  System.out.println("run线程该停止咯");
              }
              System.out.println("main线程" + i);
          }
  
      }
  }
  

线程的休眠（sleep）

• sleep会存在异常，记得抛出

• sleep可以模拟网络延迟（放大问题的发生行），倒计时等；

• 每个对象都有一把锁，sleep不会释放锁；

• //倒计时
  public class TestSleep {
  
      public static void main(String[] args) throws InterruptedException {
          tenDown();
      }
  
      public static void tenDown() throws InterruptedException {
          int num = 10;
         while (true){
             Thread.sleep(1000);
             System.out.println(num--);
             if(num <= 0){
                 break;
             }
         }
  
      }
  }
  

线程礼让（yield）

• 礼让不一定成功

• Thread.yield();
  

线程强制执行（join）

• Thread.join();
  

• 插队的线程执行完毕之后，才能继续执行

线程的状态

//观察线程的状态
public class TestThreadState {

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() ->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("++++++++++");
        });

        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state);

        //观察启动后，线程的状态
        thread.start();
        state = thread.getState();//更新状态
        System.out.println(state);

        while (state != Thread.State.TERMINATED){
            Thread.sleep(100);
            state = thread.getState();//更新状态
            System.out.println(state);//输出状态
        }
        
        thread.start();//这句会报错，因为死亡后的线程是不能再次启动的

    }
}

• 线程的状态：

  NEW
  RUNNABLE
  TIMED_WAITING

  TERMINATED

线程的优先级

• 需要先设置优先级，再启动；

• public class TestThreadPriority {
      public static void main(String[] args) {
          System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority());
  
          MyPriority myPriority = new MyPriority();
          Thread t1 = new Thread(myPriority);
          Thread t2 = new Thread(myPriority);
          Thread t3 = new Thread(myPriority);
          Thread t4 = new Thread(myPriority);
  
          //没有设置优先级，t1是默认的优先级
          t1.start();
  
          t2.setPriority(1);
          t2.start();
  
          t3.setPriority(6);
          t3.start();
  
          t4.setPriority(10);
          t4.start();
  
  
  
      }
  
  }
  
  class MyPriority implements  Runnable{
  
      @Override
      public void run() {
          System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority());
      }
  }
  

• 线程优先级高的不一定先执行；main线程一定是最先执行的；

守护线程

• 线程分为用户线程和守护线程

• 虚拟机必须确保用户线程执行完毕，但是不用等守护线程执行完毕

• //用户线程和守护线程
  public class TestDaemon {
  
      public static void main(String[] args) {
          God god = new God();
          You2 you2 = new You2();
  
          Thread thread = new Thread(god);
          thread.setDaemon(true);//默认为false，这就是设置为是守护线程；不用等守护线程执行完毕
  
          thread.start();
          new Thread(you2).start();
  
  
  
      }
  
  }
  
  class God implements Runnable{
  
      @Override
      public void run() {
          while (true){
              System.out.println("老天爷保佑你");
          }
      }
  }
  
  class You2 implements Runnable{
  
      @Override
      public void run() {
          for (int i = 0; i < 36500; i++) {
              System.out.println("开心的活着");
          }
          System.out.println("世界~再见啦");
      }
  }
  

死锁

//死锁的例子
public class TestDeakLock {
    public static void main(String[] args) {
        MakeUp m1 = new MakeUp(0,"heihei");
        MakeUp m2 = new MakeUp(1,"baibai");
        m1.start();
        m2.start();
    }
}

//口红
class Lipstick{

}

//镜子
class Mirror{

}

class MakeUp extends Thread{
     static Lipstick lipstick =  new Lipstick();
     static Mirror mirror =  new Mirror();

     int choice;//选择镜子还是口红
     String girlName;//使用化妆品的人

    public MakeUp(int choice,String girlName){
        this.choice = choice;
        this.girlName = girlName;
    }
    @Override
    public void run() {
        if (choice == 0) {
            synchronized (lipstick) {
                System.out.println(this.girlName + "获得口红的锁");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (mirror) {
                    System.out.println(this.girlName + "获得镜子的锁");
                }
              }
//            synchronized (mirror) {
//                System.out.println(this.girlName + "获得镜子的锁");   //这个打开，上面删除，就解决死锁；下同
//            }
            }else{
                synchronized (mirror) {
                    System.out.println(this.girlName + "获得镜子的锁");
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (lipstick) {
                        System.out.println(this.girlName + "获得口红的锁");
                    }
                }
//            synchronized (lipstick) {
//                System.out.println(this.girlName + "获得口红的锁");
//            }
            }
        }

}

lock锁

线程协作

• 生产者消费模型

  • 管程法

  • //生产者与消费者模式：管程法
    public class TsetPC {
        public static void main(String[] args) {
            SynContainer container = new SynContainer();
            new Productor(container).start();
            new Consumer(container).start();
        }
    }
    
    //生产者
    class Productor extends Thread{
        SynContainer container;
        public Productor(SynContainer container){
            this.container = container;
        }
    
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                container.push(new Chicken(i));
                System.out.println("生产了" + i+ "只鸡");
            }
        }
    }
    
    //消费者
    class Consumer extends Thread{
        SynContainer container;
        public Consumer(SynContainer container){
            this.container = container;
        }
    
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
    
                System.out.println("消费了" + container.pop().id + "只鸡");
            }
        }
    
    }
    
    
    //产品
    class Chicken{
        int id ;//产品编号
    
        public Chicken(int id) {
            this.id = id;
        }
    }
    
    
    //缓冲区
    class SynContainer{
    
        Chicken[] chickens = new Chicken[10];
    
        int count = 0;
    
        public synchronized void push(Chicken chicken){
    
            if(count == chickens.length){
                //消费者可以消费了，生产者等待；
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    
            chickens[count] = chicken;
            count++;
    
            //可以通知消费者消费
            this.notifyAll();
        }
    
        public synchronized Chicken pop(){
    
            if(count == 0){
                //生产开始了，消费者等待
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    
            //如果可以消费
            count--;
            Chicken chicken = chickens[count];
    
            //可以通知生产者生产
            this.notifyAll();
            return chicken;
    
        }
    }
    

  • 信号灯法：

  • //生产者与消费者模式：信号灯法
    public class TestPC2 {
        public static void main(String[] args) {
    
            Tv tv = new Tv();
            new Player(tv).start();
            new Watcher(tv).start();
        }
    }
    
    //生产者 》》演员
    class  Player extends Thread{
    
        Tv tv;
        public Player(Tv tv){
            this.tv = tv;
        }
    
        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                if(i % 2 == 0){
                    this.tv.play("小猪吃老虎");
                }else {
                    this.tv.play("广告");
                }
            }
        }
    }
    
    
    //消费者 》》 观众
    class Watcher extends Thread{
    
        Tv tv;
        public Watcher(Tv tv){
            this.tv = tv;
        }
    
        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                tv.watch();
            }
        }
    }
    
    
    //缓冲池 》》 电视
    class Tv {
    
        String move;
        boolean flag = true;
    
        //观众看节目
        public synchronized void play(String move){
            if(!flag){
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    
            System.out.println("演员表演了" + move);
            this.notifyAll();
            this.move = move;
            this.flag = !this.flag;
    
    
        }
    
    
        public synchronized void watch(){
            if(flag){
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("观看了" + move);
            this.notifyAll();
            this.flag = !this.flag;
    
    
        }
    }
    
    

线程池

//测试线程池
public class TestThreadPool {
    public static void main(String[] args) {

        //创建服务，创建线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        //关闭连接
        service.shutdown();
    }

}

class MyThread implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() );
    }
}

注解

例如：

@override ：限定某个方法，是重写父类方法

@deprecated:表示以及过时的，不推荐程序员使用，或者存在更好的方式

@SuppressWarnings(“all”):表示抑制警告

​ 在{“”}里面可以写不同的东西，来抑制你想抑制掉的警告；里面可以写的东西有很多，可以上网查阅；

​ 1）unchecked是忽略没有检查的警告

​ 2）rawtypes是忽略没有指定泛型的警告（传参时没有指定泛型的警告错误）

​ 3）unused是忽略没有使用某个变量的警告错误

​ 4）@SuppressWarnings可以修饰的程序元素为，查看@Target

​ 5）生成@SupperssWarnings时，不用背，直接点击左侧的黄色提示，就

​ 可以选择（注意可以指定生成的位置）

作用范围：和你放置的位置相关（放置的位置有讲究）；

元注解

1）Retention(保留)//指定注解的作用范围，三种SOURCE,CLASS,RUNTIME

2）Target//指定注解可以在哪些地方使用

3）Documented//指定该注解是否会javadoc体现

4）Inherited//子类会继承父类注解

//自定义注解
public class Test01  {

    @MyAnnotation(age = 1)
    public void t(){

    }
}


@Target(value = {ElementType.TYPE,ElementType.METHOD})//表示我们的注解可以用到哪些地方
@Retention(value = RetentionPolicy.RUNTIME)//Retention:表示我们的注解，在哪些地方还有效，一般自定义的注解都是Runtime
@Documented    //表示是否将我们的注解生成在Javadoc文档中
@Inherited    //子类可以继承父类的注解
@interface MyAnnotation{//自定义的注解MyAnnotation
    //注解的参数：参数类型 + 参数名（）
    //default "",写了之后MyAnnotation（），括号里面的值可以写可以不写；如果没有默认值，就必须写
    String name() default " ";
    int age() ; 
    String[] company() default "中软国际";
    
}

反射

概述

• 静态语言（Java）/动态语言（JavaScript：在运行的时代码可以根据某些条件改变自身的结构）
• 反射允许程序在执行期借助Reflection API取得任何类的内部信息；

获取反射对象

Class c1 = Class.forName("com.edu.reflection.test01");

Class类的创建方式

forname获得

通过对象获得

通过类名.class获得

基本内置类型的包装类都有一个Type属性

//Class类的创建方式
public class test02 {
    public static void main(String[] args) throws ClassNotFoundException {

        Person person = new Student();
        System.out.println("这个人是" + person.name);

        //方式一：forname获得
        Class c1 = Class.forName("com.edu.reflection.Student");
        System.out.println(c1);

        //方式二：对象.getClass()获得
        Class c2 = person.getClass();
        System.out.println(c2);

        //方式三：通过类名.class获得
        Class c3 = Student.class;
        System.out.println(c3);

        //方式四：基本内置类型的包装类都有一个Type属性
        Class c4 = Integer.TYPE;
        System.out.println(c4);

        //获得父类的类型
        Class c5 = c1.getSuperclass();
        System.out.println(c5);

    }
}

class Person{
    public String name;

    public Person() {
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

class Student extends Person{
    public Student(){
        this.name = "学生";
    }
}


class Teacher extends Person{
    public Teacher(){
        this.name = "老师";
    }
}

所有类型的Class

//所有类型的Class
public class test03 {
    public static void main(String[] args) {
        Class c1 = Object.class;//Object
        Class c2 = String[].class;//一维数组
        Class c3 = int[][].class;//二维数组
        Class c4 = Override.class;//注解
        Class c5 = ElementType.class;//枚举类型
        Class c6 = Comparable.class;//接口
        Class c7 = Integer.class;//基本数据类型
        Class c8 = void.class;//void
        Class c9= Class.class;//Class

        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
        System.out.println(c9);


        //a和b的hashcode是一样的，说明只要元素类型和维度一样，只有一个class对象
        //
        int[] a = new int[5];
        int[] b = new int[100];
        System.out.println(a.getClass().hashCode());
        System.out.println(b.getClass().hashCode());

    }
}

类加载内存分析

加载》》链接》》初始化

class对象在类加载的时候就创建了

什么时候发生类的初始化

//类什么时候会初始化
public class test04 {
    static{
        System.out.println("main方法加载");
    }
    public static void main(String[] args) throws ClassNotFoundException {


        //类的主动引用（一定会发生类的初始化）
        //方式一：
//        Son son = new Son();
        //方式二
//         Class.forName("com.edu.reflection.Son");

        //类的被动引用（不会发生类的初始化）
        //子类不会初始化
//        System.out.println(Son.b);

        //不会初始化
//        Son[] a = new Son[2];
        System.out.println(Son.M);

    }
}

class Father{
    static int b;
    static {
        System.out.println("父类初始化");
    }
}

class Son extends Father{
    static {
        System.out.println("子类初始化");
        m = 300;
    }

    static int m = 100;
    static final int M = 1;
}

类的加载器

//类加载器
public class test05 {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取系统类的加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);

        //获取系统类加载器的父类加载器-->扩展类加载器    jre1.8.0_91\lib\ext
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);

        //获取扩展类加载器父类加载器-->根加载器(c/c++)  jre1.8.0_91\lib\rt.jar
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);

        //测试当前类是哪个加载器加载的
        ClassLoader classLoader = Class.forName("com.edu.reflection.test05").getClassLoader();
        System.out.println(classLoader);

        //测试JDK内置的类是谁加载的
        classLoader = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader);

        //如何获得系统类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));

        //双亲委派机制  检测安全性 你写的类和跟加载器一样的不会用你写的类
        //java.lang.String -->往上推


        /**
         * D:\Environment\java\jdk1.8.0_91\jre\lib\charsets.jar;
         * D:\Environment\java\jdk1.8.0_91\jre\lib\deploy.jar;
         * D:\Environment\java\jdk1.8.0_91\jre\lib\ext\access-bridge-64.jar;
         * D:\Environment\java\jdk1.8.0_91\jre\lib\ext\cldrdata.jar;
         * D:\Environment\java\jdk1.8.0_91\jre\lib\ext\dnsns.jar;
         * D:\Environment\java\jdk1.8.0_91\jre\lib\ext\jaccess.jar;
         * D:\Environment\java\jdk1.8.0_91\jre\lib\ext\jfxrt.jar;
         * D:\Environment\java\jdk1.8.0_91\jre\lib\ext\localedata.jar;
         * D:\Environment\java\jdk1.8.0_91\jre\lib\ext\nashorn.jar;
         * D:\Environment\java\jdk1.8.0_91\jre\lib\ext\sunec.jar;
         * D:\Environment\java\jdk1.8.0_91\jre\lib\ext\sunjce_provider.jar;
         * D:\Environment\java\jdk1.8.0_91\jre\lib\ext\sunmscapi.jar;
         * D:\Environment\java\jdk1.8.0_91\jre\lib\ext\sunpkcs11.jar;
         * D:\Environment\java\jdk1.8.0_91\jre\lib\ext\zipfs.jar;
         * D:\Environment\java\jdk1.8.0_91\jre\lib\javaws.jar;
         * D:\Environment\java\jdk1.8.0_91\jre\lib\jce.jar;
         * D:\Environment\java\jdk1.8.0_91\jre\lib\jfr.jar;
         * D:\Environment\java\jdk1.8.0_91\jre\lib\jfxswt.jar;
         * D:\Environment\java\jdk1.8.0_91\jre\lib\jsse.jar;
         * D:\Environment\java\jdk1.8.0_91\jre\lib\management-agent.jar;
         * D:\Environment\java\jdk1.8.0_91\jre\lib\plugin.jar;
         * D:\Environment\java\jdk1.8.0_91\jre\lib\resources.jar;
         * D:\Environment\java\jdk1.8.0_91\jre\lib\rt.jar;
         * E:\StudyProject\annotation_reflection\out\production\annotation_reflection;
         * D:\WorkingSoftware\IntelliJ IDEA 2020.3.1\lib\idea_rt.jar
         */
    }
}

获取类的信息

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class test06 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        Class c1 = Class.forName("com.edu.reflection.Person");
        System.out.println(c1);

        System.out.println("--------------");
        Field[] field = c1.getFields();//只能找到public的属性
        field = c1.getDeclaredFields();//能找到全部属性
        for (Field field1 : field) {
            System.out.println(field1);
        }

        System.out.println("--------------");
        Method[] methods = c1.getMethods();//获得本类以及父类的public方法
        for (Method method : methods) {
            System.out.println("正常的" + method);
        }
        Method[] declaredMethods = c1.getDeclaredMethods();//获得本类的所有方法
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);
        }
        //获得指定的方法
        //重载
        Method getNames = c1.getMethod("getName", null);
        Method setName = c1.getMethod("setName", String.class);
        System.out.println(getNames);
        System.out.println(setName);
        
        //获得指定的构造器
        System.out.println("--------------");
//        同上
    }
}

反射操作属性/方法

newInstance()，本质上调用了类的无参构造器

invoke(对象，值):激活的意思

不能直接操作私有属性，需要关闭程序的安全检测，属性或者方法的name.setAccessible(true)

使用反射时最好关闭检测，这样能提高效率

//动态创建对象，通过反射
public class test07 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        Class c1 = Class.forName("com.edu.reflection.User");
//        User user = (User)c1.newInstance();//newInstance()，本质上调用了类的无参构造器
//        System.out.println(user);

        //通过构造器创建对象
//        Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, String.class);
//        User user2 = (User)constructor.newInstance("请回复", 50, "女");
//        System.out.println(user2);

        //通过反射调用普通方法
        //invoke(对象，值):激活的意思
//        User user3= (User)c1.newInstance();
//        Method setName = c1.getDeclaredMethod("setName", String.class);
//        setName.invoke(user3,"小黄牛");
//        System.out.println(user3.getName());

         //通过反射操作属性
        User user4= (User)c1.newInstance();
        Field name = c1.getDeclaredField("name");
        //不能直接操作私有属性，需要关闭程序的安全检测，属性或者方法的name.setAccessible(true)
        name.setAccessible(true);
        name.set(user4,"大丰收");
        System.out.println(user4.getName());



    }
}
class User{
    private String name;
    private int age;
    private String gender;

    public User() {
    }

    public User(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 "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                '}';
    }
}

反射操作泛型

反射操作注解

//反射操作注解
import java.lang.annotation.*;
import java.lang.reflect.Field;

public class Test08 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Class.forName("com.edu.reflection.Student02");

        //通过反射获得注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        TableWang tableWang = (TableWang) c1.getAnnotation(TableWang.class);
        String value = tableWang.value();
        System.out.println(value);

        //获得类指定的注解
        Field f = c1.getDeclaredField("age");
        FieldWang annotation = f.getAnnotation(FieldWang.class);
        System.out.println(annotation.columnName());
        System.out.println(annotation.type());
        System.out.println(annotation.length());



    }

}

@TableWang("db_student")
class Student02{
    @FieldWang(columnName = "db_name",type = "varchar",length = 10)
    private String name;
    @FieldWang(columnName = "db_age",type = "int",length = 10)
    private int age;
    @FieldWang(columnName = "db_name",type = "varchar",length = 3)
    private String gender;

    public Student02() {
    }

    public Student02(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 "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                '}';
    }
}


//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableWang{
    String value();
}

//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldWang {
    String columnName();
    String type();
    int length();
}

lic static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
Class c1 = Class.forName(“com.edu.reflection.Student02”);

    //通过反射获得注解
    Annotation[] annotations = c1.getAnnotations();
    for (Annotation annotation : annotations) {
        System.out.println(annotation);
    }
    TableWang tableWang = (TableWang) c1.getAnnotation(TableWang.class);
    String value = tableWang.value();
    System.out.println(value);

    //获得类指定的注解
    Field f = c1.getDeclaredField("age");
    FieldWang annotation = f.getAnnotation(FieldWang.class);
    System.out.println(annotation.columnName());
    System.out.println(annotation.type());
    System.out.println(annotation.length());



}

}

@TableWang(“db_student”)
class Student02{
@FieldWang(columnName = “db_name”,type = “varchar”,length = 10)
private String name;
@FieldWang(columnName = “db_age”,type = “int”,length = 10)
private int age;
@FieldWang(columnName = “db_name”,type = “varchar”,length = 3)
private String gender;

public Student02() {
}

public Student02(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 "User{" +
            "name='" + name + '\'' +
            ", age=" + age +
            ", gender='" + gender + '\'' +
            '}';
}

}

//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableWang{
String value();
}

//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldWang {
String columnName();
String type();
int length();
}