java

快捷键

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

中文在线文档

https://www.matools.com

java运行机制

编译型：翻译成一本书、java
解释型：对速度要求不高，操作系统再解释

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{@Overridepublic 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{@Overridepublic 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;@Overridepublic 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> {@Overridepublic 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;}@Overridepublic 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{@Overridepublic void happyMarry() {System.out.println("你要结婚啦，好啊开心");}
}class WeddingCompany implements Marry{private Marry target;public WeddingCompany(Marry target) {this.target = target;}@Overridepublic 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{@Overridepublic void ya() {System.out.println("i am lamdba2");}}public static void main(String[] args) {//第一种：newILove love = new Love();love.ya();//        第二种：静态内部类love = new Love2();love.ya();//第三种：局部内部类class Love3 implements ILove{@Overridepublic void ya() {System.out.println("i am lamdba3");}}love = new Love3();love.ya();//第四种：匿名内部类love = new ILove(){@Overridepublic 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{@Overridepublic void ya() {System.out.println("i am lamdba1");}
}

线程停止

推荐让线程自己停下来

//线程的停止
public class TestThreadStop implements Runnable{private boolean flag = true;@Overridepublic 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{@Overridepublic 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{@Overridepublic void run() {while (true){System.out.println("老天爷保佑你");}}
}class You2 implements Runnable{@Overridepublic 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;}@Overridepublic 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;}@Overridepublic 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;}@Overridepublic 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;}@Overridepublic 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;}@Overridepublic 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{@Overridepublic 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;}@Overridepublic 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;//ObjectClass 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;//voidClass c9= Class.class;//ClassSystem.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\extClassLoader parent = systemClassLoader.getParent();System.out.println(parent);//获取扩展类加载器父类加载器-->根加载器(c/c++)  jre1.8.0_91\lib\rt.jarClassLoader 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;}@Overridepublic 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;}@Overridepublic 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();
}

Java学习笔记（完结）相关推荐

java学习笔记11--Annotation
java学习笔记11--Annotation Annotation:在JDK1.5之后增加的一个新特性,这种特性被称为元数据特性,在JDK1.5之后称为注释,即:使用注释的方式加入一些程序的信息. j ...
java学习笔记13--反射机制与动态代理
本文地址:http://www.cnblogs.com/archimedes/p/java-study-note13.html,转载请注明源地址. Java的反射机制在Java运行时环境中,对于任意 ...
准备写java学习笔记
准备写java学习笔记 java int 转载于:https://blog.51cto.com/cryingcloud/1975267
Java学习笔记--StringTokenizer的使用
2019独角兽企业重金招聘Python工程师标准>>> Java Tips: 使用Pattern.split替代String.split String.split方法很常用,用于切割 ...
java学习笔记12--异常处理
java学习笔记系列: java学习笔记11--集合总结 java学习笔记10--泛型总结 java学习笔记9--内部类总结 java学习笔记8--接口总结 java学习笔记7--抽象类与抽象方法 j ...
Java学习笔记（十）--控制台输入输出
输入输出一.控制台输入在程序运行中要获取用户的输入数据来控制程序,我们要使用到 java.util 包中的 Scanner 类.当然 Java 中还可以使用其他的输入方式,但这里主要讲解 Scan ...
java学习笔记16--I/O流和文件
本文地址:http://www.cnblogs.com/archimedes/p/java-study-note16.html,转载请注明源地址. IO(Input Output)流 IO流用来处理 ...
java学习笔记15--多线程编程基础2
本文地址:http://www.cnblogs.com/archimedes/p/java-study-note15.html,转载请注明源地址. 线程的生命周期 1.线程的生命周期线程从产生到消亡 ...
java学习笔记14--多线程编程基础1
本文地址:http://www.cnblogs.com/archimedes/p/java-study-note14.html,转载请注明源地址. 多线程编程基础多进程一个独立程序的每一次运行称为 ...
java学习笔记11--集合总结
java学习笔记系列: java学习笔记10--泛型总结 java学习笔记9--内部类总结 java学习笔记8--接口总结 java学习笔记7--抽象类与抽象方法 java学习笔记6--类的继承.Ob ...

Java学习笔记（完结）