目录
五:假设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。