最全Java笔试题

分手后的思念是犯贱 2022-06-16 10:09 249阅读 0赞

自己做过的总结的Java面试题，后续还会补充新的，请多多支持，一起讨论！

\------------------------------------------------------------------------------------------------------------  
假设 a 是一个由线程 1 和线程 2 共享的初始值为 0 的全局变量，则线程 1 和线程 2 同时执行下面的代码，最终 a 的结果不可能是（）  
  
boolean isOdd = false;  
  
for(int i=1;i<=2;++i)  
\{  
if（i%2==1）isOdd = true；  
else isOdd = false；  
a+=i\*(isOdd?1:-1)；  
\}  
  
假设两线程为A、B，设有3种情况：  
1.AB不并发：此时相当于两个方法顺序执行。A执行完后a=-1，B使用-1作为a的初值，B执行完后a=-2  
2.AB完全并发：此时读写冲突，相当于只有一个线程对a的读写最终生效。相同于方法只执行了一次。此时a=-1  
3.AB部分并发：假设A先进行第一次读写，得到a=1;之后A的读写被B覆盖了。B使用用1作为a的初值，B执行完后a=0  
  
\------------------------------------------------------------------------------------------------------------  
重点：  
class A \{   
double f(double x, double y) \{   
return x + y;   
  \}   
  static int g(int n) \{   
return n \* n;   
\}   
 \}   
 class B extends A \{   
double f(double x, double y) \{   
double m = super.f(x, y);   
return m + x \* y;   
  \}   
   static int g(int n) \{   
int m = A.g(n);   
     return m + n;   
   \}   
 \}   
 public class PrintMethod \{   
public static void main(String\[\] args) \{   
A a = new B( );   
System.out.println(a.f(10.0,8.0));   
    System.out.println(a.g(3));   
  \}   
 \}  
    
  98.0  9  
  (m = 18.0  m = 18.0 + 10.0\*8.0 = 98.0\*8  
   return 3\*3  
  )  
  
 子类可以继承父类的静态方法，但是子类不能重写父类的静态方法。在这种情况下，子类隐藏了父类的静态方法。  
 因为不能重写，所以a是A类型的引用时，调用的是父类中的g方法。  
\------------------------------------------------------------------------------------------------------------  
  
开发与运行Java程序需要经过的三个主要步骤为  
编译源程序  
编译字节码  
解释运行字节码  
  
\------------------------------------------------------------------------------------------------------------  
关于下列程序段的输出结果  
public class MyClass\{  
static int i;  
public static void main(String argv\[\])\{  
System.out.println(i);  
  \}  
\}  
0  
类变量在不设置初始值时，会进行默认值赋值，而局部方法中声明的变量则必须进行初始化，它不会进行默认值赋值。  
\------------------------------------------------------------------------------------------------------------  
Java的数据类型分为：基本数据类型和引用数据类型  
  
一般关系数据模型和对象数据模型之间有以下对应关系：表对应类，记录对应对象，表的字段对应类的属性  
  
接口方法默认为public，抽象类方法默认为protected  
  
Java语言中默认整数int,默认浮点数double(而不是float);long和double都占了64位（64bit）的存储空间。  
  
哪些情况下需要使用抽象类？  
1, 当一个类的一个或多个方法是抽象方法时  
2, 当类是一个抽象类的子类，并且不能为任何抽象方法提供任何实现细节或方法体时  
3, 当一个类实现一个接口，并且不能为任何抽象方法提供实现细节或方法体时  
  
\------------------------------------------------------------------------------------------------------------  
下列代码中第几行的sobj复合垃圾回收标准?  
1,Object sobj = new Object();  
2,Object sobj = null;  
3,Object sobj = new Object();  
4,sobj = new Object();  
  
解析：因为第二行将sobj赋值为null，所以第一行的sobj符合标准；  
      而第四行相当于把sobj赋值为null，所以第三行也符合标准。  
 如果有一个对象的句柄a，且你把a作为某个构造器的参数，即  
 new Constructor(a),则即使你将a赋值为null，a也不符合垃圾  
 收集器的收集标准。直到由上面构造器构造的新对象被赋值为空  
 时，a才可以被垃圾收集器收集。  
\------------------------------------------------------------------------------------------------------------  
1，Object aobj = new Object();  
2, Object bobj = new Object();  
3, Object cobj = new Object();  
4, aobj = bobj;  
5, aobj = cobj;  
6, cobj = null;  
7, aobj = null;  
  
解析：这种题型可能是遇到最难的题了；  
      行1-3分别创建了Object的3个类对象：aobj、bobj、cobj  
 行4此时对象aobj的句柄指向bobj，所以该行的执行不能使aobj符合收集标准；  
 行5此时对象aobj的句柄指向cobj，所以该行的执行不能使aobj符合收集标准；  
 行6：此时仍然没有任何一个对象符合收集标准；  
 行7：对象cobj符合垃圾收集器的收集标准，因为cobj的句柄指向了单一的地址空间。  
 在第6行的时候，cobj已经为null，但由于cobj同时指向了aobj(第五行)，cobj也不符合。  
 而在第7行，aobj所指向的地址空间已经被完全赋予了空值。所以cobj符合收集标准。但  
 aobj和bobj仍然判断是否符合收集标准。  
总之：在Java中，判断一块内存空间是否符合垃圾收集器收集标准只有以下两个：  
      (1)给对象赋予了null，以后在没有调用过；  
 (2)给对象赋值了新值，即重新分配了内存空间  
\------------------------------------------------------------------------------------------------------------  
RandomAccessFile raf = new RandomAccessFile("myfile.txt", "rw");  
上面是RandomAccessFile的正确创建方式  
在Java的I/O结构中，RandomAccessFile是比较不寻常的类，直接继承Object，并不属于Streams的一部分

\------------------------------------------------------------------------------------------------------------  
RandomAccessFile raf = new RandomAccessFile("myfile.txt", "rw");  
上面是RandomAccessFile的正确创建方式  
在Java的I/O结构中，RandomAccessFile是比较不寻常的类，直接继承Object，并不属于Streams的一部分  
\------------------------------------------------------------------------------------------------------------  
下面结果会输出什么？  
class Value\{  
public int i = 25;  
\}  
public  class Test\{  
public static void main(String\[\] args)\{  
Test t = new Test();  
t.first();  
\}  
public void first()\{  
int i = 5;  
Value v = new Value();  
v.i = 25;  
second(v,i);  
System.out.println(v.i);  
\}  
public void second(Value v,int i)\{  
i = 0;  
v.i = 20;  
Value val = new Value();  
v = val;  
System.out.println(v.i+" "+i);  
\}  
\}  
  
解析：  
方法参数有基本类型，如int等，另外一种是Object对象。JAVA方法  
参数传对象，传的是这个对象引用的一个副本，即地址值，跟原来  
的引用都是指向同一个对象。  
在本题中，对象v也是传一份引用的副本，v.i=20;通过引用的副本  
改变原对象的值为20。但在语句Value val = new Value();中new了一个新的  
对象，然后执行v=val；相当于引用的副本指向了一本新的Object。所以，  
v.i=15是改变新的Object的值，而不是改变原对象得值。  
15 0 20   
\------------------------------------------------------------------------------------------------------------  
下面代码的输出结果是？  
public static void main(String\[\] args) \{  
int num = 32;  
System.out.println(num >> 32);  
\}  
进行模32位运算，而二进制中8位是一个循环，所以num>>32相当于num>>0,  
num>>33相当于num>>1，所以还是32  
\------------------------------------------------------------------------------------------------------------  
下面代码的输出结果是？  
public static void main(String\[\] args) \{  
char x = 'x';  
int i = 10;  
System.out.println(false ? i:x);  
System.out.println(false ? 10 :x);  
\}  
因为i是int型，第一个输出x被提升为int型了，x的int型为120，所以第一个输出120  
Java编程规范中提到，当后两个表达式有一个常量表达式时(本题10)，而后一个类型为T(本题char)，  
常量表达式可以被T表示时，输出结果为T类型。  
所以10为常量，可以被char表示，结果输出char  
\------------------------------------------------------------------------------------------------------------  
下面代码的输出结果是？  
public class Test｛  
public static void main(String\[\] args)｛  
int a = 5;  
System.out.println("value is:"+ ((a<5) ? 10.9 :9));  
｝  
｝  
因为里面有个10.9，而后面直接跟个9，这是Java就会根据运算符的精度类型  
进行自动转换，由于前面有一个10.9，后面会自动变成9.0  
\------------------------------------------------------------------------------------------------------------  
HashCode被设计用来提高性能。equals()方法与hashCode()方法的区别在于：  
1，如果两个对象相等(equal)，那么他们一定有相同的哈希值。  
2，如果两个对象的哈希值相同，但他们未必相等(equal)。  
  
**设计模式**：  
代理模式：  
定义：为其他对象提供一种代理，以控制对这个对象的访问  
     代理对象起到中介的作用，可去掉功能服务或增加额外的服务  
     火车票代售点就是火车站售票处的代理  
常见的代理模式：  
远程代理:  为不同地理的对象提供局域网代表对象，  
  例：客户端&服务器  
虚拟代理： 根据需要将资源消耗很大的对象进行延迟，真正需要的时候进行创建  
  例：浏览帖子，正文优先加载，图片延迟加载  
保护代理： 对权限进行控制  
  例：只有登录才能发帖等等  
   智能引用代理：  提供对目标对象额外服务  
  例： 火车票代售处提供一些额外服务  
  
以只能引用代理为例：  
静态代理：代理和被代理对象在代理之前是确定的。他们都实现相同的接口或继承相同的抽象类  
  
\------------------------------------------------------------------------------------------------------------  
下列哪种说法是正确的（ ）  
  A 实例方法可直接调用超类的实例方法  
  B 实例方法可直接调用超类的类方法  
  C 实例方法可直接调用其他类的实例方法  
  D 实例方法可直接调用本类的类方法  
  
  选d，类方法就是静态方法。其它的就是实例方法  
  实例方法可以对当前对象的实例变量进行操作，也可以对类变量进行操作，  
  但类方法不能访问实例变量。实例方法必须由实例对象来调用，而类方法除了可由实例对象调用外，还可以由类名直接调用。  
  另外，在类方法中不能使用 this 或 super。 关于类方法的使用，有如下一些限制：  
  1 在类方法中不能引用对象变量。  
  2 在类方法中不能使用super、this关键字。  
  3 类方法不能调用类中的对象方法。与类方法相比，实例方法几乎没有什么限制：  
  1 实例方法可以引用对象变量（这是显然的），也可以引用类变量。  
  2 实例方法中可以使用super、this关键字。  
  3 实例方法中可以调用类方法。  
\------------------------------------------------------------------------------------------------------------  
  
关于C++/JAVA类中static 成员和对象成员的说法正确的是？  
 A static 成员变量在对象构造时生成  
 B static 成员函数在对象成员函数中无法调用  
 C 虚成员函数不可能是static成员函数  
 D static 成员函数不能访问static成员变量  
  
 static为成员变量或函数，在类初始化是加载完成，可以被成员函数调用或访问  
 在java语言中虚函数指代的就是抽象方法，抽象方法中不能用private，static，synchronized，native等修饰词修饰。  
  
\------------------------------------------------------------------------------------------------------------  
有如下一段代码，请选择其运行结果（）  
 public class StringDemo\{  
    private static final String MESSAGE="taobao";  
    public static void main(String \[\] args) \{  
       String a ="tao"+"bao";  
       String b="tao";  
       String c="bao";  
       System.out.println(a==MESSAGE);  
       System.out.println((b+c)==MESSAGE);  
    \}  
  \}  
 Java对String的相加是通过StringBuffer实现的，先构造一个StringBuffer里面存放”tao”,  
 然后调用append()方法追加”bao”，然后将值为”taobao”的StringBuffer转化成String对象。  
 StringBuffer对象在堆内存中，那转换成的String对象理所应当的也是在堆内存中。  
 MESSAGE成员变量及其指向的字符串常量肯定都是在栈内存里的  
 对于字符串常量的相加，在编译时直接将字符串合并，而不是等到运行时再合并。也就是说  
 String a = "tao" + "bao" 和String a =  "taobao"编译出的字节码是一样的。  
 所以等到运行时，根据上面说的栈内存是数据共享原则，a和MESSAGE指向的是同一个字符串。  
  
\------------------------------------------------------------------------------------------------------------  
接口和抽象类：  
相同点：都不能被实例化,位于继承树的顶端，都包含抽象方法  
不同点：1、设计目的：  
接口：  
     体现的一种规范，类似与整个系统的总纲，  
              制订了系统各模块应该遵循的标准，因此接口不应该经常改变，一旦改变对整个系统是辐射性的。  
抽象类：  
                      作为多个子类的共同父类，体现的是一种模板式设计，可以当作系统实现过程中的中间产品，已经实现了系统部分功能。  
        2、使用不同  
    （1）接口只能包含抽象方法，抽象类可以包含普通方法。  
    （2）接口里不能定义静态方法，抽象类可以。  
    （3）接口只能定义静态常量属性，不能定义普通属性，抽象类可以。  
    （4）接口不包含构造器，抽象类可以（不是用于创建对象而是让子类完成初始化）。  
    （5）接口里不能包含初始化块，抽象类完全可以。  
    （6）接口多继承，抽象类单继承（只能有一个直接父类）。  
总结：  
   接口所有方法全是抽象方法只能public abstract修饰（默认public abstract修饰）,属性默认public static final修饰。  
抽象类除了包含抽象方法外与普通类无区别。   
  
\------------------------------------------------------------------------------------------------------------  
  
关于volatile关键字，下列描述  
A 用volatile修饰的变量，每次更新对其他线程都是立即可见的  //正确  
B 对volatile变量的操作是原子性的  //错误  
C 对volatile变量的操作不会造成阻塞  //正确  
D 不依赖其他锁机制，多线程环境下的计数器可用volatile实现     //错误  
  
  
\------------------------------------------------------------------------------------------------------------  
两个最基本的java回收算法：  
   复制算法和标记清理算法  
                复制算法：两个区域A和B，初始对象在A，继续存活的对象被转移到B。此为新生代最常用的算法  
                标记清理：一块区域，标记要回收的对象，然后回收，一定会出现碎片，那么引出  
                标记-整理算法：多了碎片整理，整理出更大的内存放更大的对象  
   两个概念：新生代和年老代  
                新生代：初始对象，生命周期短的  
                永久代：长时间存在的对象  
   整个java的垃圾回收是新生代和年老代的协作，这种叫做分代回收。  
   P.S： Serial New收集器是针对新生代的收集器，采用的是复制算法  
         Parallel New（并行）收集器，新生代采用复制算法，老年代采用标记整理  
         Parallel  Scavenge（并行）收集器，针对新生代，采用复制收集算法  
         Serial Old（串行）收集器，新生代采用复制，老年代采用标记清理  
         Parallel   Old（并行）收集器，针对老年代，标记整理  
         CMS收集器，基于标记清理  
         G1收集器：整体上是基于标记清理，局部采用复制  
  
  
综上：新生代基本采用复制算法，老年代采用标记整理算法。cms采用标记清理。  
  
\------------------------------------------------------------------------------------------------------------  
Java虚拟机功能：  
 1 通过 ClassLoader 寻找和装载 class 文件  
 2 解释字节码成为指令并执行，提供 class 文件的运行环境  
 3 进行运行期间垃圾回收  
 4 提供与硬件交互的平台  
  
\------------------------------------------------------------------------------------------------------------  
关于ThreadLocal以下说法正确的是？  
A ThreadLocal继承自Thread       //错误，ThreadLocal继承Object，相当于没继承任何特殊的。  
B ThreadLocal实现了Runnable接口        //错误，ThreadLocal没有实现任何接口  
C ThreadLocal重要作用在于多线程间的数据共享       //错误  
D ThreadLocal是采用哈希表的方式来为每个线程都提供一个变量的副本              //正确  
E ThreadLocal保证各个线程间数据安全，每个线程的数据不会被另外线程访问和破坏   //正确  
  
  
   线程的角度看，每个线程都保持一个对其线程局部变量副本的隐式引用，只要线程是活动的并且 ThreadLocal 实例是可访问的；  
在线程消失之后，其线程局部实例的所有副本都会被垃圾回收  
  
\------------------------------------------------------------------------------------------------------------  
以下JAVA程序的输出是什么（）  
public class HelloSogou\{  
     public static synchronized void main(String\[\] a)\{  
         Thread t=new Thread()\{  
             public void run()\{Sogou();\}  
     \};  
     t.run();  
     System.out.print("Hello");  
     \}  
     static synchronized void Sogou()\{  
     System.out.print("Sogou");  
    \}  
\}  
A HelloSogou     B SogouHello        C Hello       D 结果不确定  
\------------------------------------------------------------------------------------------------------------  
  
如果是t.start()，(静态同步函数的锁是该类的字节码文件.class main函数和Sogou方法都是static的，所以持有相同锁  
HelloSogou.class那么，在main线程（main 是一个线程也是一个进程 ）中又开了一个线程，调用Sogou方法，锁会冲突。 选D  
但是，t.run()只是普通方法，顺序执行，选B  
  
\------------------------------------------------------------------------------------------------------------  
ServerSocket (int port)  
创建一个serversocket 绑定在特定的端口  
  
Socket(InetAddress address, int port)  
创建一个socket流，连接到特定的端口和ip地址  
  
\------------------------------------------------------------------------------------------------------------  
  
一般关系数据模型和对象数据模型之间有以下对应关系：表对应类，记录对应对象，表的字段对应类的属性。  
  
\------------------------------------------------------------------------------------------------------------  
线程通过调用对象的synchronized方法可获得对象的互斥锁定；  
线程调度算法是平台独立的：  
线程调度分为协同式调度和抢占式调度，Java使用的是抢占式调度，也就是每个线程将由操作系统来分配执行时间，  
线程的切换不由线程本身来决定（协同式调度）。这就是平台独立的原因。  
  
\------------------------------------------------------------------------------------------------------------  
优化Hibernate所鼓励的7大措施：  
1.尽量使用many-to-one，避免使用单项one-to-many  
2.灵活使用单向one-to-many  
3.不用一对一，使用多对一代替一对一  
4.配置对象缓存，不使用集合缓存  
5.一对多使用Bag 多对一使用Set  
6.继承使用显示多态 HQL:from object polymorphism="exlicit" 避免查处所有对象  
7.消除大表，使用二级缓存  
\------------------------------------------------------------------------------------------------------------  
class Car extends Vehicle  
\{  
    public static void main (String\[\] args)  
    \{  
        new  Car(). run();  
    \}  
    private final void run()  
    \{  
        System. out. println ("Car");  
    \}  
\}  
class Vehicle  
\{  
    private final void run()  
    \{  
        System. out. println("Vehicle");  
    \}  
\}  
首先final声明的方法是不能被覆盖的，但是这里并不错误，因为方法是private的，  
也就是子类没有继承父类的run方法，因此子类的run方法跟父类的run方法无关，并不是覆盖。  
new Car().run()也是调用子类的run方法。输出Car。  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*v  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
public class Test2  
\{  
    public void add(Byte b)\{  
        b = b++;  
    \}  
    public void test()\{  
        Byte a = 127;  
        Byte b = 127;  
        add(++a);  
        System.out.print(a + " ");  
        add(b);  
        System.out.print(b + "");  
    \}  
\}  
public void add(Byte b)\{ b=b++; \} 这里涉及java的自动装包/自动拆包(AutoBoxing/UnBoxing)   
Byte的首字母为大写，是类，看似是引用传递，但是在add函数内实现++操作，会自动拆包成byte值传递类型，  
所以add函数还是不能实现自增功能。也就是说add函数只是个摆设，没有任何作用。 Byte类型值大小为-128~127之间。  
add(++a);这里++a会越界，a的值变为-128 add(b); 前面说了，add不起任何作用，b还是127  
  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
  
class C \{  
    C() \{  
        System.out.print("C");  
    \}  
\}  
class A \{  
    C c = new C();  
   
    A() \{  
        this("A");  
        System.out.print("A");  
    \}  
   
    A(String s)\{  
        System.out.print(s);  
    \}  
\}  
class Test extends A\{  
    Test()\{  
        super("B");  
        System.out.print("B");  
    \}  
   
    public static void main(String\[\] args) \{  
        new Test();  
    \}  
\}  
//解答1：  
初始化过程是这样的： 父类Ｂ静态代码块->子类Ａ静态代码块->父类Ｂ非静态代码块->父类Ｂ构造函数->子类Ａ非静态代码块->子类Ａ构造函数  
1.首先，初始化父类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化；   
2.然后，初始化子类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化；   
3.其次，初始化父类的普通成员变量和代码块，在执行父类的构造方法；  
4.最后，初始化子类的普通成员变量和代码块，在执行子类的构造方法；   
   
（1）初始化父类的普通成员变量和代码块，执行 C c = new C(); 输出C   
（2）super("B"); 表示调用父类的构造方法，不调用父类的无参构造函数，输出B   
（3） System.out.print("B");   
 所以输出CBB  
//解答2：  
首先new了一个子类对象，那么就要调用构造方法来初始化该子类对象，但是该类继承自A，所以要先调用父类的构造方法，  
这里通过super("B")显示的调用了父类的带参构造。  
执行父类的带参构造前要先对父类中的对象进行初始化，对父类中的c成员进行初始化，调用了C类的无参构造，所以调用顺序为：  
先调用C类的无参构造  
再调用A类的带参构造  
最后调用调用子类的构造  
  
\------------------------------------------------------------------------------------------------------------  
  
假设有以下代码String s = "hello"：String t = “hello”；char c \[ \] = \{'h','e','l','l','o'\}；下列选项中返回false的语句是？  
A s.equals (t)；  
B t.equals (c)；  
C s==t；  
D t.equals (new String ("hello"))；  
  
  
Sting 类保存字符串只是保存所有单单的字符串;  
而 char\[\] 字符数组 会在最后自动加上'\\n';  
所以B:t.equals(c)会返回fasle；  
所以 答案B  
  
\------------------------------------------------------------------------------------------------------------  
  
根据下面的代码，  
String s = null;  
会抛出NullPointerException异常的有:  
  A if( (s!=null) & (s.length()>0) ) B if( (s!=null) && (s.length()>0) )  
  C if( (s==null) | (s.length()==0)) D if( (s==null) || (s.length()==0) )  
  
String s=null;没有给s开辟任何空间，当执行length()方法时候，  
因为没有具体指向的内存空间，所以报出NullPointerException没有指向的错误。  
A &是与，位运算，两个都得执行，执行到s.length()自然就报错了。  
B s！=null  结果为false 整体就为false ，&& 后面就不会执行。下面的同理。 AC  
  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
HashMap和Hashtable两个类都实现了Map接口，二者保存K-V对（key-value对）  
HashTable不允许null值(key和value都不可以),HashMap允许null值(key和value都可以)。  
Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap就必须为之提供外同步  
迭代 HashMap 采用快速失败机制，而 HashTable 不是，因为 HashTable是线程安全的  
HashMap把Hashtable的contains方法去掉了,改成 containsvalue 和 containsKey。因为contains方法容易让人引起误解  
HashTable使用Enumeration，HashMap使用Iterator  
  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
例化线程： 1、如果是扩展java.lang.Thread类的线程，则直接new即可。  
           2、如果是实现了java.lang.Runnable接口的类，则用Thread的构造方法：  
  
  
public class MyRunnable implements Runnable\{   
     public void run()             \{   
       (new Thread(new MyRunnable()).start()  
     \}   
 \}  
  
\------------------------------------------------------------------------------------------------------------  
  
<<表示左移位  
>>表示带符号右移位  
>>>表示无符号右移  
但是没有<<<运算符  
\-----------------------------------------------------------------------------------------------------------  
  CopyOnWriteArrayList适用于读多写少的并发场景  
  ReadWriteLock即为读写锁，要求写与写之间互斥，读与写之间互斥，读与读之间可以并发执行。在读多写少的情况下可以提高效率  
  ConcurrentHashMap是同步的HashMap，读写都加锁  
  volatile只保证多线程操作的可见性，不保证原子性  
  
\------------------------------------------------------------------------------------------------------------  
String str = new String("abc")，"abc"在内存中是怎么分配的？  
A 堆  
B 栈  
C 字符串常量区  
D 寄存器  
当你new String("abc")时，其实会先在字符串常量区生成一个abc的对象，然后new String()时会在堆中分配空间，然后此时会把字符串常量区中abc复制一个给堆中的String，故abc应该在堆中和字符串常量  
\------------------------------------------------------------------------------------------------------------  
byte b1=1,b2=2,b3,b6,b8;  
final byte b4=4,b5=6,b7;  
b3=(b1+b2);  /\*语句1\*/  
b6=b4+b5;    /\*语句2\*/  
b8=(b1+b4);  /\*语句3\*/  
b7=(b2+b5);  /\*语句4\*/  
上面代码片段中，存在编辑错误的语句是?  
本题答案应为：B、C、D  
  
Java表达式转型规则由低到高转换：  
1、所有的byte,short,char型的值将被提升为int型；  
2、如果有一个操作数是long型，计算结果是long型；  
3、如果有一个操作数是float型，计算结果是float型；  
4、如果有一个操作数是double型，计算结果是double型；  
5、被fianl修饰的变量不会自动改变类型，当2个final修饰相操作时，结果会根据左边变量的类型而转化。  
  
语句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修饰，即只可赋值一次，便不可再改变。  
\------------------------------------------------------------------------------------------------------------

Java类Demo中存在方法func0、func1、func2、func3和func4，请问该方法中，哪些是不合法的定义？( )  
public class Demo\{   
　　float func0()byte,short,char-> int -> long -> float -> double  
　　\{ 小转大不用强转，大转小需要强转  
　　　　byte i=1;func1  没有返回值；func4  大转小需要强转  
　　　　return i;  
　　\}  
　　float func1()  
　　\{   
　　　　int i=1;  
　　　　return;  
　　\}  
　　float func2()  
　　\{  
　　　　short i=2;  
　　　　return i;  
　　\}  
　　float func3()  
　　\{  
　　　　long i=3;  
　　　　return i;  
　　\}  
　　float func4()  
　　\{  
　　　　double i=4;  
　　　　return i;  
　　\}  
\}  
\------------------------------------------------------------------------------------------------------------  
  
  
java中除了基本数据类型都是引用数据类型  
java中的基本数据类型如下：  
byte   short  int   long   float   double   char  boolean  
除此之外都是引用类型  
  
\------------------------------------------------------------------------------------------------------------  
可用来实现线程间通知和唤醒：  
    Object.wait/notify/notifyAll  
    Condition.await/signal/signalAll  
  
\------------------------------------------------------------------------------------------------------------  
  
Statement是sql语句的载体  
Statement是标准的Statement类，通过字符串对sql语句进行拼接，但是它存在sql注入的危险  
PreparedStatement对sql语句进行了预编译，可以防止SQL注入  
CallableStatement用来调用存储过程的  
BatchedStatement用于批量操作数据库，BatchedStatement不是标准的Statement类  
  
\------------------------------------------------------------------------------------------------------------  
面向对象的五大基本原则：  
   单一职责原则（SRP）  
   开放封闭原则（OCP）   
   里氏替换原则（LSP）   
   依赖倒置原则（DIP）   
   接口隔离原则（ISP）  
\------------------------------------------------------------------------------------------------------------  
下面有关java实例变量,局部变量,类变量和final变量的说法，错误的是？  
A 实例变量指的是类中定义的变量，即成员变量，如果没有初始化，会有默认值    // 正确  
B 局部变量指的是在方法中定义的变量，如果没有初始化，会有默认值            //\*\*\*\*\*\*\*\*局部变量必须有初始值\*\*\*\*\*\*  
C 类变量指的是用static修饰的属性      //正确  
D final变量指的是用final修饰的变量      //正确  
\------------------------------------------------------------------------------------------------------------  
构造函数不可以用private修饰   //错误，单例模式中，构造器私有化  
构造函数必须与类名相同        //正确  
构造方法不能被子类继承，所以用final修饰没有意义。  
构造方法用于创建一个新的对象，不能作为类的静态方法，所以用static修饰没有意义。  
此外，Java语言不支持native或synchronized的构造方法  
\------------------------------------------------------------------------------------------------------------  
Java默认使用Unioncode编码，即不论什么语言都是一个字符占两个字节  
Java的class文件编码为UTF-8，而虚拟机JVM编码为UTF-16  
UTF-8编码下，一个中文占3个字节，一个英文占1个字节  
Java中的char默认采用Unicode编码，所以Java中char占2个字节  
1(byte)字节=8(bit)位  
\------------------------------------------------------------------------------------------------------------  
  
floor:   求小于参数的最大整数。返回double类型-----n. 地板，地面  
         例如：Math.floor(-4.2) = -5.0  
ceil:   求大于参数的最小整数。返回double类型-----vt. 装天花板；  
         例如：Math.ceil(5.6) = 6.0  
round:  对小数进行四舍五入后的结果。返回int类型  
         例如：Math.round(-4.6) = -5  
  
\------------------------------------------------------------------------------------------------------------  
Integer i = 42;  
Long l = 42l;  
Double d = 42.0;   下面为true的是?  
  
  
A i == l         B i == d      C l == d  
D i.equals(d)        E d.equals(l)        F i.equals(l)      G l.equals(42L)  
  
ABC3 个选项很明显，不同类型引用的 == 比较，会出现编译错误，不能比较。  
DEF 调用 equals 方法，因为此方法先是比较类型，而 i ， d ， l 是不同的类型，所以返回假。  
选项 G ，会自动装箱，将 42L 装箱成 Long 类型，所以调用 equals 方法时，类型相同，且值也相同，因此返回真  
  
\------------------------------------------------------------------------------------------------------------  
  
Java致力于检查程序在编译和运行时的错误  
Java虚拟机实现了跨平台接口  
类型检查帮助检查出许多开发早期出现的错误  
Java自己操纵内存减少了内存出错的可能性  
Java还实现了真数组，避免了覆盖数据的可能  
注意，是避免数据覆盖的可能，而不是数据覆盖类型   
  
\------------------------------------------------------------------------------------------------------------  
  
java不允许单独的方法，过程或函数存在,需要隶属于某一类中  
java语言中的方法属于对象的成员,而不是类的成员。不过，其中静态方法属于类的成员  
  
\------------------------------------------------------------------------------------------------------------  
  
形式参数可被视为local variable  
对于形式参数只能用final修饰符  
形参的值在调用时根据调用者更改，实参则用自身的值更改形参的值（指针、引用皆在此列），也就是说真正被传递的是实参