首页 技术 正文

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

技术 2022年11月10日
0 收藏 532 点赞 2,756 浏览 8443 个字

欢迎加群：239063848

成团的笔记：该组仅用于技术共享和交流，问题和答案公布

潘基聊天、禁止广告、禁止招聘……

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

package test;public class Manager {public static void main(String args[]){
Second s=new Second();
s.getFirst();
}
/**
 * 打印结果： */
}
class First{
}
class Second{First f;Second(){
System.out.println("Creating Second");
}First lazy(){
if(f==null){
 System.out.println("Creating First");
f=new First();
}
return f;
}public First getFirst(){
return lazy();
}
}

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

package test;public class Manager {public static void main(String args[]){
Sub s=new Sub();
s.apply();s.dilute();s.foam();s.scrub();s.sterilize();
new print(s);
}/**
 * 打印结果：
Cleanser apply() dilute() foam() sub.scrub Detergent.scrub()sub.sterilize()
 */
}
class print{
print(Object obj){
System.out.println(obj);
}
}
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();
new print(x);
}
}
class Detergent extends Cleanser{
public void scrub(){
append(" Detergent.scrub()");
}
public void foam(){
append(" foam()");
}}
class Sub extends Detergent{
public void scrub(){
append(" sub.scrub");
super.scrub();
}
public void sterilize(){
append("sub.sterilize()");
}
}

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

package test;public class Manager {public static void main(String args[]){
new Cartoon();
}/**
 * 打印结果：
Art constructor
Drawing constructor
 */
}
class print{
print(Object obj){
System.out.println(obj);
}
}
class Art{
Art(){
new print("Art constructor ");
}
}
class Drawing extends Art{
Drawing(){
new print("Drawing constructor ");
}
}
class Cartoon extends Drawing{
}

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

package test;public class Manager {public static void main(String args[]){
new Child();
}/**
 * 打印结果：
父类构造器输出
子类构造器输出
 */
}
class print{
print(Object obj){
System.out.println(obj);
}
}
class Parent{
Parent(){
new print("基类构造器输出");
}
}
class Child extends Parent{
Child(){
new print("子类构造器输出");
}
}

练习5：（1）创建两个带有默认构造器（空參数列表）的类A和类B。

从A中继承产生一个名为C的新。并在C内创建一个B类的成员。不要给C编写构造器。

创建一个C类的对象并观察其结果。

package test;public class Manager {public static void main(String args[]){
new C();
}/**
 * 打印结果：
A()……
B()……
B()……
C()……
 */
}
class print{
print(Object obj){
System.out.println(obj);
}
}
class A{
A(){
new print("A()……");
}
}
class B{
B(){
new print("B()……");
}}
class C extends A{
private B b=new B();
C(){
new print("C()……");
}
private B b2=new B();
}

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

package test;public class Manager {public static void main(String args[]){
new Chess();
}/**
 * 打印结果：
Exception in thread "main" java.lang.Error: Unresolved compilation problem:
Implicit super constructor BordGame() is undefined. Must explicitly invoke another constructorat test.Chess.<init>(Manager.java:32)
at test.Manager.main(Manager.java:6)
 */
}
class print{
print(Object obj){
System.out.println(obj);
}
}
class Game{
Game(int i){
new print("Game constructor");
}
}
class BordGame extends Game{
BordGame(int i){
super(i);
new print("BordGame constructor");
}}
class Chess extends BordGame{Chess(){//Implicit super constructor BordGame() is undefined. Must explicitly invoke another constructor
new print("Chess constructor");
}}

练习7：（1）改动练习5，使A和B以带參数的构造器代替默认的构造器。为C写一个构造器，并在当中运行全部初始化。

package test;public class Manager {public static void main(String args[]){
new C();
}/**
 * 打印结果：
A()……
B()……
B()……
C()……
 */
}
class print{
print(Object obj){
System.out.println(obj);
}
}
class A{
A(int i){
new print("A()……");
}
}
class B{
B(){
new print("B()……");
}}
class C extends A{
private B b=new B();
C(){
super(1);//必须
new print("C()……");
}
private B b2=new B();
}

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

package test;
public class Test {      public static void main(String[] args) {      }
}class A{/** 非默认构造器 **/
A(int i){
System.out.println("基类");
}
}
class B extends A{B(){
super(1);/** 调用基类构造函数  **/
}
B(int i){
super(i);/** 调用基类构造函数  **/
System.out.println("导出类");
}
}

练习9：（2）创建一个Root类。令其含有名为Component1、Component 2、Component3的类的各一个实例（这些也由你写）。

从Root中派生一个类Stem，也含有上述各“组成部分”。

全部的类都应带有可打印出类的相关信息的默认构造器。

package test;
public class Test {      public static void main(String[] args) {
       new Stem();
    }
    /**
     * 输出
Component1 constructor
Component2 constructor
Component3 constructor
Root constructor
Component1 constructor
Component2 constructor
Component3 constructor
Stem constructor
     */
}class Root{private Component1 component1=new Component1();private Component2 component2=new Component2();private Component3 component3=new Component3();Root(){
System.out.println("Root constructor");
}
}
class Stem extends Root{private Component1 component1=new Component1();private Component2 component2=new Component2();private Component3 component3=new Component3();Stem(){
System.out.println("Stem constructor");
}
}
class Component1{Component1(){
System.out.println("Component1 constructor");
}
}
class Component2{Component2(){
System.out.println("Component2 constructor");
}
}
class Component3{Component3(){
System.out.println("Component3 constructor");
}
}

练习10：（1）改动练习9，使每一个类都仅具有非默认的构造器。

package test;
public class Test {      public static void main(String[] args) {
       new Stem(1);
    }
    /**
     * 输出
Component1 constructor 1
Component2 constructor 2
Component3 constructor 3
Root constructor
Component1 constructor 1
Component2 constructor 2
Component3 constructor 3
Stem constructor
     */
}class Root{private Component1 component1=new Component1(1);private Component2 component2=new Component2(2);private Component3 component3=new Component3(3);Root(int i){
System.out.println("Root constructor");
}
}
class Stem extends Root{private Component1 component1=new Component1(1);private Component2 component2=new Component2(2);private Component3 component3=new Component3(3);Stem(int i){
super(i);
System.out.println("Stem constructor");
}
}
class Component1{Component1(int i){
System.out.println("Component1 constructor "+i);
}
}
class Component2{Component2(int i){
System.out.println("Component2 constructor "+i);
}
}
class Component3{Component3(int i){
System.out.println("Component3 constructor"+i);
}
}

练习11：（3）改动Detergent.java。让它使用代理。

package test;public class Test {public static void main(String args[]){
Sub s=new Sub();
s.apply();s.dilute();s.foam();s.scrub();s.sterilize();
new print(s);
}/**
 * 打印结果：
Cleanser apply() dilute() foam() sub.scrub Detergent.scrub()sub.sterilize()
 */
}
class print{
print(Object obj){
System.out.println(obj);
}
}
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();
new print(x);
}
}
class Detergent{Cleanser Cleanser=new Cleanser();public void append(String str){
Cleanser.append(str);
}public void dilute(){
append(" dilute()");
}
public void apply(){
append(" apply()");
}
public String toString(){
return Cleanser.toString();
}public void scrub(){
append(" Detergent.scrub()");
}
public void foam(){
append(" foam()");
}}
class Sub extends Detergent{
public void scrub(){
append(" sub.scrub");
super.scrub();
}
public void sterilize(){
append("sub.sterilize()");
}
}

练习12：（3）将一个适当的dispose()方法的层次结构加入到练习9的全部类中。

package test;
public class Test {      public static void main(String[] args) {
    Stem s=new Stem();
       try{
       s.toString();
       }finally{
       s.dispose();
       }
    }
    /**
     * 输出
Component1 constructor
Component2 constructor
Component3 constructor
Root constructor
Component1 constructor
Component2 constructor
Component3 constructor
Stem constructor
Stem dispose
Root dispose
     */
}class Root{private Component1 component1=new Component1();private Component2 component2=new Component2();private Component3 component3=new Component3();Root(){
System.out.println("Root constructor");
}void dispose(){
System.out.println("Root dispose");
}
}
class Stem extends Root{private Component1 component1=new Component1();private Component2 component2=new Component2();private Component3 component3=new Component3();Stem(){
System.out.println("Stem constructor");
}void dispose(){
System.out.println("Stem dispose");
super.dispose();
}
}
class Component1{Component1(){
System.out.println("Component1 constructor");
}void dispose(){
System.out.println("Component1 dispose");
}
}
class Component2{Component2(){
System.out.println("Component2 constructor");
}void dispose(){
System.out.println("Component2 dispose");
}
}
class Component3{Component3(){
System.out.println("Component3 constructor");
}void dispose(){
System.out.println("Component3 dispose");
}
}

练习13：（2）创建一个类。它应带有一个被重载了三次的方法。

继承产生一个新类，并加入一个该方法的新的重载定义，展示这四个方法在导出类中都是能够使用的。

package test;
public class Test {      public static void main(String[] args) {
    Stem s=new Stem();
    s.a();
    int i=10;
    s.a(i);
    float f=10f;
    s.a(f);
    double d=10d;
    s.a(d);
    }
    /**
     * 输出
a()
a(int)10
a(float)10.0
a(double)10.0
     */
}class Root{void a(){
System.out.println("a()");
}
void a(int i){
System.out.println("a(int)"+ i);
}
void a(float i){
System.out.println("a(float)"+ i);
}
}
class Stem extends Root{
void a(double i){
System.out.println("a(double)"+ i);
}}

行使14：（1）在Car.java在以Engine加入一service(),和main()调用此方法。

点赞 532

贡献者

上一篇： android中利用实现二级联动的效果
下一篇： KafkaSpout 浅析
相关推荐
python开发_常用的python模块及安装方法
python开发_常用的python模块及安装方法
adodb：我们领导推荐的数据库连接组件bsddb3：BerkeleyDB的连接组件Cheetah-1.0：我比较喜欢这个版本的cheeta…
技术
日期：2022-11-24 点赞：878 阅读：9,489
Educational Codeforces Round 11 C. Hard Process 二分
Educational Codeforces Round 11 C. Hard Process 二分
C. Hard Process题目连接：http://www.codeforces.com/contest/660/problem/CDes…
技术
日期：2022-11-24 点赞：807 阅读：5,904
下载Ubuntn 17.04 内核源代码
下载Ubuntn 17.04 内核源代码
zengkefu@server1:/usr/src$ uname -aLinux server1 4.10.0-19-generic #21…
技术
日期：2022-11-24 点赞：569 阅读：6,737
可用Active Desktop Calendar V7.86 注册码序列号
可用Active Desktop Calendar V7.86 注册码序列号
可用Active Desktop Calendar V7.86 注册码序列号Name: www.greendown.cn Code: &nb…
技术
日期：2022-11-24 点赞：733 阅读：6,490
Android调用系统相机、自定义相机、处理大图片
Android调用系统相机、自定义相机、处理大图片
Android调用系统相机和自定义相机实例本博文主要是介绍了android上使用相机进行拍照并显示的两种方式，并且由于涉及到要把拍到的照片显…
技术
日期：2022-11-24 点赞：512 阅读：8,128
Struts的使用
Struts的使用
一、Struts2的获取　　Struts的官方网站为：http://struts.apache.org/　　下载完Struts2的jar包,…
技术
日期：2022-11-24 点赞：671 阅读：5,290
Lomu

贡献者

这家伙很懒，只想把你留下。

文章
39
收藏
0
人气
120,406
粉丝
进主页
文章展示
  • [ 技术 ] python开发_常用的python模块及安装方法
  • [ 技术 ] Educational Codeforces Round 11 C. Hard Process 二分
  • [ 技术 ] 下载Ubuntn 17.04 内核源代码
  • [ 技术 ] 可用Active Desktop Calendar V7.86 注册码序列号
  • [ 技术 ] Android调用系统相机、自定义相机、处理大图片
  • [ 技术 ] Struts的使用
    • 个人收藏笔记记录
    我的笔记
    首页 首页 菜单 首页 首页