JavaseSE笔试选择题（知识点总结）

1、在 Java 中，存放字符串常量的对象属于（ ）类对象。B

A Character B String C StringBuffer D Vector

2、已知如下类定义： 如下哪句可以正确地加入子类中？D

class Base { public Base (){ //... } public Base ( int m ){ //... } public void fun( int n ){ //... } } public class Child extends Base{ // member methods }

A private void fun( int n ){ //...}

B void fun ( int n ){ //... }

C protected void fun ( int n ) { //... }

D public void fun ( int n ) { //... }

重写

方法名、参数、返回值相同。

子类方法不能缩小父类方法的访问权限。

子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。

存在于父类和子类之间。

方法被定义为final不能被重写。

重载

参数类型、个数、顺序至少有一个不相同。

不能重载只有返回值不同的方法名。

存在于父类和子类、同类中。

3、面向对象基本方法的基本概念有对象、类和实例、消息、继承与多态性

4、成员变量和局部变量的区别：

成员变量：

成员变量定义在类中，在整个类中都可以被访问。

成员变量随着对象的建立而建立，随着对象的消失而消失，存在于对象所在的堆内存中。

成员变量有默认初始化值。

局部变量：

局部变量只定义在局部范围内，如：函数内，语句内等，只在所属的区域有效。

局部变量存在于栈内存中，作用的范围结束，变量空间会自动释放。

局部变量没有默认初始化值 

成员变量和类变量的区别：

1.两个变量的生命周期不同

      成员变量随着对象的创建而存在，随着对象的回收而释放。

      静态变量随着类的加载而存在，随着类的消失而消失。

2.调用方式不同

      成员变量只能被对象调用。

      静态变量可以被对象调用，还可以被类名调用。

3.别名不同

      成员变量也称为实例变量。

      静态变量也称为类变量。

4.数据存储位置不同

      成员变量存储在堆内存的对象中，所以也叫对象的特有数据。

      静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

成员变量和静态变量的区别：

   1.成员变量所属于对象。所以也称为实例变量。

      静态变量所属于类。所以也称为类变量。

   2.成员变量存在于堆内存中。

      静态变量存在于方法区中。

   3.成员变量随着对象创建而存在。随着对象被回收而消失。

      静态变量随着类的加载而存在。随着类的消失而消失。

   4.成员变量只能被对象所调用 。

      静态变量可以被对象调用，也可以被类名调用。

5、Java提供了4种访问控制符，主要用于控制其他类是否可以访问某一类中的属性或方法，从而实现数据封装。

四种访问控制符的权限大小(由大到小)为public(公共)、protected(保护)、default(默认)、 private(私有)。

private(私有)：当类中属性或方法被private修饰时，表示此成员或方法只能被自己类中的方法使用，而不能被外部类或对象直接使用。

default(默认)：具有包访问权限，如果类中属性或方法不使用public,protected,privete修饰符修饰时，则说明其具有包访问权限，具有包访问权限的属性或方法既可以被自己类中的方法使用也可以被同一包下的其他类使用，但不能被其他包中的类使用。

protected(保护)：具有子类访问权限。如果类中属性或方法被protected修饰符修饰，则此类中属性或方法可以被同一包下的类使用，也可以被不同包下的子类使用，但不能被不同包下的其他类使用。

public(公共)：具有公共访问权限。如果类中的属性或方法被public修饰，则此类中的属性或方法可以被任何类调用。

6、假设 A 类有如下定义，设 a 是 A 类的一个实例，下列语句调用哪个是错误的？（）C

public class A {public int i;static String s;void method1(){}static void method2(){} }

A System.out.println(a.i); B a.method1(); C A.method1(); D A.method2();

static关键词修饰的变量或方法可以通过类名直接调用，而非静态的变量或方法无法通过类名直接调用。 

 7、下面代码将输出什么内容：（）B

public class SystemUtil{public static boolean isAdmin(String userId){return userId.toLowerCase()=="admin";}public static void main(String[] args){System.out.println(isAdmin("Admin"));} }

A true B false C 1 D 编译错误

对于两个引用变量，只有他们指向同一个引用时，==才会返回true。题目中"admin"指向堆内存字符串常量池里admin的地址，而String类 的方法都是通过创建新的对象也就是new String()的方式返回的，因此userId.toLowerCase()指向的是这个字符串对象在堆内存中的地址。如果题目中isAdmin方 法返回值更改为`return userId.toLowerCase().equals("admin");`，输出结果将变为true。 

8、在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，否则编译不通过

9、如下代码的 结果是什么 ?        B

class Base {Base() {System.out.print("Base");} } public class Alpha extends Base {public static void main( String[] args ) {new Alpha();//调用父类无参的构造方法new Base();} }

A Base B BaseBase C 编译失败 D 代码运行但没有输出 E 运行时抛出异常 

10、下列哪一种叙述是正确的（）D

A abstract修饰符可修饰字段、方法和类

B 抽象方法的body部分必须用一对大括号{ }包住

C 声明抽象方法，大括号可有可无

D 声明抽象方法不可写出大括号

A：abstract只能修饰方法和类，变成抽象方法和抽象类，不能修饰字段。
B：既然是抽象方法，也就是没有具体的实现方法，所以根本没有body部分。
C：不能有大括号，有大括号就相当于有了具体的实现方法，有了实现方法就不能说是抽象类了。
D：抽象方法不能写出大括号。

11、以下代码运行输出的是  C

public class Person{private String name = "Person";int age=0; } public class Child extends Person{public String grade;public static void main(String[] args){Person p = new Child();System.out.println(p.name);} }

A 输出：Person B 没有输出 C 编译出错 D 运行出错 

父类private的成员变量，根据权限修饰符的访问控制范围，只有在类内部才能被访问，就算是他的子类，也不能访问。这里如果将Person p = new Child();改成 Person p = new Person();代码依然无法通过编译，因为子类作用域中访问不到父类的私有变量，无法为其生成正确的字节码。另外，一个Java文件中不能有两 个public类。 

12、以下程序的输出结果为 D

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

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

在调用子类构造器之前，会先调用父类构造器，当子类构造器中没有使用"super(参数或无参数)"指定调用父类构造器时，是默认调用父类的无参构造器，如果父类中包含有参构造器，却没有无参构造器，则在子类构造器中一定要使用“super(参数)”指定调用父类的有参构造器，不然就会报错。 

13、下列描述中，错误的是 C

A SQL语言又称为结构化查询语言

B java中”static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问

C 面向对象开发中，引用传递意味着传递的并不是实际的对象，而是对象的引用，因此，外部对引用对象所做的改变不会反映到所引用的对象上

D java是强类型语言，javascript是弱类型语言 E 面向对象的三大特性包括：封装，继承，多态 

外部对引用对象所做的改变会反映到所引用的对象上

14、程序读入用户输入的一个值，要求创建一个自定义的异常，如果输入值大于 10 ，使用 throw 语句显式地引发异常，异常输出信息为 ”something’swrong!” ， 语句为（）A

A if(i>10)throw new Exception("something’swrong!");

B if(i>10)throw Exception e("something’swrong!");

C if(i>10) throw new Exception e("something’swrong!");

D if(i>10)throw Exception( "something’swrong!");

15、 类所实现的接口以及修饰不可以是（）。D

A void B public C abstract D final

16、 以下代码结果是什么？C

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

A 代码可以编译运行，输出“AB.AB”。

B 代码可以编译运行，输出“A.A”。

C 代码可以编译运行，输出“AB.B”。

D 代码可以编译运行，输出“A.B”。

关于值传递和引用传递的解释如下：

值传递：是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。 引用传递：是指在调用函数时将实际参数的地址直接传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。 这道题中a、b（是引用的副本，Java中没有引用传递）传入operate()函数中，但最后a指向的对象的值发生了变化，而b指向的对象的值没有发生变化，这是因 为x.append(y);改变了a指向的对象的值，而y=x;并没有改变b指向对象的值，指向将y指向了x所指向的对象（之前y和b指向同一个对象）。 

 17、下列有关JAVA异常处理的叙述中正确的是（）A B D

A finally是为确保一段代码不管是否捕获异常都会被执行的一段代码

B throws是用来声明一个成员方法可能抛出的各种非运行异常情况

C final用于可以声明属性和方法，分别表示属性的不可变及方法的不可继承

D throw是用来明确地抛出一个异常情况

final用于可以声明属性和方法，分别表示属性的不可变及方法的不能被重写

18、 关于抽象类与最终类，下列说法错误的是？D

A 抽象类能被继承，最终类只能被实例化。

B 抽象类和最终类都可以被声明使用

C 抽象类中可以没有抽象方法，最终类中可以没有最终方法

D 抽象类和最终类被继承时，方法可以被子类覆盖

final修饰的类不能被继承 

19、阅读下列程序，选择哪一个是正确的输出结果 C

class HelloA{public HelloA(){System.out.println("I’m A class ");}static{System.out.println("static A");} } public class HelloB extends HelloA{public HelloB(){System.out.println("I’m B class");}static{System.out.println("static B");}public static void main (String[] args){new HelloB();} }

A static A I’m A class static B I’m B class

B I’m A class I’m B class static A static B

C static A static B I’m A class I’m B class

D I’m A class static A I’m B class static B

Java类初始化顺序：父类静态变量---> 父类静态代码块---> 子类静态代码块---> 父类非静态代码块 --->父类构造函数 --->子类非静态代变量 --->子类非静态代码块---> 子类构造器

20、 下列代码的输出结果是_____ B

boolean b=true ? false : true==true?false:true; System.out.println(b)

A true B false C null D 空字符串

21、 在Java中下面Class的声明哪些是错误的？A B C

A public abstract final class Test { abstract void method(); }

B public abstract class Test { abstract final void method(); }

C public abstract class Test { abstract void method() { } } 

D public class Test { final void method() { } }

1、抽象类不能被实例化，实例化的工作应该交由它的子类来完成，它只需要有一个引用即可。

2、抽象方法必须由子类来进行重写。

3、只要包含一个抽象方法的类，该类必须要定义成抽象类，不管是否还包含有其他方法。

4、抽象类中可以包含具体的方法，当然也可以不包含抽象方法。

5、abstract不能与final并列修饰同一个类。

6、abstract 不能与private、static、final或native并列修饰同一个方法。

22、关于以下程序代码的说明正确的 D

class HasStatic{private static int x = 100;public static void main(String args[ ]){HasStatic hs1 = new HasStatic();hs1.x++;HasStatic hs2 = new HasStatic();hs2.x++;hs1=new HasStatic();hs1.x++;HasStatic.x--;System.out.println( "x=" +x);} }

A 5行不能通过编译，因为引用了私有静态变量

B 10行不能通过编译，因为x是私有静态变量

C 程序通过编译，输出结果为：x=103

D 程序通过编译，输出结果为：x=102 

当static作用于某个字段时，肯定会改变数据创建的方式（因为一个static字段对每个类来说都只有一份储存空间，而非static字段则是对每个对象有一个储存空间）；
所以无论是HasStatic类的对象hs1,hs2，或是直接通过类名修改static作用的字段，都是一个，因此选择D 

23、java 语言使用的字符码集是 D

A.ASCII B.BCD C.DCB D.Unicode

24、 Test.main() 函数执行后的输出是（）D

public class Test {public static void main(String [] args){System.out.println(new B().getValue());}static class A{protected int value;public A(int v) {setValue(v);}public void setValue(int value){this.value = value;}public int getValue(){try{value++;return value;} catch(Exception e){System.out.println(e.toString());} finally {this.setValue(value);System.out.println(value);}return value;}}static class B extends A{public B() {super(5);setValue(getValue() - 3);}public void setValue(int value){super.setValue(2 * value);}} }

 A 11 17 34

B 22 74 74

C 6 7 7

D 22 34 17

首先，super()函数指的是调用父类的构造方法

1.new B()

执行B的构造函数，第一行是super(5);

此时执行的是A的构造函数，A的构造函数调用的是setValue()方法，由于B重写了A的这个方法，

所以，执行的是B的 setValue()方法。即传入的参数是2*5=10

此时，因为super，所以调用的是父类的 setValue()方法，即value=10

第一行执行完毕。

第二行是 setValue(getValue()-3);

B没有getValue()方法，故执行父类的此方法，

try返回的是value=10+1=11，保存在临时栈中

finally中调用this的方法，这个this指的是B的对象，又重写，故就是B的 setValue()方法

value=2*11=22，第一个打印到屏幕上的数字

接下来参数 getValue()-3=11-3=8

传入B的 setValue()方法

此时value=2*8=16

至此，new B()执行结束

2.new B(). getValue()

B没有 getValue()，故执行A的 getValue()

try返回16+1=17，保存到临时栈中

finally调用B的 setValue()方法，value=17*2=34，第二个打印到屏幕上面的数字

最后主函数打印返回值，也就是try保存到临时栈的17

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

A for循环逐一复制 B System.arraycopy C Arrays.copyOf D 使用clone方法

效率：System.arraycopy > clone > Arrays.copyOf > for循环 

26、 有关下述Java代码描述正确的选项是____。F

public class TestClass {private static void testMethod(){System.out.println("testMethod");}public static void main(String[] args) {((TestClass)null).testMethod();} }

A 编译不通过

B 编译通过，运行异常，报NullPointerException

C 编译通过，运行异常，报IllegalArgumentException

D 编译通过，运行异常，报NoSuchMethodException

E 编译通过，运行异常，报Exception

F 运行正常，输出testMethod

虽然我们能用对象来调用静态方法，但是对于java来说，即使我们用对象去调用，java自己也会在将源文件编译成class文件时将其转化为用类名去调用静态方法。由于空指针异常是运行时异常，所以eclipse编译检查也不会报错，而实际运行的是class文件，java已经将class文件里的调用修改为类名去调用了，所以也就不会在运行时出现空指针异常。 

27、 下面代码运行结果是（）C

public class Test{public int add(int a,int b){try {return a+b;}catch (Exception e) {System.out.println("catch语句块");}finally{System.out.println("finally语句块");}return 0;}public static void main(String argv[]){Test test =new Test();System.out.println("和是："+test.add(9, 34));} }

A catch语句块 和是：43

B 编译异常

C finally语句块 和是：43

D 和是：43 finally语句块

1、不管有木有出现异常，finally块中代码都会执行；
2、当try和catch中有return时，finally仍然会执行；
3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的；
4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值 

28、 下列Java代码中的变量a、b、c分别在内存的____存储区存放。C

class A {private String a = “aa”;public boolean methodB() {String b = “bb”;final String c = “cc”;} }

A 堆区、堆区、堆区

B 堆区、栈区、堆区

C 堆区、栈区、栈区

D 堆区、堆区、栈区

E 静态区、栈区、堆区

F 静态区、栈区、栈区

常量池：未经 new 的常量

堆区：成员变量的引用，new 出来的变量

栈区：局部变量的引用

成员变量的引用在堆区，是因为成员变量的所属对象在堆区，所以它也在堆区。

局部变量的引用在栈区，是因为局部变量不属于某一个对象，在被调用时才被加载，所以在栈区。

29、下面代码的输出结果是什么？D

public class ZeroTest {public static void main(String[] args) {try{int i = 100 / 0;System.out.print(i);}catch(Exception e){System.out.print(1);throw new RuntimeException();}finally{System.out.print(2);}System.out.print(3);} }

A.3 B.123 C.1 D.12

try catch是直接处理，处理完成之后程序继续往下执行，throw则是将异常抛给它的上一级处理，程序便不往下执行了。本题的catch语句块里面，打印完1之后，又抛出了一个RuntimeException，程序并没有处理它，而是直接抛出，因此执行完finally语句块之后，程序终止了 

30、 代码片段： 关于上面代码片段叙述正确的是（）C

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

A 输出结果：13

B 语句：b6=b4+b5编译出错

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

D 运行期抛出异常

被final修饰的变量是常量，这里的b6=b4+b5可以看成是b6=10；在编译时就已经变为b6=10了

而b1和b2是byte类型，java中进行计算时候将他们提升为int类型，再进行计算，b1+b2计算后已经是int类型，赋值给b3，b3是byte类型，类型不匹配，编译不会通过，需要进行强制转换。

Java中的byte，short，char进行计算时都会提升为int类型。

 

总结

以上是生活随笔为你收集整理的JavaseSE笔试选择题（知识点总结）的全部内容，希望文章能够帮你解决所遇到的问题。

如果觉得生活随笔网站内容还不错，欢迎将生活随笔推荐给好友。