JavaSE《习题集》类和对象的认识等

原创已于 2024-03-27 23:41:48 修改 · 1k 阅读

40 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#java #开发语言

于 2024-03-27 23:38:38 首次发布

选择题（单选15）

1.下面代码的运行结果是（）

2.阅读如下代码。请问，对语句行 test.hello(). 描述正确的有（）

3.修改Data类的定义

4.关于包的说法, 下列错误的是:（）

5.下面哪一项不是 java 类访问控制关键字（）

6.在JAVA中，假设A有构造方法A(int a)，则在类A的其他构造方法中调用该构造方法和语句格式应该为（）

7.以下哪项说法是正确的？（）

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

9.cnt的值是（）

10.给定以下代码程序输出结果为()

11.关于以下程序代码的说明正确的是()

13.当你编译和运行下面的代码时，会出现下面选项中的哪种情况？()

14.已知如下类说明如下哪些在main函数中使用是正确的（）

15.如下代码的输出结果是什么？()

选择题（单选15）

1.下面代码的运行结果是（）

public static void main(String[] args){

  String s;

  System.out.println("s="+s);

}

A.代码编程成功，并输出”s=”

B.代码编译成功，并输出”s=null”

C.由于String s没有初始化，代码不能编译通过。

D.代码编译成功，但捕获到NullPointException异常

本题中的代码不能编译通过，因为在Java当中局部变量必须先初始化，后使用。所以此处编译不能通过！

2.阅读如下代码。请问，对语句行 test.hello(). 描述正确的有（）

package NowCoder;
class Test {
	public static void hello() {
	    System.out.println("hello");
	}
}
public class MyApplication {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Test test=null;
		test.hello();
	}
}

A.能编译通过，并正确运行

B.因为使用了未初始化的变量，所以不能编译通过

C.以错误的方式访问了静态方法

D.能编译通过，但因变量为null，不能正常运行

hello方法是一个静态方法，调用静态方法不需要创建实例对象。

此时的 Test test=null; 表示test这个引用不指向任何对象。所以此处可以正常访问。

但是我们需要牢记，静态方法的正确访问方式应该是用过类型来访问。即：Test.hello();

3.修改Data类的定义

代码如下：

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            int x = scanner.nextInt();
            int y = scanner.nextInt();
            Data data = new Data(x, y);
            System.out.println(data.getX() + data.getY());
        }
    }

}

class Data {

    private int x;
    private int y;

    private Data(int x, int y) {
        x = x;
        y = y;
    }

    private int getX() {
        return x;
    }

    private int getY() {
        return y;
    }

}

本题主要考察两点：

1.构造方法的形参名和成员变量名字相同，需要使用this指定

2.构造方法，getX()方法和getY()方法，在类外使用需要将访问修饰符修改为public。

正确的代码如下：

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            int x = scanner.nextInt();
            int y = scanner.nextInt();
            Data data = new Data(x, y);
            System.out.println(data.getX() + data.getY());
        }
    }

}

class Data {

    private int x;
    private int y;

    public Data(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

}

4.关于包的说法, 下列错误的是:（）

A.包是一组类的集合

B.包能防止类的名字冲突

C.import 语句能够导入一个指定的包

D.import static 能够导入一些静态方法

通过上图我们可以看到：

第1行导入的是具体的包中的类。

第2行报错，不能导入指定包。

第3行导入的是包下的所有类，用到这个包底下哪个类就回调用哪个。

选项D中，参考课件代码。

5.下面哪一项不是 java 类访问控制关键字（）

A.public B.this C.private D.protected

Java中的访问修饰符有3个：private，public，protected，但是当定义一个成员变量的时候，没有写这3个任意一个访问修饰符的时候，此时的权限是默认权限。
public class Test {
    public int age;
    private String name;
    protected String sex;
    String weight;//默认权限
}

6.在JAVA中，假设A有构造方法A(int a)，则在类A的其他构造方法中调用该构造方法和语句格式应该为（）

A.this.A(x) B.this(x) C.super(x) D. A(x)

this共有2种使用方式：

this.data 访问当前对象的实例成员变量

this.func() 访问当前对象的实例成员方法

this(参数列表) 访问当前对象的构造方法

此处在当前类当中，调用构造方法A(int a)，使用this(x)；的方式，所以选择B。

A：不能通过点号访问构造方法

C：super(x)，是初始化父类继承过来的那部分成员

D：缺少this

7.以下哪项说法是正确的？（）

A.public关键字只能修饰类名 B.public关键字只能修饰方法

C.public关键字只能修饰成员变量 D.以上说法都不对

public只是一个访问修饰限定符，可以修饰类名，接口，方法，成员变量等。所以ABC错，D正确。

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

public class TestDemo{

	private int count;

	public static void main(String[] args) {

		TestDemo test=new TestDemo(88);

		System.out.println(test.count);

	}

	 TestDemo(int a) {

		 count=a;

	}

}

A.编译运行通过，输出结果是88

B.编译时错误，count变量定义的是私有变量

C.编译时错误，System.out.println方法被调用时test没有被初始化

D.编译和执行时没有输出结果

观察代码当执行：
TestDemo test = new TestDemo(88);
的时候，会先执行构造方法，将88的值，赋值给count，所以最终输出的值是88.

9.cnt的值是（）

public class Test{
    static int cnt = 6;
    static{
        cnt += 9;
    }
    public static void main(String[] args）{
        System.out.println（"cnt = " + cnt);
    }
    static{
        cnt /=3;
    };
}

A.cnt=5 B. cnt=2 C.cnt=3 D.cnt=6

本题考察的是代码块的执行顺序。带代码中存在代码块和构造方法的时候。执行顺序为：

1.静态代码块

2.实例代码块

3.调用的对应的构造方法

第2种情况：当存在相同类型的代码块和成员变量的时候，需要看定义顺序执行。

本题中：
public class Test{
    static int cnt = 6;//1
    static{
        cnt += 9;//2
    }
    public static void main(String[] args）{
        System.out.println（"cnt = " + cnt);
    }
    static{
        cnt /=3;//3
    };
}
本题中先执行注释1处，再执行注释2处，此时结果变为了15，再执行注释3处，cnt = 5；

10.给定以下代码程序输出结果为()

class Test{	
	public String toString() {
		System.out.print("aaa");
		return "bbb";
	}
}

public static void main(String[] args) {
    Test test = new Test();
	System.out.println(test);
}

A.aaa B.bbb C.aaabbb D.bbbaaa

本题中主要考察toString 方法：
System.out.println(test);
在执行println函数的时候，会调用Object类的toString方法，此时当我们自己类重新通过编译器实现了toString方法之后，会调用我们自己写的方法。此处具体的原因，我们会在继承，多态章节讲到的。大家先用起来。

根据上面所述，调用我们自己写的toString方法后，执行输出语句，输出aaa,返回bbb交给println函数，输出bbb。

11.关于以下程序代码的说明正确的是()

 public class HasStatic {// 1
	private static int x = 100;// 2
	public static void main(String args[]) {// 3
		HasStatic hsl = new HasStatic();// 4
		hsl.x++;// 5
		HasStatic hs2 = new HasStatic();// 6
		hs2.x++;// 7
		hsl = new HasStatic();// 8
		hsl.x++;// 9
		HasStatic.x--;// 10
		System.out.println(" x=" + x);// 11
	}
}

A.程序通过编译，输出结果为:x=102

B.程序通过编译，输出结果为:x=103

C.10行不能通过编译.因为x星私有静态变量

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

本题中的静态成员变量x，属于类变量，只有一份。所有对x的操作针对的都是同一份。

静态成员变量的访问需要通过类名访问，这是正确的访问方式。本题中虽然使用了对象引用访问，但是不会报错，我们不建议这样访问，但不是错误，所以，不会编译报错。

综合以上2点，得出结论：本题可以正常通过编译和运行，输出结果是102。

13.当你编译和运行下面的代码时，会出现下面选项中的哪种情况？()

public class Pvf{
    static boolean Paddy;
    public static void main(String args[]){
        System.out.println(Paddy);
    }
}

A.编译时错误

B.编译通过并输出结果false

C.编译通过并输出结果true

D.编译通过并输出结果null

在Java当中，成员变量没有赋初值的时候，会有默认的初始值。基本类型是对应的0值。如：int是0，boolean是false,char类型是'\u0000'，引用类型是null，如String.

14.已知如下类说明如下哪些在main函数中使用是正确的（）

A.t.f = 3.0 B.this.n C.Test.m D.Test.n

A：f是float类型，3.0默认是double，所以此时不能赋值

B：n是静态的，需要通过类名访问，不能通过this访问，this代表当前对象的引用，但是静态的成员变量不属于this。

C：m是实例成员变量，需要通过对象来进行调用。

D：正确

故：答案选D