1、有以下代码：

class ClassA{
	public void method(int value){
		System.out.println(value);
	}
	public void method(){
		System.out.println(value);
	}
	int value;
}
class TestClassA{
	public static void main(String args[]){
		ClassA classA = new ClassA();
		classA.value = 10;
		classA.method();
		classA.method(20);
	}
}

请选择正确结果：
A. 编译不通过
B. 输出10 10
C. 输出 10 20
D. 输出0 20

C 调用第一个method方法时，根据方法重载，调用的是无参的method方法，打印的value为实例变量的值，结果为 10。
调用第二个method方法时，会调用method(int value)这个方法，由于这个方法具有一个value形参，相当于局部变量。局部变量会和实例变量命名冲突， 打印时会打印局部变量的值，也就是打印 参数 20。

2、有以下代码：

class ClassA{
	void method(){
		System.out.println("method()");
	}
	int method(int i){
		System.out.println("method(int)");
	}
	public static void main(String args[]){
		ClassA a = new ClassA();
		a.method();
		a.method(10);
	}
}

该程序是否能编译通过？
如果可以，写出该程序运行结果。
如果不能，请说明理由，以及如何修改。

不能编译通过，因为int method(int)方法没有返回值。需添加相应的return语句。

3、关于构造方法，下列说法正确的是：

A. 每个类中都有至少一个构造方法
B. 一个类中可以有多个构造方法
C. 构造方法可以有返回值
D. 构造方法可以有多个参数

ABD

A正确，因为即使不写构造方法，编译器也会自动生成一个默认构造方法。
B正确，一个类中可以有多个构造方法，这些方法间构成重载
C错误，构造方法没有返回值
D正确。

4、有以下代码：

class MyClass{
	int value;
}
public class TestRef{
	public static void main(String args[]){
		int a = 10;
		int b = a;
		b++;
		System.out.println(a);
		MyClass mc1 = new MyClass();
		mc1.value = 10;
		MyClass mc2 = mc1;
		mc2.value++;
		System.out.println(mc1.value);
	}
}

请写出编译运行后的结果。

10 11

5、有以下代码：

class MyClass{
	int value;
}
public class TestMyClass{
	public static void main(String args[]){
		MyClass mc1 = new MyClass();
		MyClass mc2 = new MyClass(10);
		System.out.println(mc1.value);
		System.out.println(mc2.value);
	}
}

问：这个程序能否编译通过？如果可以，输出结果是什么？如果不可以，则应该如何修改？

编译不能通过，MyClass默认有无参构造方法，传递整型参数报错

6、根据注释，把下面代码补充完整：

//定义⼀个Dog 类
class Dog{
	//定义⼀个name 属性，该属性为String 类型
	______________________;
	//定义⼀个age 属性，该属性为int 类型
	______________________;
	//定义⼀个sexual 属性，该属性为boolean 类型
	//true 表示为公，false 表示为⺟
	______________________;
	public Dog(){
	}
	public Dog(String name, int age, boolean sexual){
	//分别根据参数，设置Dog 类的属性
	}
	public void play(){
	System.out.println(name + “ play”);
	}
	public void play(int n){
		System.out.println(name + “ play ” + n + “ minutes”);
	}
}
public class TestDog{
	public static void main(String args[]){
		Dog d;
		//创建⼀个Dog 对象，调⽤有参构造函数
		//名字为joy，年龄为2 岁，性别为⺟
		_________________;
		//调⽤Dog 对象⽆参的play ⽅法。
		_________________;
		//调⽤Dog 对象有参的play ⽅法，参数为30
		_________________;
	}
}

String name;

int age;

boolean sexual;

Dog dog = new Dog("joy",2,false);

dog.play();

dog.play(30);

7、有以下代码：

class ClassA{
	public ClassA(){
		System.out.println("ClassA()");
	}
}
class ClassB{
	public ClassB(){
		System.out.println("ClassB()");
	}
}
class ClassC{
	ClassA a = new ClassA();
	ClassB b;
	public ClassC(){
		System.out.println("ClassC()");
		b = new ClassB();
	}
}
public class TestConstructor{
	public static void main(String args[]){
	ClassC cc = new ClassC();
	}
}

请选择正确答案：
A. 编译不通过
B. 输出ClassA() ClassB() ClassC()
C. 输出 ClassA() ClassC() ClassB()
D. 输出 ClassC() ClassB() ClassA()

C

8、有以下代码：

class ClassA{
	int value;
}
public class TestClassA{
	public static void main(String args[]){
		int value = 10;
		changeInt(value);
		System.out.println(value);
		ClassA ca = new ClassA();
		ca.value = 10;
		changeObject(ca);
		System.out.println(ca.value);
	}
public static void changeInt(int value){
	value++;
}
public static void changeObject(ClassA ca){
	ca.value++;
	}
}

编译运行TestClassA 时，结果是
A. 编译出错

B. 输出 10 10

C. 输出 10 11

D. 输出 11 11

C

9、程序改错：

public class Student{
	int age;
	String name;
public void Student(){}//构造方法不能有返回值类型，把void去掉
	void init(){
	age = 10;
	name = "limy";
}
public Student(String name){
	this.init();
	this.name = name;
}
public Student(String name, int age){
	this.init();
	this(name);//this()必须放在构造函数中的第一⾏ this.age=age;
	this.age = age;
	}
}

×

10、写⼀个Worker 类，并创建多个Worker 对象：

10.1 为Worker 类添加三个属性：
10.1.1 String 类型的name，表示工人的姓名。
10.1.2 int 类型的age，表示工人的年龄。
10.1.3 double 类型的salary，表示工人的公资。
10.2 为Worker 类添加两个构造方法：
10.2.1 公开无参构造方法。
10.2.2 接受三个参数的构造方法，三个参数分别为字符串、int 和double 类型。
10.3 为Worker 类添加两个work方法：
10.3.1 无参构造方法
10.3.2 带整数参数构造方法，表示工人工作的时间（为多少小时）。

public class Worker {
	// Worker类添加三个属性
	String name;
	int age;
	double salary;
	// 公开无参构造方法
	public Worker() {
	}
	// 接受三个参数的构造方法
	public Worker(String a, int b, double c/* String name,int age,souble salary */) {
		/*
		 * this.name = name; this.age = age; this.salary = salary;
		 */
		name = a;
		age = b;
		salary = c;
	}
	// 无参work方法
	public void work() {
	}
	// 带参work方法
	public void work(int hour) {
		System.out.println("共工作" + hour + "小时");
	}
	public void print() {
		System.out.println("员工名字是：" + name + "\t" + "年龄" + age + "\t" + "月薪水是：" + salary);
	}

}

public class TestWorker {
	public static void main(String[] args) {
		
		Worker work1 = new Worker();
		work1.name = "光头强";
		work1.age = 18;
		work1.salary = 1;
		work1.print();
		
		Worker work2 = new Worker("李员工",20,5.5);
		work2.print();
		
		work1.work(8);
		
	}
}

11、创建⼀个Address 类，描述如下：

11.1 该类有两个属性：11.1.1 String 类型的address，表示地址。
11.1.2 String 类型的zipCode，表示邮编。
11.2 该类有两个构造方法：
11.2.1 无参构造方法。
11.2.2 带两个参数的构造方法。

public class Address {
	
	String address;
	String zipCode;
	//无参
	public Address() {
		
	}
	//有参
	public Address(String a,String z) {
		address = a;
		zipCode = z;
	}
	public void print() {
		  System.out.print("地址："+address+"\t");
		  System.out.print("邮编："+zipCode+"\t");
		 }
	
}
public class TestAddress {
	
	public static void main(String[] args) {
		
		Address add = new Address();
		add.address = "青岛";
		add.zipCode = "266000";
		add.print();
		
		Address add1 = new Address("北京东城区","10000");
		add1.print();
	}
	
}

12、编程：

为第11题中的Worker类添加⼀个属性addr，该属性为Address类型。
要求：创建一个Worker对象，其姓名为"zhangsan"，年龄为25，工资为2500，家庭住址为“北京市海淀区清华园1号”，邮政编码为100084。

public class TestAddressWorker {
	
	public static void main(String[] args) {
		Worker worker = new Worker("zhangsan",25,2500);
		worker.print();
		Address addr = new Address("北京市海淀区清华园1号","100084");
		addr.print();
	}
}