您的位置：首页 > 编程语言 > Java开发

Java编程思想第四版第七章练习

2017-11-10 01:56 567 查看

练习1:创建一个简单的类。第二个类中，将一个引用定义为第一个类的对象。运用惰性初始化来实例化这个对象

public class Exercise7_1 {
public static void main(String[] args) {
Second second  = new Second("Init String");
second.chenked();
System.out.println(second.getSimple());
second.chenked();
System.out.println(second);
second.setSimple("New String");
System.out.println(second);
}
}
class Simple{
String s;
public Simple(String si) {
s = si;
}
public String toString() {
return s;
}
public void setString(String sNew) {
s = sNew;
}
}
class Second{
Simple simple;
String s;
public Second(String si) {
s = si;
}
public void chenked() {
if(simple==null) {
System.out.println("not initialized");
}else {
System.out.println("initialized");
}
}
private Simple lazy() {
if(simple==null) {
System.out.println("Creating simple");
simple = new Simple(s);
}
return simple;
}
public Simple getSimple() {
return lazy();
}
public String toString() {

return lazy().toString();
}
public void setSimple(String sNew) {
lazy().setString(sNew);

}
}

练习2：从Detergent中继承产生一个新的类。覆盖scrub()并添加一个名为sterilize()的新方法。

class Cleanser {
private String s = "Cleanser";
public void append(String a) { s += a; }
public void dilute() { append(" dilute()"); }
public void apply() { append(" apply()"); }
public void scrub() { append(" scrub()"); }
public String toString() { return s; }
public static void main(String[] args) {
Cleanser x = new Cleanser();
x.dilute(); x.apply(); x.scrub();
System.out.println(x);
}
}

public class Detergent extends Cleanser {
// Change a method:
public void scrub() {
append(" Detergent.scrub()");
super.scrub(); // Call base-class version
}
// Add methods to the interface:
public void foam() { append(" foam()"); }
// Test the new class:
public static void main(String[] args) {
Detergent x = new Detergent();
x.dilute();
x.apply();
x.scrub();
x.foam();
System.out.println(x);
System.out.println("Testing base class:");
Cleanser.main(args);
}
}

public class Exercise7_2 {
public static void main(String[] args) {
NewDetergent newDetergent = new NewDetergent();
newDetergent.dilute();
newDetergent.scrub();
newDetergent.sterilize();
System.out.println(newDetergent);
}
}
class NewDetergent extends Detergent{
public void scrub() {
append("new Detergent.scrub");
super.scrub();
}
public void sterilize() {
append("sterilize");
}
}

练习3：证明前面两句话（即使你不为Cartoon创建构造器，编译器也为会你合成一个默认的构造器，该构造器将调用基类的构造器）

public class Exercise7_3 {
public static void main(String[] args) {
new CartoonWithDefCtor();
}
}
class Art{
Art(){
System.out.println("Art constructor");
}
}
class Drawing extends Art{
Drawing(){
System.out.println("Drawing Contructor");
}
}
class CartoonWithDefCtor extends Drawing{
//  public CartoonWithDefCtor() {
//      System.out.println("CartoonWithDefCtor Contructor");
//  }
}

练习4：证明基类构造器总是会被调用，在导出类构造器之前被调用。

public class Exercise7_4 {
public static void main(String[] args) {
new Derived2();
}
}
class Base1{

public Base1() {
System.out.println("Base1");
}
}
class Derived1 extends Base1{

public Derived1() {
System.out.println("Derived");
}
}
class Derived2 extends Derived1{

public Derived2() {
System.out.println("Derived2");
}
}

练习5：创建两个带有默认构造器（空参数列表）的类A和类B。从A中继承产生一个名为C的新，并在C内创建一个B类的成员。不要给C编写构造器。创建一个C类的对象并观察其结果。

public class Exercise7_5 {
public static void main(String[] args) {
new C();
}

}
class A{
public A() {
System.out.println("A");
}
}
class B{
public B() {
System.out.println("B");
}
}
class C extends A{
B b = new B();
}

练习6：用Chess证明前面两名话

class Game {
Game(int i) {
System.out.println("Game constructor");
}
}

class BoardGame extends Game {
BoardGame(int i) {
super(i);
System.out.println("BoardGame constructor");
}
}

public class Exercise7_6 extends BoardGame {
Exercise7_6() {
super(11);
System.out.println("Chess constructor");
}
public static void main(String[] args) {
Exercise7_6 x = new Exercise7_6();
}
}

练习7：修改练习5，使A和B以带参数的构造器取代默认的构造器。为C写一个构造器，并在其中执行所有初始化。

public class Exercise7_7 {
public static void main(String[] args) {
new C(1);
}

}
class A{
public A(int i) {
System.out.println("A");
}
}
class B{
public B(String s) {
System.out.println(s);
}
}
class C extends A{

public C(int i) {
super(i);
B b = new B("s");
}

}

练习8：创建一个基类，它仅有一个非默认构造器；再创建一个导出类，它带有默认构造器和非默认构造器。在导出类的构造器中调用基类的构造器。

public class Exercise7_8 {
public static void main(String[] args) {
new DerivedTwoContructors();
new DerivedTwoContructors(74);
}
}
class BaseNonDefault{

public BaseNonDefault(int i) {

}
}
class DerivedTwoContructors extends BaseNonDefault{

public DerivedTwoContructors() {
super(47);
}

public DerivedTwoContructors(int i) {
super(i);

}

}

练习9：创建一个Root类，令其含有名为Component1、Component 2、Component3的类的各一个实例（这些也由你写）。从Root中派生一个类Stem，也含有上述各“组成部分”。所有的类都应带有可打印出类的相关信息的默认构造器

public class Exercise7_9 {
public static void main(String[] args) {
new Stem();
}
}

class Root{
Component1 c1  = new Component1();
Component2 c2  = new Component2();
Component3 c3  = new Component3();
public Root() {
System.out.println("Root");
}

}
class Stem extends Root{
Component1 c1  = new Component1();
Component2 c2  = new Component2();
Component3 c3  = new Component3();
public Stem() {
System.out.println("Stem");
}
}
class Component1{
public Component1() {
System.out.println("Component1");
}
}
class Component2{
public Component2() {
System.out.println("Component2");
}
}
class Component3{
public Component3() {
System.out.println("Component3");
}
}

练习10：修改练习9，使每个类都仅具有非默认的构造器。

public class Exercise7_10 {
public static void main(String[] args) {
new Stem2(1);
}
}

class Root2{
Componentb1 c1  = new Componentb1();
Componentb2 c2  = new Componentb2();
Componentb3 c3  = new Componentb3();
public Root2(int i) {
System.out.println("Root"+i);
}

}
class Stem2 extends Root2{
Componentb1 c1  = new Componentb1();
Componentb2 c2  = new Componentb2();
Componentb3 c3  = new Componentb3();
public Stem2(int i) {
super(i);
System.out.println("Stem2"+i);
}

}
class Componentb1{
public Componentb1() {
System.out.println("Component1");
}
}
class Componentb2{
public Componentb2() {
System.out.println("Component2");
}
}
class Componentb3{
public Componentb3() {
System.out.println("Component3");
}
}

练习11: 修改Detergent.java。让它使用代理。

public class Exercise7_11 {
public static void main(String[] args) {
DetergentDelegation delegation = new DetergentDelegation();
delegation.append("Detergent");
System.out.println(delegation);
}
}
class Cleanser2 {
private String s = "Cleanser";
public void append(String a) { s += a; }
public void dilute() { append(" dilute()"); }
public void apply() { append(" apply(
1102b
)"); }
public void scrub() { append(" scrub()"); }
public String toString() { return s; }
}
class DetergentDelegation{
private Cleanser2 c = new Cleanser2();
public void append(String a) { c.append(a);}
public void dilute() {c.dilute(); }
public void apply() { c.apply(); }
public void scrub() { c.scrub(); }
public String toString() { return c.toString(); }
}

//Detergent.Java
class Cleanser {
private String s = "Cleanser";
public void append(String a) { s += a; }
public void dilute() { append(" dilute()"); }
public void apply() { append(" apply()"); }
public void scrub() { append(" scrub()"); }
public String toString() { return s; }
public static void main(String[] args) {
Cleanser x = new Cleanser();
x.dilute(); x.apply(); x.scrub();
System.out.println(x);
}
}

public class Detergent extends Cleanser {
// Change a method:
public void scrub() {
append(" Detergent.scrub()");
super.scrub(); // Call base-class version
}
// Add methods to the interface:
public void foam() { append(" foam()"); }
// Test the new class:
public static void main(String[] args) {
Detergent x = new Detergent();
x.dilute();
x.apply();
x.scrub();
x.foam();
System.out.println(x);
System.out.println("Testing base class:");
Cleanser.main(args);
}
}

练习12：将一个适当的dispose()方法的层次结构添加到练习9的所有类中。

public class Exercise7_12 {
public static void main(String[] args) {
new Stemc().dispose();
}
}
class Rootc{
Componentc1 c1  = new Componentc1();
Componentc2 c2  = new Componentc2();
Componentc3 c3  = new Componentc3();
public Rootc() {
System.out.println("Root");
}
public void dispose() {
System.out.println("Rootc.dispose()");
c1.dispose();
c2.dispose();
c3.dispose();
}

}
class Stemc extends Rootc{
Componentc1 c1  = new Componentc1();
Componentc2 c2  = new Componentc2();
Componentc3 c3  = new Componentc3();
public Stemc() {
System.out.println("Stem");
}
public void dispose() {
System.out.println("Rootc.dispose()");
c1.dispose();
c2.dispose();
c3.dispose();
super.dispose();

}

}
class Componentc1{
public Componentc1() {
System.out.println("Component1");
}
public void dispose() {
System.out.println("Componentc1.dispose()");

}
}
class Componentc2{
public Componentc2() {
System.out.println("Component2");
}
public void dispose() {
System.out.println("Componentc2.dispose()");

}
}
class Componentc3{
public Componentc3() {
System.out.println("Component3");
}
public void dispose() {
System.out.println("Componentc3.dispose()");
}
}

练习13: 创建一个类，它应带有一个被重载了三次的方法。继承产生一个新类，并添加一个该方法的新的重载定义，展示这四个方法在导出类中都是可以使用的。

public class Exercise7_13 {
public static void main(String[] args) {
MoreOverloads moreOverloads = new MoreOverloads();
moreOverloads.f(1);
moreOverloads.f(1.1);
moreOverloads.f('c');
moreOverloads.f("Hello");
}
}
class ThreeOverLoads{
public void f(int i) {
System.out.println("f(int i)");
}
public void f(double d) {
System.out.println("f(double d)");
}
public void f(char c) {
System.out.println("f(char c)");
}
}

class MoreOverloads extends ThreeOverLoads{
public void f(String s) {
System.out.println("f(string s)");
}
}

练习14：在Car.java中给Engine添加一个service(),并在main()中调用该方法。

public class Exercise7_14 {
public static void main(String[] args) {
Car car = new Car();
car.left.window.rollup();
car.wheel[0].inflate(72);
car.engine.Service();

}
}
class Engine {
public void start() {}
public void rev() {}
public void stop() {}
public void Service() {
System.out.println("Engine.Service");
}
}

class Wheel {
public void inflate(int psi) {}
}

class Window {
public void rollup() {}
public void rolldown() {}
}

class Door {
public Window window = new Window();
public void open() {}
public void close() {}
}

class Car {
public Engine engine = new Engine();
public Wheel[] wheel = new Wheel[4];
public Door
left = new Door(),
right = new Door(); // 2-door
public Car() {
for(int i = 0; i < 4; i++)
wheel[i] = new Wheel();
}

}

练习15：在包中编写一个类，类应具备一个protected方法。在包外部，试着调用protede方法并解释其结果。然后，从你的类中继承产生一个类，并从该导出类的方法内部调用该protected方法

练习16：创建一个名为Amphibian的类，由此继承产生一个成为Frog的类，在基类中设置适当的方法，在main（）中，创建一个Frog向上转型至Amphibian，然后说明所有方法都可工作。

public class Exercise7_16 {
public static void main(String[] args) {
Amphibian amphibian = new Frog();
amphibian.moveInWater();
amphibian.moveInLand();

}
}
class Amphibian{
public void moveInWater() {
System.out.println("moveInWater");
}
public void moveInLand() {
System.out.println("moveInLand");
}
}
class Frog extends Amphibian{

}

练习17：修改练习16，使Frog覆盖基类中方法的定义。请留心main中都发生了什么

public class Exercise7_17 {
public static void main(String[] args) {
Amphibian2 amphibian = new Frog2();
amphibian.moveInWater();
amphibian.moveInLand();
}
}
class Amphibian2{
public void moveInWater() {
System.out.println("moveInWater");
}
public void moveInLand() {
System.out.println("moveInLand");
}
}
class Frog2 extends Amphibian2{
public void moveInWater() {
System.out.println("Frog.moveInWater");
}
public void moveInLand() {
System.out.println("Frog.moveInLand");
}

}

练习18：创建一个含有static final域和final域的类，说明二者间的区别。

public class Exercise7_18 {
public static void main(String[] args) {
System.out.println("First Object");
System.out.println(new WithFinalFields());
System.out.println("Second Object");
System.out.println(new WithFinalFields());
}
}
class SelfCounter{
private static int count;
private int id = count++;
public String toString(){
return "Selfcounter"+id;
}
}

class WithFinalFields{
final SelfCounter selfCounter = new SelfCounter();
static final SelfCounter s = new SelfCounter();
public String toString(){
return "selfcounter = "+selfCounter+" \ns = "+s;
}
}

练习19 ：创建一个含有指向某对象的空白final引用类。在所有构造器内部都执行空白final的初始化操作。说明Java确保final在使用前必须初始化，且一旦被初始化即无法改变

public class Exercise7_19 {
public static void main(String[] args) {
WithFInalBlankField field = new WithFInalBlankField(10);
System.out.println(field.geti());
}
}
class WithFInalBlankField{
private final Integer i;

public WithFInalBlankField(int i1) {
i = new Integer(i1);
}
public Integer geti() {
//      if(i==null) {
//          i= new Integer(47);
//      }
return i;
}
}

练习20：展示@Override注解可以解决本节中的问题

class WithFinals {
// Identical to "private" alone:
private final void f() { System.out.println("WithFinals.f()"); }
// Also automatically "final":
private void g() { System.out.println("WithFinals.g()"); }
}

class OverridingPrivate extends WithFinals {
private final void f() {
System.out.println("OverridingPrivate.f()");
}
private void g() {
System.out.println("OverridingPrivate.g()");
}
}

class OverridingPrivate2 extends OverridingPrivate {
public final void f() {
System.out.println("OverridingPrivate2.f()");
}
public void g() {
System.out.println("OverridingPrivate2.g()");
}
}

public class FinalOverridingIllusion {
public static void main(String[] args) {
OverridingPrivate2 op2 = new OverridingPrivate2();
op2.f();
op2.g();
// You can upcast:
OverridingPrivate op = op2;
// But you can't call the methods:
//! op.f();
//! op.g();
// Same here:
WithFinals wf = op2;
//! wf.f();
//! wf.g();
}
}

public class Exercise7_20 {
public static void main(String[] args) {
OverridingPrivate20 oPrivate = new OverridingPrivate20();
//  oPrivate.f();
//  oPrivate.g();
}
}
class OverridingPrivate20 extends WithFinals{
@Override private final void f() {
System.out.println("OverridingPrivate.f()");
}
@Override private  void g() {
System.out.println("OverridingPrivate.g()");
}
}
class OverridingPrivate30 extends OverridingPrivate20{
@Override public  void f() {
System.out.println("OverridingPrivate2.f()");
}
@Override public  void g() {
System.out.println("OverridingPrivate2.g()");
}
}

练习21：创建一个但final方法的类。由此继承产生一个类并尝试覆盖该方法

public class Exercise7_21 extends WithFinalMethod{
//   void f() {
//
//   }
public static void main(String[] args) {

}
}
class WithFinalMethod{
final void f() {

}
}

练习22：创建一个final类并试着继承它

public class Exercise7_22 extends FinalClass {
public static void main(String[] args) {

}
}
final class FinalClass{

}

练习23：请证明加载类的动作仅发生一次。证明该类的第一个实体的创建者或者对static成员的访问都有可能引起加载

public class Exercise7_23 {
public static void main(String[] args) {
System.out.println("Calling static member");
LoadTest.staticMember();
System.out.println("Creating an object");
new LoadTest();
}
}
class LoadTest{
static{
System.out.println("Loading loadTest");
}
static void staticMember() {};
}

练习24：在Beetle.java中，从Beetle类继承产生一个具体类型的“甲壳虫”。其形式与现有类相同，跟踪并解释其输出结果

public class Exercise7_24 {
public static void main(String[] args) {
new JapaneseBeetle();
}
}
class JapaneseBeetle extends Beetle{
int m = printInit("JapaneseBeetle.m.initilized");
public JapaneseBeetle() {
System.out.println("m = "+m);
System.out.println("j = "+j);
}
static int x3 = printInit("static JapansesBeetle.x3 initlized");
}

//Beetle.java
class Insect {
private int i = 9;
protected int j;
Insect() {
System.out.println("i = " + i + ", j = " + j);
j = 39;
}
private static int x1 =
printInit("static Insect.x1 initialized");
static int printInit(String s) {
System.out.println(s);
return 47;
}
}

public class Beetle extends Insect {
private int k = printInit("Beetle.k initialized");
public Beetle() {
System.out.println("k = " + k);
System.out.println("j = " + j);
}
private static int x2 =
printInit("static Beetle.x2 initialized");
public static void main(String[] args) {
System.out.println("Beetle constructor");
Beetle b = new Beetle();
}
} /* Output:
static Insect.x1 initialized
static Beetle.x2 initialized
Beetle constructor
i = 9, j = 0
Beetle.k initialized
k = 47
j = 39
*///:~

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签： java

相关文章推荐

新的分享

章节导航