岁月平添了我的愁

1. 通配符的使用类A是类B的父类，G和G是没有关系的，二者共同的父类时：G<?> List<Object> list1=null; List<String> list2=null; List<?> list=null; list=list1; list=list2; dayin(list1); dayin(list2)}public static void dayin(List&l

泛型在继承方面的体现类A是类B的父类，G和G二者不具备子父类关系，两者是并列关系，此时编译不通过：List<Object> list1=null;List<String> list2=null;list1=list2;类A是类B的父类，A是B的父类...

1. 泛型方法在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系，换句话说，泛型方法所属的类是不是泛型类都没关系泛型方法在调用时指明泛型参数的类型，并非在实例化类时确定， arr给E指挥的类型是integer，并且可以加staticpublic <E> List<E> copy(E[] arr){ ArrayList<E> list=new ArrayList<>(); for (E e : arr) { l

1. 为什么要有泛型问题：类型不安全，list里面啥都能存，什么int啊，string啊强转时，可能出现ClassCastException：其他类型的强转失败了~package com.ran;//自定义泛型类public class Order<T> { String name; int orderId; //类的内部结构就可以使用类的泛型 T orderT; public Order() { } publi

1. 获取运行时类的树形结构及其内部结构（了解）package com.fanshe;import java.lang.reflect.Field;import java.lang.reflect.Modifier;public class test { public static void main(String[] args) { Class clazz= Person.class; //获取属性结构 //getFields():获取

调用运行时类中的方法package com.fanshe;import sun.plugin2.util.ParameterNames;import java.lang.annotation.Annotation;import java.lang.reflect.*;public class test { public static void main(String[] args) throws Exception { Class clazz=Person.clas

获取运行时类中的指定属性package com.fanshe;import sun.plugin2.util.ParameterNames;import java.lang.annotation.Annotation;import java.lang.reflect.*;public class test { public static void main(String[] args) throws Exception { Class clazz=Person.cl

通过反射创建运行时类的对象newInstance（）：调用此方法，创建对应运行时类的对象，内部是调用了运行时类的空参构造器要想此方法正常运行，要求：运行时类必须提供空参构造器空参构造器的访问权限得够，通常设置为publicpublic static void main(String[] args) throws IllegalAccessException, InstantiationException { Class clazz= Person.class; Perso

Class实例的说明

获取Class实例的四种方式前三种方式需要掌握！第三种用的比较多package com.fanshe;public class test { //反射之前对于Person的操作 public static void main(String[] args) throws Exception { //方式一：调用运行时类的属性：.class Class clazz1=Person.class; System.out.println(cl

Class类的理解类的加载过程：​ 程序在经过javac.exe命令以后，会生成一个或多个字节码文件（.class结尾）​ 接着我们使用java.exe对某个字节码文件进行解释运行。将某个字节码文件加载到内存中，此过程称为类的加载。​ 加载到内存中的类，称为运行时类，此运行时类，就作为一个Class的一个实例换句话说：Class的实例就对应着一个运行时类。我们加载到内存中的运行时类，会缓存一定的时间，在此时间之内，我们可以通过不同的方式来获取此运行

反射的强大：调用类的私有结构package com.fanshe;import java.lang.reflect.Constructor;import java.lang.reflect.Field;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;public class test { //反射之前对于Person的操作 public static void

1. 反射之前的正常person操作package com.fanshe;public class Person { private String name; public int age; public Person() { } public Person(String name, int age) { this.name = name; this.age = age; } private Person(S

反射机制的概述

注解 √1. 注解的理解2. JDK内置的三个基本注解Override：限定重写父方法，该注解只能用于方法Deprecated：用于表示所修饰的元素（类、方法等）已过时（但是方法过时了还是可以用的，只是有点危险）SuppressWarnings：抑制编译器警告3. 自定义注解注解申明为：@interface内部定义成员，通常使用value表示可以指定成员的默认值，使用default定义如果自定义的注解没有成员，表明是一个标识作用如果这个注解有成员，在使用注解的时候，

使用enum关键字定义的枚举类实现接口实现接口，在enum类中实现接口的抽象方法（普通接口实现方式）让我们的枚举类的对象分别去实现接口中的抽象方法package com.ran;import java.util.concurrent.*;import java.util.concurrent.locks.ReentrantLock;public class ran { public static void main(String[] args) { Seaso

Enum类中的常用方法package com.ran;import java.util.concurrent.*;import java.util.concurrent.locks.ReentrantLock;public class ran { public static void main(String[] args) { Season autumn = Season.AUTUMN; //toString（）：返回当前的对象名 S

使用enum关键字定义枚举类定义的枚举类默认继承于java.lang.enum类package com.ran;import java.util.concurrent.*;import java.util.concurrent.locks.ReentrantLock;public class ran { public static void main(String[] args) { Season autumn = Season.AUTUMN; Sy

自定义枚举类package com.ran;import java.util.concurrent.*;import java.util.concurrent.locks.ReentrantLock;public class ran { public static void main(String[] args) { Season autumn = Season.AUTUMN; System.out.println(autumn); }}/

枚举类的使用如果枚举类中只有一个对象，则可以作为单例模式的实现方式

多线程的创建方式（四）提供指定数量的线程池执行指定的线程操作，需要提供实现runnable接口或callable接口实现类的对象关闭连接池package com.ran;import java.util.concurrent.*;import java.util.concurrent.locks.ReentrantLock;public class ran { public static void main(String[] args) { Executo

4.14 多线程的创建方式（三）创建一个实现Callable接口的实现类实现call方法，将此线程需要执行的操作声明在call（）中创建callable接口实现类的对象将此callable实现类的对象作为参数传递到FutureTask的构造器中，创建FutureTask的对象将FutureTask的对象作为参数传递到Thread的构造器中，创建Thread对象并调用start（）get（）返回值即为FutureTask构造器参数Callable实现类重写call（）的返回值package

1. 面试题sleep（）和wait（）方法的异同：同：一旦执行方法，都可以使得当前线程进入阻塞状态不同点：两个方法申明的位置不一样，Thread类中申明sleep（），Object类中申明wait（）调用的要求是不一样的，sleep（）是可以在任何需要的场景下调用，wait（）必须使用在同步代码块或同步方法中关于是否释放同步监视器的问题：如果两个方法都使用在同步代码块或同步方法中：sleep（）不会释放同步监视器，wait（）会释放。2. 生产者消费者例题package c

线程的通信两个线程交替打印100以内的整数：package com.ran;import java.util.concurrent.locks.ReentrantLock;public class ran { public static void main(String[] args) { Number number = new Number(); Thread t1 = new Thread(number); Thread t2 = ne

线程的安全问题错票情况：不是说没加sleep就不会出错，程序本身就有缺陷，只是出错的概率低而已，加了阻塞只是使他的错误概率提高了。卖票过程中，出现了重票、错票 --------------> 出现了线程安全问题问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。解决：当一个线程a在操作ticket的时候，其他线程不可以参与进来，直到线程a操作完才可以参与，这种情况即使线程a出现了阻塞也不能被改变（安全）在Java中，通过同步机制来解决

线程的生命周期

两种线程创建方式的比较开发中：优先选择实现runnable接口的方式原因：实现的方式没有类的单继承性的局限性实现的方式更适合来处理多个线程有共享数据的情况联系：Thread也继承了Runnable接口相同点：两种方式都需要重写run方法，将线程要执行的逻辑声明在run（）中...

多线程的创建方式（二）实现Runnable接口创建一个实现了Runnable接口的类实现类去实现Runnable中的抽象方法：run（）创建实现类的对象将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象通过Thread类的对象调用start（）package com.ran;public class ran { public static void main(String[] args) { //创建实现类的对象 MT

卖票例子创建三个卖票窗口，总票数为100张package com.ran;public class ran { public static void main(String[] args) throws InterruptedException { duoxiancheng t1=new duoxiancheng(); duoxiancheng t2=new duoxiancheng(); duoxiancheng t3=new duoxian

线程优先级的设置NORM_PRIORITY：默认优先级、高优先级的线程抢占低优先级线程CPU的执行权，只是从概率上来讲，高优先级的线程高概率被执行，并不意味着只有当高优先级的线程执行完之后，低优先级的线程才执行...

线程的常用方法yield（）：有可能在下一刻又分配到当前的线程，不一定抢得过！ 类似于跳球，给你机会但是不一定是你的join（）：在线程a中调用线程b的join（）方法，此时线程a就进入阻塞状态，直到线程b完全执行以后，线程a才结束阻塞状态！类似于球权转换，球权给你，直到你把24秒进攻时间打完，才轮到我打...

创建过程中三个问题的说明不可直接run（），这样就只是对象调用run（）方法，线程根本没有启动起来再启动一个线程，遍历一百以内的偶数，不可以让已经start的线程去执行，这个时候会报非法线程异常，需要重新创建一个对象启动两个不同的线程的两种方式定义两个类，分别重新run方法，然后创建其对象，start使用匿名内部类重写run方法，start new Thread(){ @Override public void run() {

多线程的创建方式一和使用多线程的创建：方式一：继承于Thread类创建一个继承于Thread类的子类重写Thread类的run（）方法 ------------> 将此线程执行的操作声明在run（）方法中创建Thread类子类的对象通过此对象调用start（）方法package com.ran;public class ran { public static void main(String[] args) { //例子 遍历100以内所有偶数

程序、进程、线程概念

System、Math、BigInteger、BigDecimal类

使用Comparator实现定制排序当元素类型没有实现Comparable接口而又不方便修改代码，或者实现了接口但是不适合当前的操作，那么可以考虑Comparator接口。重写Compare（obj o1，obj o2）方法：如果方法返回正整数，表示o1 > o2如果返回0，表示o1 = o2如果方法返回负整数，表示o1 < o2package com.ran;import java.io.UnsupportedEncodingException;import

自定义类实现Comparable自然排序package com.ran;public class Goods implements Comparable { private String name; private double price; @Override public String toString() { return "Goods{" + "name='" + name + '\'' +

2.9 DateTimeFormatter类格式化或解析日期、时间，类似于SimpleDateFormatDateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;//格式化 日期 -----> 字符串LocalDateTime localDateTime = LocalDateTime.now();System.out.println(localDateTime);System.out.println(fo

Instant类类似于java.utils.Date//now获取的是本初子午线的时间Instant now = Instant.now();System.out.println(now); //2020-09-11T13:32:36.046Z 本初子午线时间//添加时间的偏移量OffsetDateTime offsetDateTime = now.atOffset(ZoneOffset.ofHours(8));System.out.println(offsetDateTime);

LocalDate、LocalTime、LocalDateTime说明：LocalDateTime相较于LocalDate、LocalTime，使用频率更高类似于Calendar//now（）：获取当前的日期、时间、日期+时间LocalDate localDate = LocalDate.now();LocalTime localTime = LocalTime.now();LocalDateTime localDateTime = LocalDateTime.now();System