java基础易错题1

1.String s = new String("xyz")；创建了几个StringObject?

A:两个或者一个都有可能
B:两个
C:一个
D:三个

答：B

解析：String a = "XYZ"

String b = new String("XYZ")

这两个分别的意思：第一个在我们的字符串常量池中直接开辟一个空间XYZ，

假如没有第一个单独使用第二个，它在堆内存中先开辟一个空间，然后栈内存当中这个变量b指向堆内存当中的空间的值是放在字符串常量池中的，所以正确答案是创建两个，一个堆里，一个字符串常量池。

字符串常量池，特点数据可以共享，实现new b前提，已经创建XYZ，所以只在堆中创建一个。

做一个验证。

public static void main(String[] args){
    String aString = "123";
    String bString = "123";
    System.out.println(aString == bString);//== 在引用数据类型的时候 比较的是地址
}

结果是 true

换一下

public static void main(String[] args){
    String aString = "123";
    String bString = "123";
    System.out.println(aString == bString);//== 在引用数据类型的时候 比较的是地址
    
    String aString2 = "123";
    String bString = newString("123");
    System.out.println(aString2 == bString2);
}

结果false，因为bString2指向了堆里的内存空间，aString2实际指向字符串常量池。

z== 在基本类型的时候 比较的是值

String s = “123”;这个语句有几个对象产生？

若字符串池中没有"123"，则产生一个对象，并且放入常量池中，若有"123"，则产生0个对象。

若是String s = new String("123")，若常量池中没有，则在常量池中创建一个，然后在堆内存中创建一个。

2.下列代码的输出是什么？

public static void main(String[] args) {
		StringBuffer a = new  StringBuffer("A");
		StringBuffer b = new  StringBuffer("B");
		change(a, b);
		System.out.println(a+","+b);
	}
	
	public static void change(StringBuffer x,StringBuffer y) {
		x.append(y);
		y = x;
	}

A: A,A
B: A,B
C: B,B
D: AB,B

答：D

简单的值传递的问题。值传递：地址值

看代码先从内存的角度看，画一个栈内存、堆内存。首先main方法入栈

 有一个a,它指向堆内存空间然后指向字符串常量池中A，b同理，调用change方法，change方法入栈之后，有两个局部变量x,y,

 假设a指向的内存空间为0x1,b指向的0x2，在进行值传递的过程中，a b 都会把内存空间拿过去，

x 0x1 ,y 0x2,之后append方法，做了字符串拼接值变成AB，把x的给了y,y 0x1,堆里的东西没有变，然后change出栈，出栈之后又调用a 、b,a就变成AB，b还是B。

3.下列关于final,finally和finalize的说法正确的是（）

A:final可以用来修饰类、方法、变量 
B:finally是java代码保证重点代码一定要执行的一种机制 
C:变量被final修饰后不能再指向其他对象，但可以重写 
D:finalize设计目的是保证对象在被垃圾收集完成

答：ABD

A:final可以用来修饰类、方法、变量 ，有不同的含义，首先修饰类不能被继承，修饰方法不能被重写，finally修饰变量表示常量。

B:finally是java代码保证重点代码一定要执行的一种机制  ，异常有trycatch，finally，trycatch正常执行try，出现错误执行catch，finally一定是重点执行的。
C:变量被final修饰后不能再指向其他对象，但可以重写  ，不可以重写变量
D:finalize设计目的是保证对象在被垃圾收集完成资源

4..局部内部类可以用那些修饰符修饰？abstract  final

5.执行下列代码会发生什么？

public class Test {
  static {
	  int x = 5; 
  }
  static int x,y;   
  
  public static void main(String[] args) {
        x--; 
        myMethod();
        System.out.println(x+y+ ++x);
  }
  
  public static void myMethod() {
	  y = x++ + ++x;
  }
  
}

A:编译出错
B:输出1
C:输出2
D:输出3
E:输出7
F:输出8

答：D

解析：一个栈内存、堆内存、一个方法区

运行流程，首先编写一个Test.java文件，本身是用英文写的文件，十进制的文件，通过javac命令编译成.class文件，

通过java命令加载到内存当中方法区中

static:修饰的代码块进行表达，而且是在main方法之前进行，

入栈，入完栈之后马上出栈，x,y在方法区当中，而且属于类，

之后main方法入栈，x--,x--是多少，int默认值是0，所以x--是-1，y为0。下一步执行myMethod,让它入栈，y = x++ + ++x,x++是先执行，再赋值，x++先根据-1进行执行，++x等于1，myMethod都执行完了之后x现在的值是1， 上面x+y+ ++x=1+0 + 2=3,输出3。

6.下面那些赋值语句是正确的 ABD

A:long text = 012; B:float t = -412; C:int other = (int) true; D:double d = 0x12345678; E:byte b = 128;

7.以下程序的输出结果 

class Base {
	public Base(String s) {
		System.out.println("B");
	}
}
public class Dervid extends Base {
	public Dervid(String s) {
		System.out.println("D");
	}
	public static void main(String[] args) {
		System.out.println("C");
	}
}

A:BD
B:DB
C:C
D:编译错误

答：D 

考察java执行顺序，先父类再子类。main方法再子类当中，举例，

子类 对象名 = new 子类()

真实的先创建父类对象，再子类对象。

重写：子类重写父类的方法， 正常情况下是这样，也就是子类把父类覆盖掉。

按题上写出会报错， 如果把父类无参，就不报错，父类有参就会报错，子类需要给父类提交参数，

加载：父类完成后 ——》子类 ——》父类——》子类 后一轮不叫加载，叫创建对象，一定是调用构造参数，子类需要给父类提交一些值。

唯一就是少了一个super关键字。super：指向父类。

8..java继承的特点，下列说法正确的是

A:使类的定义复杂化
B:java只支持单继承，不可多继承，但可以通过实现接口来达到多继承的目的
C:子类继承父类的所有成员变量和方法，包括父类的构造方法 
D:不可以多层继承，既一个类不可以继承一个类的子类

答：B

继承的本质：代码的复用

9.关于final关键字下列说法正确的是

A:如果修饰局部变量必须初始化
B:如果修饰类,则该类只能被一个子类继承
C:如果修饰方法，则该方法不能在子类当中重写
D:如果修饰方法，则该方法所在的类不能被继承

答：C

局部变量方法内部的变量不一定初始化。

final修饰类不能被继承，修饰方法不能被重写。

10.下列说法正确的是

A:在类方法当中可以用this来调用本类的方法
B:在类方法当中调用本类的类方法可以直接调用
C:在类方法当中只调用本类的方法
D:在类方法中绝对不能调用实例方法 (new 对象)

答：B

类方法：static修饰的方法

实例方法：没有static修饰的方法

类是创建对象的模板

this-----当前对象，类是创建对象的模板----->有类不一定有对象，有对象一定有类

类方法存储在方法区当中，实例方法存储在对象当中，对象存储在堆当中

创建两个方法

D不对 new对象调用了

11. 关于java异常处理机制的叙述有哪些是正确的？ BC

A:catch部分捕捉到异常情况时，才会执行finally部分 B:当try区段的程序发生异常的时候，才会执行catch区段的程序 C:在try区段不论程序是否发生异常，都会执行fianlly部分 D:以上都是

12.java 反射机制主要提供了以下哪些功能？ ABCD

A:在运行时判断一个对象所属的类 B:在运行时构造一个类的对象 C:在运行时判断一个类所具有的成员变量和方法 D:在运行时调用一个对象的方法

13..下列代码运行的结果是

public class DemoTest {
	public static void main(String[] args) {
		String s;
		System.out.println("hello" + s);
	}
}

A:在控制台打印hello
B:报异常java.lang.NullPointException
C:编译报错
D:报异常java.RuntimeException

答：C

局部变量需要定义

14.下列程序的运行结果

class Two{
	Byte x;
}
public class Student {
	public static void main(String[] args) {
		Student student = new Student();
		student.start();
	}
	void start() {
		Two two = new Two();
		System.out.print(two.x +"  ");
		Two two2 = fix(two);
		System.out.println(two.x + " "+two2.x);
	}
	Two fix(Two tt) {
		tt.x = 42;
		return tt;
	}
}

A: null null 42
B：null 42 42
C:0 0 42
D:0 42 42
E:Anexception is thrown at runtime

答：B

首先main方法入栈，创建一个student对象，它指向我们当前实际的对象，有两个方法start,fix,

先调用start，new一个对象two，当前有一个Byte类型的变量，x默认值null，输出two.x即null，

之后调用fix方法，入栈之后，有个参数tt,由于你需要把two传进去，实际传的是当前地址值0x2，之后tt.x 是42，return出去恰好被一个变量接收叫two2，two2接收到0x2返回0x2，之后再调用two.x two2.x就是42,42

值传递