安排如下
1.看leetcode
2.看idea
动态绑定机制，属性没有动态绑定机制，方法有
当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定
toString。是将对象的10进制hash值转为16进制的数，以及全类名。
hashcode不是真实地址，而是通过哈希算法将原地址转化为哈希地址
我F6一行一行，F5跳入断点，F7跳出，F8跳到下一个断点
普通代码块，每创建一个对象就加载一次，静态代码块，随着类的加载而执行，只会加载一次。
Claas.静态代码块，父类也会被加载，而且先执行父类的静态，在执行子类的静态
接口Interface 接口有属性和抽象方法，抽象方法的abstract关键字可以省略，public (abstract) void mehtod1();
可以有普通方法，但方法必须加上default关键字，default public void mehtod2(){
} 可以有静态方法，public static void method3(){} ，接口中定义的int a =10等价于public static final int a =10;
内部类分为四种，局部内部类，匿名内部类，成员内部类，静态内部类
局部内部类可以用final修饰，不可以用其他修饰符修饰(比如四个权限修饰符以及static），
内部类可以直接访问外部类的成员变量，当成员变量和局部内部类的变量重名时，
就近原则访问的是局部内部类的变量，如果一定要访问外部类的同名变量，用外部类.this.变量来访问，外部类.this相当于一个外部类对象
匿名内部类
成员内部类
Outer08.Inner08 inner08 = outer08.new Inner08();
静态内部类
Outer10.Inner10 inner10 = new Outer10.Inner10();
编译异常一定要处理，比如try{}cathch(){}或者throws出来
运行时异常，没处理就是默认throw出
Number类下有Byte,Integer,Long,Float,Double,Short都是其子类
基本数据类型的int和Integer类型的值是相等的
Serializable可串行化就是能在网络传输
String str = "abc"+"def"
String str1 = "abc";
String str2 = "def";
String str3 =str1+str2;
str1不等于str2
Arrays.toString()
Arrays.asList()
无参构造器创建ArrayList对象，初始数组elementData容量为0,存进去数数组容量就变为10，存满就1.5位增长，变成容量15，再存满继续15*1.5=22
如果是指定容量大小，需要扩容，则直接扩容elementData为1.5倍
LinkedList 双向链表 增删效率高
vector
set取出的顺序虽然不是添加的顺序，即无序，但取出顺序不会改变
HashSet 数组+链表+红黑树
LinkedHashSet 数组+双向链表，所以能够保证插入和遍历取出的顺序一致
泛型方法可以定义在普通类中也可以定义在泛型类中
List c ?表示可以接受任意类型
Listc 表示可以接受AA以及AA的子类
Listc 表示可以接受AA以及AA的父类
主线程结束了运行，子线程并不代表已经结束了，不会阻塞
为什么不能执行run()，要用start()。因为start()才真的开启线程，run()只是普通的一个方法，比如在main方法中，执行run()其实也是主线程的一部分，而不是重新开启一个线程
守护线程 setDaemon(true)
线程的同步在SynchronizedTest类中，注意都是implements Runnable
同步代码块要写在方法里面
同步方法或者同步代码块中用Thread.sleep()，Thread.yiled()并不会释放锁。。wait方法会释放锁
String.class 解读为String类型的class对象
获取类对象的方式
①Class.forname("全类名")，一般应用于配置文件Class.forname(classpath)
②通过类名.class. 这种应用场景多应用于参数传递，比如String.class
③对象关联的class对象，已经知道有对象实例了。比如 Car car=new Car(),car.getClass()
④ClassLoder classLoder = car.getClass().getClassLoder();
Class clazz = classLoder .loadClass("全类名")；
⑤8大基本数据类型 Class clazz = int.Class
⑥8大基本数据类型对应的包装类可以Class clazz = Integer.Type =int.class !=Integer.class
反射动态加载，执行到时才加载类，如果没有运行到这里，即使没有该类也不会报错。new的方式新建对象，那么编译时new的类就得加载，即静态加载
final,static,String均在堆中
set接口不能用get(i)来遍历，因为没有索引
hashset=数组+链表+红黑树
hashset是通过hashMap实现的
HashSet ，新增add（）第一次扩容到16个空间，加载因子0.75 临界值12+
utf-8 一个中文字符占3个字节，英文字母一个字节，gbk 一个中文字符两个字节，英文一个字节。
一个字节均等于8个比特位bit
对象注入 @Autowired 根据类型注入@Qualifer 根据名称注入 @Resource 根据名称或类型注入
注入普通类型属性@value @value(value="abc")
String name;
可以@Autowired
@Qualifer(value ="UserDaoImp") 或者@Resource(name ="UserDaoImp")
@Configuration
@ComponentScan(basePackages="{com.atguigu}")
事务传播行为
事务的全注解完整开发，以下是配置类
@Configuration
@ComponentScan(basePackages="com.proxy")
@EnableTransactionManament//开启事务
public txConfig{
}
java和resources都放在web-inf下的classes下
/**代表所有文件夹及里面的子文件夹
相对路径是相对于当前项目所在的project，而不是module
由上可知，SpringBoot项目的classpath包含三个：
src/main/java路径
src/main/resouces路径
第三方jar包的根路径
函数式接口(接口内只有一个方法声明，默认方法和静态方法不算在内)，写死小括号，添加右箭头，提取{} lambda表达式
1-2锁 同步方法锁的不是同步方法而是资源类，即同一时间只有一个线程能够得到资源类，访问其中的一个同步方法，其余线程无法同时获得资源类，访问另外的同步方法，
即锁的是当前调用的对象this
3-4锁 没有加同步的普通方法，无影响，
换成两个对象后。不是同一把锁
5-6 2个静态同步方法，锁的是类
一个静态同步，一个同步，两个锁的对象不同
多线程，高并发，防止虚假唤醒，必须用while判断①synchronize ，wait, notify,notifyAll。②lock,await,signal,signalAll
cas 比较并交换 不加锁也能保证数据正常
CountDownLatch 火箭发射倒计时，减少计数
public class CountDownLatchDemo {
//10个普通线程，一个主线程,保证main线程最后执行
public static void main(String[] args)throws InterruptedException {
CountDownLatch countDownLatch =new CountDownLatch(10);
for (int i =1; i <=10; i++) {
new Thread(()->{
System.out.println(Thread.currentThread().getName());
countDownLatch.countDown();
},String.valueOf(i)).start();
}
countDownLatch.await();
System.out.println(Thread.currentThread().getName()+"结束");
}
}
CyclicBarrier 循环栅栏，开会，先来的就等着，直到来齐了，开会
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierDemo {
public static void main(String[] args) {
CyclicBarrier cyclicBarrier =new CyclicBarrier(10, () -> {
System.out.println(Thread.currentThread().getName() +"开始会议");
});
for (int i =1; i <=10; i++) {
new Thread(() -> {
try {
System.out.println(Thread.currentThread().getName() +"\t" +"进入会议室等待");
cyclicBarrier.await();
}catch (InterruptedException e) {
e.printStackTrace();
}catch (BrokenBarrierException e) {
e.printStackTrace();
}
},String.valueOf(i)).start();
}
}
}
//线程池
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
public class ThreadPoolDemo {
public static void main(String[] args) {
ExecutorService threadPool =Executors.newFixedThreadPool(5);//一池5线程
//ExecutorService threadPool = Executors.newCachedThreadPool();//一池n线程，可扩容的，带变化的线程池
try {
for (int i =1; i <=100; i++) {
int finali=i;
threadPool.submit(()-> {
System.out.println(Thread.currentThread().getName()+"为客户"+"/t"+finali+"办理业务");
});
}
}catch (Exception e){
e.printStackTrace();
}finally {
threadPool.shutdown();
}
}
}