java编程思想第四版第七章习题

简介: 创建两个带有默认构造器(空参数列表)的类A和类B。从A中继承产生一个名为C的新,并在C内创建一个B类的成员。不要给C编写构造器。创建一个C类的对象并观察其结果。
  1. (略)


  1. (略)


  1. (略)


  1. (略)


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


package net.mindview.reusing;
public class A {
    public A(){
        System.out.println("A");
    }
}
package net.mindview.reusing;
public class B {
    public B(){
        System.out.println("B");
    }
}
package net.mindview.reusing;
public class C extends A {
    B b = new B();
    public static void main(String[] args) {
        C c = new C();
    }
}


6.(略)


7.(略)


8.(略)


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


package net.mindview.reusing;
public class Root {
    private Component1 c1 = new Component1();
    private Component2 c2 = new Component2();
    private Component3 c3 = new Component3();
    public Root() {
        System.out.println("Root");
        System.out.println("Root->c1");
        System.out.println("Root->c2");
        System.out.println("Root->c3");
    }
}
package net.mindview.reusing;
public class Component1 {
    public Component1() {
        System.out.println("Component1");
    }
}
package net.mindview.reusing;
public class Component2 {
    public Component2() {
        System.out.println("Component2");
    }
}
package net.mindview.reusing;
public class Component3 {
    public Component3() {
        System.out.println("Component3");
    }
}
package net.mindview.reusing;
public class Stem extends Root {
    private Component1 c1 = new Component1();
    private Component2 c2 = new Component2();
    private Component3 c3 = new Component3();
    public Stem() {
        System.out.println("RootChild");
        System.out.println("Stem->c1");
        System.out.println("Stem->c2");
        System.out.println("Stem->c3");
    }
    public static void main(String[] args) {
        Root t = new Stem();
    }
}


10.(略)可参考总结中的第5点,使用代理模式。


11.(略)


12.(略)


13.(略)


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


package net.mindview.reusing;
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(){}
}
public class Car {
    public Engine engine = new Engine();
    public Wheel[] wheels = new Wheel[4];
    public Door left = new Door(),right = new Door();
    public Car(){
        for(int i=0;i<4; i++){
            wheels[i] = new Wheel();
        }
    }
    public static void main(String[] args) {
        Car car = new Car();
        car.left.window.rollup();
        car.wheels[0].inflate(72);
        car.engine.Service();
    }
}


15.(略)


16.创建一个名为Amphibian的类,由此继承产生一个成为Frog的类,在基类中设置适当的方法,在main()中,创建一个Frog向上转型至Amphibian, 然后说明所有方法都可工作


package net.mindview.reusing;
//两栖动物
class Amphibian{
    //交配
    public void mating(Amphibian amphibian){
        System.out.println("两栖动物交配");
    }
}
//青蛙
public class Frog extends Amphibian{
    public static void main(String[] args) {
        Frog frog = new Frog();
        frog.mating(frog);
    }
}


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


package net.mindview.reusing;
//两栖动物
class Amphibian{
    //交配
    public void mating(Amphibian amphibian){
        System.out.println("两栖动物交配");
    }
}
//青蛙
public class Frog extends Amphibian{
    public void mating(Frog frog){
        System.out.println("青蛙交配");
    }
    public static void main(String[] args) {
        Frog frog = new Frog();
        frog.mating(frog);
    }
}


18.(略)


19.(略)

相关文章
|
9天前
|
设计模式 安全 Java
Java编程中的单例模式深入剖析
【10月更文挑战第21天】在Java的世界里,单例模式是设计模式中一个常见而又强大的存在。它确保了一个类只有一个实例,并提供一个全局访问点。本文将深入探讨如何正确实现单例模式,包括常见的实现方式、优缺点分析以及最佳实践,同时也会通过实际代码示例来加深理解。无论你是Java新手还是资深开发者,这篇文章都将为你提供宝贵的见解和技巧。
90 65
|
1天前
|
Java API Apache
Java编程如何读取Word文档里的Excel表格,并在保存文本内容时保留表格的样式?
【10月更文挑战第29天】Java编程如何读取Word文档里的Excel表格,并在保存文本内容时保留表格的样式?
14 5
|
1天前
|
安全 Java 调度
Java中的多线程编程入门
【10月更文挑战第29天】在Java的世界中,多线程就像是一场精心编排的交响乐。每个线程都是乐团中的一个乐手,他们各自演奏着自己的部分,却又和谐地共同完成整场演出。本文将带你走进Java多线程的世界,让你从零基础到能够编写基本的多线程程序。
8 1
|
5天前
|
缓存 Java 调度
Java中的多线程编程:从基础到实践
【10月更文挑战第24天】 本文旨在为读者提供一个关于Java多线程编程的全面指南。我们将从多线程的基本概念开始,逐步深入到Java中实现多线程的方法,包括继承Thread类、实现Runnable接口以及使用Executor框架。此外,我们还将探讨多线程编程中的常见问题和最佳实践,帮助读者在实际项目中更好地应用多线程技术。
12 3
|
7天前
|
监控 安全 Java
Java多线程编程的艺术与实践
【10月更文挑战第22天】 在现代软件开发中,多线程编程是一项不可或缺的技能。本文将深入探讨Java多线程编程的核心概念、常见问题以及最佳实践,帮助开发者掌握这一强大的工具。我们将从基础概念入手,逐步深入到高级主题,包括线程的创建与管理、同步机制、线程池的使用等。通过实际案例分析,本文旨在提供一种系统化的学习方法,使读者能够在实际项目中灵活运用多线程技术。
|
8天前
|
存储 安全 Java
Java编程中的对象序列化与反序列化
【10月更文挑战第22天】在Java的世界里,对象序列化和反序列化是数据持久化和网络传输的关键技术。本文将带你了解如何在Java中实现对象的序列化与反序列化,并探讨其背后的原理。通过实际代码示例,我们将一步步展示如何将复杂数据结构转换为字节流,以及如何将这些字节流还原为Java对象。文章还将讨论在使用序列化时应注意的安全性问题,以确保你的应用程序既高效又安全。
|
5天前
|
缓存 安全 Java
Java中的多线程编程:从基础到实践
【10月更文挑战第24天】 本文将深入探讨Java中的多线程编程,包括其基本原理、实现方式以及常见问题。我们将从简单的线程创建开始,逐步深入了解线程的生命周期、同步机制、并发工具类等高级主题。通过实际案例和代码示例,帮助读者掌握多线程编程的核心概念和技术,提高程序的性能和可靠性。
8 2
|
6天前
|
Java
Java中的多线程编程:从基础到实践
本文深入探讨Java多线程编程,首先介绍多线程的基本概念和重要性,接着详细讲解如何在Java中创建和管理线程,最后通过实例演示多线程的实际应用。文章旨在帮助读者理解多线程的核心原理,掌握基本的多线程操作,并能够在实际项目中灵活运用多线程技术。
|
6天前
|
Java 程序员 开发者
Java编程中的异常处理艺术
【10月更文挑战第24天】在Java的世界里,代码就像一场精心编排的舞蹈,每一个动作都要精准无误。但就像最完美的舞者也可能踩错一个步伐一样,我们的程序偶尔也会遇到意外——这就是所谓的异常。本文将带你走进Java的异常处理机制,从基本的try-catch语句到高级的异常链追踪,让你学会如何优雅地处理这些不请自来的“客人”。
|
8天前
|
Java 数据处理 开发者
Java多线程编程的艺术:从入门到精通####
【10月更文挑战第21天】 本文将深入探讨Java多线程编程的核心概念,通过生动实例和实用技巧,引导读者从基础认知迈向高效并发编程的殿堂。我们将一起揭开线程管理的神秘面纱,掌握同步机制的精髓,并学习如何在实际项目中灵活运用这些知识,以提升应用性能与响应速度。 ####
30 3