第11章习题（1）
目录
第一题
思路分析：
第二题
思路分析
第三题
思路分析：
第四题
思路分析：
第一题
思路分析：
1.在执行Car c = new Car();这句化的时候，因为创建一个对象会导致类的加载，因此会先执行静态属性，所以此时的color是white 紧接着再去执行无参构造器，将price赋成9，又将color属性赋值成 red ，所以此时color的值是red
2.在执行 Car c1 = new Car(100); 这句话的时候，因为类的加载只会发生一次，所以在这里创建对象的时候，不会在加载类，因为我们通过构造器进行了赋值 所以将price的值赋成了100
3.最后在输出的c的时候，输出的就是 9.0 red
4.在输出c1的时候 输出的就是 100 red
package idea.chapter11.homework;
public class Homework01 {
public static void main(String[] args) {
Car c = new Car();
//在创建c对象的时候 会先去执行静态属性初始化也就是 static String color="white";
//所以此时color是white 然后再去执行构造器 初始化price=9 color=red
Car c1 = new Car(100);
//在创建c1对象时,不会再去执行静态属性初始化了，因为静态初始化发生在类加载的时候，只会执行一次
//因此只会把price置成100
System.out.println(c);//9.0,red
//所以这里输出的就是 9.0和red因为时double类型的
System.out.println(c1);//100.0,red
//因为又修改了price的值所以这里会输出100 因为color时static修饰的所以指向的都是同一个地方因此也是输出red
}
}
/*
思路分析：
1.在执行Car c = new Car();这句化的时候，因为创建一个对象会导致类的加载，因此会先执行静态属性，所以此时的color是white
紧接着再去执行无参构造器，将price赋成9，又将color属性赋值成 red ，所以此时color的值是red
2.在执行 Car c1 = new Car(100); 这句话的时候，因为类的加载只会发生一次，所以在这里创建对象的时候，不会在加载类，因为我们通过构造器进行了赋值
所以将price的值赋成了100
3.最后在输出的c的时候，输出的就是 9.0 red
4.在输出c1的时候 输出的就是 100 red
*/
class Car {
double price = 10;
static String color = "white";
public String toString() {
return price + "\t" + color;
}
public Car() {
this.price = 9;
this.color = "red";
}
public Car(double price) {
this.price = price;
}
}第二题
思路分析
1.1.在Frock类中声明私有的静态属性currentNum[int类型]，初始值为100000，作为衣服出厂的序列号起始值。
这句话要我们完成的就是定义一个静态的私有属性，并且设置初始值 也就是这样 private static int currentNum = 100000;
2.2.声明公有的静态方法getNextNum，作为生成上衣唯一序列号的方法。每调用一次，将 currentNum增加100，并作为返回值。
这句话要我们完成的就是 编写一个方法
public static int getNextNum() {
return currentNum += 100;
}
3.3.在TestFrock类的main方法中，分两次调用getNextNum方法，获取序列号并打印输出。
这句话要我们完成的就是
System.out.println(Frock.getNextNum());
System.out.println(Frock.getNextNum());
4.4. 在Frock类中声明serialNumber(序列号)属性，并提供对应的get方法；
这句话话要我们完成的就是
private int serialNumber;
public int getSerialNumber() {
return serialNumber;
}
5.5.在Frock类的构造器中，通过调用getNextNum方法为Frock对象获取唯一序列号，赋给serialNumber属性。
这句话要我们完成的就是
public Frock() {
this.serialNumber = getNextNum();
}
6.6. 在TestFrock类的main方法中，分别创建三个Frock对象，并打印三个对象的序列号，验证是否为按100递增。
这句话要我们完成的就是
Frock frock = new Frock();
Frock frock1 = new Frock();
Frock frock2 = new Frock();
System.out.println(frock.getSerialNumber());
System.out.println(frock1.getSerialNumber());
System.out.println(frock2.getSerialNumber());
package idea.chapter11.homework;
public class Homework02 {
public static void main(String[] args) {
/*
1.在Frock类中声明私有的静态属性currentNum[int类型]，初始值为100000，作为衣服出厂的序列号起始值。
2.声明公有的静态方法getNextNum，作为生成上衣唯一序列号的方法。每调用一次，将 currentNum增加100，并作为返回值。
3.在TestFrock类的main方法中，分两次调用getNextNum方法，获取序列号并打印输出。
4. 在Frock类中声明serialNumber(序列号)属性，并提供对应的get方法；
5.在Frock类的构造器中，通过调用getNextNum方法为Frock对象获取唯一序列号，赋给serialNumber属性。
6. 在TestFrock类的main方法中，分别创建三个Frock对象，并打印三个对象的序列号，验证是否为按100递增。
*/
System.out.println(Frock.getNextNum());
System.out.println(Frock.getNextNum());
Frock frock = new Frock();
Frock frock1 = new Frock();
Frock frock2 = new Frock();
System.out.println(frock.getSerialNumber());
System.out.println(frock1.getSerialNumber());
System.out.println(frock2.getSerialNumber());
}
}
/*
思路分析
1.1.在Frock类中声明私有的静态属性currentNum[int类型]，初始值为100000，作为衣服出厂的序列号起始值。
这句话要我们完成的就是定义一个静态的私有属性，并且设置初始值 也就是这样 private static int currentNum = 100000;
2.2.声明公有的静态方法getNextNum，作为生成上衣唯一序列号的方法。每调用一次，将 currentNum增加100，并作为返回值。
这句话要我们完成的就是 编写一个方法
public static int getNextNum() {
return currentNum += 100;
}
3.3.在TestFrock类的main方法中，分两次调用getNextNum方法，获取序列号并打印输出。
这句话要我们完成的就是
System.out.println(Frock.getNextNum());
System.out.println(Frock.getNextNum());
4.4. 在Frock类中声明serialNumber(序列号)属性，并提供对应的get方法；
这句话话要我们完成的就是
private int serialNumber;
public int getSerialNumber() {
return serialNumber;
}
5.5.在Frock类的构造器中，通过调用getNextNum方法为Frock对象获取唯一序列号，赋给serialNumber属性。
这句话要我们完成的就是
public Frock() {
this.serialNumber = getNextNum();
}
6.6. 在TestFrock类的main方法中，分别创建三个Frock对象，并打印三个对象的序列号，验证是否为按100递增。
这句话要我们完成的就是
Frock frock = new Frock();
Frock frock1 = new Frock();
Frock frock2 = new Frock();
System.out.println(frock.getSerialNumber());
System.out.println(frock1.getSerialNumber());
System.out.println(frock2.getSerialNumber());
*/
class Frock {
//静态私有属性
private static int currentNum = 100000;
private int serialNumber;
//构造器
public Frock() {
this.serialNumber = getNextNum();
}
public int getSerialNumber() {
return serialNumber;
}
public static int getNextNum() {
return currentNum += 100;
}
}第三题
思路分析：
1.因为Animal是父类也是抽象类，在Animal类中有一个抽象方法，因为一个类中如果有抽象方法，那么这个类就一定要是抽象类 所以，在Cat类和Dog类在继承Animal类的时候，都需要去实现抽象类中的抽象方法，否则会报错 2.因为Cat类和Dog类都继承了Animal，所以Animal是父类，因此父类可以指向子类的对象，父类的引用可以指向子类的对象，就是向上转型 并且还有动态绑定机制 Animal cat = new Cat(); 此时cat 的编译类型是Animal 运行类型是 Cat 因此在调用方法的show方法的时候，找到的是Cat类中的show方法 Animal dog = new Dog(); 此时cat 的编译类型是Animal 运行类型是 Dog 因此在调用方法的show方法的时候，找到的是Dog类中的show方法
package idea.chapter11.homework;
public class Homework03 {
public static void main(String[] args) {
/*
1.动物类Animal包含了抽象方法 show();
2.Cat类继承了Animal，并实现方法show()，打印“猫会喵喵叫”
3.Dog类继承了Animal，并实现方法show()，打印“狗会汪汪叫”
4.在测试类中实例化对象Animal cat =new Cat()，并调用cat的show方法
5.在测试类中实例化对象Animal dog=new Dog()，并调用dog的show方法
*/
Animal cat = new Cat();
cat.show();
Animal dog = new Dog();
dog.show();
}
}
/*
思路分析：
1.因为Animal是父类也是抽象类，在Animal类中有一个抽象方法，因为一个类中如果有抽象方法，那么这个类就一定要是抽象类
所以，在Cat类和Dog类在继承Animal类的时候，都需要去实现抽象类中的抽象方法，否则会报错
2.因为Cat类和Dog类都继承了Animal，所以Animal是父类，因此父类可以指向子类的对象，父类的引用可以指向子类的对象，就是向上转型
并且还有动态绑定机制
Animal cat = new Cat();
此时cat 的编译类型是Animal 运行类型是 Cat
因此在调用方法的show方法的时候，找到的是Cat类中的show方法
Animal dog = new Dog();
此时cat 的编译类型是Animal 运行类型是 Dog
因此在调用方法的show方法的时候，找到的是Dog类中的show方法
*/
abstract class Animal {
abstract void show();
}
class Cat extends Animal {
@Override
void show() {
System.out.println("猫会叫");
}
}
class Dog extends Animal {
@Override
void show() {
System.out.println("狗会叫");
}
}
第四题
思路分析：
1.我们定义一个Computer接口里面有一个work方法因为最后是需要该方法完成加分的运算，所以在方法的参数上，我们定义了两个int型的变量
2.我们使用匿名内部类来解决，因为在使用匿名内部类的时候 会有动态绑定机制，此时的运行类型是 Homework04$1 这是在底层系统创建的，
3.因此在main方法中调用work方法的时候，调用的就是main方法中的work方法
4.注意匿名内部类中的最后的扩容出可以传参数 cellphone.testWork(new Computer() { @Override public int work(int n1, int n2) { return n1 + n2; } }, 1, 2);//就是这里可以传参数
package idea.chapter11.homework;
//第一种方式
public class Homework04 {
public static void main(String[] args) {
/*
.计算器接口具有work方法，功能是运算，有一个手机类Cellphone，定义方法testWork
测试计算功能，调用计算接口的work方法，
.要求调用CellPhone对象 的testWork方法，使用上 匿名内部类
*/
Cellphone cellphone = new Cellphone();
cellphone.testWork(new Computer() {
@Override
public int work(int n1, int n2) {
return n1 + n2;
}
}, 1, 2);
}
}
/*
思路分析：
1.我们定义一个Computer接口里面有一个work方法因为最后是需要该方法完成加分的运算，所以在方法的参数上，我们定义了两个int型的变量
2.我们使用匿名内部类来解决，因为在使用匿名内部类的时候 会有动态绑定机制，此时的运行类型是 Homework04$1 这是在底层系统创建的，
3.因此在main方法中调用work方法的时候，调用的就是main方法中的work方法
4.注意匿名内部类中的最后的扩容出可以传参数
cellphone.testWork(new Computer() {
@Override
public int work(int n1, int n2) {
return n1 + n2;
}
}, 1, 2);//就是这里可以传参数
*/
interface Computer {
public int work(int n1, int n2);
}
class Cellphone {
public void testWork(Computer computer, int n1, int n2) {
System.out.println(n1 + n2);
}
}
//第二种方式
//public class Homework04 {
// public static void main(String[] args) {
// /*
// .计算器接口具有work方法，功能是运算，有一个手机类Cellphone，定义方法testWork
// 测试计算功能，调用计算接口的work方法，
// .要求调用CellPhone对象 的testWork方法，使用上 匿名内部类
// */
//
// Cellphone cellphone = new Cellphone();
// cellphone.testWork(new Computer() {
// @Override
// public void work(int n1, int n2) {
// System.out.println(n1+n2);
// }
// },1,2);
//
// }
//}
//
//interface Computer {
// public void work(int n1, int n2);
//}
//
//class Cellphone {
// public void testWork(Computer computer, int n1, int n2) {
// computer.work(n1,n2);
// }
//}