java练习题错误集（做就更新）

以后也要开始自己做一些面试题了。前天参加了一个java的编程。。惨败，只有优秀奖。。。要潜心学习了。膜拜大佬
关于线程的一道题。

以下程序运行的结果为（）

public class Example extends Thread{
     @Override
     public void run(){
        try{
             Thread.sleep(1000);
             }catch (InterruptedException e){
             e.printStackTrace();
             }
             System.out.print("run");
     }
     public static void main(String[] args){
             Example example=new Example();
             example.run();
             System.out.print("main");
     }
}

应该是先 run 在 main ，开始我以为是调用的start启动线程，原来是调用的run方法，并没有用线程。所有是按顺序执行的。

类似的一道题

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");
    }
}

也是调用的run，就是说按顺序执行。
。。。。。。。。。。。。。。。。。。。。。。。。。。。。

关于自动拆箱装箱

下列 java 程序输出结果为______。

int i=0;
Integer j = new Integer(0);
System.out.println(i==j);
System.out.println(j.equals(i));

两个都是ture

基本类型与基本封装类型进行双等于运算的比较时，封装的会自动进行拆箱。返回为true
进行equals比较时会进行自动装箱进行比较。

对于abstract声明的类 ：可以被抽象类继承，也可以被非抽象类继承。并不是只能被继承，过于肯定。

。。。。。。。。。。。。。。。。。。。。。。。。。。。
java程序不能依赖于垃圾回收的时间或者顺序

。。。。。。。。。。。。。。。。。。。。。。。。。。。
静态内部对象与非静态内部对象

public class Enclosingone {
    //非静态内部类
    public class InsideOne {}
    //静态内部类
    public static class InsideTwo{}
}

class Mytest02{
    public static void main(String args []){
        Enclosingone.InsideOne obj1 = new Enclosingone().new InsideOne();//非静态内部类对象
        Enclosingone.InsideTwo obj2 = new Enclosingone.InsideTwo();//静态内部类对象
    }
}

。。。。。。。。。。。。。。。。。。。。。。。。。。。

JAVA语言的下面几种数组复制方法中，哪个效率最高？

for循环逐一复制
System.arraycopy
System.copyof
使用clone方法

选择 System.arraycopy

System.arraycopy()源码。可以看到是native方法：native关键字说明其修饰的方法是一个原生态方法，方法对应的实现不是在当前文件，而是在用其他语言（如C和C++）实现的文件中。 可以将native方法比作Java程序同Ｃ程序的接口。
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,int length);

。。。。。。。。。。。。。。。。。。。。。。。。。。。

中间件是一种独立的系统软件或服务程序，分布式应用软件借助这种软件在不同的技术之间共享资源。中间件位于客户机/ 服务器的操作系统之上，管理计算机资源和网络通讯。是连接两个独立应用程序或独立系统的软件。相连接的系统，即使它们具有不同的接口，但通过中间件相互之间仍能交换信息。执行中间件的一个关键途径是信息传递。通过中间件，应用程序可以工作于多平台或OS环境。
（简单来说，中间件并不能提高内核的效率，一般只是负责网络信息的分发处理）

。。。。。。。。。。。。。。。。。。。。。。。。。。。
对象存储在堆区
数组是一种对象
java虚拟机规范，所有的对象实例和数组都是要在堆上分配的

Java把内存分成两种，一种叫做栈内存，一种叫做堆内存。

在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配。当在一段代码块中定义一个变量时，java就在栈中为这个变量分配内存空间，当超过变量的作用域后，java会自动释放掉为该变量分配的内存空间，该内存空间可以立刻被另作他用。

堆内存用于存放由new创建的对象和数组。在堆中分配的内存，由java虚拟机自动垃圾回收器来管理。在堆中产生了一个数组或者对象后，还可以在栈中定义一个特殊的变量，这个变量的取值等于数组或者对象在堆内存中的首地址，在栈中的这个特殊的变量就变成了数组或者对象的引用变量，以后就可以在程序中使用栈内存中的引用变量来访问堆中的数组或者对象，引用变量相当于为数组或者对象起的一个别名，或者代号。

引用变量是普通变量，定义时在栈中分配内存，引用变量在程序运行到作用域外释放。而数组＆对象本身在堆中分配，即使程序运行到使用new产生数组和对象的语句所在地代码块之外，数组和对象本身占用的堆内存也不会被释放，数组和对象在没有引用变量指向它的时候（比如先前的引用变量x=null时），才变成垃圾，不能再被使用，但是仍然占着内存，在随后的一个不确定的时间被垃圾回收器释放掉。这个也是java比较占内存的主要原因。

也就是说栈中存的是指向堆中的变量。

以下程序执行的结果是：

class X{
    Y y=new Y();
    public X(){
        System.out.print("X");
    }
}
class Y{
    public Y(){
        System.out.print("Y");
    }
}
public class Z extends X{
    Y y=new Y();
    public Z(){
        System.out.print("Z");
    }
    public static void main(String[] args) {
        new Z();
    }
}

初始化过程：
1. 初始化父类中的静态成员变量和静态代码块 ；
2. 初始化子类中的静态成员变量和静态代码块 ；
3.初始化父类的普通成员变量和代码块，再执行父类的构造方法；
4.初始化子类的普通成员变量和代码块，再执行子类的构造方法；

（1）初始化父类的普通成员变量和代码块，执行 Y y=new Y(); 输出Y
（2）再执行父类的构造方法；输出X
（3） 初始化子类的普通成员变量和代码块，执行 Y y=new Y(); 输出Y
（4）再执行子类的构造方法；输出Z
所以输出YXYZ
。。。。。。。。。。。。。。。。。。。。。。。。。。。

默认值 取值范围 示例
字节型 ： 0 -2^7—-2^7-1 byte b=10;
字符型 ： ‘ \u0000′ 0—-2^16-1 char c=’c’ ;
short : 0 -2^15—-2^15-1 short s=10;
int : 0 -2^31—-2^31-1 int i=10;
long : 0 -2^63—-2^63-1 long o=10L;
float : 0.0f -2^31—-2^31-1 float f=10.0F
double : 0.0d -2^63—-2^63-1 double d=10.0;
boolean: false true\false boolean flag=true;
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
链接：https://www.nowcoder.com/questionTerminal/ffc5e33f5ca7490e8e85d4ee7538baa3
来源：牛客网

以下代码在编译和运行过程中会出现什么情况

public class TestDemo{ 
   private int count;  
   TestDemo test=new TestDemo(88);              System.out.println(test.count);   
     }    
}}

编译运行通过，输出结果是88
编译时错误，count变量定义的是私有变量
编译时错误，System.out.println方法被调用时test没有被初始化
编译和执行时没有输出结果
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

class Person {
    String name = "No name";
    public Person(String nm) {
        name = nm;
    }
}
class Employee extends Person {
    String empID = "0000";
    public Employee(String id) {
        empID = id;
    }
}
public class Test {
    public static void main(String args[]) {
        Employee e = new Employee("123");
        System.out.println(e.empID);
    }
}

编译报错
子类的构造方法总是先调用父类的构造方法，如果子类的构造方法没有明显地指明使用父类的哪个构造方法，子类就调用父类不带参数的构造方法。
而父类没有无参的构造函数，所以子类需要在自己的构造函数中显示的调用父类的构造函数。
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
java语言中的异常处理包括声明异常、抛出异常、捕获异常和处理异常四个环节。
throw用于抛出异常。
throws关键字可以在方法上声明该方法要抛出的异常，然后在方法内部通过throw抛出异常对象。
try是用于检测被包住的语句块是否出现异常，如果有异常，则抛出异常，并执行catch语句。
cacth用于捕获从try中抛出的异常并作出处理。
finally语句块是不管有没有出现异常都要执行的内容。
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。A，CopyOnWriteArrayList适用于写少读多的并发场景
B，ReadWriteLock即为读写锁，他要求写与写之间互斥，读与写之间互斥，
读与读之间可以并发执行。在读多写少的情况下可以提高效率
C，ConcurrentHashMap是同步的HashMap，读写都加锁
D，volatile只保证多线程操作的可见性，不保证原子性
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
Java中数组是对象，不是基本数据类型（原生类），大小不可变且连续存储，因为是对象所以存在堆中
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
一般关系数据模型和对象数据模型之间有以下对应关系：表对应类，记录对应对象，表的字段对应类的属性

。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
byte b1=1,b2=2,b3,b6;
final byte b4=4,b5=6;
b6=b4+b5;
b3=(b1+b2);
System.out.println(b3+b6);

输出 语句：b3=b1+b2编译出错

被final修饰的变量是常量，这里的b6=b4+b5可以看成是b6=10；在编译时就已经变为b6=10了
而b1和b2是byte类型，java中进行计算时候将他们提升为int类型，再进行计算，b1+b2计算后已经是int类型，赋值给b3，b3是byte类型，类型不匹配，编译不会通过，需要进行强制转换。
Java中的byte，short，char进行计算时都会提升为int类型。