1. 基本

   1. 程序运行

      • .java文件（源代码）–JDK中javac编译 .class 文件–JVM–二进制机器码文件
      • JVM类加载器首先加载字节码，然后通过解释器逐行解释执行。
      • 后面引入JIT编译器，JIT运行时编译，JIT完成第一次编译后保存对应的机器码。JAVA是编译与解释共存的语言。

   2. 泛型

      • 泛型是JDK1.5引入的新特性，本质是参数化类型，既操作的数据类型被指定为一个参数。

      • java的泛型是伪泛型，因java在编译期间，所有的泛型信息都会被擦掉，这也就是通常说的类型擦除

        //泛型类，泛型标识可任意，T、E、K、V等
        //一般？表示不确定的java类型
        //T(type)表示具体的一个java类型
        //KV分别代表键值对中的key value
        //E(element)代表Element
        public class Generic<Y>{private Y key;public Generic(Y key){this.key = key;}public Y getKey() {return key;}}
        //实例化泛型类
        Generic<Integer> genericInteger = new Generic<Integer>(123123);
        //泛型方法
        public static <E> void printArray(E[] inputArray){for (E ele:inputArray){System.out.printf("%s",ele);}System.out.println();}
        //使用方法
        Integer[] intArray = {1,2,3};
        String[] strArray = {"hehe","wawa"};
        printArray(intArray);
        printArray(strArray);

   3. ==和equals

      • 基本数据类型比值，引用数据类型比较内存地址，对象==比较地址判断是不是同一个对象

      • 因java只有值传递，所以不管什么类型==本质比较的都是值，数值、地址值。

      • equals()判断对象是否相等，不能比较基本数据类型的变量equals()存在Object类中，Object类是所有类的直接或间接父类

        //Object中的equals
        public boolean equals(Object obj){return (this == obj);}
        

      • 可重写equals()方法实现对象内容比较

        //String重写了equals()
        public class test{public static void main(String[] args) {String a = new String("ab");//a为一个引用String b = new String("ab");//b为另一个引用，对象的内容一样String aa = "ab";//放在常量池中String bb = "ab";//从常量池中查找if (aa == bb) System.out.println(); //trueif (a == b) System.out.println();// false 非同一个对象if (a.equals(b)) System.out.println();//trueif (42 == 42.0) System.out.println();//true}
        }
        //String中的equals()
        public boolean equals(Object anObject) {if (this == anObject) {return true;}if (anObject instanceof String) {String anotherString = (String)anObject;int n = value.length;if (n == anotherString.value.length) {char v1[] = value;char v2[] = anotherString.value;int i = 0;while (n-- != 0) {if (v1[i] != v2[i])return false;i++;}return true;}}return false;}
        

   4. hashCode()与equals()

      • hashCode()获取哈希码，返回一个int整数。作用是确定对象在哈希表中的所有位置，hashCode()定义在Object类中，意味着所有类都有hashCode()函数，另外他是本地方法，也就是c/c++实现的。该方法通常用来将对象的内存地址转换为整数之后返回。

      • HashSet查重：对象加入HashSet时，先根据对象的hashCode值判断对象加入的位置，与已加入的对象比较若有相等的hashCode值，调用equals()方法比较对象是否真的相同，相同加入失败，不同，重新散列到其他位置。这样减少了equals()次数，提升速度。《Head first java 第二版》

      • why重写equals必须重新hashCode?

        两个对象相等哈希值一定相等equals()为true，但是哈希值相等对象不一定相等，因此equals被覆盖，hashCode也必须覆盖。

        hashCode默认行为是对堆上的对象产生独特值。如果没有重新hashCode,则该class的两个对象无论如何都不会相等（即使两对象指向相同数据）

   5. 基本数据类型（8种）

      • 6种数字类型：byte(1字节，默认0)、short(2字节，默认0)、 int(4字节，默认0)、 long(8字节，默认0L)、 float(4字节，默认0f)、 double(8字节，默认0d)

      • 1种字符：char(2字节，默认’u0000’)

      • 1种布尔：boolean(1为，未知字节，默认false)

      • 对应的包装类：Byte、Short、 Integer、 Long、 Float、 Double、Character、Boolean

        boolean 官方文档未明确定义，依赖JVM厂商的具体实现。逻辑上占1位，实际考虑计算机高效存储问题

   6. 包装类和常量池

      • 对象池：为了一定程度上减少频繁创建对象，将一些对象保存到一个”容器“中

      • java基本类型的包装类大部分实现了常量池技术Byte、Short、 Integer、 Long、Character、Boolean：前四种默认创建数值[-128，127]的相应类型的缓存数据，Character创建了数值在[0，127]范围的缓存数据Boolean直接返回True 或者False，**超过对应范围仍会去开辟自己的堆内存创建新的对象。**Double、Float两种浮点数据类型则没有实现，String也实现了常量池技术。

        public static Boolean valueOf(boolean b){return (b? TRUE : FALSE);
        }
        //
        private static class CharacterCache{private CharacterCache(){}static final Character cache[] = new Character[127 + 1];static{for (int i = 0;i < cache.length;i++){cache[i] = new Character((char)i);}}
        }
        //Double、Float两种浮点数据类型则没有实现
        Integer i1 = 33;
        Integer i2 = 33;
        System.out.println(i1 == i2)//范围内输出为true
        Integer i3 = 33;
        Integer i4 = 33;
        System.out.println(i3 == i4)//范围外输出为false
        Double i5 = 1.2
        Double i6 = 1.2
        System.out.println(i5 == i6)//未实现常量池技术，都是开辟新堆内存新建对象，输出为false
        /**Integer缓存源代码
        此方法始终缓存-128，127（闭区间）范围内的值，并可以缓存此范围之外的其他值。
        */
        public static Integer valueOf(int i){if (i >= IntegerCache.low && i <= IntegerCache.high)return IntegerCache.cache[i + (-IntegerCache.low)];return new Integer(i);
        }
        //应用： 
        Integer i7 = new Integer(40) //创建新对象;
        Integer i8= 40; //编译时直接封装成Integer i = Integer.valueOf(40),使用常量池中的对象；
        //+操作符不适用Integer对象，计算时i8,i9先自动拆箱,然后Integer对象无法与数值比较，i7也自动拆箱为int值
        Integer i9 = 0;
        i7 == i8 + i9//true
        

   7. why java只有值传递？

      • 按值调用（call by value）:表示方法接收的是调用者提供的值。
      • 按引用调用（call by refrernce）:表示方法接收的是调用者提供的变量地址。
      • 方法可以修改传递引用所对应的变量值，而不能修改传递值调用所对应的变量值。
      • java值传递，方法得到的是所有参数值的一个copy，也就是说方法不能修改传递给他的任何参数变量的内容。
      • 总结
        1. 一个方法不能修改一个基本数据类型的参数（即数值类型或布尔型）
        2. 一个方法可以改变一个对象参数的状态
        3. 一个方法不能让对象参数引用一个新的对象
        4. ------《java核心技术卷Ⅰ》第十版第四章

   8. 深拷贝浅拷贝

      • Shallow Clone：基本类型值传递，引用类型引用传递。
      • Deep Clone：基本类型值传递，引用类型创建新对象并复制内容。

2. 类和对象

   1. 构造器/构造方法

      • 作用：完成对象创建的初始化工作。

      • 特点：名称与类相同；没有返回值，不能用void声明；生成类对象自动执行。

      • 构造器Constructor不能被重写Override，但是可以被重载Overload。

      • 程序执行子类的构造方法时，没super()指定父类构造方法时默认调用父类无参构造方法。

      • 既没super()指定，父类又没有无参构造方法，编译报错。

      • 自己不写，默认有无参构造方法，自己添加构造方法后（无论有参无参），不会再使用默认的无参构造方法了。

      • new对象要加（）因为默认调用了无参构造方法。

      • 调用子类构造器时会先调用父类的构造器目的是帮助子类初始化工作。

   2. 变量

      • 成员变量
        • 属于类
        • public, private,ststic,final
        • 从内存看，被static修饰这个成员变量属于类，没有static修饰则属于实例，实例对象存在堆内存中
        • 生存时间看，成员变量是对象的一部分，随对象的创建存在消失
        • 成员变量没有赋值则根据数据类型默认赋值（例外：final修饰的必须显示赋值）
      • 局部变量
        • 方法的参数或变量
        • final
        • 存于栈内存
        • 局部变量不会自动赋值
      • 对象的创建
        • new创建对象实例（对象实例存在堆内存中）
        • 对象引用指向对象实例（对象引用存放在栈内存中）
      • 封装：属性私有化，get()/set()操作
      • 继承：
        • 子类拥有父类所有的属性和方法（包括私有属性，方法）但是父类的私有属性方法子类无法访问，只是拥有
      • 多态：父类的引用指向子类的实例
        • 对象类型和引用类型之间有继承（类）/（实现）接口的关系
        • 对象类型不可变，引用类型可变
        • 方法具有多态性，属性不具有
        • 多态不能调用“只在子类不在父类”的方法。
        • 子类重写父类，执行的时子类的方法，没有覆盖执行的时父类的方法。

   3. 修饰符

      • 静态方法不可以通过对象调用，因此静态方法里不能调用其他非静态变量，也不可访问非静态成员变量。
      • 调用静态方法：“类名.方法名”；“对象名.方法名”。可以无需创建对象。
      • 调用实例方法：“对象名.方法名”
      • 静态方法再访问本类成员时，只允许访问静态成员（即静态成员变量和静态方法），不允许方法实例成员变量和实例方法。

   4. 接口、抽象类

      • 接口方法默认修饰符public，抽象方法可以public,protected,default所有方法在接口中不能实现（java8开始接口方法可以有默认实现），抽象类可以有非抽象的方法

      • 接口处理static、final变量，不能有其他变量，抽象类不一定。

      • 抽象方法就是为了被重写所以不能private修饰（java9接口允许定义私有方法）。

      • 设计层面上。抽象时对类的抽象，是一种模板设计；而接口时对行为的抽象，是一种行为规范。

        jdk8中，接口也可自定义静态方法，可直接用接口名调用。实现类和实现时不可调用的。如果同时实现两个接口，接口中定义了一样的默认方法，则必须重写，不然会报错。（详见issue:https://github.com/Snailclimb/JavaGuide/issues/146

        jdk7或之前，接口只能有常量变量和抽象方法。这些接口方法必须由选择实现接口的类实现。

        jdk8的时候接口可以有默认方法和静态方法功能。

        jdk9在接口中引入私有方法和私有静态方法。

   5. String、StringBuffer、StringBuilder

      • String不可变：String类中使用final修饰字符数组保存字符串private final har value[];java9之后改由byte数组存储private final byte[] value。

      • 当创建String类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相等的情况，有就把他赋值给当前引用。如果没有就在常量池中重新创建一个String对象。

      • StringBuffer、StringBuilder都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串har[] value但是没有用final关键字，所以都是可变的

        //AbstractStringBuilder.java
        abstract class AbstractStringBuilder implements Appendable,
        CharSequence{//the value is used for character storage.char[] value;//the count is the number of characters used.int count;AbstractStringBuilder(int capacity){value = new char[capacity];}}
        

      • 线程安全：

        • String对象不可变，线程安全；改变String回生成一个新对象
        • StringBuffer对方法加了同步锁或者调用的方法加了同步锁，线程安全。
        • StringBuilder并没有对方法进行加同步锁，非线程安全。性能比StringBuffer高10%~15%。
        • 操作少量数据：String。
        • 单线程操作字符串缓冲区下操作大量数据：用StringBuilder。
        • 多线程操作字符串缓冲区下操作大量数据：用StringBuffer。

   6. Object类

      //常用11方法
      //native方法，返回当前运行时对象的Class对象，使用final修饰，不允许子类重写
      public final native Class<?> getClass()
      //native方法，返回对象的哈希码，主要使用在哈希表中比如JDK中的HashMap。
      public native int hashCode()
      //用于比较2个对象的内存地址是否相等
      public boolean equals(Object obj)
      //创建并返回当前对象的一份拷贝。一般情况下对于任何对象x，表达式x.clone() ！=x 为true，x.clone().getClass() === x.getClass()为true。Object本身没有实现Cloneable接口，所以不重写clone方法并且进行调用的话会发生CloneNotSupportedException异常
      protected native Object clone() throws CloneNotSupportedException
      //返回类的名字@实例的哈希码的16进制的字符串。建议Object的所有子类都重写这个方法。
      public String toString()
      //唤醒一个 在此对象监视器上等待的线程（监视器相当于锁的概念）。如果有多个线程在等待智慧任意唤醒一个。
      public final native void notify()
      //跟notify()一样唯一区别会唤醒再次对象监视器上等待的所有线程，而不是一个线程。
      public final native void notfyAll()
      //暂停线程的执行。注意:sleep方法没有释放锁，而wait方法释放了。timeout是等待时间。
      public final native void wait(long timeout) throws InterruptedException
      //埵而来nanos参数，这个参数表示额外时间（以毫秒为单位，范围是0-999999）。所以超时的时间还需加上nanos毫秒。 
      public final void wait(long timeout,int nanos) throws InterruptedException
      //跟之前的2个wait方法一样，只不过该方法一直等待，没有超时的概念  
      public final void wait() throws InterruptedException
      //实例垃圾回收器回收的时候触发的操作  
      protected void finalize() throws Throwable{ }
      

   7. 获取键盘输入常用的两种方法

      • Scanner

        Scanner input = new Scanner(System.in);
        String s = input.nextLine();
        inptu.close();
        

      • BufferedReader

        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        String s = input.readLine();
        

3. 核心

   1. Collections工具类和Arrays工具类常见方法总结

   2. 异常

      • 祖先类：java.lang包中的Throwable类，Throwable类两个重要子类Exception(异常),Error(错误)

      • try-catch-finally

        • try和finally语句中都有return语句时，在方法返回之前，finally语句的内容将被执行，并且finally语句的返回值将会覆盖原始的返回值。

          //调用f(2)返回0，finally覆盖了try语句块
          public class Test{public static int f(int value){try{return value *value;}finally{if(value == 2){return 0;}}}
          }
          

        • 《Effective java》指出，面对要关闭的资源，优先try-with-resources代替try-catch-finally，产生的代码更简短更清晰。try-with-resources语句让我们更容易编写必须要关闭的资源的代码。

        • java中InputStream、OutputStream、Scanner、PrintWriter等的资源都需要我们调用close()方法手动关闭。一般情况下

          Scanner scanner = null;
          try{scanner = new Scanner(new File("D://read.txt"));while(scanner.hasNext()){System.out.println(scanner.nextLine());}
          }catch(FileNotFoundException e){e.printStackTrace();
          }finally{if(scanner !=null){scanner.close();}
          }
          

        • 使用java7之后的try-with-resources改造后

          try(Scanner scanner = new Scanner(new File("test.txt"))){while(scanner.hasNext()){System.out.println(scanner.nextLine());}
          }catch(FileNotFoundException fnfe){fnfe.printStackTrace();
          }
          

   3. 多线程

      • 程序：静态概念，数据结构+算法。（含有指令和数据的文件）

      • 线程：多个线程共享同一块内存空间和一组系统资源。

      • 进程：动态概念，程序的一次执行过程，系统运行程序的基本单位

      • 线程状态：《java并发编程艺术》4.1.4

        • 初始(new)创建后，启动前

        • 运行(runnable)，start()后，ready(可运行)，获得cpu时间片后running(运行)

          操作系统隐藏java虚拟机中的ready和running状态所以java一般将这两状态统称runnable（）状态

        • 阻塞(block)阻塞于锁

        • 等待(wating)等其他线程，wait()后,需要其他线程通知才能返回运行。

        • 超时等待(time_waiting)指定时间返回

        • 中止(terminated)

   4. 文件与IO流

      • IO流
        • 流向：输入流输出流；操作单元：字节流字符流；角色：节点流处理流。
      • 4个抽象基类
        • InputStream/Reader：所有的输入流的基类，前字节流，后字符流。
        • OutputStream/Writer：所有输出流的基类，前字节流，后字符流。
      • 有了字节流为什么还要字符流
        • 字符流是java虚拟机将字节流转换得到的，耗时，且不知道编码类型容易乱码。所有IO流就干脆提供了直接操作字符的接口，方便字符操作。音视频等媒体文件用字节流比较好。
      • BIO、NIO、AIO
        • BIO(Blocking I/O)：同步阻塞IO模式，数据读写必须阻塞在一个线程内。活动连接数不是很高（小于单机1000）情况下，可以让每个连接专注自己的IO，模型简单，不用考虑系统过载、限流等问题。线程池本身就是一个天然漏斗，可缓冲一些系统处理不了的连接或请求，面对十万以上连接不行。
        • NIO（Non-blocking/New I/O）：同步非阻塞IO模型，Java1.4引入NIO框架对应java.nio，提供了Channel,Selector,Buffer等抽象。支持面向缓冲的，基于通道的IO操作方法。NIO提供了与传统BIO模型中的Socket和ServerSocket相对应的SocketChannel和ServerSocketChannel两种不同的套接字通道实现，两种都支持阻塞和非阻塞模式。阻塞模式使用就像传统的支持一样，比较简单，但性能可靠性都不好；非阻塞模式正好与之相反。对于低负载、低并发的应用程序，可以使用同步阻塞IO提升开发速率和更好的维护性；对于高负载、高并发的（网络）应用，应使用NIO的非阻塞模式开发。
        • AIO（Asynchronous IO）：异步非阻塞IO模型，AIO也就是NIO2。java7引入NIO的改进版AIO，他是异步非阻塞的IO模型。异步是基于事件和回调机制实现的，也就是应用操作后直接返回，不会阻塞在那里，后台处理完成，操作系统会通知相应的线程进行后续的操作。

​

​

​