错题合集1_JavaSE章节测试

错题合集1_JavaSE章节测试

	思来想去,
	还是在此记录总结一下每次错误的题目吧,
	加深自己记忆的同时
	也希望出现了同样错误的盆友可以看到我的总结之后受到启发,
	有错误的地方还请大家多多指教!!

1. 下列选项说法错误的是(B)

A、成员变量可以不用初始化
B、局部变量可以不用初始化进行使用
C、局部变量存在于栈中
D、非静态成员变量存在于堆中

答案解析:
成员变量是类中方法外的变量,会被系统默认初始化,
**局部变量**是方法内的变量或者方法的形参,**必须**要初始化!!
注意!!
①静态成员变量也没系统默认初始化,
必须在初始化块或者定义时或者构造函数里进行手动初始化!!
②有时候会忘记main方法也是方法,注意,main方法里面的变量也是局部变量哦,一定要初始化.

静态成员变量和静态成员方法存在方法区.
栈内存存储的是局部变量而堆内存存储的是实体,对象.

2.对于形参和实参下列说法正确的是(D)
A、实参和给形参赋值的数据类型不用一一对应
B、实参给形参赋值的永远是数据值
C、实参给形参赋值的永远是地址值
D、实参给形参赋值的时候可能是地址值也可能是数据值

答案解析:
形参是在方发声明上的,用来接收实参
实参是调用对象时给的的参数,是给形参赋值

实参与形参的关系:
有形参调方法必给实参! 
-> 要什么给什么(类型),要几个给几个(个数),怎么要怎么给(类型顺序) 

3.给定java代码，如下：编译运行，结果是（B）

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

A、编译通过，但出现运行时错误
B、编译错误
C、正常运行，输出s=null
D、正常运行，输出s=

答案解析:
如上面第一题所说,局部变量必须初始化,没有直接输出就报错.

4.下列方法定义正确的是 (B)
A、Person method1( ) { return 1;}
B、int x( ) { char ch='a'; return (int)ch;}
C、void method1(){ return true;}
D、Boolean method1(){return "false";}

答案解析:
返回值 : 方法执行完毕后的结果
	有返回值: 方法执行完毕有结果返回
	无返回值: 方法执行完毕无结果,void 无返回值

5.下列代码输出的结果是(C)
class Db{
	Db() {
		int a=1;
		System. out.println(a);
	}
}

public class DbTest2 extends Db {
	public static void main(String[] args) {
		int a = 200;
		DbTest2 d= new DbTest2() ;
		System. out. println(a);
	}
}
A、200
B、1
C、1 然后再换行输出 200
D、200 然后再换行输出 1

答案解析:
类DbTest2与类Db是继承关系,前者是子类,
子类只要实例化对象就会自动调用它的构造方法,
每一个构造方法的默认第一句是super()----调用本类父类的无参构造,
所以在子类中初始化变量a之后先运行父类中的无参构造,运行完毕,再运行子类中的输出语句.
注意:
子类继承父类所有非私有的成员

6.程序将出现何问题(D)
class Db {
	string objType;
	Db() {
		objType = "I am a Base type";
	}
}
public class DbTest2 extends Db {
	DbTest2() {
	objType = "I am a Derived type" ;
	}
	public static void main(String[] args) {
		DbTest2 d = new DbTest2();
	}
}
A、程序输出 I am a Derived type
B、程序输出I am a Base type
C、程序输出I am a Base type和 I am a Derived type
D、程序没有问题，没有输出

注意:
如果直接在main方法里面输出objType会报错,
静态方法中不能引用非静态的变量,
需要在String objType前面加上静态static修饰.

7.以下描述成员变量和局部变量的区别正确的是(A,B,C,D)
A、成员变量作为类的成员直接声明在类中，可以通过this引用
B、局部变量可用在方法定义中或声明上
C、成员变量有默认值初始化
D、局部变量必须正确声明初始化后才可使用

8.编译运行如下Java代码，输出结果是（D）。
class Base {
	public void method(){
	System.out.print ("Base method");
	}
}

class Child extends Base{
	public void methodB(){
	System.out.print ("Child methodB");
	}
}

class Sample {
	public static void main(String[] args) {
	Base base = new Child();
	base.methodB();
	}
}
A、Base method
B、Child methodB
C、Base method Child MethodB
D、编译错误

答案解析:
多态的条件如下:
1. 必须有继承/实现关系 -> 必要条件
2. 父引用指向子类对象 -> 必要条件
3. 子类要重写父类中的方法 -> 不是必要条件

父类引用子类只能调用子类从父类继承过来的方法或者子类重写继承自父类的方法
所以base.methodB();这行代码会报错,
解决方案:
在父类Base中定义一个methodB()方法,这样相当于子类重写了父类的方法,又因为子类有调用的方法就近使用子类的方法,输出Child methodB.

9.下列代码执行结果正确的是（B）
public static void main(String[] args) {
    String s1 = new String("hello");
    String s2 = new String("hello");
    System.out.println(s1 == s2);
    System.out.println(s1.equals(s2));
}
A、true true
B、false true
C、false false
D、true false

答案解析:
对于引用数据类型来说，==和equals都是来比较两个变量的地址，
String类重写了equals方法，所有String.equals可以比较两个字符串内容是否相等。
总结如下:
对于基本数据类型的变量,比较相等使用 == 号;
对于引用数据类型的变量,分为三种情况:
对于引用数据类型，分3种情况
1) == 始终比较的是两个变量的地址
2) Object类的equals方法，比较的也是两个变量的地址
boolean equals(Object o2){undefined
	return this == o2;
}
3)java.util.String类重写了从父类Object继承过来的equals方法，
比较两个字符串的内容是否完全相等，所有String.equals可以比较具体内容。

10.下列选项中关于Java中封装的说法错误的是（D ）
A、封装可以将属性私有化，提供公有的方法访问私有属性
B、属性的访问方法包括setter方法和getter方法
C、setter方法用于赋值、getter方法用于取值
D、类的属性必须进行封装，否则无法通过编译

答案解析:
非静态成员变量就没有进行封装.
封装的几种常见体现:
1. 循环 : 把重复的代码用循环结构进行封装 -> 提高代码的复用性
2. 方法 : 把重复的功能用方法结构进行封装 -> 提高代码的复用性,方法还完成的数据的传递
3. private : 把一类事物的属性用private修饰 -> 提高了代码的安全性
4. 定义事物描述类 : 把一类事物的属性和行为进行类的包裹 -> 提高代码的多样性
其中A容易看不懂,其实就是上面的第四种情况,提供共有的方法访问就是setter方法和getter方法.

11.给定两个java程序，如下：
public interface Face{
	int counter = 40;
}

public class Test implements Face{
	private static int counter;
	public static void main(String[] args) {
		System.out.println(++counter) ;
	}
}
Test.java的编译运行结果是(D)。
A、40
B、41
C、0
D、1

答案解析:
Test类里面自己有counter且为静态的会直接使用自己的静态变量.
++自增在变量前面,先则先自增后赋值,
如果在变量后面,结果是默认值0.

12.下列代码说法正确的是（C）
public class MyAr {
	public static void main(String[] args) {
	MyAr ma = new MyAr();
	ma.method();
}
public void method() {
	static int i;
	System.out.println(i);
	}
}
A、输出结果为 0
B、输出结果为 null
C、编译错误
D、运行出错
答案解析:
static int i; 这句代码有两处错误:
①static不能修饰局部变量②局部变量需要初始化.

static可以
修饰属性成为静态成员变量,
修饰方法成为静态成员方法,
修饰代码块成为静态代码块,
静态导入包,
构造静态内部类(定义在类成员位置上且被static关键字修饰的类叫静态成员内部类)

13.下列选项中，关于Java的抽象类和抽象方法说法正确的是（ ）
A、抽象类中可以含有0个或多个抽象方法
B、抽象类中可以有构造方法
C、一个类中若有抽象方法，则这个类必为抽象类
D、子类必须重写父类所有的方法

答案解析:
    抽象类的成员: 可以什么都没有
        成员变量 : 可以有
        构造方法 : 可以有,但是不能创建对象
        成员方法 : 可以有
        静态方法 : 可以有
        抽象方法 : 可以有 -> 抽象方法必须存在于抽象类或接口中
        
    抽象类和普通类的区别:
        1. 抽象类有构造方法,但是不能创建对象
        2. 抽象类中可以有抽象方法,而普通类不可以有
  D、子类必须重写父类所有的抽象方法

14.Java中有关final关键字，下列说法正确的是（A,B,C,D）
A、final关键字修饰变量，表示该变量不能被修改
B、final关键字修饰方法，表示该方法不能被重写
C、final关键字修饰类，表示该类不能被继承
D、final的作用是用来保证变量不可变，static作用于成员变量表示内存中一份存储空间，但值可改变

答案解析:
final 关键字 
修饰类:类 -> 不能被继承
修饰成员变量 -> 不能被修改,变成了自定义常量
		自定义常量的标准定义格式:
			public static final 数据类型 常量名 = 初始化值;
		常量名的命名方式 : 全部大写,多个单词之间使用_分隔 -> JAVA_HOME
修饰成员方法 -> 不能被重写
局部变量:最终的局部变量 -> 不能被修改,变成了一个局部位置的自定义常量
引用类型变量:不能被重新赋值，但可以改变引用类型变量所引用对象的内容

15.下面对于toString()方法和equals()方法描述正确的是? （D）
A、类重写toString()方法是为了打印对象的地址
B、类重写equals()方法是为了比	较对象的地址
C、类重写toString()方法是打印对象中的属性,重写equals()是比较对象中的属性
D、类重写的是Object中的toString()方法和equals()方法

答案解析:
1.toString方法的介绍
java.lang.Object类是Java语言中的根类，是所有类的父类。
所有对象（包括数组），都实现了这个类的方法。
在调用toString方法时，都需要对其进行覆盖重写。
toString方法时用于返回字符串的一种方法。
2.equals方法的介绍
在Object中，该方法数用于比较两个对象是否相等。
使用格式：
　　　　　　boolean equals （object obj）
其中，参数obj可以传递任意的对象。
equals方法，对基本数据类型，比较的是值是否相等。
　　　　　　对引用数据类型，比较的是地址值。
若需要通过该方法对引用数据类型的内容进行比较，
则需要对equals方法进行覆盖重写。
判断两个java对象是否相等，不能使用"=="，
因为"=="比较的是两个对象的内存地址
3.Objects类中的equals方法的介绍
使用Objects类中的equals方法，也可以对两个对象进行比较，
但该类中的equals方法可以防止空指针异常
（在Object类中这样使用equals方法：null.equals("abc")时会发生空指针异常）。
在Objects类中，equals的使用方法和Object中一样，直接调用即可。