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 并发编程的艺术:深入理解 ExecutorService
【4月更文挑战第21天】 在 Java 中,处理并发任务是一项挑战,但也至关重要。本文将深入探讨 Java 的 ExecutorService,这是一个强大的工具,用于管理和执行异步任务。我们将详细解析其内部工作原理,以及如何有效利用它来提升应用程序的性能和响应性。通过实例演示,我们将揭示 ExecutorService 的最佳实践,并展示如何避免常见的并发陷阱。
|
9天前
|
缓存 Java 调度
Java并发编程学习10-任务执行与Executor框架
【4月更文挑战第12天】本篇 重点讲解任务执行和 Executor框架的基础知识
21 4
Java并发编程学习10-任务执行与Executor框架
|
3天前
|
存储 SQL 安全
Java 安全性编程:基本概念与实战指南
【4月更文挑战第27天】在当今的软件开发领域,安全性编程是一个至关重要的方面。Java,作为广泛使用的编程语言之一,提供了多种机制来保护应用免受常见的安全威胁。本博客将探讨 Java 安全性编程的基本概念,并通过实际示例来展示如何实现这些安全措施。
10 3
|
1天前
|
Java
Java中的条件语句结构在编程中的应用
Java中的条件语句结构在编程中的应用
4 0
|
1天前
|
安全 Java
Java修饰符在编程中的应用研究
Java修饰符在编程中的应用研究
6 0
|
1天前
|
Java 关系型数据库 MySQL
【JDBC编程】基于MySql的Java应用程序中访问数据库与交互数据的技术
【JDBC编程】基于MySql的Java应用程序中访问数据库与交互数据的技术
|
3天前
|
Java 开发者 UED
Java 异步和事件驱动编程:探索响应式模式
【4月更文挑战第27天】在现代软件开发中,异步和事件驱动编程是提高应用性能和响应性的关键策略。Java 提供了多种机制来支持这些编程模式,使开发者能够构建高效、可扩展的应用程序。
14 4
|
3天前
|
设计模式 Java
Java 设计模式:混合、装饰器与组合的编程实践
【4月更文挑战第27天】在面向对象编程中,混合(Mixins)、装饰器(Decorators)和组合(Composition)是三种强大的设计模式,用于增强和扩展类的功能。
9 1
|
3天前
|
Java
Java 事件驱动编程:概念、优势与实战示例
【4月更文挑战第27天】事件驱动编程是一种编程范式,其中程序的执行流程由外部事件的发生而触发或驱动。
9 0
|
3天前
|
Java Shell API
Java 模块化编程:概念、优势与实战指南
【4月更文挑战第27天】Java 模块化编程是 Java 9 中引入的一项重大特性,通过 Java Platform Module System (JPMS) 实现。模块化旨在解决 Java 应用的封装性、可维护性和性能问题
9 0