JAVA入门速成(三)-选择 – drinkflower's blog

判断篇https://drinkflower.asia/wordpress/archives/397

1.下列哪个叙述是正确的？

A.一个类最多可以实现两个接口

B.允许接口中只有一个抽象方法

C.如果一个抽象类实现某个接口，那么它必须要重写接口中的全部方法

D.如果一个非抽象类实现某个接口，那么它可以只重写接口中的部分方法

b
A选项是错误的，一个类可以实现多个接口,前面判断题提到接口具有多继承性
C选项是错误的，抽象类实现了接口,可以将接口的方法声明为抽象方法而一个都不实现
D选项是错误的，如果一个类实现了接口，那么它必须要实现接口中的所有方法。==这里重写的意思就是实现,因为接口没有函数体,所以对函数的实现肯定是重写==

2.关于对字符串缓冲区类的操作，如下代码执行结果是（）。

StringBuffer buffer=new StringBuffer();
System.out.println(buffer.length()+" "+buffer.capacity());

A.0 0

B.0 16

C.16 16

D.16 0

b
(一)中提到.length属性返回容量,和这里的.capacity()方法一样,比如int[] arg=new int[3],那么arg的length就是3,而arg的length()因为没有填入元素所以是0
在实例化一个 StringBuffer 对象时，如果不指定缓冲区大小，会默认创建一个初始大小为 16 的缓冲区。

3.下列程序代码运行结果是：（）。

import java.util.*;    
public class Test {     
    public int hashCode() {        
         return 1;     
    }     
    public boolean equals(Object b) {        
        return true;    
   }    
    public static void main(String args[]) {        
        Set set = new HashSet();        
        set.add(new Test());        
        set.add(new String("ABC"));        
        set.add(new Test());        
        System.out.println(set.size());     
    }
}

A.1

B.2

C.3

D.4

b
size()获取的是元素数而不是空间大小,这里应该是因为set集合不能存放相同元素

4.正确配置classpath环境变量的方式是：（）。

A.在系统环境变量classpath原有的字符串基础上，加上点符号和分号“.;”，然后再加上JDK安装路径下的bin目录

B.新建系统环境变量classpath，其值为：点符号和分号“.;”，然后再连上JDK安装路径下的bin目录

C.在系统环境变量classpath原有的字符串基础上，加上点符号和分号“.;”，然后再加上JDK安装路径下的lib目录

D.新建系统环境变量classpath，其值为：点符号和分号“.;”，然后再连上JDK安装路径下的lib目录

d
在系统环境变量中，classpath需要指定Java类文件所在的路径，一般指JDK安装路径下的lib目录。.;来将前一个和新添加的值分开

5.下面哪些元素不能作为Java标识符的首字符？（）

A.字母

B.数字

C.下划线_

D.$

b
Java标识符的首字符只能是字母、下划线或$，不能以数字开头

6.有如下一维数组的定义：

int[] arr1=new int[10];

arr1数组元素批量赋值（预设值为：100）的方式中，错误的有：

A.Arrays.fill(arr1,100);

B.arr1.fill(100);

for(int i=0;i<arr1.length;i++)
{ arr1[i]=100; }

for(int v:arr1)
{v=100;}

b
fill方法是Array类下面的方法,接收数组名和填充值,将目标数组填充目标值,不能用数组去调用,b错误

7.JAVA中，下面哪个赋值表达式正确：（）

A.float f=1.3;

B.char c="a";

C.byte b=257;

D.int i=10;

d
A. float类型的数值可以通过一个小数直接赋值，例如1.3f或1.3F，否则编译器会将1.3默认解释为double类型，导致编译错误。
B. 字符类型(char)必须用单引号表示字符常量，例如'a'。如果用双引号表示，编译器会将它解释为字符串类型(String)，导致编译错误。
C. byte类型的数值范围是-128到127，如果直接赋值为257会导致编译错误。

8.下面说法错误的是：

int i=1,j=1;

System.out.print(i==j);

输出结果为true。

int i=100,j=100;

System.out.print(i==j);

输出结果为true。

Integer i=100,j=100;

System.out.print(i==j);

输出结果为true。

Integer i=1000,j=1000;

System.out.print(i==j);

输出结果为true。

d
基本数据类型比较可以使用==比较,a,b正确
封装类的比较用\==比较的是地址,这么比较一般是不相等的(String有个池化),但是==Integer类的对象如果范围在-128~127之间,会被装箱(指向常量池的缓冲地址)==,所以c是正确的,指针都指向了常量池的缓冲地址,d不行

每次都要开辟新空间会占用大量的资源，因此他们规定在-128~127（因为Java设计者认为大家对数的使用大多在100以内）
之间的Integer类型的变量，直接指向常量池中的缓存地址，不会new开辟出新的空间。

9.执行完以下代码int[ ] x = new int[25]；后，以下哪项说明是正确的（）。

A.x[24]为0

B.x[25]为0

C.x[0]为空

D.x[24]未定义

a
数组下标是从 0 开始的，数组长度为 25，因此 x[24] 为最后一个元素，初始值为 0。

10.有如下程序代码，程序运行的结果是（）。

StringBuffer buffer=new StringBuffer(); 
buffer.append("abc").append("123"); 
System.out.println(buffer);

A.abc123

B.abc

C.123

D.空行

a
append()方法将字符串添加到字符串的后面

11.关于类和对象的关系，下列说法哪种说法是错误的？

A.类和对象都是具体的。

B.类是抽象的，对象是具体的。

C.一般情况下，在定义类之后，能创建无数个对象，可以说，类能化身千万。

D.类是引用型数据类型。

a
类没被实例化是抽象的

12.有如下程序代码，程序运行的结果是（）。

String s1 = "sdut";
String s2 = "I love " + s1;
String s3 = "I love " + s1;
System.out.print(s2 == s3);
Sytem.out.println(" "+s2.equals(s3));

A.true false

B.true true

C.false false

D.false true

d
(一)里面做过这个了,==比较地址,equals()方法比较值,而字符串拼接的时候不会池化

13.有如下代码，程序执行的结果是（）。

String str1 = "sdut@sdut.edu.cn";
String[] strings = str1.split("u");
System.out.println(Arrays.toString(strings));

sd, t@sd, t.ed, .cn

[sd, t@sd, t.ed, .cn]

[sdu, t@sdu, t.edu, .cn]

sdu, t@sdu, t.edu, .cn

b
split把字符串按参数分开,并且不包含参数,得到一个字符数组
Arrays.toString() 可以将字符串数组转换成字符串并输出

14.有如下代码，程序执行的结果是（）。

int i= 110;    
String str2="lucky"+i+2;    
System.out.println(str2);

A.lucky1102

B.lucky112

C.1102lucky

D.112lucky

a
字符串连接运算符“+”从左到右执行，将int类型的变量i先转换成字符串，然后和"lucky"连接成一个新的字符串"lucky110"，再和整型数值2连接成一个新的字符串"lucky1102"，最终输出结果为"lucky1102"。

15.关于枚举类型，说法错误的是：（）。

A.实质是类类型

B.可以定义若干个常量，如颜色、星期、月份等。

C.可利用类型名称.values()方法列出所有常量

D.其定义的位置可以在main方法中

d
枚举类型没学,但是不能在main函数中

16.如下程序代码输出的结果是：（）。

public class Main {
    public static void main(String[] args) {
       int a=023;
       int b=0x10;
       System.out.println(a+" "+b);
    }
}

A.19 16

B.23 16

C.23 10

D.19 10

a
其中，变量a使用的是八进制数023，其对应的十进制数为19；变量b使用的是十六进制数0x10，其对应的十进制数为16。因此，输出结果为19 16。
拿16进制复习一下进制转换,0x是16进制标识符,10（十六进制）= 1×16^1 + 0×16^0 = 16（十进制）

17.关于构造方法定义与作用，下列说法错误的是：（）。

A.用来创建类的实例时调用的方法

B.调用该方法时，对实例变量赋值

C.定义时，方法名称与类名相同，返回值类型可以不写，也可以写成void

D.一个类的构造方法可以定义多个，多个构造方法的参数有明显区别。

c
构造方法没有返回值,也不能用void

18.假设定义了类 Test ,正确创建对象的格式是( ）。

A.Test t = 1 ;

B.Test t = new Test() ;

C.Test t = new Test ;

D.Test t = Test() ;

19.下列选项中，( ) 发生时将调用类的构造方法。

A.调用对象方法

B.创建对象

C.使用对象变量

D.类定义

20.以下有关构造方法的说法，正确的是： ____。

A.一个类的构造方法可以有多个

B.构造方法在类定义时被调用

C.构造方法只能由对象的其它方法调用

D.构造方法可以和类同名，也可以和类名不同

a
a可以方法重载,b是类实例化对象的时候被调用,c随便谁都能调,d必须同名

21.JAVA中，void 的含义：（）。

A.方法体为空

B.定义的方法没有形参

C.定义的方法没有返回值

D.方法的返回值不能参加算术运算

22.为了区分方法重载中同名的不同方法，要求（）。

A.形式参数个数不同或者类型不同

B.返回值类型不同

C.调用时用类名或对象名做前缀

D.形式参数名称不同

a
重载即函数签名不同,包括:形式参数个数不同或者类型不同

23.在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数的个数、类型或顺序各不相同，传回的值也可以不相同，这种面向对象程序特性称为（）。

A.封装

B.继承

C.覆盖

D.重载

d
和22.一样

24.在下面的代码中，程序执行的结果将是：（）。

public class Test {
  public static void main(String[] args) {
         String str = "123";
         System.out.println(str);
         change(str);
         System.out.println(str);
     }
    public static void change(String str){
      str = "456";
    }
}

456
123

456
456

123
456

123
123

d
在(一)中讨论过,str不是全局变量,change函数不能改main函数中str的值,要改的话就得使用return

==25.关于以下代码的说明，正确的是（）。?==

class Main {
    static int x = 10;
    static {
        x += 5;
        System.out.println("x=" + x);
    }
    public static void main(String args[ ])
    {
        System.out.println("x=" + x);
    }
    static {
        x /= 3;
        System.out.println("x=" + x);
    }
}

A.不能通过编译，因为缺少方法名和返回类型

B.不能通过编译，因为只能有一个静态初始化器

C.编译通过，执行结果为：

x=15
x=5
x=5

D.编译通过，执行结果为：

x=3
x=8
x=8

26.类中的一个成员方法被下面哪个修饰符修饰，该方法只能在本类被访问（）

A.pubic

B.protected

C.private

D.默认

27.哪种访问权限修饰的成员，在任何包、任何类中都可以进行访问（）

A.private

B.默认

C.protected

D.public

28.在Java中，针对类和成员提供了4种访问级别，以下控制级别由小到大的顺序是：（）。

A.private< 默认 < protected < public

B.默认 < private< protected < public

C.protected < 默认 < private < public

D.protected < private< 默认 < public

a
protected同一包内的类以及其子类可以访问。
缺省可以被这个类本身以及同一个包中的类访问。包内的类包括其子类，但是包外的类一律无法访问。子类都访问不了,当然比protected严格

29.在成员方法的访问控制修饰符中，规定访问权限只包含该类自身作用域和同包作用域的修饰符是（）。

A.protected

B.public

C.默认

D.private

c
同28.

30.构造方法中调用其他构造方法时，this(,,...)须放在代码的第（）行。

A.可以不出现

B.1

C.末

D.无限制

b
和这个类似的题,如果有super,要先调super,先执行父类的构造方法(好像叫啥函数调用栈来着)

31.某个类的方法中，在成员变量和局部变量重名的情况下，（）变量优先使用。

如果要使用（）变量，必须使用关键字（）进行限定。

A.局部成员 this

B.成员局部 this

C.类实例 this

D.实例类 this

a
局部变量会优先使用。如果要使用成员变量，必须使用关键字 this进行限定。

32.下列关于修饰符使用的说法，错误的是（）。

A.abstract不能与final并列修饰同一个类

B.abstract类中可以有private的成员

C.abstract方法必须在abstract类中

D.static方法中能访问非static的属性

d
a导致抽象类不能继承,显然没用
b抽象类中不只是抽象方法,非抽象方法当然可以private
c有一个抽象方法,类就得定义为抽象类

33.在非静态成员方法中，可以使用关键字（）指代当前对象，访问类的其他非静态成员。

A.this

B.super

C.static

D.public

34.Java关于方法的重写，哪个说法是错误的？（）

A.对一个方法的重写必须发生在具有继承关系的两个类中，即子类对父类方法的重写。

B.方法的重写在一般意义上要求：两个方法的参数个数和类型以及返回值类型都一致。

C.方法的重写是一个类的两个方法，方法的名称相同，但参数不同。

D.子类对象调用子类重写了父类的方法时，优先调用子类的方法。

35.已知类的继承关系如下：

class Employee{}
class Manager extends Employee{}
class Director extends Employee{}

则下列语句通过编译的有哪些？（）

A.Employee e=new Manager();

B.Director d= new Manager();

C.Director d= new Employee();

D.Manager m=new Director();

36.以下有关类的继承的叙述中，正确的是：（）。

A.子类能直继承父类所有的私有属性和私有方法，但是没有访问权限

B.子类只能继承父类的方法，不能继承父类的属性

C.子类能继承父类的成员变量和变员方法，访问没有任何限制

D.子类不能继承父类的私有属性和私有方法

d
继承不能继承私有属性，而不是能继承却没有权限访问

37.在Java中，要想让一个类继承另一个类，可以使用以下哪个关键字？（）

A.inherits

B.implements

C.extends

D.modifies

38.如下代码，程序的输出结果将是：（）。

class A {
    int a = 11;
    int b = 12;

    public void print() {
        System.out.println(a + " " + b);
    }
}

class B extends A {
    int a = 20;

    public void print() {
        System.out.println(a + " " + b);
    }
}

public class Main {
    public static void main(String[] args) {
        A aObj = new A();
        aObj.print();
        B bObj = new B();
        bObj.print();
    }
}

11 12
20 0

20 12
20 12

11 12
11 12

11 12
20 12

d
调用aObj.print()时，会调用A类的print()方法，输出a和b的值，即11和12。调用bObj.print()时，由于B类中的a变量与A类中的a变量同名，因此访问B类中的a变量，而不是从A类中继承的a变量，输出值为20；由于B类中并没有覆盖A类中的b变量，所以仍然访问从A类中继承的b变量，输出值为12。因此输出结果为“11 12”和“20 12”。
简单来说用了上面某个题的知识点:==成员变量和局部变量同名,优先使用局部变量,如果要用成员变量,需要用this关键字==

39.定义一个Java类时，如果前面使用关键字（）修饰，它是最终类，该类不可以被继承。

A.private

B.final

C.static

Dpublic

b
如果在定义Java类时使用关键字final修饰，它就是一个最终类，即该类不可以被继承。使用final关键字修饰的类、方法和变量，都是不可变的，不可以被修改。

40.关于关键字instanceof的说法不正确的是：（）。

A.它不能作为标识符名称出现

B.它用来表示某变量所指向的对象是否是另一种类型的实例

Scanner sc=new Scanner(System.in);
boolean b=sc instanceof String;
//这种用法是正确的

Scanner sc=new Scanner(System.in);
boolean b=sc instanceof Object;
//这种用法是正确的

c
不在一个继承树上不能用instanceof

41.下面程序的输出结果为：（）。

class A {
 double f(double x, double y) {
  return x * y;
 }
}

class B extends A {
 double f(double x, double y) {
  return x + y;
 }
}

public class Test {
 public static void main(String args[]) {
  A obj = new B();
  System.out.println(obj.f(4, 6));
 }
}

A.10.0

B.24.0

C.2.0

D.11.0

a
在main()方法中，通过A obj = new B();创建了一个B类的对象，然后将其赋值给了A类型的变量obj。因为B类继承自A类，所以可以用B类的对象赋值给A类型的变量。接下来输出obj.f(4,6)的结果。因为A类的f()方法是一个普通方法，而不是一个静态方法，所以实际调用的是B类的f()方法，这是由多态性决定的。因此，调用的是B类的f()方法，B类的f()方法实现了加法操作，所以输出结果为10.0。
boj创建了一个A对象被强制转换成了B对象,全程跟A没啥关系

42.有如下程序代码，哪处出现编译错误？（）

class Father {
 int a = 100;    // A
 final public void print() { // B
  System.out.println(a);
 }
}

class Child extends Father { 
 int a = 200;                // C
 public void print() {       // D
  System.out.println(a);  
 }
}

A.A处

B.B处

C.C处

D.D处

d
final修饰的方法可以被继承和重载，但不能被重写,==d处虽然没改,但是也算是重写?==

43.有如下程序代码，哪处出现编译错误？（）

final class Father{           //A
 int a=100;
}
 class Child  extends Father{  //B
  int b=200;
 }
 public class B{              //C
  public static void main(String[] args) {
   Child child=new Child();   //D  
 }  
 }

A.A处

B.B处

C.C处

D.D处

b
final修饰的类不能被继承

==44.有如下程序代码：?==

class Dog{ }
class Cat { }
public class Test{
 public static void main(String[] args) {
  Dog dog=new Dog();
  Cat cat=new Cat();
  System.out.println(cat instanceof Dog);    //A
  System.out.println(dog instanceof Dog);   //B
 }  
 }

关于A、B两段代码，下列哪种说法是正确的？（）

A.输出：

false
true

B.输出：

true
true

C.输出：

false
false

D.出现语法编译错误，程序不能执行

45.在下面的代码中，若要在子child类中对父类的addvalue方法进行重写，下面对于child类中的addvalue方法的声明哪个是正确的：（）。

class father {
 public int addvalue(int a, int b) {
  int s = a + b;
  return s;
 }
}

class child extends father {

}

A.public int addvalue(int i,int j)

B.void addvalue(int a,int b)

C.void addvalue(double i)

D.int addvalue(int a)

a
a是重写,其他三个是重载

46.有如下程序代码，编译(执行)的结果为：

class A {
 int v1 = 10;
 int v2 = 10;

 public void m1() {
  System.out.println("A m1");
 }

 public void m2() {
  System.out.println("A m2");
 }
}

class B extends A {
 int v2 = 20;
 int v3 = 20;

 public void m2() {
  System.out.println("B m2");
 }

 public void m3() {
  System.out.println("B m3");
 }
}

public class Main {
 public static void main(String[] args) {
  A a = new B();
  a.m1();
  a.m2();
  a.m3();
  System.out.println(a.v1);
  System.out.println(a.v2);
  System.out.println(a.v3);
 }
}

A m1
B m2
A m3
10
10
10

A m1
B m2
B m3
10
10
20

a.m3();       编译错误
System.out.println(a.v3);   编译错误

  a.m3();       编译错误

c
尽管在代码中创建了一个 B 的实例并将其引用赋值给 A 类型的变量 a，但是在这个过程中，a 仍然是一个 A 类型的变量。这意味着，在使用 a 调用方法时，只能调用 A 类型中声明的方法。因为 A 类型没有定义 m3() 方法，所以编译器会报错。
虽然将a从A对象转换成了B对象,但是能力声明还是看的A的能力,A没有m3()和v3所以报错

47.有如下代码，程序执行的结果是：（）。

class A {
 int v1 = 10;
 int v2 = 10;

 public void m1() {
  System.out.println("A m1");
 }

 public void m2() {
  System.out.println("A m2");
 }
}

class B extends A {
 int v2 = 20;
 int v3 = 20;

 public void m2() {
  System.out.println("B m2");
 }

 public void m3() {
  System.out.println("B m3");
 }
}

public class Main {
 public static void main(String[] args) {
  A a = new B();
  a.m1();
  a.m2();
  System.out.println(a.v1);
  System.out.println(a.v2);
 }
}

A m1
B m2
10
10

B m1
B m2
20
20

A m1
A m2
10
10

A m1
B m2
10
20

48.有如下程序代码，程序编译(执行)的结果为：

class A {
 int v1 = 10;
 int v2 = 10;
 public A() {
 }
 public void m1() {
  System.out.println("A m1");
 }
 public void m2() {
  System.out.println("A m2");
 }
}

class B extends A {
 int v2 = 20;
 int v3 = 20;
 public B() {
 }
 public void m2() {
  System.out.println("B m2");
 }
 public void m3() {
  System.out.println("B m3");
 }
}
public class Main {
 public static void main(String[] args) {
  B b = new B();
  b.m1();
  b.m2();
  b.m3();
  System.out.println(b.v1);
  System.out.println(b.v2);
  System.out.println(b.v3);
 }
}

B m1
B m2
B m3
20
20
20

A m1
B m2
B m3
10
20
20

A m1
B m2
B m3
20
20
20

A m1
B m2
B m3
20
10
20

b
这个就简单了,没有类型转换,子类覆盖看子类,子类没覆盖看父类

49.有如下程序代码，编译(执行)的结果为：

class A {
 int v1 = 10;
 int v2 = 10;
 public A() {
 }
 public void m1() {
  System.out.println("A m1");
 }
 public void m2() {
  System.out.println("A m2");
 }
}

class B extends A {
 int v2 = 20;
 int v3 = 20;
 public B() {
 }
 public void m2() {
  System.out.println("B m2");
 }
 public void m3() {
  System.out.println("B m3");
 }
}
public class Main {
 public static void main(String[] args) {
  A a = new B();
  a.m1();
  a.m2();
  a.m3();
  System.out.println(a.v1);
  System.out.println(a.v2);
  System.out.println(a.v3);
 }
}

A m1
B m2
B m3
10
20
20

A m1
B m2
B m3
10
10
20

 a.m3();   编译错误
 System.out.println(a.v3);   编译错误

 a.m3();   编译错误

c
47.和48.结合,类型转换加继承,判断a的能力看A(本题的父类),调用a的属性或方法看B(本题的子类),子类B的属性或方法覆盖了A就看B的属性或方法,没覆盖就看A
题没出好,和之前一样了.直接看A的能力声明,A没有m3()和v3,直接编译不过

50.有如下程序代码，编译(执行)的结果为：

class A {
 int v1 = 10;
 int v2 = 10;
 public A() {
 }
 public void m1() {
  System.out.println("A m1");
 }
 public void m2() {
  System.out.println("A m2");
 }
}

class B extends A {
 int v2 = 20;
 int v3 = 20;
 public B() {
 }
 public void m2() {
  System.out.println("B m2");
 }
 public void m3() {
  System.out.println("B m3");
 }
}
public class Main {
 public static void main(String[] args) {
  A a = new B();
  a.m1();
  a.m2();

  System.out.println(a.v1);
  System.out.println(a.v2);
 }
}

A m1
A m1
10
10

B m2
B m2
10
20

A m1
B m2
10
20

A m1
B m2
10
10

51.有如下程序代码，执行的结果为：

class Base {
    void test() {
        System.out.println("Base.test()");
    }
}

class Child extends Base {
    void test() {
        System.out.println("Child.test()");
    }
}

public class Main {
    public static void main(String[] a) {
        Child anObj = new Child();
        Base baseObj = anObj;
        baseObj.test();
    }
}

Child.test()
Base.test()

Base.test()
Child.test()

Base.test()

Child.test()

d
Base baseObj = anObj;这句是引用赋值,相当于是Base baseObj = new Child()

52.有如下程序代码，程序执行的结果是：（）。

class Base {
 static void test() {
  System.out.println("Base.test()");
 }
}

 class Child extends Base {
 static void test() {
  System.out.println("Child.test()");
  Base.test();     // Call the parent method
 }
}

public class Main {
    public static void main(String[] a) {
        Child.test();
    }
}

Child.test()
Base.test()

Base.test()
Base.test()

Base.test()
Child.test()

Runtime error. Cannot override a static method by an instance method

a
Child.test();调了Child的静态test(),在Child.test()中Base.test()又调了Base类的静态test(),都是静态方法,不存在什么父类优先

53.有如下程序代码，程序编译(执行)的结果是（）。

class Father {
    int a = 100;
    int b = 200;

    public void print() {
        System.out.println(a + " " + b);
    }
}

class Child extends Father {
    int b = 300;
    int c = 400;

    public void print() {
        System.out.println(a + " " + b + " " + c);
    }

    public void printExtend() {
        System.out.println(c);
    }

}

public class Main {
    public static void main(String[] a) {
        Father obj = new Child();
        System.out.println(obj.a);   / AA语句
        System.out.println(obj.b);   // BB语句
        obj.print();       // CC语句
        obj.printExtend(); // DD语句
    }
}

100
200
100 300 400
400

100
300
100 300 400
400

100
300
100 200 400
400

D.DD处有编译错误

d
老套路了,Father obj将obj对象的能力限定在Father类,Father类没有printExtend(),直接报错
后面碰到这种题就不写解析了

54.有如下程序代码，执行的结果是（）。

class Father {
    int a = 100;
    int b = 200;

    public void print() {
        System.out.println(a + " " + b);
    }
}

class Child extends Father {
    int b = 300;
    int c = 400;

    public void print() {
        System.out.println(a + " " + b + " " + c);
    }

    public void printExtend() {
        System.out.println(c);
    }

}

public class Main {
    public static void main(String[] a) {
          Father obj=new Child();
          System.out.println(obj.a+" "+obj.b);   
          obj.print();  
    }
}

100 200
100 200 400

100 300
100 300 400

100 300
100 200 400

100 200
100 300 400

55.有如下父类、子类及测试类的定义，程序执行后，输出结果是true的语句为：（）。

class Father {
}
class Child extends Father {
}

public class Main {
    public static void main(String[] a) {

          Father f1=new Father();
          System.out.println(f1 instanceof Father);  //AA语句
          System.out.println(f1 instanceof Child);   //BB语句

          Father obj=new Child();
          System.out.println(obj instanceof Father);  //CC语句
          System.out.println(obj instanceof Child);   //DD语句

          Child c1=new Child();
          System.out.println(c1 instanceof Father);   //EE语句
          System.out.println(c1 instanceof Child);    //FF语句

    }
}

A.AA、BB、CC、DD、EE、FF

B.AA、BB、CC、DD、EE

C.AA、CC、DD、EE、FF

D.AA、BB、DD、FF

c
insanceof用来判断对象是否属于一个类,父类的对象不被认为属于子类,而子类的对象被认为属于父类
对于cc和dd,类被转化成了子类的对象,所以效果和ee,ff是一样的

56.有如下父类、子类及测试类的定义，程序执行结果是：（）。

class Father {
 int a =100;
 public void print() {
  System.out.println(a);
 }
}
class Child1 extends Father {
 int a =200;
 public void print() {
  System.out.println(a);
 }
}
class Child2 extends Father {
 int a =300;
 public void print() {
  System.out.println(a);
 }
}
public class Main {
    public static void main(String[] a) {
        Father obj1;
          obj1=new Child1();
          System.out.println(obj1.a);
          obj1.print(); 

          obj1=new Child2();
          System.out.println(obj1.a);
          obj1.print(); 
    }
}

57.有如下代码，程序执行结果是：（）。

abstract class Person {
 public abstract void eat();
}
public class Main {
    public static void main(String[] a) {

          Person p = new Person() {
           public void eat() {
            System.out.println("eat something");
           }
          };
          p.eat();
    }
}

A.空字符串

B.编译错误

C.eat something

D.运行错误

c
Person p = new Person()后面直接实现了整个类,这种方法叫匿名内部实例,实例化了一个匿名的person类的子类,实现了原本的抽象eat方法

58.有如下代码，程序的执行结果是（）。

interface Person {
 public void eat();
}

public class Main {
    public static void main(String[] a) {

          Person p = new Person() {
           public void eat() {
            System.out.println("eat something");
           }
          };
          p.eat();
    }
}

A.空字符串

B.编译错误

C.eat something

D.运行时错误

c
和57.是一样的

59.下面关于JAVA面向对象的理解，说法中不正确的是：（）。

A.Java中，一个类只允许实现一个接口

B.抽象类中允许有非抽象方法的存在

C.静态的成员变量可以直接用类名调用

D.通过super可以调用父类的构造函数

a
接口具有多继承性,而父类具有单继承性:一个父类可以有多个子类，而一个子类只能有一个直接父类。这种关系被称为单继承。

60.以下关于继承的叙述正确的是（）。

A.在Java中类只允许单一继承

B.在Java中,一个类只能实现一个接口

C.在Java中，一个类不能同时继承一个类和实现一个接口

D.在Java中，接口也具有单继承性

a
59.里面提到了

61.判断两个对象的引用是否相同，使用（）方式进行判断。

A.equals()

B.hashcode()

C.toString()

D.==

d
==判断地址,equals()判断字典序

62.程序代码中包含产生CheckedException受检异常（非运行时异常）的语句时，（）。

A.如果程序错误，就使用try-catch语句处理异常；否则，不必处理

B.必须进行处理，或使用try-catch语句处理异常，或在调用方法上使用throws将其抛出

C.只能使用try-catch语句处理

D.可以置之不理

b
受检异常和非受检异常都是可以被try-catch处理
异常分为受检异常（Checked Exception）和非受检异常（Unchecked Exception）。受检异常必须要在代码中进行处理，否则编译不通过；非受检异常不要求在代码中进行处理，但建议进行处理以提高程序的稳定性。
受检异常需要在方法签名中声明这种可能性并在调用该方法时处理或继续抛出这种异常。否则，代码将无法通过编译。如果无法在代码中处理该异常，则可以在方法签名中使用throws关键字将其抛出，告诉调用方需要处理该异常。既可以通过try-catch,也可以通过throw处理

63.关于Java中异常的叙述，正确的是：（）。

A.异常是程序编写过程中代码的语法错误

B.异常是程序编写过程中代码的逻辑错误

C.异常出现后程序的运行马上中止

D.异常是可以捕获和处理的

64.关于异常，下列说法正确的是 ( )。

A.程序运行过程中，若产生异常，它是某种异常类型的对象

B.一旦程序运行，异常对象将被创建

C.为了保证程序运行速度，要尽量避免异常控制

D.以上说法都不对

a
java为了异常好处理,将异常分了类,异常被表示为异常类的对象，当程序运行时产生异常时，就会创建一个异常对象

65.Java中用来抛出异常的关键字是：（）。

A.try

B.catch

C.throw和throws

D.finally

c
throw 和 throws 是用来抛出异常的关键字。其中 throw 用于方法体中抛出一个异常实例，而 throws 则用在方法声明中，表示该方法可能会抛出某种异常，调用者在调用该方法时需要进行处理。

66.在异常处理时，将可能发生异常的代码放在（）语句块中，后面紧跟着一个或多个（）语句块，还可以再跟零个或一个（）语句块。

A.catch、try、finally

B.try、catch、finally

C.try、finally、exception

D.exception、try、finally

b
finally不能有多个

67.关于try语句对应的多个catch子句中，若捕获的异常类型有父子类关系时，它们的排列下列哪种是正确的( ) 。

A.异常父类在先，异常子类在后

B.异常子类在先，异常父类在后

C.有继承关系的异常不能同时出现在同一个try程序段之后

D.先后顺序无所谓

68.在异常处理中，如释放资源、关闭文件、关闭数据库等由（）来完成。

A.try子句

B.catch子句

C.finally子句

D.throw子句

c
这种无论如何一定要做的就交给finally吧

69.关于字符串的方法，如下代码执行结果是（）。

String fileName = "sdut@sdut.edu.cn"; 
System.out.println(fileName.lastIndexOf("."));

A.9

B.10

C.13

D.12

c
lastindexof找目标最后一次出现的位置前面有多少字符,第一位是0

70.关于字符串的方法，如下代码执行结果是 ____ 。

A.dut

B.sdut

C.sdu

D.dut@

a
代码都没有,做什么,,,

71.关于字符串的方法，如下代码执行结果是（）。

String fileName = "中国China"; 
System.out.println(fileName.indexOf("国"));

A.0

B.1

C.2

D.3

b
indexof找目标第一次出现的位置前面有多少字符

72.关于字符串的方法，如下代码执行结果是（）。

String fileName = "中国China"; 
System.out.println(fileName.length());

A.7

B.9

C.11

D.13

73.关于字符串的比较，如下代码执行结果是（）。

        String s1 = "imooc";
        String s2 = "I love " + s1;
        String s3="I love imooc";
        System.out.println(s2 == s3);

A.true

B.false

C.0

D.1

b
(二)里面提到,字符串拼接的时候是不会池化的

74.关于字符串的构造方法，如下代码执行结果是（）。

String str="ABCDEFG";
char[] chars=str.toCharArray(); 
System.out.println(new String(chars,1,3));

A.ABC

B.BCD

C.AB

D.BC

b
char[] chars=str.toCharArray()将字符串转换为字符数组。数组的每一个空间存了一个字符
new String(chars,1,3) 用字符数组中从索引1开始的三个字符创建一个新的字符串对象，即 "BCD"。第二个参数是要提取的字符的起始位置，第三个参数是要提取的字符的数量。

75.关于字符串的构造方法，下面代码执行结果是（）。

String str="中国123";
byte[] bytes=str.getBytes();
System.out.println(new String(bytes,2,3));

A.123

B.国

C.国12

D.国1

76.关于字符串的方法，如下代码执行结果是（）。

String str="中国GOOD";
System.out.println(str.getBytes().length);

A.6

B.7

C.8

D.9

77.关于字符串的方法，如下代码执行结果是（）。

String str="中国GOOD";
System.out.println(str.toCharArray().length);

A.6

B.7

C.8

D.9

78.关于字符串的相关使用，如下代码执行结果是（）。

String str1 = "110"; 
int i=Integer.parseInt(str1,2);
int i1=i+2;
System.out.println(i1);

A.112

B.8

C.110

D.10

b
代码首先将二进制字符串"110"转换为整数，因为参数2代表的是字符串的进制，所以最终将110转换为了6。然后将6加2，得到8，并将结果打印出来。因此答案是B。

79.关于字符串的方法，如下代码执行结果是（）。

String str1 = "sdut@sdut.edu.cn";   
System.out.println(str1.toUpperCase());
System.out.println(str1);

sdut@sdut.edu.cn
SDUT@SDUT.EDU.CN

sdut@sdut.edu.cn
sdut@sdut.edu.cn

SDUT@SDUT.EDU.CN
SDUT@SDUT.EDU.CN

SDUT@SDUT.EDU.CN
sdut@sdut.edu.cn

d
touppercase()不会改变原有的对象

80.关于字符串的方法，如下代码执行结果是（）。

String str1 = "sdut@sdut.edu.cn";
String str2 = str1.toLowerCase();
System.out.println(str2);
System.out.println(str1);
System.out.println(str1 == str2);

sdut@sdut.edu.cn
sdut@sdut.edu.cn
true

sdut@sdut.edu.cn
sdut@sdut.edu.cn
false

sdut@sdut.edu.cn
SDUT@SDUT.EDU.CN
true

sdut@sdut.edu.cn
SDUT@SDUT.EDU.CN
false

a
池化导致地址相同

81.关于字符串的方法，如下代码执行结果是（）。

String str1 = "abcd"; 
String str2="sdut";
System.out.println(str1.compareTo(str2)>0);

A.true

B.false

C.1

D.-1

b
compareto比较字典序,a比s小1,结果应该小于0

82.关于字符串的方法，如下代码执行结果是（）。

String str1 = "sdut12"; 
String str2="sDut12";
System.out.println(str1.equalsIgnoreCase(str2));

A.true

B.false

C.0

D.1

a
equalsIgnoreCase忽略大写小写比较字符串

83.String类的equals方法，其作用是：（）

A.比较2个字符串对象是否为同一个对象

B.比较2个字符串对象的字符长度是否相同

C.比较2个字符串对象的首地址是否相同

D.比较2个字符串对象的字符序列是否相同

d
不比较地址,只比较字典序

84.关于字符串的方法，如下代码执行结果是（）。

String str = "    abcd123";
  str.toUpperCase();
  str.trim();
  System.out.println(str);

abcd123

B.abcd123

ABCD123

ABCD123

a
这俩方法都没有改变对象,而临时的结果也没有被类似于str=str.trim()来赋值,所以strr本身是不变的

85.关于字符串的相关操作，如下代码执行后输出的结果是：（）。

String str1="abc";
String str2=str1.toUpperCase();
String str3=str1.toLowerCase();
System.out.println(str1==str2);
System.out.println(str1==str3);

false
true

false
false

true
true

true
false

a
池化导致地址相同

86.下列关于字符串对象的叙述中，错误的是（）。

A.字符串常量是对象

B.String 对象存储字符串的效率比 StringBuilder 高

C.字符串对象具有不变性

D.String类提供了许多用来操作字符串的方法：连接、提取、查询等，一旦返回的结果与原字符串不同，就生成一个新对象，而不是在原字符串进行修改

b
字符串常量是对象，字符串对象具有不变性，String类提供了许多用来操作字符串的方法，但是字符串对象存储字符串的效率比StringBuilder高是错误的，因为String对象在执行任何修改操作时，都需要创建新的对象，而StringBuilder对象则可以直接在原有对象的基础上修改，因此StringBuilder对象的效率更高。

87.已知: String s="abcdedcba”; 则s.substring(3,4)返回的字符串是哪个（）

A.cd

B.de

C.d

D.dedc

c
方法 substring(startIndex, endIndex)返回从 startIndex 到 endIndex-1 的子字符串。在这种情况下，startIndex 是3，endIndex是4，因此返回的子字符串只包含第四个字符 "d"。
substring(3)不能得到第三位,而是表示第3位到最后一位,需要使用charAt()方法

88.关于字符串对象的比较，==用于比较字符串对象的（）是否相同；equals()方法用于比较字符串对象的（）是否相同。

A.存储地址字符序列

B.存储地址存储地址

C.字符序列存储地址

D.字符序列字符序列

89.执行如下两行代码之后，则内存中存在几个字符串对象（）

String str="abc"; 
str+="def";

A.1

B.2

C.3

D.4

90.关于对StringBuffer类对象的操作，下面代码执行后，输出结果是（）。

StringBuffer buffer=new StringBuffer();
StringBuffer buffer2=buffer.append("abc").append("123");
System.out.println(buffer==buffer2);

A.true

B.false

C.0

D.1

a
.append会改变原对象,StringBuffer池化了指向同一个地址,所以不论是==还是.equal都是一样的

91.StringBuffer类对象与String类对象相比，它的优势在于其可以在原来对象基础上进行字符的更改，但它在（）方面不如String类提供的功能丰富。

A.插入、追加

B.删除

C.修改

D.查询、检索

d
StringBuffer类对象与String类对象相比，它的优势在于其可以在原来对象基础上进行字符的更改。也就是说，StringBuffer类对象支持修改、插入、追加和删除等操作。
但是，String类提供的功能比StringBuffer类要更丰富。例如，String类有许多用于查询和检索字符串的方法，如 indexOf()、lastIndexOf()、startsWith()、endsWith() 等。

92.StringBuffer类维护字符的容量和长度的概念。有该类的对象buf1，其容量与长度的关系是：（）。

A.buf1.capacity()>=buf1.length()

B.buf1.capacity()<=buf1.length()

C.buf1.size()>buf1.=length()

D.buf1.size()<buf1.=length()

a
a,b和2.一样
.size() 是指获取对象的元素数量。该方法通常用于集合或容器类（如 List、Map、Set 等）。如果两者都能用的话,数量应该是相等的

93.关于StringBuffer对象的操作，有如下程序代码，程序运行的结果是（）。

StringBuffer buf1=new StringBuffer("abcd");
StringBuffer buf2=buf1.append("def");
System.out.print(buf1+" ");
System.out.print(buf2+" "); 
System.out.println(buf1==buf2);

A.abcd abcddef false

B.abcddef abcddef true

C.abcd abcddef true

D.abcddef abcddef false

b
上面提到,StringBuffer的append会改变原字符,所以buf1是abcddef不变,池化导致地址相同
==不过如果是new出来的,而不是封装出来的,即使内容相同地址也不同(String和StringBuffer都满足)==

94.有如下程序代码，程序运行的结果是（）。

StringBuffer buf=new StringBuffer("Beijing2008");
buf.insert(7, "@");
System.out.println(buf);

Beijing@2008

Beijing2008@

@Beijing2008

Beijing#2008

a
insert(7, "@")在第7位后面插一个@

95.关于对StringBuffer对象的操作，有如下程序代码，程序运行的结果是（）。

        StringBuffer buf=new StringBuffer("abcde");
        buf.reverse();
        System.out.println(buf);

A.abcde

B.edcba

C.abcd

D.edcb

b
和上面一样StringBuffer的操作都会改变类本身

96.阅读下面的程序段，以下表达式的值为true的是哪个（）

        String str1=new String("java");
        String str2=new String("java");
        StringBuffer str3=new StringBuffer("java");
        StringBuffer str4=new StringBuffer("java");

A.str1==str2

B.str1.equals(str2)

C.str3==str4

D.str3.equals(str4)

E.str1==str3

F.str1.equals(str4)

b
new出来的地址都不一样,所以a,c排除
不能使用==比较String和StringBuffer类,会报错,e排除
不能使用.equals方法来比较StringBuffer类,因为这个类没有重写equals方法,所以调用了父类Object类的方法,导致equals比较的不是字典序而是地址,相当于==的作用,d,f排除

97.Java中对日期数据按照国家和地区的使用习惯进行格式化字符串及日期格式转换，要使用到java.text.SimpleDateFormat类。

把日期转换成符合格式的字符串，调用（）方法；把某格式的字符串转换成日期对象，调用（）方法。

A.parse format

B.parse dateFormat

C.format parse

D.format parseDate

c
把日期转换成符合格式的字符串，应该调用 format() 方法。把某格式的字符串转换成日期对象，应该调用 parse() 方法。这俩方法是 SimpleDateFormat 类中用于将日期对象格式化为指定格式字符串的方法。

SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
String formattedDate = dateFormat.format(new Date());
System.out.println(formattedDate); // 输出格式化后的字符串形式的日期

SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date date = dateFormat.parse("2023-05-07");
System.out.println(date); // 输出日期对象

98.利用java.util.Date类创建对象，欲得到系统当前时间的语句为：（）。

A.new Date();

B.new Date(0);

C.new Date(NOW);

D.new Date(-1);

a
Date now = new Date(); System.out.println(now);

99.关于基本类型的数据与其封装类对象之间的转换，下面说法错误的是( )。

A.Integer类型的对象可以通过拆箱，可以自动转化为int基本类型的数值。

B.int类型的数据通过装箱操作，可以自动转换成Integer类型的对象。

C.int类型的数值通过装箱操作，可以自动封装为Long 类型对象

D.long类型的数据通过装箱操作，可以自动封装为Long类型对象

c
基本类型与其对应的封装类之间可以进行装箱和拆箱操作。装箱是指将一个基本类型转换为其对应的引用类型（封装类），拆箱是指将一个引用类型（封装类）转换为其对应的基本类型。]
装箱拆箱是对应类型之间的事,两种类型之间的转换不属于装箱拆箱

100.下列程序代码运行结果是：（）。

import java.util.ArrayList;
    import java.util.List;
public class Test {
     public static void main(String args[]) {
        List list = new ArrayList();
        list.add(new Test());
        list.add(new String(""ABC""));
        list.add(new Test());
        System.out.println(list.size());
     }
    }

A.1

B.2

C.3

D.4

c
前面提到,size()和length()差不多,只是针对的数据类型不一样

101.返回Collection 中的元素数量的方法是（）。

A.length()

B.capacity()

C.size()

D.count()

c
同上,capacity()返回空间大小,size()返回元素个数

102.Java的集合框架中重要的接口java.util.Collection定义了许多方法。选项中哪个方法不是Collection接口所定义的？( )

A.int size()

B.boolean containsAll(Collection c)

C.compareTo(Object obj)

D.boolean remove(Object obj)

A. `int size()`: 返回集合中元素的数量，该方法是 `Collection` 接口中定义的方法之一。

B. `boolean containsAll(Collection c)`: 判断集合是否包含另一个集合中的所有元素，该方法是 `Collection` 接口中定义的方法之一。

C. `compareTo(Object obj)`: 该方法并不是 `Collection` 接口中定义的方法，而是 `java.lang.Comparable` 接口中定义的方法，用于比较对象之间的大小关系。

D. `boolean remove(Object obj)`: 从集合中删除指定的元素，如果成功删除则返回 `true`，否则返回 `false`。该方法是 `Collection` 接口中定义的方法之一。

103.向Collection中增加数据的方法是（）。

A.insert

B.add

C.append

D.concat

b
Collection中有add方法,比如ArrayList就使用了add方法

104.欲构造ArrayList类的一个实例，此类实现了List接口，下列哪个写法是正确的？

A.ArrayList myList=new Object()；

B.List myList=new ArrayList()；

C.ArrayList myList=new List()；

D.List myList=new List();

b
List看作接口不好理解,可以看成内置类(接口本来就是特殊的类),当作ArrayList的子类向上转型就好

105.字符串“山东理工”使用UTF-8编码格式得到字节数组bytes，下面哪条语句能够还原为原字符串信息

A.new String(bytes)

B.new String(bytes, "UTF-8")

C.new String(bytes, "GBK")

D.bytes.toString()

A. new String(bytes)：这种方式会使用平台默认的编码格式进行解码，结果可能会因为平台环境的变化而不稳定，不推荐使用。

C. new String(bytes, "GBK")：这种方式使用了不同于编码时的编码格式进行解码，因此无法正确还原原始字符串信息。

D. bytes.toString()：这种方式与原始字符串信息无关，只是将字节数组对象转换为字符串并输出其存储地址等信息，不能还原原始字符串。

106.File类中以字符串形式返回文件绝对路径的方法是哪一项？（）

A.getParent()

B.getName()

C.getAbsolutePath()

D.getPath()

c
作用就像它的英文名一样

A. getParent() 方法返回文件所在目录的绝对路径，而不是文件的绝对路径。

B. getName() 方法返回文件名称，而不是文件的绝对路径。

D. getPath() 方法返回相对或绝对路径名字字符串，但它不会将相对路径转换为绝对路径，因此不是获取文件绝对路径的方法。

107.想得到文件（目录）的名称，如：

File file1=new File(""F:\\abc\\"");     //--> abc
File file2=new File(""F:\\abc.txt"");   //--> abc.txt

需要使用java.io.File类的对象调用（）方法。

A.toString()

B.getName()

C.getAbsolutePath()

D.getParent()

b
上一题提到了

108.要从“file.dat”文件中读出第10个字节到变量c中，下列哪个方法适合（）

FileInputStream in=new FileInputStream("file.dat"); 
int c=in.read();

RandomAccessFile in=new RandomAccessFile("file.dat"); 
in.skip(9); 
int c=in.readByte();

FileInputStream in=new FileInputStream("file.dat"); 
in.skip(9); 
int c=in.read();

FileInputStream in=new FileInputStream("file.dat"); 
in.skip(10); 
int c=in.read();

c
a只能读第一位,b读的时候会加一些限制,不好(据说会导致16进制数据带符号?)d直接读的第10位

109.在编写Java程序时，若需要使用到标准输入输出流的若干个类，导入包时宜在程序的开头写上（）语句。

A.import java.awt.* ;

B.import java.applet.Applet;

C.import java.io.*;

D.import java.awt.Graphics;

c
java.io 包提供了有关输入输出、文件读写等功能的类和接口，包括常用的输入输出流、字节与字符集转换等功能。

A. java.awt 包提供了窗口组件、绘图、布局管理等图形用户界面相关的类和接口

B. java.applet.Applet 是 Applet 类所在的包

D. java.awt.Graphics 是绘图相关的类

110.在输入流的read方法返回哪个值，表示读取结束？

A.0

B.1

C.-1

D.null

c
InputStream 类是所有输入流的超类，它的 read() 方法用于从输入流中读取一个字节的数据，并将读取到的字节作为整数返回。如果已经到达输入流的末尾，则返回 -1，表示读取结束。

javaCopy CodeInputStream in = ...;
int b;
while ((b = in.read()) != -1) {
    // 处理读取到的数据
}

111.利用FileInputStream和FileOutputStream读写文件，哪个方法不抛出IOException( )

A.两个类的构造方法

B.read

C.write

D.close

112.desc tablename; 命令的作用是：

A.连接数据库

B.创建数据库

C.查看表结构的详细信息

D.删除数据库

c
java怎么考sql了🤔

113.关于Java，以下描述错误的是：

A.Java编译成字节代码，字节代码可以在任何操作系统下直接运行。

B.java的源代码后缀名是 java，编译后的字节代码后知名是 class。

C.使用 Javac 对源代码进行编译，java是虚拟机。

D..class 文件需要在java虚拟机上运行。

a
java的源代码后缀名是 java，编译后的字节代码后知名是 class。Javac 是 Java 编译器，用于将 Java 源代码编译成字节代码。编译后的字节代码文件后缀名是 .class，这些文件需要在 Java 虚拟机上运行。

114.关于Java文件的描述，错误的是：

A.Java文件中定义的类名和文件名保持一致。

B.一个Java文件中可以定义多个class。

C.一个Java文件中只能定义一个public class

D.main函数不一定定义成static

d
main如果不是静态的,就需要实例化,main是入口函数,谁能实例化

115.Java编程中，常见的错误类型不包括：

A.System Errors

B.Syntax Errors

C.Runtime Errors

D.Logic Errors

116.关于Java代码，描述错误的是

A.在Eclipse中，所有的Java源文件应该都保存在src这个目录中。

B.package edu.cuit.screen; 这个包申明表示该Java源文件的目录对应：edu/cuit.screen.java

public static void main(String[] args)
{
...
}

作为一个程序的主函数入口，String[] args这个参数不能省略。

D.主函数的申明是固定的，如：
public static void main(String[] args)
且返回值一定是void

117.关于Scanner,错误的描述是：

A.Scanner 在使用前必须使用new 创建一个实体，且赋值给一个Scanner类型的变量，如下：
Scanner input = new Scanner(System.in);

B.Scanner 可以读取整数、double、浮点、字符串、字符等基本数据类型。

C.每次读取一个数据必须新建立一个Scanner对象，如下述代码。
Scanner input1 = new Scanner(System.in);
int v1 = input1.nextInt();
Scanner input2 = new Scanner(System.in);
int v2 = input2.nextInt();

D.Scanner可以从不同的输入源读取数据，不单是控制台。

c
Scanner可以复用

118.关于Java的基本类型，说法错误的是

A.Java中所有的数值类型都是有符号的。

B.数值计算表达式的类型以该表达式中取值范围最大的变量确定。

C.当取值范围大的变量赋值到取值范围小的变量时，可以不做强制类型转换，系统会隐含进行类型转换。

String a = "hello";
int b = 110;
那么：
a+b 是正确的表达式。

E.byte、short、int、long、float、double 取值范围依次变大

c
取值范围大转小需要强制类型转换,因为可能出现数据损失,小转大不需要

119.Java属于以下哪种语言（）

A.机器语言

B.汇编语言

C.高级语言

D.以上都不对

120.下列选项中，哪一个是多行注释符号（）

A.//**//

B./*/*

C.//

D./**/

121.下列关于变量作用域的说法中，正确的是（）

A.在main()方法中任何位置定义的变量，其作用域为整个main()方法。

B.代码块中定义的变量，在代码块外也是可以使用的。

C.变量的作用域为：从定义处开始，到变量所在代码块结束的位置。

D.变量的作用域不受代码块的限制。

c
局部方法(代码块的一种)中定义的变量只在局部方法中有效,bd错误
main方法中有if或者for(代码块的另一种)中定义的变量只在if或for中有效

122.以下标识符中，不合法的是（）

A.user

B.$inner

C.class

D.login_1

c
class关键字占用了

123.下列选项中，不属于Java中关键字的是（）

A.if

B.float

C.Final

D.try

c
大写

124.下列选项中，属于布尔常量的是（）

A.198

B.2e3f

C.true

D.null

125.以下关于变量的定义，正确的是（）

A.int a=10;

B.b=2；

C.int =20；

D.int a；b=a+10；

126.下列选项中，哪一个不能通过编译（）

A.byte a=1;

B.short b=100;

C.int c='a';

D.long d=8888888888888888;

127.下列浮点数的定义中，正确的是（）

A.float f = 1F;

B.float f = 1.0;

C.float f = '1';

D.float f = "1";

a
float f = 1F最后那个f的大小写是无所谓的

128.关于变量类型转换的描述中，正确的是（）

A.只有数据类型相同的数据才能进行运算。

B.byte类型和short类型的数据是不能一起运算的。

C.两个byte类型数据一起运算时会把先自动提升到int类型再运算。

D.两个整型在一起运算时，结果一定是int。

d
在java运算中，在涉及到数据类型范围小于int的（如byte，char，short）时，数据类型会自动提升为int类型.所以a,c错,同时两个长整型(long)运算得到长整型,而不是int🤔

129.若int a = 7;a %= 2;则执行后，变量a的值是（）

A.7

B.1

C.2

D.3

b
和c一样,a%=x相当于a=a%x

130.下列选项中，不属于赋值运算符的是（）

A.-=

B.=

C.==

D.*=

c
c是逻辑运算符,判断两个数是否相等

131.下列选项中，不属于比较运算符的是（）

A.=

B.==

C.<

D.<=

a
和130.一样

132.下列关于条件语句的描述中，错误的是（）

A.if语句中的条件表达式是一个布尔值。

B.选择语句分为if条件语句和switch条件语句。

C.switch语句中的表达式只能是布尔类型的值。

D.switch语句只能针对某个表达式的值作出判断。

c
case支持很多类型,比如case 1是可以的,case "1"也可以

133.请阅读下面的程序

public class SwitchDemo3 {
    public static void main(String[] args) {
        char c = ‘B’;
        switch(c) {
            case ‘A’:System.out.println(“优”);break;
            case ‘B’:System.out.println(“良”);break;
            case ‘C’:System.out.println(“差”);break;
        }
    }
}

下列选项中，哪一个才是程序的运行结果（）

A.优

B.良

C.差

D.编译失败

b
没有break就是良差了,不过这里是中文的引号,谁知道是不是想考编译失败🤣

134.while语句的循环体中不能包含的语句是（）

A.while语句

B.方法定义语句

C.if语句

D.switch语句

b
会导致重复定义一个方法

135.请阅读下面的程序

public class Example  {                                                            
    public static void main(String[] args) {                                  
        int x = 1;                                                                            
        do {                                                                                   
            x++;                                                                        
        } while (x <= 4);      
        System.out.println("x = " + x);                                      
    }                                                                                   
}

程序的运行结果是（）

A.3

B.4

C.5

D.6

c
4满足while,触发了下一个do,导致+1,即5

136.请阅读下面的程序

public class Test {
    public static void main(String[] args) {
        for(int x =0;x<5;x++){
            if(x%2==0)
                break;
            System.out.println(x);
        }
    }
}

运行结果正确的是（）

A.12345

B.024

C.13

D.不输出任何内容

d
x=0刚进来就被break掉了,要想输出024应该是continue

137.int[] a={45,4,67,23,65,87,34,52,56}；数组中a[4]的值为（）

A.23

B.45

C.65

D.87

c
数组索引从0开始,4是第5个

138.请阅读下列示意代码

int a = 1;
int b = a++;
int c = ++a;
int d = ++a + ++a;
System.out.print(a + "," + b + "," + c + "," + d);

下面选项中，哪一个是程序的输出结果（）

A.5,1,3,9

B.5,2,3,9

C.5,1,2,9

D.5,1,3,8

a
a++是先去a的值,再对a自增,++a是a先自增再带入运算

139.执行完以下代码int[ ] x = new int[25]；后，以下哪项说明是正确的（）。

A.x[24]为0

B.x[25]为0

C.x[0]为空

D.x[24]未定义

a
没定义的都是0,x[25]溢出

140.以下有关构造方法的说法，正确的是： ____。

A.一个类的构造方法可以有多个

B.构造方法在类定义时被调用

C.构造方法只能由对象的其它方法调用

D.构造方法可以和类同名，也可以和类名不同

a
和20.一样

141.以下关于继承的叙述正确的是（）。

A.在Java中类只允许单一继承

B.在Java中,一个类只能实现一个接口

C.在Java中，一个类不能同时继承一个类和实现一个接口

D.在Java中，接口也具有单继承性

a
和60.一样

142.Java源代码文件的扩展名为（）

A..txt

B..class

C..java

D..doc

c
源文件是.java,编译后的字节代码就是.class

143.在控制台显示消息的语句正确的是（）

A.System.out.println(我是一个Java程序员了！);

B.System.Out.println("我是一个Java程序员了！");

C.System.out.println("我是一个Java程序员了！");

D.System.Out.Println("我是一个Java程序员了！")

144.下面选项中不是开发Java程序的步骤（）

A.编译

B.编写源代码

C.运行

D.发布

145.如果希望某些属性被所有对象共享，就必须将其声明为（）属性。

A.final

B.public

C.static

D.this

146.以下表达式中，（）不可作为循环条件。

A.x = 10

B.y >= 80

C.inputPass == truePass

D.m !=3

147.下列变量定义中，符合Java命名规范的是（）

A.3a

B.int-name

C.$number

D.field name

c
a不能以数字开头,b不能有-,d不能有空格

148.字节码文件经过Java编译器翻译成一种特殊的二进制文件，由JVM负责解释执行。该二进制文件扩展名为（）

A..java

B..class

C..obj

D..bin

b
142.提到了

149.这个程序的输出是？

public class Demo{
    public static void main(String[] args){
        boolean flag = false;
        System.out.println(flag?"hello":"word");
    }
}

A.hello

B.word

C.true

D.程序出错

b
三目运算,?前面为真则取:前面的,为假则取:后面的

150.使用以下方法test(),那一项是正确的？（）

public int test(int num,String str){
    return num+str;
}

A.test("1",2)

B.test()

C.test(1)

D.test(1,"2")

151.请问以下哪个修饰符用于声明一个常量？请选择一个正确答案：

A.static

B.final

C.abstract

D.public

152.设有下面两个类的定义，类 Person 和类 Student 的关系是（）。

class Person {
    long id; // 身份证号
    String name; // 姓名
}
class Student extends Person {
    int score; // 入学总分
    int getScore(){
    return score;
    }
}

A.包含关系

B.实现关系

C.继承关系

D.没有关系

153.下面的代码段执行之后count的值是什么( )

    int count = 1;
    for (int i = 1; i <= 5; i++) {
        count += i;
    }
    System.out.println(count);

A.5

B.1

C.15

D.16

154.while循环和 do…while循环的区别是：（）

A.没有区别，这两个结构任何情况下效果一样

B.while循环比 do…while循环执行效率高

C.while循环是先循环后判断，所以循环体至少被执行一次

D.do…while循环是先循环后判断，所以循环体至少被执行一次

155.关于继承的说法正确的是：（）

A.子类将继承父类所有的属性和方法

B.子类将继承父类的非私有属性和方法

C.子类只继承父类public方法和属性

D.子类只继承父类的方法，而不继承属性

b
public,protected,缺省都能被继承

156.以下关于构造函数的描述错误的是（）

A.构造函数的返回类型只能是void型

B.构造函数是类的一种特殊函数，它的方法名必须与类名相同

C.构造函数的主要作用是完成对类的对象的初始化工作

D.一般在创建新对象时，系统会自动调用构造函数

157.下列哪一个关键字用于实现接口？（）

A.extends

B.interface

C.abstract

D.implements

158.如果局部变量和成员变量同名，如何在局部变量作用域引用成员变量？( )

A.不能引用，必须改名，使它们的名称不相同

B.在成员变量前加this，使用this访问该成员变量

C.在成员变量前加super，使用super访问该成员变量

D.不影响，系统可以自己区分

b
前面提到过,局部变量优先,如需调用成员变量需要加this关键字

159.在编写异常处理的Java程序中，catch语句块应该与( )语句块对应，使得用该语句块来启动Java的异常处理机制。

A.try

B.switch

C.break

D.default

160.用关键字 private 修饰的成员变量，下列说法正确的是（）

A.只能被该类自身所访问或修改

B.只能被同一包中的其它类访问

C.可以被其它包中的类访问

D.可以被其它包中该类的子类所访问

a
public 修饰符表示被修饰的成员可以被任何类访问，无论该类是在哪个包中定义的。
protected 修饰符表示被修饰的成员可以被本类、同一包中的其他类和不同包中的子类所访问，但不能被不同包中的非子类所访问。
默认的（即不加任何修饰符）表示被修饰的成员可以被本类和同一包中的其他类所访问，但不能被不同包中的类所访问，包括不同包中的子类。当一个成员没有显式指定访问修饰符时，默认使用该成员所在类的访问修饰符。

161.程序执行后，num的值应该是（）

public  static  void  main(String[]  args){
    int i=0, j=0, num=0;
    for(i=0; i<4; i++){
        for(j=i; j<2;j++){
            num=num+j;      
        }
    }
    System.out.println(num);              
}

A.2

B.4

C.0

D.3