类和对象！

1：局部变量

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

public static void main(String[] args){

  String s;

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

}
1
2
3
4
5
6
7

A.代码编程成功，并输出”s=”
B.代码编译成功，并输出”s=null”
C.由于String s没有初始化，代码不能编译通过。
D.代码编译成功，但捕获到NullPointException异常
本题中的代码不能编译通过，因为在Java当中局部变量必须先初始化，后使用。所以此处编译不能通过！

2：

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;

	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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

3：构造方法的调用

在JAVA中，假设A有构造方法A(int a)，则在类A的其他构造方法中调用该构造方法和语句格式应该为（）
作业内容
A.this.A(x)
B.this(x)
C.super(x)
D. A(x)
1
2
3
4
5
6

this共有2种使用方式：

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

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

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

此处在当前类当中，调用构造方法A(int a)，使用this(x)；的方式，所以选择B。
A：不能通过点号访问构造方法
C：super(x)，是初始化父类继承过来的那部分成员D：缺少this
1
2
3
4
5
6
7
8
9
10
11
12
13

4：

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

public class Pvf{
    static boolean Paddy;
    public static void main(String args[]){
        System.out.println(Paddy);
    }
}
1
2
3
4
5
6

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

5：

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();
  }
  }
1
2
3
4
5
6
7
8

如下哪些在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：正确

6：

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

 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
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

A.程序通过编译，输出结果为:x=102
B.程序通过编译，输出结果为:x=103
C.10行不能通过编译.因为x星私有静态变量
D.5行不能通过编译.因为引用了私有静态变量

1：本题中的静态成员变量x，属于类变量，只有一份。所有对x的操作针对的都是同一份。
2: 静态成员变量的访问需要通过类名访问，这是正确的访问方式。本题中虽然使用了对象引用访问，但是不会报错，我们不建议这样访问，但不是错误，所以，不会编译报错。
综合以上2点，得出结论：本题可以正常通过编译和运行，输出结果是102。

7：

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);
}
1
2
3
4
5
6
7
8
9
10

在执行println函数的时候，会调用Object类的toString方法，此时当我们自己类重新通过编译器实现了toString方法之后，会调用我们自己写的方法。根据上面所述，调用我们自己写的toString方法后，执行输出语句，输出aaa,返回bbb交给println函数，输出bbb。

8：

一级目录