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 + 鼠标左键可以实现多行复制中文在线文档
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{ @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_WAITINGTERMINATED
线程的优先级
需要先设置优先级，再启动；
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();
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
