Java题

第九次

每次循环都是减二，i一直不为0，所以循环为无限执行

以#开头，后面是数字和a-f的字符（大写或小写），这个值是6位或3位。要匹配一个3位是为了符合16进制颜色的简写规则

运行异常，可以通过java虚拟机来自行处理。非运行异常，我们应该捕获或者抛出

会产生信息丢失不如说丢失精度，这样可能更容易明白，而精度丢失只会发生在从大范围到小范围的转换
没有final修饰的变量相加后会被自动提升为int型，与目标类型byte不相容，需要强制转换（向下转型）
Hashtable的方法都是synchrnized修饰的线程安全，ConcurrentHashMap并发容器，JDK7采用分段锁，JDK8采用CAS算法，线程安全，建议使用，Connections工具类提供了一个方法synchrnizedMap可以把Map同步，本质就是给每一个方法加上synchrnized关键字进行同步



HttpServlet是GenericServlet的子类。
GenericServlet是个抽象类，必须给出子类才能实例化。它给 出了设计servlet的一些骨架，定义了servlet生命周期，还有一些得到名字、配置、初始化参数的方法，其设计的是和应用层协议无关的，也就是说 你有可能用非http协议实现它。
HttpServlet是子类，当然就具有GenericServlet的一切特性，还添加了doGet, doPost, doDelete, doPut, doTrace等方法对应处理http协议里的命令的请求响应过程。
一般没有特殊需要，自己写的Servlet都扩展HttpServlet

启动类加载器
负责将存放在 < JAVA_HOME > \lib目录中的，或者被-Xbootclasspath参数所指定的路径中的，并且是虚拟机识别的（仅按照文件名识别，如rt.jar,名字不符合的类库即使放在lib中也不会被加载）类库加载到虚拟机内存中。
扩展类加载器
扩展类加载器（Extension ClassLoader）:这个加载器由sun.misc.LauncherKaTeX parse error: Undefined control sequence: \lib at position 35: …责加载< JAVA_HOME>\̲l̲i̲b̲\ext目录中的，或者被jav…App-ClassLoader实现。由于这个类加载器是ClassLoader中的getSystemClassLoader()方法的返回值，所以一般也称它为系统类加载器。它负责加载用户类路径（classPath）上所指定的类库，开发者可以直接使用这个类加载器，如果应用程序中没有自定义过自己的类加载器，一般情况下这个就是程序中默认类加载器

语句1错误：b3=(b1+b2);自动转为int，所以正确写法为b3=(byte)(b1+b2);或者将b3定义为int；
语句2正确：b6=b4+b5;b4、b5为final类型，不会自动提升，所以和的类型视左边变量类型而定，即b6可以是任意数值类型；
语句3错误：b8=(b1+b4);虽然b4不会自动提升，但b1仍会自动提升，所以结果需要强转，b8=(byte)(b1+b4);
语句4错误：b7=(b2+b5); 同上。同时注意b7是final修饰，即只可赋值一次，便不可再改变

节点流：
FileInputStream，FileOutputStrean，FileReader，FileWriter
StringReader，StringWriter
ByteArrayInputStream ，ByteArrayOutputStream ，CharArrayReader
PipedInputStream PipedOutputStream PipedReaderPipedWriter
处理流：
BufferedInputStrean，BufferedOutputStream，BufferedReader，BufferedWriter
InputStreamReader，OutputStreamReader
DataInputStream，DataOutputStream
PrintWriter
节点流的前缀都是名词，如File，String，Char等；处理流的前缀都是动词，如input，print，bufferd等等

重载与返回值无关

方法的重写（override）两同两小一大原则：
方法名相同，参数类型相同
子类返回类型小于等于父类方法返回类型，
子类抛出异常小于等于父类方法抛出异常，
子类访问权限大于等于父类方法访问权限。

A:不存在x[25] 索引从0开始到length-1
B:x[24] 存的是默认值0(java中没有’\0’这一说)
C:超出内存 正确
D:第二元素

javac是将源程序.java编译成.class文件
java是将字节码转换为机器码文件执行

java规定类名首字母必须大写，这里可以直观的看出来Boolean是一个引用类型，不是基本数据类型。
java中的基本数据类型都对应一个引用类型，如Float是float的引用类型，Integer是int的引用类型

常量池中的字符串，只有变量名不同是可以用双等号判断是否相等的，内存都是常量池中的字符串
但是new出来的字符串，只能用equals，用双等号是不相等的，因为是两个内存对象

初始化为{5,3,1}
nums.add(6)后list为{5,3,1,6}
nums.add(0,4)是在0号索引上添加数字4得到list为{4,5,3,1,6}
nums.remove(1)是将1号索引上的5进行remove得到list为{4,3,1,6}

因为x的 修饰符为 static 所以x为类变量，即对于所有的实例来说，他们访问的x为同一个x，类变量存储在方法区，不属于每个实例的私有，
刚开始x=100
调用hs1.x++ x为101;
调用hs2.x++ x为102;
调用hs1.x++ x为103 (此时hs1指向了一个新的HasStatic实例，但是依然访问的是同一个X)
调用HasStatic.x-- x为102

File类能操作文件本身，但不能对文件内容进行修改

第八次

这是运算优先符。先计算t1+t2 =5 然后t1＜t2为真 然后再是三目运算符 真取前面假取后面。所以答案为2

1、本类的方法可以访问
2、反射也可以访问

不论向上或者向下转型，都是一句话，“编译看左边，运行看右边”。也就是编译时候，会看左边引用类型是否能正确编译通过，运行的时候是调用右边的对象的方法。
一旦在finally块中使用了return或throw语句，将会导致try块，catch块中的return，throw语句失效
Integer类型在-128–>127范围之间是被缓存了的，也就是每个对象的内存地址是相同的，赋值就直接从缓存中取，不会有新的对象产生，而大于这个范围，将会重新创建一个Integer对象，也就是new一个对象出来，当然地址就不同了，也就！=；

Float a = new Float(1.0); 这个的东西能存在，是因为Float类中有形参是float和double的两个构造器。
Double d = new Double(1.0F);这个能成立的原因是float向上转型了。
Float a = 1.0；这个东西不成立是因为浮点型的默认类型是double，而double不会自动转成float，然后再装箱。
Double d = 1.0f；不成立的原因是因为Double类中的装箱方法，只有valueOf(String s)和valueOf(double d)；装箱本身可不会自动向上转型啊。

一般关系数据模型和对象数据模型之间有以下对应关系：表对应类，记录对应对象，表的字段对应类的属性

i++ (先使用i, 再自增)
++i (先自增,再使用i)

局部变量必须有初始值。

静态方法中，可以调用其他类的静态方法
静态方法中可以调用实例方法，但是必须要new一个对象
静态方法中不能用this.实例方法，因为此时对象还没有

正则表达式

try,catch,finally中:
num=0,捕获异常，执行catch语句，catch中返回0，执行finally语句，finally语句中返回-1，于是返回finally中的-1；
num=1,try中返回2，执行finally语句，finally语句中返回1，于是返回finally中的1；
num=2,try中返回1，执行finally语句，finally语句中没有返回，于是返回try中的1；
num=4,try中返回0，执行finally语句，finally语句中没有返回，于是返回try中的0.

s( Single-Resposibility Principle ): 单一职责原则
o( Open-Closed principle ): 开放封闭原则
l( Liskov-Substituion Principle ): 里氏原则
i( Interface-Segregation Principle ): 接口隔离原则
d( Dependecy-Inversion Principle ): 依赖倒置原则
一个单词：立方体(solid)

深入理解Java虚拟机 书籍中p66，真正宣布一个对象死亡，至少需要经历2次标记过程。当第一次标记时会同时进行一次筛选(判断此对象是否有必要执行finalize方法)。如果对象没有覆盖该方法，就面临死亡，所以说这个方法是对象逃脱死亡命运的最后一次机会

总是为一个类提供了一个默认的构造函数是Java语言的一个重要特性 。
事实上只有在我们没有显示声明任何构造方法时java才会为我们提供一个默认的无参构造函数

运行时异常故名思议就是程序在运行的时候出现异常，隐含的一个前提就是程序在编译时是检测不到异常的存在，作者本人也并不知道是否自己的代码中含有运行时异常，所以根本也不可能提前使用try{}catch{}捕获．
1.首先，初始化父类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化；
2.然后，初始化子类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化；
3.其次，初始化父类的普通成员变量和代码块，在执行父类的构造方法；
4.最后，初始化子类的普通成员变量和代码块，在执行子类的构造方法；

函数内没有赋值

Java体系结构包括四个独立但相关的技术：
Java程序设计语言
Java.class文件格式
Java应用编程接口（API）
Java虚拟机

重载是在同一个类中，有多个方法名相同，参数列表不同(参数个数不同，参数类型不同),与方法的返回值无关，与权限修饰符无关，B中的参数列表和题目的方法完全一样了
A : 在private 修饰不能在外部类中调用，main 方法属于Test类的方法， 所以 对象 t 可以在他自己的类方法中调用它的private
B ： static 方法中没有this 这么一说
C: b不是static变量

打印顺序为A的静态代码块，A的构造代码块，A的构造函数

1.final修饰变量，则等同于常量
2.final修饰方法中的参数，称为最终参数。
3.final修饰类，则类不能被继承
4.final修饰方法，则方法不能被重写。

    try { System.out.println("Test this Project!")
    }catch (Exception e) {
      throw new Exception(e.toString());

注意throws是写在方法上，申明要抛出的异常。throw是抛出异常

接口和抽象类的区别：
1.接口的方法默认为public abstract ,接口中的变量默认为public static final，在java8之前所有的方法不能有实现
抽象类中可以有非抽象方法
2.一个类可以实现多个接口，但只能继承一个抽象类
3.一个类实现接口，要实现该接口的所有抽象方法。
4.接口不能被实例化，但可以声明，但是必须引用一个实现该接口的对象。
抽象类可以有构造方法，但是不能被直接通过new进行实例化。但可以通过子类继承，实例化子类的时候抽象类也会被实例化。
这其实用到了多态，向上转型。父类引用指向子类对象。
5.从设计层面来说，抽象类是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范

在Java7之前，switch只能支持 byte、short、char、int或者其对应的封装类以及Enum类型。在Java7中，也支持了String类型
String byte short int char Enum 类型


数组a.equals(数组b)，和Arrays.equals(数组a,数组b)是不同的

第七次

Map接口有两个金典的子类分别是 Hashtable 和 Hashmap。
Hashtable 线程安全，不支持key和value为空，key不能重复，但value可以重复，不支持key和value为null。
Hashmap 非线程安全，支持key和value为空，key不能重复，但value可以重复，支持key和value为null。



既然是实现接口，就要实现接口的所以方法，相当于重写方法，方法的重写需要满足：三同一大一小（方法名、返回值类型、形参相同；访问权限>=重写前；抛出异常<=重写前）
length 返回当前长度
如果字符串长度没有初始化长度大，capacity返回初始化的长度
如果append后的字符串长度超过初始化长度，capacity返回增长后的长度

1、Statement对象用于执行不带参数的简单SQL语句。
2、Prepared Statement 对象用于执行预编译SQL语句。
3、Callable Statement对象用于执行对存储过程的调用。

题目中有要求是‘整型’‘常量’ ，所以int final这两个关键字必须有，而被final修饰的常量必须赋值，所以选C
返回的都是字符串,只有char变成 int 的时候才会变为对应的assic码
Arraylist默认数组大小是10，扩容后的大小是扩容前的1.5倍，最大值小于Integer 的最大值减8，如果新创建的集合有带初始值，默认就是传入的大小，也就不会扩容

jvm中没有进程的概念 ，但是jvm中的线程映射为操作系统中的进程，对应关系为1：1。那这道题的问的就是jvm中线程如何异步执行 。 在jvm中 是使用监视器锁来实现不同线程的异步执行， 在语法的表现就是synchronized

A、正确，就这3个，没什么好说的
B、错误，类（接口）相同的条件：全限定名相同 + 使用相同类加载器加载
C、正确，没什么好说的
D、错误，ClassLoader 的 loadClass 方法加载不存在的类会抛 ClassNotFoundException
E、正确，双亲委派模式机制就是扔给父类加载器解决，解决不了再传递回来
F、错误，Boostrap加载器加载核心库类，Extension加载器加载 jre/lib/ext 下的类，System加载器加载CLASSPATH环境指定路径的类

记住特殊情况， System.exit(0) 可以直接终止程序，其他情况就是无论如何都会执行 finally

A，类是一个封装，类的成员只能在类内部使用，外部需要 “对象名.变量名” 来引用。
B，正确，局部变量只在定义它的代码块或者函数内部可见
C，跟类的成员变量一样，需要指定对象才能引用
D，如果类没有构造方法，JVM会生成一个默认构造方法，如果定义了任意类型的构造方法，编译器都不会自动生成构造方法。

考for循环的执行顺序，1.先执行初始化条件，2.执行判断条件，3.如果满足2的条件，执行循环体中代码；4.执行foo(‘c’), 5.初始化条件不在执行，友从2开始执行
A，我们写java程序的时候只是设定事物的隔离级别，而不是去实现它
B，Hibernate是一个java的数据持久化框架，方便数据库的访问
C，事物隔离级别由数据库系统实现，是数据库系统本身的一个功能
D，JDBC是java database connector，也就是java访问数据库的驱动

匹配到case 2 num->3 但是其后没有break,所以继续执行case 3 num->4、default num->5而后结束,所以答案为 5

String str1 = new String("hello");
这种方式创建的字符串，和正常创建对象一样，保存在堆区。
String str3 = "hello";
这种方式创建的字符串，保存在字符串常量区。

因为 String 是不可变类型，是存储在常量字符区的， 所以答案是ABCD。

答案是 A foobar 这道题是考线程的调用情况，线程的启动方式只能通过start这种方式启动才能真正的实现多线程的效果，如果是手动调用run方法和普通方法调用没有区别，所以这个还是按照顺序执行首先执行run方法之后，执行输出语句所以最终得到结果foobar.

构造方法不能被子类继承，所以用final修饰没有意义。构造方法用于创建一个新的对象，不能作为类的静态方法，所以用static修饰没有意义。此外，Java语言不支持native或synchronized的构造方法
"|"是按位或：先判断条件1，不管条件1是否可以决定结果（这里决定结果为true)，都会执行条件2
"||"是逻辑或：先判断条件1，如果条件1可以决定结果（这里决定结果为true)，那么就不会执行条件2

四个选项都是Swing组件。JTextField输入单行文本，JTextArea输入多行文本，JButton显示按钮，JLebel提示信息
count = count++ 原理是 temp = count； count = count+1 ； count = temp； 因此count始终是0


栈的规则：先进后出
例如进栈序列为：1，2，3，4
全部进栈完成再出栈的序列则为：4，3，2，1
注：一个元素进栈后可以马上出栈，不用等全部进栈
例如：2这个元素一进就想出了，后面的3，4正常进栈再出栈。
那么出栈顺序就是：2，4，3，1 (1是第一个进的，进的时候也没有立刻出去，所以被压在栈底，最后才能出去）
例如：2这个元素一进就想出了，后面的3一进也想立刻想出去了，后面的4跟着进栈
那么出栈顺序就是：2，3，4，1 (2，3都进了立刻出 所以这时4压着的是1，所以出栈顺序是4在前面）

(s==u) ，因为， s 是 Integer 类型， u 是 Long 类型，两个不同类型的引用不能进行 == 比较。

(s==t) ， s 是指向一个 9 的引用，而 t 也是一个指向 9 的引用，虽然都是指向 9 ，但却是指向不同的 9 ，即是两个不同的引用。因此 == 比较返回的是假。
(s.equals(t)) ， Integer 的 equals 方法如下：

   public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false ;
	}

是 Integer 的实例且 value 值也相等的情况下返回真，其他返回假。
在这里， s 和 t 都是 Integer 类型且值都为 9 ，因此结果为真。
(s.equals(9)) , 在进行 equals 比较之前，会对 9 调用 Integer.valueOf 方法，进行自动装箱 , 由于 IntegerCache 中已经存在 9 ，所以，直接返回其引用，引用相同， equals 就自然相同了。所以结果为真。
(s.equals( new Integer(9)) ，直接创建了一个新的 Integer 实例，但且值也为 9 ，所以，满足条件，返回真。

abstract修饰的类是抽象类，是可以继承的，而final修饰的类表示不能再被继承，故肯定不能共同使用。故B错。
HashMap中提供的get(key)获取的是变量，无法判断是否存在key。所以C是错的
volatile关键字是一种轻量级的同步机制，只保证数据的可见性，而不保证数据的原子性。故D对

is-a 表示继承：Gadget is-a Widget就表示Gadget 继承 Widget；
has-a表示从属：Gadget has-a Sprocket就表示Gadget中有Sprocket的引用，Sprocket是Gadget的组成部分；
like-a表示组合：如果A like-a B，那么B就是A的接口

hashCode()的存在是为了查找的快捷性,用于在散列存储结构中确定对象的存储地址
如果两个对象 equals相等,则 hashCode()也一定相等
如果 equals方法被重写,则 hashCode()也应该被重写
如果两个对象的 hashCode()相等, equals()方法不一定相等
equals方法没有重写,比较的就是应用类型的变量所指向的对象的地址

第六次
数组的角标是从0开始的。从arr[0]到arr[arr.length-1]

接口中的所以方法都是抽象的-方法定义
接口中的值都是public static final的-常量值

封装主要是隐藏内部代码；
继承主要是复用现有代码；
多态主要是改写对象行为。

选C
A、说反了。父类引用指向子类对象
B、类都是单继承。
D、抽象类也可以继承。

每次-2， 减三次1 减第四次－1 等不到0，理论一直做

静态方法中不能调用对象的变量，因为静态方法在类加载时就初始化，对象变量需要在新建对象后才能使用

抽象类中的抽象方法（其前有abstract修饰）不能用private、static、synchronized、native访问修饰符修饰。原因如下：抽象方法没有方法体，是用来被继承的，所以不能用private修饰；static修饰的方法可以通过类名来访问该方法（即该方法的方法体），抽象方法用static修饰没有意义；使用synchronized关键字是为该方法加一个锁。。而如果该关键字修饰的方法是static方法。则使用的锁就是class变量的锁。如果是修饰 类方法。则用this变量锁。但是抽象类不能实例化对象，因为该方法不是在该抽象类中实现的。是在其子类实现的。所以。锁应该归其子类所有。所以。抽象方 法也就不能用synchronized关键字修饰了；native，这个东西本身就和abstract冲突，他们都是方法的声明，只是一个吧方法实现移交给子类，另一个是移交给本地操作系统。如果同时出现，就相当于即把实现移交给子类，又把实现移交给本地操作系统，那到底谁来实现具体方法呢？
接口是一种特殊的抽象类，接口中的方法全部是抽象方法（但其前的abstract可以省略），所以抽象类中的抽象方法不能用的访问修饰符这里也不能用。而且protected访问修饰符也不能使用，因为接口可以让所有的类去 实现（非继承） ，不只是其子类，但是要用public去修饰。接口可以去继承一个已有的接口。

成员变量有初始值，而局部变量没有初始值得。本体中的s定义在方法中所以为局部变量-没有初始值。变量没有初始值就使用了，编译通不过
重写了object 的equals 的方法，使他怎么输出都是true
A.Java中涉及到byte、short和char类型都可以强制转化为int，符合返回类型 A正确
B.方法中定义为void 应该没有返回值，但返回值为boolean类型 B错
C. 方法中类型为int，应该返回int类型值，但是 返回值为boolean类型 C错
D.方法应该定义为int(int a,int b)，所以D错

注意看i
在第7行的时候，调用的是t.run();方法，之间调用run方法就是普通的方法调用而已，所以肯定是先执行pong()再执行System.out.print(“ping”);
如果第7行换成t.start()方法，答案就应该选择c，因为t.start()后，线程变为就绪状态，什么时候开始执行时不确定的，可能是主程序先继续执行，也可能是新线程先执行。

依赖注入和控制反转是对同一件事情的不同描述，从某个方面讲，就是它们描述的角度不同。依赖注入是从应用程序的角度在描述，可以把依赖注入描述完整点：应用程序依赖容器创建并注入它所需要的外部资源；而控制反转是从容器的角度在描述，描述完整点：容器控制应用程序，由容器反向的向应用程序注入应用程序所需要的外部资源

A this指当前对象只能在实际方法和构造函数中调用。C 可以调用其他类的非私有类方法。D 不能直接调用，到先生成对象。通过对象即可调用实例方法

这在java中是正确的，在C语言中是错误的，java的char类型占两个字节，默认使用GBK编码存储。这种写法是正确的，此外java还可以用中文做变量名

字符串在java中存储在字符串常量区中，判断的是对象引用是否是同一个引用，判断字符串相等要用equals方法
首先判断a==MESSAGE 同一份字符串常量在内存中只有一份，因此是同一地址，返回true
再次比较(b+c)==MESSAGE 这相当于 new String(b+c)==MESSAGE 这里new了一个String对象，所以返回false

这题选A，考察的是值传递与引用传递，Java中原始数据类型都是值传递，传递的是值得副本，形参的改变不会影响实际参数的值， 引用传递传递的是引用类型数据，包括String,数组，列表, map,类对象等类型，形参与实参指向的是同一内存地址，因此形参改变会影响实参的值。

除了jre中的JVM不是用java实现的，jdk的开发工具包应该都是用java写的
子类构造方法在调用时必须先调用父类的，由于父类没有无参构造，必须在子类中显式调用

由于replaceAll方法的第一个参数是一个正则表达式，而".“在正则表达式中表示任何字符，所以会把前面字符串的所有字符都替换成”/"。如果想替换的只是"."，那么久要写成"\."

exception是JSP九大内置对象之一，其实例代表其他页面的异常和错误。只有当页面是错误处理页面时，即isErroePage为 true时，该对象才可以使用。对于C项，errorPage的实质就是JSP的异常处理机制,发生异常时才会跳转到 errorPage指定的页面，没必要给errorPage再设置一个errorPage。所以当errorPage属性存在时， isErrorPage属性值为false

在一个子类被创建的时候，首先会在内存中创建一个父类对象，然后在父类对象外部放上子类独有的属性，两者合起来形成一个子类的对象。所以所谓的继承使子类拥有父类所有的属性和方法其实可以这样理解，子类对象确实拥有父类对象中所有的属性和方法，但是父类对象中的私有属性和方法，子类是无法访问到的，只是拥有，但不能使用。就像有些东西你可能拥有，但是你并不能使用。所以子类对象是绝对大于父类对象的，所谓的子类对象只能继承父类非私有的属性及方法的说法是错误的。可以继承，只是无法访问到而已

重写(Overriding)是父类与子类之间多态性的一种表现，类的不同实现可以重写父类方法，实现同方法名，同参数，同返回类型，不同的实现。重载(Overloading)最典型的就是一个类的不同构造函数，方法名相同，参数个数不同，返回类型也可以不同，重载是一个类中多态性的一种表现。
函数方法名必须相同，看参数列表即可，无关返回值

null表示没有地址；null可以赋值给引用变量，不能将null赋给基本类型变量，例如int、double、float、boolean

私有线程区域：
程序计数器、虚拟机栈、本地方法栈
线程共享区域：
堆、方法区


接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。另外，接口和抽象类在方法上有区别：
1.抽象类可以有构造方法，接口中不能有构造方法。
2.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
3.抽象类中可以有普通成员变量，接口中没有普通成员变量
4. 抽象类中的抽象方法的访问类型可以是public，protected和默认类型
5. 抽象类中可以包含静态方法，接口中不能包含静态方法
6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型
7. 一个类可以实现多个接口，但只能继承一个抽象类。二者在应用方面也有一定的区别：接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。而抽象类在代码实现方面发挥作用，可以实现代码的重用，例如，模板方法设计模式是抽象类的一个典型应用，假设某个项目的所有Servlet类都要用相同的方式进行权限判断、记录访问日志和处理异常，那么就可以定义一个抽象的基类，让所有的Servlet都继承这个抽象基类，在抽象基类的service方法中完成权限判断、记录访问日志和处理异常的代码，在各个子类中只是完成各自的业务逻辑代码。

方法a为同步方法，方法b里面的是同步块，同步方法使用的锁是固有对象this，同步块使用的锁可以是任意对象，但是方法b里面的同步块使用的锁是对象this，所以方法a和方法b锁住的是同一个对象。方法 c为静态同步方法，使用的锁是该类的字节码文件，也就是Test.class。方法d里面的也是同步块，只不过使用的锁是Test.class，所以方法c和方法d锁住的是同一个对象

1.静态内部类才可以声明静态方法
2.静态方法不可以使用非静态变量
3.抽象方法不可以有函数体

第五次

1、一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程（通常说的主线程）。
2、资源分配给进程，同一进程的所有线程共享该进程的所有资源。
3、线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。
4、处理机分给线程，即真正在处理机上运行的是线程。
5、线程是指进程内的一个执行单元，也是进程内的可调度实体。

ava中线程分为两种类型：
1：用户线程。通过Thread.setDaemon(false)设置为用户线程；
2：守护线程。通过Thread.setDaemon(true)设置为守护线程，如果不设置，默认用户线程；
守护线程是服务用户线程的线程，在它启动之前必须先set。

采用synchronized修饰符实现的同步机制叫做互斥锁机制，它所获得的锁叫做互斥锁。每个对象都有一个monitor(锁标记)，当线程拥有这个锁标记时才能访问这个资源，没有锁标记便进入锁池。任何一个对象系统都会为其创建一个互斥锁，这个锁是为了分配给线程的，防止打断原子操作。每个对象的锁只能分配给一个线程，因此叫做互斥锁。

RMI采用的是TCP/IP协议
Map接口和Collection接口是同一等级的

对于线程而言，start是让线程从new变成runnable。run方法才是执行体的入口。
但是在Thread中，run方法是个空方法，没有具体实现。
Bground继承了Thread，但是没有重写run方法，那么调用run方法肯定是无输出。

substring实际是new，5字符
str3和4也都是new，每个5字符
分别都会创建新的对象
常量池是PermGen的
因此应该是一共15字符

-Xmx2G：设置JVM最大可用内存为2G。
-Xms1G：设置JVM促使内存为1G。此值可以设置与-Xmx相同，以避免每次垃圾回收完成后JVM重新分配内存。
-Xmn500M：设置年轻代大小为2G。整个JVM内存大小=年轻代大小 + 年老代大小 + 持久代大小。
-XX:SurvivorRatio=3:新生代中又会划分为 Eden 区，from Survivor、to Survivor 区。
其中 Eden 和 Survivor 区的比例默认是 8:1:1，当然也支持参数调整 -XX:SurvivorRatio=3的话就是3:1:1。
故该题为500*（3/5）=300M.

理解为适配器模式，继承该类则不需要实现一个接口全部方法。

DE 数据成员和函数成员默认是default访问权限，同一个包下的所有类都可以访问
类B不一定和类A同包，所以DE才错

对象赋值时，比如A=B，只是把A对象的地址指向了B对象的地址，所以其实对象只有一个
单例模式，obj1和obj2其实是一个对象,应该返回true

floor ： 意为地板，指向下取整，返回不大于它的最大整数 ceil ： 意为天花板，指向上取整，返回不小于它的最小整数 round ： 意为大约，表示“四舍五入”，而四舍五入是往大数方向入。Math.round(11.5)的结果为12，Math.round(-11.5)的结果为-11而不是-12

用new创建的对象在堆区
函数中的临时变量在栈去
java中的字符串在字符串常量区

常用ASCII码值：空格为32；数字0为48；“A”为65；“a”值为97。

字节型 ： 0 -2^7—-27-1 byte b=10;
字符型 ： ‘ \u0000′ 0—-2^16-1 char c=’c’ ;
short : 0 -2^15—-215-1 short s=10;
int : 0 -2^31—-231-1 int i=10;
long : 0 -2^63—-263-1 long o=10L;
float : 0.0f -2^31—-231-1 float f=10.0F
double : 0.0d -2^63—-263-1 double d=10.0;
boolean: false true\false boolean flag=true;

GUI PANEL 容器以及布局管理器 Panel是AWT中的另一个典型的容器，它代表不能独立存在、必须放在其他容器中使用。 1、可作为容器来盛装其他组件，为放置组件提供空间。 2、不能单独存在，必须放置到其他容器当中。 3、默认使用FlowLayout作为布局管理器。

1.静态语句块中x为局部变量，不影响静态变量x的值
2.x和y为静态变量，默认初始值为0，属于当前类，其值得改变会影响整个类运行。
3.java中自增操作非原子性的
main方法中：
执行x–后 x=-1
调用myMethod方法，x执行x++结果为-1(后++)，但x=0，++x结果1，x=1 ，则y=0
x+y+ ++x,先执行x+y，结果为1，执行++x结果为2，得到最终结果为3

逻辑运算符：&&和|| 是按照“短路”方式求值的。如果第一个操作数已经能够确定表达式的值，第二个操作数就不必计算了
位移运算符：&和| 运算符应用于布尔值，得到的结果也是布尔值，不按“短路”方式计算。即在得到计算结果之前，一定要计算两个操作数的值。

Java集合框架主要由Collection和Map两个根接口及其子接口、实现类组成。 collection 的子接口包括List,set,queue。而Map包括三个实现类HashMap，HashTable，LinkeHashMap


++在前表示先使用再计算，++在后表示先计算再使用。第一次输出时，先使用m的值（12），再将m加1（13），先将n加1（35）,在使用n的值（35）.所以此时输出的结果为1235，第二次输出之前m = 13,n = 35,同理，此时输出为3514，两次输出加起来即为12353514
初始化块在构造器执行之前执行，类初始化阶段先执行最顶层父类的静态初始化块，依次向下执行，最后执行当前类的静态初始化块；创建对象时，先调用顶层父类的构造方法，依次向下执行，最后调用本类的构造方法。

类实现多个接口的时候，只需要一个implements，多个接口通过逗号进行隔开，先继承类再实现接口

应该是：public>protected>默认(包访问权限)>private，因为protected除了可以被同一包访问，还可以被包外的子类所访问

catch可以省略，try的形式有三种：
try-catch
try-finally
try-catch-finally
但catch和finally语句不能同时省略！

RandomAccessFile 可以通过 seek(long pos) 方法去移动文件指针进行追加更新写入.
OutputStream() 是一个抽象类 不能直接实例化去写入
DataOutputStream() 也无法追加写入

如果在常量池中已经存在“xyz”，那么不会继续创建，只创建一个new String(“xyz”)的对象。如果常量池中没有，则会创建两个对象，一个是对象的值“xyz”，一个是new String(“xyz”)的对象

throws用于在方法上声明该方法不需要处理的异常类型,用在方法上后面跟异常类名 可以是多个异常类
throw用于抛出具体异常类的对象,用在方法内 后面跟异常对象只能是一个异常类型实体.
try块必须和catch块或和finally同在,不能单独存在,二者必须出现一个.
finally块总会执行,不论是否有错误出现.但是若try语句块或会执行的catch语句块使用了JVM系统退出语句,finally块就不会被执行了. 一般我们把关闭资源的代码放在finally里面 保证资源总是能关闭

java对象初始化顺序
父类静态代码块，父类静态成员变量（同级，按代码顺序执行）
子类静态代码块，子类静态成员变量（同级，按代码顺序执行）
父类普通代码块，父类普通成员变量（同级，按代码顺序执行）
父类构造方法
子类普通代码块，子类普通成员变量（同级，按代码顺序执行）
子类构造方法

第四次
private : 修饰私有变量
public : 修饰公有变量
protected: 修饰受保护变量
没有final, final用于保护变量不受改变

Java中类是单继承，但接口可以多继承，Interfere1 extends Interface2,Interface3…

在上面main()方法中，并没有创建一个新的线程，只是简单地方法调用而已，如果想要创建线程，需要t.start();创建线程，等待cpu时间片，而run()方法只是简单地方法调用，所以先执行run()，在输出dazhong
没有break，从case 4开始一直执行到最后，j自加3次变成了4,结果返回8
return i++, 先返回i，然后i+1；
第一次调用getNext()方法时，返回的是1，但此时i=2；
第二次调用 getNext()方法时，返回的是2，但此时i=3；
第三次调用 getNext()方法时，返回的是3，但此时i=4；

public void foo(){} 方法名相同，返回值不同–>不是重写；而参数列表与父类相同，那么也不是重载。
public int foo(){return 1;} 方法名相同，返回值不同–>不是重写；而参数列表与父类相同，那么也不是重载。
public A foo(B b){return b;} 方法名相同，返回值（无所谓），而参数列表与父类不相同，那么是重载。另：B是A的子类，根据里氏替换原则/自动向上转型，可以这个选项正确。
public A foo(){return A;} 方法名相同，返回值相同，而参数列表也与父类相同，那么也不是重载。

weblogic中开发消息Bean时的persistent与non-persisten的差别：
persistent方式的MDB可以保证消息传递的可靠性,也就是如果EJB容器出现问题而JMS服务器依然会将消息在此MDB可用的时候发送过来。
non－persistent方式的消息将被丢弃。

正则表达式
https://www.jianshu.com/p/3c076c6b2dc8

Java通过方法重写和方法重载实现多态
方法重写是指子类重写了父类的同名方法
方法重载是指在同一个类中，方法的名字相同，但是参数列表不同

list有序可重复，set无序不可重复

静态成员和静态方法，可以直接通过类名进行调用；其他的成员和方法则需要进行实例化成对象之后，通过对象来调用
原生类是指Java中，数据类型分为基本数据类型（或叫做原生类、内置类型）和引用数据类型
throws：写在方法声明之后，表示方法可能抛出异常，调用者需要处理这个异常
throw：写在方法体中，表示方法一定会抛出一个异常，要么try…catch处理，要么throws抛出
本题正是有了throw，所以才会顺序执行，否则不执行catch块中的语句

HashMap可以插入null的key或value，插入的时候，检查是否已经存在相同的key，如果不存在，则直接插入，如果存在，则用新的value替换旧的value，在本题中，第一条put语句，会将key/value对插入HashMap，而第二条put，因为已经存在一个key为name的项，所以会用新的value替换旧的vaue，因此，两条put之后，HashMap中只有一个key/value键值对。那就是（name，jack）。所以，size为1

t.run是调用的Thead类中的run()方法，t.start才是执行线程，所以这题就是执行普通run()方法，先输出pong，在输出ping

构造函数不能被继承，构造方法只能被显式或隐式的调用

1.Java三大注解分别是@Override @Deprecated @Suppresswarnings
2.@Override 注解表名子类中覆盖了超类中的某个方法，如果写错了覆盖形式，编译器会报错
3.@Deprecated 表明不希望别人在以后使用这个类，方法，变量等等
4.@Suppresswarnings 达到抑制编译器产生警告的目的，但是不建议使用，因为后期编码人员看不懂编译器提示的警告，不能更好的选择更好的类去完成任务

A选项是RuntimeException的定义;
B选项是把Error的第二段定义拿来改掉换成RuntimeException,但这样说对于RuntimeException也没错;
C选项也是把Error的定义换成了RuntimeException,但这里的"indicates serious problems"不应该用在RuntimeException上,Error才表示严重的错误,RuntimeException并不是.

String是引用类型类型常量，所以赋值会让两个String指向同一个字符串
session.setAttribute()和session.getAttribute()配对使用，作用域是整个会话期间，在所有的页面都使用这些数据的时候使用。request.getAttribute()表示从request范围取得设置的属性，必须要先setAttribute设置属性，才能通过getAttribute来取得，设置与取得的为Object对象类型。其实表单控件中的Object的 name与value是存放在一个哈希表中的，所以在这里给出Object的name会到哈希表中找出对应它的value。setAttribute()的参数是String和Object。
在Java中5.0是double类型,所以结果的数据类型为double。因为1/4结果为0，所以结果为-6.0

Socket套接字
就是源Ip地址，目标IP地址，源端口号和目标端口号的组合
服务器端：ServerSocket提供的实例
ServerSocket server= new ServerSocket(端口号)
客户端：Socket提供的实例
Socket soc=new Socket(ip地址，端口号)

方法重写应遵循“三同一小一大”原则：
“三同”：即方法名相同，形参列表相同，返回值类型相同；
“一小”：子类方法声明抛出的异常比父类方法声明抛出的异常更小或者相等；
“一大”:子类方法的访问修饰符应比父类方法更大或相等

Java提供的事件处理模型是一种人机交互模型。它有三个基本要素：
事件源（Event Source）：即事件发生的场所，就是指各个组件，如按钮等，点击按钮其实就是组件上发生的一个事件；
事件（Event）：事件封装了组件上发生的事情，比如按钮单击、按钮松开等等；
事件监听器（Event Listener）：负责监听事件源上发生的特定类型的事件，当事件到来时还必须负责处理相应的事件；

B、C f1、f2、f3是数组，是引用类型，f、x是基本类型。基本类型之间的比较，应该会将低精度类型自动转为高精度类型再比较,B选项是long和float比较，相当于long和long比较，所以B对
Java有5种方式来创建对象：
使用 new 关键字（最常用）： ObjectName obj = new ObjectName();
使用反射的Class类的newInstance()方法： ObjectName obj = ObjectName.class.newInstance();
使用反射的Constructor类的newInstance()方法： ObjectName obj = ObjectName.class.getConstructor.newInstance();
使用对象克隆clone()方法： ObjectName obj = obj.clone();
使用反序列化（ObjectInputStream）的readObject()方法： try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(FILE_NAME))) { ObjectName obj = ois.readObject(); }


resume与suspended一起使用
wait与notify(notifyAll)一起使用
sleep会让线程暂时不执行

USES-A：依赖关系，A类会用到B类，这种关系具有偶然性，临时性。但B类的变化会影响A类。这种在代码中的体现为：A类方法中的参数包含了B类。
关联关系：A类会用到B类，这是一种强依赖关系，是长期的并非偶然。在代码中的表现为：A类的成员变量中含有B类。
HAS-A：聚合关系，拥有关系，是关联关系的一种特例，是整体和部分的关系。比如鸟群和鸟的关系是聚合关系，鸟群中每个部分都是鸟。
IS-A：表示继承。父类与子类，这个就不解释了。
要注意：还有一种关系：组合关系也是关联关系的一种特例，它体现一种contains-a的关系，这种关系比聚合更强，也称为强聚合。它同样体现整体与部分的关系，但这种整体和部分是不可分割的

第三次
java.awt：包含构成抽象窗口工具集的多个类，用来构建和管理应用程序的图形用户界面
java.lang：提供java编成语言的程序设计的基础类
java.io：包含提供多种输出输入功能的类，
java.net：包含执行与网络有关的类，如URL，SCOKET，SEVERSOCKET，
java.applet：包含java小应用程序的类
java.util：包含一些实用性的类


JAVA的JVM的内存可分为3个区：堆(heap)、栈(stack)和方法区(method)
栈区:每个线程包含一个栈区，栈中只保存方法中（不包括对象的成员变量）的基础数据类型和自定义对象的引用(不是对象)，对象都存放在堆区中
每个栈中的数据(原始类型和对象引用)都是私有的，其他栈不能访问。
栈分为3个部分：基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。
堆区:存储的全部是对象实例，每个对象都包含一个与之对应的class的信息(class信息存放在方法区)。
jvm只有一个堆区(heap)被所有线程共享，堆中不存放基本类型和对象引用，只存放对象本身，几乎所有的对象实例和数组都在堆中分配。
方法区:又叫静态区，跟堆一样，被所有的线程共享。它用于存储已经被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

JSP 四大作用域： page (作用范围最小)、request、session、application（作用范围最大）。
存储在application对象中的属性可以被同一个WEB应用程序中的所有Servlet和JSP页面访问。（属性作用范围最大）
存储在session对象中的属性可以被属于同一个会话（浏览器打开直到关闭称为一次会话，且在此期间会话不失效）的所有Servlet和JSP页面访问。
存储在request对象中的属性可以被属于同一个请求的所有Servlet和JSP页面访问（在有转发的情况下可以跨页面获取属性值），例如使用PageContext.forward和PageContext.include方法连接起来的多个Servlet和JSP页面。
存储在pageContext对象中的属性仅可以被当前JSP页面的当前响应过程中调用的各个组件访问，例如，正在响应当前请求的JSP页面和它调用的各个自定义标签类。

初始条件是x=2，循环终止的条件是x>=n/2,执行一次循环，x就乘以2，所以执行t次循环后，x的值为2的t+1次方，若此时达到终止条件，则2的t+1次方=n/2。

1、java文件中类型为public的类有两种，一种是外部类，一种是内部类；
2、当外部类的类型为public时，文件名需要与其相同；
3、当内部类的类型为public时，而外部类不是public类型的，则文件名可随意，但需要满足命名规范（以字母或下划线开头）

Java在序列化时不会实例化static变量和transient修饰的变量，因为static代表类的成员，transient代表对象的临时数据，被声明这两种类型的数据成员不能被序列化

shell中的特殊变量：
变量名
含义
$0
shell或shell脚本的名字
$*
以一对双引号给出参数列表
$@
将各个参数分别加双引号返回
$#
参数的个数
$_
代表上一个命令的最后一个参数
$$
代表所在命令的PID
$!
代表最后执行的后台命令的PID
$?
代表上一个命令执行后的退出状态 echo $? 如果返回值是0，就是执行成功；如果是返回值是0以外的值，就是失败。

局部变量可以先申明不用必须初始化，但使用到了一定要先初始化

HashMap,TreeMap 未进行同步考虑，是线程不安全的。
HashTable 和 ConcurrentHashMap 都是线程安全的。区别在于他们对加锁的范围不同，HashTable 对整张Hash表进行加锁，而ConcurrentHashMap将Hash表分为16桶(segment)，每次只对需要的桶进行加锁。
Collections 类提供了synchronizedXxx()方法，可以将指定的集合包装成线程同步的集合。比如，
List list = Collections.synchronizedList(new ArrayList());
Set set = Collections.synchronizedSet(new HashSet());

类支持单继承，接口支持多继承

在空闲时间以不定时的方式动态回收无任何引用的对象占据的内存空间

静态内部类可以访问外围类的静态数据，包括私有数据，但不能访问非静态数据；
非静态内部类可以直接访问外围类的数据，包括私有数据

这个程序就是在删除数组中的0 ，但是会有个小问题，就是连续的0会只删除一个
原因：当执行remove的时候，ArrayList 数组的 size 会变小一个，原本的位置上的 0 会被后面的 0 给替代；而在执行完remove后执行了k++;所以跳过了第二个0

服务器端，首先是服务器初始化Socket，然后是与端口进行绑定(blind()),端口创建ServerSocket进行监听(listen()),然后调用阻塞(accept()),等待客户端连接。与客户端发生连接后，会进行相关的读写操作(read(),write())，最后调用close()关闭连接

算法包括0个或多个输入，1个或多个输出，中间有穷个处理过程。
存储结构不属于算法结构

Object.equals()比较的是两个数组的地址，相当于==的作用，如果是遍历数组中的元素，进行一一比较，应该选择Arrays.equals()

run()方法用来执行线程体中具体的内容
start()方法用来启动线程对象，使其进入就绪状态
sleep()方法用来使线程进入睡眠状态
suspend()方法用来使线程挂起，要通过resume()方法使其重新启动

1，新生代：（1）所有对象创建在新生代的Eden区，当Eden区满后触发新生代的Minor GC，将Eden区和非空闲Survivor区存活的对象复制到另外一个空闲的Survivor区中。（2）保证一个Survivor区是空的，新生代Minor GC就是在两个Survivor区之间相互复制存活对象，直到Survivor区满为止。
2，老年代：当Survivor区也满了之后就通过Minor GC将对象复制到老年代。老年代也满了的话，就将触发Full GC，针对整个堆（包括新生代、老年代、持久代）进行垃圾回收。
3，持久代：持久代如果满了，将触发Full GC。

1、super()表示调用父类构造函数、this()调用自己的构造函数，而自己的构造函数第一行要使用super()调用父类的构造函数，所以这俩不能在一个构造函数中会出现重复引用的情况
2、super()和this()必须在构造函数第一行，所以这一点也表明他俩不能在一个构造函数中
3、this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块(里面不能使用非static类型的)。

接口的方法都是 public abstract 变量都是public static final的 ，方法只能通过接口调用，不能通过实现类调用

Java中类之间的六种关系：
第一种：继承关系，例如：子类继承父类，子接口继承父接口。
第二种：实现关系，例如：类实现接口。
第三种：依赖关系，例如：一个类作为另一个类中方法的参数存在，这种关系具有偶然性和临时性。
第四种：关联关系，例如：一个类作为另一个类中的成员变量存在，它是一种强依赖关系。
第五种：聚合关系，例如：整体和部分之间，他们是可以分离的拥有各自的生命周期，并且部分是相同的。像鸟群和鸟。
第六种：组合关系，它是一种强聚合，并且整体和部分之间不可分离，具有相同的生命周期，整体包含该部分，也包含其他部分，其他部分和该部分是不相同的，像cpu和计算机，计算机除了包括cpu还有键盘和显示器等。

流媒体技术是一种可以使音频，视频和其他多媒体信息在 Internet 及 Intranet 上以实时的，无需下载等待的方式进行播放的技术，流媒体又叫流式媒体，它是指商家用一个视频传送服务器把节目当成数据包发出，传送到网络上

&& 运算时出现false时运算结果就判断为false
a != 3 && a != 4 && a != 5 && a != 6
a = 4;
因为a != 4 false 所以 结果false；
a = 6;
因为a != 6 false 所以 结果false；
a = 8;
因为a != 3 a != 4 a != 5 a != 6都为 ture 所以 结果true

执行顺序：
父类静态代码块、静态变量
子类静态代码块、静态变量
父类局部代码块、成员变量
父类构造函数
子类局部代码块、成员变量
子类构造函数

java.awt.*是导入java\awt包下所有的类，并不包括其子包下的类
java.awt.event.*才能导入java\awt\event包下的类

Applet显示相关的方法主要有3个。
paint(Graphicsg)方法，具体执行Applet的绘制。
update(Graphicsg)()方法，主要用于更新Applet的显示。
repaint()方法，主要用于Applet的重新显示，它调用update()方法实现对Applet的更新。
abstract类不能用来创建abstract类的对象；
final类不能用来派生子类，因为用final修饰的类不能被继承；
如2所述，final不能与abstract同时修饰一个类，abstract类就是被用来继承的；
类中有abstract方法必须用abstract修饰，但abstract类中可以没有抽象方法，接口中也可以有abstract方法
局部内部类之所以要在外部方法中给参数增加final参数。是因为局部内部类对于使用到的方法中的参数，会在类中生成相应的变量。而变量之间通过引用或者值传递(八大基本类型)。而在我们的逻辑中，局部内部类和方法中的参数是同一个参数

第二次

错误
在类的其他构造方法中可以用this()的方式调用其他构造方法
在类的子类中则可以通过super调用父类中指定的构造方法
在反射中可以使用newInstance()的方式调用

collection类型的集合（ArrayList,LinkedList）只能装入对象类型的数据，该题中装入了0，是一个基本类型，但是JDK5以后提供了自动装箱与自动拆箱，所以int类型自动装箱变为了Integer类型。编译能够正常通过。将list1的引用赋值给了list2，那么list1和list2都将指向同一个堆内存空间。instanceof是Java中关键字，用于判断一个对象是否属于某个特定类的实例，并且返回boolean类型的返回值。显然，list1.get(0)和list2.get(0)都属于Integer的实例

String类是final类型的，不能继承和修改这个类。str=“tesk ok”，其实是隐含的让Java生成一个新的String对象，那么就与原来的“Hello”没有任何关系，当函数结束，str作用结束，所以输出的还是“Hello”。 char ch[] 是传递引用，修改了原内容。

&与操作
|或操作
！非操作
~取反操作

short类型转为byte类型出错
a1*a2结果为int类型，转为byte类型出错

Which statement is true for the class java.util.ArrayList?
下面那个选项有关java.util.ArrayList是正确的
A.The elements in the collection are ordered.
集合中的元素是排序的
B.The collection is guaranteed to be immutable.
集合不可改变
C.The elements in the collection are guaranteed to be unique.
集合中的元素必须唯一
D.The elements in the collection are accessed using a unique key.
集合中元素的键是唯一的
E.The elements in the collections are guaranteed to be synchronized.
集合中的元素是线程同步的

java.util.Collection 是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式。java.util.Collections 是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。

Java中的那些基本类型属于原生类，而数组是引用类型，不属于原生类，可以看成是一种对象。而C中的数组声明和初始化的格式不对
数组的大小一旦指定，就不可以进行改变

栈内存中存放函数中定义的一些基本类型的变量和对象的引用变量；
堆内存中存放new创建的对象和数组。简单的来说，堆主要是用来存放对象的，栈主要是用来执行程序的。这么做是因为栈的存取速度快，栈数据可以共享，但是栈中的数据大小和生存期必须确定，缺乏灵活性中存放一些基本类型的对象和对象句柄堆是操作系统分配给自己内存，由于从操作系统管理的内存分配，所以再分配和销毁时都需要占用时间，因此用堆的效率非常低，但是优点在于编译器不需要指导从堆里分配多少存储控件，也不需要知道存储的数据要再堆里停留多长事件，因此用堆保存数据时会得到更大的灵活性

内部类可以是静态static的，也可用public，default，protected和private修饰，外部类的修饰符只能是public，abstract，final

类之间存在以下几种常见的关系
use-a 是依赖关系
has-a 一般是组合关系
is-a 一般是继承关系

String str1 = “hello”;这里的str1指的是方法区的字符串常量池中的“hello”，编译时期就知道的； String str2 = “he” + new String(“llo”);这里的str2必须在运行时才知道str2是什么，所以它是指向的是堆里定义的字符串“hello”，所以这两个引用是不一样的。如果用str1.equal(str2)，那么返回的是True；因为两个字符串的内容一样。

类与类之间的关系为继承，只能单继承，但可以多层继承。类与接口之间的关系为实现，既可以单实现，也可以多实现。接口与接口之间的关系为继承，既可以单继承，也可以多继承


hashMap在单线程中使用大大提高效率，在多线程的情况下使用hashTable来确保安全。hashTable中使用synchronized关键字来实现安全机制，但是synchronized是对整张hash表进行锁定即让线程独享整张hash表，在安全同时造成了浪费。concurrentHashMap采用分段加锁的机制来确保安全

if中的flag = true 是赋值过程

A：抽象方法只可以被public 和 protected修饰；
B：final可以修饰类、方法、变量，分别表示：该类不可继承、该方法不能重写、该变量是常量
C：static final 可以表达在一起来修饰方法，表示是该方法是静态的不可重写的方法
D：private 修饰方法（这太常见的）表示私有方法，本类可以访问，外界不能访问

java.lang.OutOfMemoryError: PermGen space
为"永久代"内存大小不足，“永久代”的解释应该为JVM中的方法区，主要用于存储类信息，常量，静态变量，即时编译器编译后代码等。本错误仅限于Hotspot虚拟机，本区进行垃圾回收很少，不够直接加大简单粗暴。
java.lang.OutOfMemoryError: Requested array size exceeds VM limit
直接翻译报错信息：数组过长导致堆内存溢出，加大堆内存或者减少数组长度。
java.lang.OutOfMemoryError: Java heap space
堆内存不足，直接增大堆内存。
D为操作系统对运行程序的账户有最大线程数限制

A：return; 没有返回值，
B：short → float 无须强制转换，
C：long → float 无须强制转换
float占4个字节为什么比long占8个字节大呢，因为底层的实现方式不同。
浮点数的32位并不是简单直接表示大小，而是按照一定标准分配的。
第1位，符号位，即S
接下来8位，指数域，即E。
剩下23位，小数域，即M，取值范围为[1 ,2 ) 或[0 , 1)
然后按照公式： V=(-1)^s * M * 2^E
也就是说浮点数在内存中的32位不是简单地转换为十进制，而是通过公式来计算而来，通过这个公式虽然，只有4个字节，但浮点数最大值要比长整型的范围要大。
D：double → float 没有强制转换，错误。


先看类型 基本数据类型只能与基本数据类型相比较， 引用类型只能与引用类型比较， 如果是基本数据类型则比较值， 如果是引用类型比较地址， String特殊，和equls都true

equals强调对象的内容比较
String s=“hello”；会在栈中生成hello字符串，并存入字符串常量池中。
String t=“hello” ；创建时，会在字符串常量池中寻找，当找到需要的hello时，不进行字符串的创建，引用已有的。 所以，st返回true，s.equals(t)也是true。
char c[]={‘h’,‘e’,‘l’,‘l’,‘o’}; c==s这个是不存在的，==两边类型不同
t.equals©这个语句在anObject instanceof String这步判断不会通过，也就是cha[] 压根不能与String相比较，类型不是相同的。返回false

char < short < int < float < double 不同类型运算结果类型向右边靠齐

inputStream是字节流输入流；而inputStreamReader是对字符流的处理，inputStreamReader将字符流处理成字节流，题目要求是用于处理字符输入，所以选C


Java致力于检查程序在编译和运行时的错误。
Java虚拟机实现了跨平台接口
类型检查帮助检查出许多开发早期出现的错误。
Java自己操纵内存减少了内存出错的可能性。
Java还实现了真数组，避免了覆盖数据的可能。
注意，是避免数据覆盖的可能，而不是数据覆盖类型

静态方法属于静态绑定，编译器根据引用类型所属的静态类型为它绑定其对应的方法。此语句会翻译成invokestatic，该指令的调用中不会涉及this,所以不会依赖对象！ 还有引用类型=null，其实就是指该引用在堆中没有对应的对象，但是编译的时候还是能根据声明找到其所属的静态类型。

case 1和case 2后都没有break语句，故都会执行到打印Test2的语句

java的50个关键字是： abstract assert boolean break byte case catch char class const continue default do double else extends enum final finally float for goto if implements import instanceof int interface long native new package private protected public return short static strictfp super switch synchronized this throw throws transient try void volatile while 另外三个:true false null是保留字

java.lang.NullPoninterException：变量未被初始化、对象未赋值、对象为空（俗称的空指针异常）
java.lang.NumberFormatException：数据格式转换失败（integer的取值范围为：-127-128，超过范围都会访问false）
java.lang.RuntimeException：运行时异常
java.lang.ArrayindexOutOfBoundsException：数组下标越界
非纯数字的字符串转化为Integer对象会报数字格式异常
parseInt 是将字符串参数解析为带符号的十进制整数
含有abstract关键字的方法是抽象方法，抽象方法没有方法体以分号结束，抽象类可不包含抽象方法但声明了抽象方法的类必须定义为抽象类，并且抽象类、接口都不可以实例化

若 catch 中的参数类型有父类子类关系，此时应该将父类放在后面，子类放在前面


名字里面由重复地方，但没有什么关系
Java是一种程序设计语言，Javascript是面向对象的动态类型的区分大小写的客户端脚本语言

substring方法将返回一个包含从开始到最后（不包含最后一个）的子字符串的字符串，类似python的切片

大多数 JVM 将内存区域划分为 Method Area（Non-Heap）（方法区） ,Heap（堆） , Program Counter Register（程序计数器） , VM Stack（虚拟机栈，也有翻译成JAVA 方法栈的）,Native Method Stack （ 本地方法栈 ），其中Method Area 和 Heap 是线程共享的 ，VM Stack，Native Method Stack 和Program Counter Register 是非线程共享的。为什么分为 线程共享和非线程共享的呢?请继续往下看。
首先我们熟悉一下一个一般性的 Java 程序的工作过程。一个 Java 源程序文件，会被编译为字节码文件（以 class 为扩展名），每个java程序都需要运行在自己的JVM上，然后告知 JVM 程序的运行入口，再被 JVM 通过字节码解释器加载运行。那么程序开始运行后，都是如何涉及到各内存区域的呢？
概括地说来，JVM初始运行的时候都会分配好 Method Area（方法区） 和Heap（堆） ，而JVM 每遇到一个线程，就为其分配一个 Program Counter Register（程序计数器） , VM Stack（虚拟机栈）和Native Method Stack （本地方法栈）， 当线程终止时，三者（虚拟机栈，本地方法栈和程序计数器）所占用的内存空间也会被释放掉。这也是为什么我把内存区域分为线程共享和非线程共享的原因，非线程共享的那三个区域的生命周期与所属线程相同，而线程共享的区域与JAVA程序运行的生命周期相同，所以这也是系统垃圾回收的场所只发生在线程共享的区域（实际上对大部分虚拟机来说知发生在Heap上）的原因




当new String(“abc”)，会先在字符串常量区生成一个abc的对象，然后new String()时会在堆中分配空间，然后此时会把字符串常量区中abc复制一个给堆中的String，故abc应该在堆中和字符串常量区






类的成员变量会被默认初始化，char[] ch = new char[3];//默认空字符
int [] Int = new int[2];//默认0
String[] strings = new String[2];//默认null




b：小数如果不加 f 后缀，默认是double类型。double转成float向下转换，意味着精度丢失，所以要进行强制类型转换。
c：是使用unicode表示的字符。
d：‘f’ 字符会自动装箱成包装类，就可以向上转型成Object了。
f：整数默认是int类型，int类型不能转型为Double，最多通过自动装箱变为Integer但是Integer与Double没有继承关系，也没法进行转型。

抽象类
特点:
1.抽象类中可以构造方法
2.抽象类中可以存在普通属性，方法，静态属性和方法。
3.抽象类中可以存在抽象方法。
4.如果一个类中有一个抽象方法，那么当前类一定是抽象类；抽象类中不一定有抽象方法。
5.抽象类中的抽象方法，需要有子类实现，如果子类不实现，则子类也需要定义为抽象的。
6,抽象类不能被实例化，抽象类和抽象方法必须被abstract修饰
关键字使用注意：
抽象类中的抽象方法（其前有abstract修饰）不能用private、static、synchronized、native访问修饰符修饰。
接口
1.在接口中只有方法的声明，没有方法体。
2.在接口中只有常量，因为定义的变量，在编译的时候都会默认加上public static final
3.在接口中的方法，永远都被public来修饰。
4.接口中没有构造方法，也不能实例化接口的对象。（所以接口不能继承类）
5.接口可以实现多继承
6.接口中定义的方法都需要有实现类来实现，如果实现类不能实现接口中的所有方法则实现类定义为抽象类。
7，接口可以继承接口，用extends









子类的构造器第一行默认都是super()，默认调用直接父类的无参构造，一旦直接父类没有无参构造，那么子类必须显式的声明要调用父类或者自己的哪一个构造器
接口只能继承接口，但是可以多继承。类都是单继承，但是继承有传递性。
一个类一旦没有显式的定义任何构造，那么JVM会默认给你一个无参构造。无参构造的第一行依然默认是super()