Java类和对象题目问答点

2301_80176093

已于 2024-09-05 16:18:03 修改

阅读量735

点赞数 9

文章标签： java 开发语言

于 2024-09-05 16:10:03 首次发布

本文链接：https://blog.csdn.net/2301_80176093/article/details/141929286

版权

一：对语句行 test.hello(). 描述正确

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

六：以下哪项说法是正确的

七：以下代码在编译和运行过程中会出现什么情况

一：对语句行 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，不能正常运行

选项：B

解释：

1.静态方法和非静态方法及其调用方式的区别？

//以两个Test方法为例子
//方法名+类名=

//静态方法
Test test=null;
test.hello();
//Test 类的 hello 方法是一个静态方法，这意味着它
//可以通过类名(Test.hello())直接调用
//也可以通过类的实例(test.hello())调用

//非静态方法必须通过类(test)的实例来调用
Test test=new Test;
test.eat();
public void eat(){
  System.out.println("正在吃饭!");
}

2.选项分析

A.在第一个代码示例中，虽然 hello 是一个静态方法，可以通过类名直接调用，但是这里尝试通过一个 null 的对象引用来调用它，这会导致运行时错误，正确的调用方式应该是Test.hello();，而不是 test.hello();，因为 test 是 null。

C.调用方式的使用是可以的，应为是静态的用类或者类的实例。

D.尝试通过一个 null 的对象引用来调用方法会导致编译错误，而不是运行时错误。

二：修改Data类的定义

现有一个Data类，内部定义了属性x和y，在main方法中实例化了Data类，并计算了data对象中x和y的和。但是，Data类的定义存在错误，请你将这些错误修正过来，使得main方法中的求和逻辑可以正常执行。

输入描述：两个整数

输出描述：两个整数的和

示例1 输入：1 2 输出：3

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：x=x修改为this.

this.x=x;
this.y=y;

a.this引用指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问。

b.this引用的是调用成员方法的对象。

c.如果不将this加上的话，那么就是x又赋值给x，并未改变的新的值。

改动地方2:将private修改成public

class Data {

    public int x;
    public int y;

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

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

}

改法二：

如果要保留private的使用的话，那么改方法如下

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.publicGetX() + data.publicGetY());
        }
        scanner.close(); // 关闭scanner对象，避免资源泄露
    }

}

class Data {

    private int x;
    private int y;

    public Data(int x, int y) {
        this.x = x; // 使用this关键字来区分成员变量和参数
        this.y = y;
    }

    private int getX() {
        return x;
    }

    private int getY() {
        return y;
    }


    //在class部分里面将private里面的getX()部分再次进行引用
    //新的引用以public进行声明
    //然后再返回这个getX()    


    // 添加公共方法以便在Main类中访问
    public int publicGetX() {
        return getX(); // 调用私有的getX()方法
    }

    public int publicGetY() {
        return getY(); // 调用私有的getY()方法
    }

}

三：关于包的说法, 下列错误的是

A.包是一组类的集合

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

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

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

选择：D

解析：import static 确实能够导入静态方法，但它不是导入“一些”静态方法，而是导入特定的静态方法或字段

四：下面不是 java 类访问控制关键字

A.public

B.this

C.private

D.protected

选择：B

解析：是一个引用变量，它指向当前对象。在方法中使用 this 可以引用当前对象的成员变量和方法，或者在构造函数中调用另一个构造函数。

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

A.this.A(x)

B.this(x)

C.super(x)

D. A(x)

选择：B

解析：

A. this.A(x) - 这是错误的，因为调用构造方法时不应该使用类名。

C. super(x); - 这是用于调用父类的构造方法，而不是当前类的另一个构造方法。

D. A(x); - 这是错误的，因为构造方法调用不能使用类名，而应该使用 this 关键字。

六：以下哪项说法是正确的

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

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

C.public关键字只能修饰成员变量

D.以上说法都不对

选择：D

解析：public 关键字可以用于修饰类、方法和成员变量。

七：以下代码在编译和运行过程中会出现什么情况

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.编译和执行时没有输出结果

选择：B

解析：在Java中，私有成员变量（使用 private 访问修饰符定义的变量）只能在其所在的类内部被访问。在 main 方法中，尝试直接访问 TestDemo 类的私有变量 count 会导致编译错误。

八：下面程序运行结果

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

cnt的值是（）

A.cnt=5

B. cnt=2

C.cnt=3

D.cnt=6

选择：A

解析：

首先，cnt 被初始化为6。然后，第一个静态代码块将 cnt 的值增加9，即 cnt += 9，这将使 cnt 的值变为15。接着，第二个静态代码块将 cnt 的值除以3，即 cnt /= 3，这将使 cnt 的值变为5。

因此，最终 cnt 的值是5。

九：下面程序运行结果

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

选择：C

解析：给定的代码中，Test 类重写了 toString() 方法。在这个方法中，首先执行 System.out.print("aaa")，这会打印 "aaa" 到控制台，但不会换行。然后，toString() 方法返回字符串 "bbb"。由于 System.out.println 在打印完对象后会添加一个换行符，所以最终的输出结果会是 "aaabbb"，紧接着是一个换行符。

十：以下程序代码的说明正确

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行不能通过编译.因为引用了私有静态变量

选择：C

解析：10行不能通过编译.因为x是私有静态(private)变量。实际上，不仅第10行不能通过编译，第5行、第7行和第9行也不能通过编译

十一：编译和运行代码会怎么样

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

A.编译时错误

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

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

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

选择：B

解析：boolean类型的在没有初始化时会显示false

十二：哪些在main函数中使用是正确

public class Test{

  private float f=1.0f;

  int m=12;

  static int n=1;

  public static void main(String args[]){

    Test t=new Test();

  }

}

A.t.f = 3.0

B.this.n

C.Test.m

D.Test.n

选择：D

解析：A.float是private类型，只能在Test方法下使用

B. this 关键字用于引用当前对象的成员，而 n 是一个静态变量。静态变量应该通过类名（Test.）来访问，而不是通过 this。

C. m 是一个非静态变量，它需要通过对象实例(t.)来访问。在 main 方法中，你可以通过 t.m 来访问 m，而不是直接通过类名 Test.m。

十三：如下代码的输出结果是

public class Test { 
    public int aMethod(){
        static int i = 0;
        i++; 
        return i;
    } 
public static void main(String args[]){
    Test test = new Test(); 
    test.aMethod(); 
    int j = test.aMethod();
    System.out.println(j);
    } 
}

A.0

B.1

C.2

D.编译失败

选择：C

解析：在 main 方法中，aMethod 被调用了两次：

第一次调用 test.aMethod() 时，i 从0增加到1，但返回值没有被赋给任何变量，也没有被打印出来。
第二次调用 test.aMethod() 时，i 再次增加，从1增加到2，并且这次返回值被赋给了变量 j。

因此，System.out.println(j); 将打印出变量 j 的值，即2。

2301_80176093

关注

9
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Java类和对象题目问答点

现有一个Data类，内部定义了属性x和y，在main方法中实例化了Data类，并计算了data对象中x和y的和。但是，Data类的定义存在错误，请你将这些错误修正过来，使得main方法中的求和逻辑可以正常执行。两个整数两个整数的和示例1输入：1 2 输出：3x = x;y = y;return x;return y;
复制链接

扫一扫