1. char字符型的默认值是’\u0000’

    2. 静态变量的设置必须在类主体中,而不是在方法中

    3. 编译看左边,运行看右边

    4. json对象要求属性必须加双引号

    5. 类成员变量包含类变量和实例变量

    6. 单例模式的6钟实现以及各实现的优缺点

      1. 懒汉式:线程不安全
      2. 饿汉式:线程安全
      3. 懒汉式(线程安全)
      4. 双重检查锁实现(线程安全)
      5. 静态内部类实现(线程安全)
      6. 枚举类实现(线程安全)

    7. 字符流= 字节流+编码集,所以,所有的字节流都是可以处理Unicode字符的

    8. 没有无符号左移赋值,只有无符号右移赋值.

    9. 标识符就是在java中可以辨别的命名规则,不同于关键字

    10. 接口与抽象类的关系(1.8之后)?

      1. 抽象类中的抽象方法不能用private,static,synchronized,native访问修饰符修饰
      2. 接口是一种特殊的抽象类,接口中的方法全部都是i抽象方法,但是其前面的abstract可以省略,

    11. String.split方法默认返回一个数组,如果没有分隔符,会把整个字符串当成一个长度为1 的字符串数组

    12. Spring可以实现声明式业务,包含了一个依赖注入的实现,也提供了aop面向切面的方式

    13. 在java中,如果输入一个小数,则系统默认的时double类型的,如果想表达其为小数,应该在该小数后面加上f

    14. 在类中,静态方法无法加载非静态的成员变量

    15. byte属于整形变量

      1. public class TestIncr {
      2. public static void main(String args[]) {
      3.     int i = 0;
      4.     i = i++ + i;
      5.     System.out.println("I =" +i);
      6. }
      7. }
      8. // 结果是1,而不是编译错误

    1. 局部变量参与运算前是必须要初始化的

    2. socket中,获取本地ip地址:getLocalAddress,获取主机名:getInnerAddress

    3. private只能本类调用:final就是一个锁定的值

      1. 1、jps：查看本机java进程信息。
      2. 2、jstack：打印线程的栈信息，制作线程dump文件。
      3. 3、jmap：打印内存映射，制作堆dump文件
      4. 4、jstat：性能监控工具
      5. 5、jhat：内存分析工具
      6. 6、jconsole：简易的可视化控制台
      7. 7、jvisualvm：功能强大的控制台

    1. 字符界面下接受用户从键盘输入,需要导入的包是java.io包

      1. 下列代码执行结果为（） 
      2. public static void main(String args[])throws InterruptedException{
      3.         Thread t=new Thread(new Runnable() {
      4.             public void run() {
      5.                 try {
      6.                     Thread.sleep(2000);
      7.                 } catch (InterruptedException e) {
      8.                     throw new RuntimeException(e);
      9.                 }
      10.                 System.out.print("2");
      11.             }
      12.         });
      13.         t.start();
      15.         t.join();
      16.         System.out.print("1");
      17.     }
    • 因为子线程的休眠时间太长，因此主线程很有可能在子线程之前结束也就是输出结果是12，但是子线程用了join函数，因此主线程必须等待子线程执行完毕才结束因此输出结果只能是21
      1. try-catch-finally块中，finally块在以下几种情况将不会执行
    1. 调用System.exit()函数
    2. 守护线程被终止
    3. 在try中存在死循环,或者程序没有运行到try catch语句
      1. 在java中,可以使用违例(Exception)来抛出一些非错误的消息,但是这样的话比直接从函数返回一结果要更大的系统开销
    • 因为函数调用是入栈出栈,而栈是在寄存器下的速度最快,且占用的空间少,而自定义异常是存在在堆中,异常的内存开销大
      1. 接口方法默认的是abstract public,所以在接口只写函数说明符合语法规则,但是变量默认的是用public final static修饰的,意思是它是静态常量,常量不管在接口还是在类中必须进行声明时初始化
      1. public interface CallableStatement extends PreparedStatement
      2. public interface PreparedStatement extends Statement

    1. 判断程序执行结果的标准是所有的前台线程执行完毕

    2. Collection接口:

      1. List接口:内容允许重复:

        1. ArrayList
        2. LinkedList,同时实现了Queue
        3. Vector
      2. Set接口:内容不允许重复
      3. Queue接口:队列接口
      4. sortedSet接口:单值排序接口

    3. Map接口:

      1. HashMap接口:无序存放,Key不重复
      2. HashTablle接口:无序存放,Key不重复
      3. TreeMap接口:按key排序,Key不重复
      4. IdentityHashMap接口:key可重复
      5. WeakHashMap接口:弱引用Map集合

    4. Cookie在http中是存在于headers中的,通过request.getHeader和request.getCookies()都可,String getParameter(String name)和Object getAttribute(String name),Cookie[] getCookies()和String getHeader(String name)

    5. wait()、sleep()、yield()的理解
      1）wait()是Object的实例方法，在synchronized同步环境使用，作用当前对象，会释放对象锁，需要被唤醒。
      2）sleep()是Thread的静态方法，不用在同步环境使用，作用当前线程，不释放锁。
      3）yield()是Thread的静态方法，作用当前线程，释放当前线程持有的CPU资源，将CPU让给优先级不低于自己的线程用，调用后进入就绪状态。
      牛客练习题 - 图1

        1. 1）Bootstrap ClassLoader
        2. 负责加载$JAVA_HOME中jre/lib/rt.jar里所有的class，由C++实现，不是ClassLoader子类
        3. 2）Extension ClassLoader
        4. 负责加载java平台中扩展功能的一些jar包，包括$JAVA_HOME中jre/lib/ *.jar或-Djava.ext.dirs指定目录下的jar包
        5. 3）App ClassLoader
        6. 负责记载classpath中指定的jar包及目录中class
        7. 4）Custom ClassLoader
        8. 属于应用程序根据自身需要自定义的ClassLoader，如tomcat、jboss都会根据j2ee规范自行实现ClassLoader
        9. 加载过程中会先检查类是否被已加载，检查顺序是自底向上，从Custom ClassLoader到BootStrap ClassLoader逐层检查，只要某个classloader已加载就视为已加载此类，保证此类只所有ClassLoader加载一次。而加载的顺序是自顶向下，也就是由上层来逐层尝试加载此类。

    1. 如果try中存在return,那么这个return执行结果会先暂时保存下来,finally中执行的代码再执行(一定会被执行,但是无法改变之前暂存的return值),然后再return

    2. ```java

      1. 只看尖括号里边的！！明确点和范围两个概念
      2. 如果尖括号里的是一个类，那么尖括号里的就是一个点，比如List,List,List
      3. 如果尖括号里面带有问号，那么代表一个范围，<? extends A> 代表小于等于A的范围，<? super A>代表大于等于A的范围，<?>代表全部范围
      4. 尖括号里的所有点之间互相赋值都是错，除非是俩相同的点
      5. 尖括号小范围赋值给大范围，对，大范围赋值给小范围，错。如果某点包含在某个范围里，那么可以赋值，否则，不能赋值
      6. List<?>和List 是相等的，都代表最大范围

        7. 7.补充：List既是点也是范围，当表示范围时，表示最大范围 public static void main(String[] args) { List a; List list; list = a; //A对，因为List就是List<?>，代表最大的范围，A只是其中的一个点，肯定被包含在内 List b; a = b; //B错，点之间不能相互赋值 List<?> qm; List o; qm = o; //C对，List<?>代表最大的范围，List只是一个点，肯定被包含在内 List d; List<? extends B> downB; downB = d; //D对，List<? extends B>代表小于等于B的范围，List是一个点，在其中 List<?extends A> downA; a = downA; //E错，范围不能赋值给点 a = o; //F错，List只是一个点 downA = downB; //G对，小于等于A的范围包含小于等于B的范围，因为B本来就比A小，B时A的子类嘛 }

        3.    35. 
        4. ```java
        5. System.out.println(1+"10"+3+"2");//11032
        6. System.out.println(1+2+"10"+3+"2");//31032
        7. System.out.println(1+"10"+3+1+"2");//110312
        8. // 字符串和数字之间用加号,从左往右相加,如果前面存在了字符串和数字相加操作,则后面都是字符串拼接

        1. 抽象类不能被实例化

        2. volatile能保证数据的可见性，但不能完全保证数据的原子性，synchronized即保证了数据的可见性也保证了原子性

        1. 在类方法中不能有this关键字

        2. 如果想要实现接口,实现的方法必须为public(不能够比父接口的访问权限小)

        3. 定义在同一个包（package）内的类可以不经过import而直接相互使用。

        4. File类是文件和目录路径名的抽象表示形式。

        5. 1. 32. Xmx10240m：代表最大堆

 -Xms10240m：代表最小堆

 -Xmn5120m：代表新生代

 -XXSurvivorRatio=3：代表Eden:Survivor = 3  根据Generation-Collection算法(目前大部分JVM采用的算法)，一般根据对象的生存周期将堆内存分为若干不同的区域，一般情况将新生代分为Eden ，两块Survivor；   计算Survivor大小， Eden:Survivor = 3，总大小为5120,3x+x+x=5120  x=1024

新生代大部分要回收，采用Copying算法，快！

老年代 大部分不需要回收，采用Mark-Compact算法

        1. 子类能继承父类的所有成员,如果是private修饰符修饰的变量,则可以通过反射来获取

        1. 在你面前有一个n阶的楼梯，你一步只能上1阶或2阶。请问，当N=11时，你可以采用多少种不同的方式爬完这个楼梯（）；当N=9时呢？
斐波那契数列的演变形式