AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

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

2022-05-07 129
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 第一题 package net.mindview.polymorphism; //基类-自行车 class Cycle{ } //子类-单轮车 class Unicycle extends Cycle{ } //子类-双轮车 class Bicycle extends Cycle{ } //子类-三轮车 class Tricycle extends Cycl...

1..第一题


package net.mindview.polymorphism;
//基类-自行车
class Cycle{
}
//子类-单轮车
class Unicycle extends Cycle{
}
//子类-双轮车
class Bicycle extends Cycle{
}
//子类-三轮车
class Tricycle extends Cycle{
}
public class CycleCompetition {
    public static void ride(Cycle cycle){
    }
    public static void main(String[] args) {
        Bicycle b = new Bicycle();
        ride(b);
    }
} 你


2.（略）


3.（略）


4.第四题


package net.mindview.polymorphism;
import java.util.Random;
//形状
class Shape{
    public void draw(){}
    public void erase(){}
}
//圆形
class Cycle1 extends Shape {
    @Override
    public void draw() {
        System.out.println("draw cycle");
    }
    @Override
    public void erase() {
        System.out.println("erase cycle");
    }
}
class Square extends Shape {
    @Override
    public void draw() {
        System.out.println("draw Square");
    }
    @Override
    public void erase() {
        System.out.println("draw Square");
    }
}
//矩形
class Triangle extends Shape {
    @Override
    public void draw() {
        System.out.println("draw Triangle");
    }
    @Override
    public void erase() {
        System.out.println("draw Triangle");
    }
}
//梯形
class Trapezoid extends Shape {
    @Override
    public void draw() {
        System.out.println("draw Trapezoid");
    }
    @Override
    public void erase() {
        System.out.println("draw Trapezoid");
    }
}
class RandomShapeFactory {
    Random random = new Random(100);
    //下面画什么形状呢
    public Shape next(){
        switch(random.nextInt(4)) {
            default:
            case 0: return new Cycle1();
            case 1: return new Square();
            case 2: return new Triangle();
            case 3: return new Trapezoid();
        }
    }
}
public class Shapes {
    public static void main(String[] args) {
        Shape[] shape = new Shape[9];
        RandomShapeFactory factory = new RandomShapeFactory();
        for(int i=0; i<shape.length; i++){
            shape[i] = factory.next();
            shape[i].draw();
        }
    }
}


5.第五题


package net.mindview.polymorphism;
//基类-自行车
class Cycle{
    public int wheels(){
        return 0;
    }
}
//子类-单轮车
class Unicycle extends Cycle{
    public int wheels(){
        return 1;
    }
}
//子类-双轮车
class Bicycle extends Cycle{
    public int wheels(){
        return 2;
    }
}
//子类-三轮车
class Tricycle extends Cycle{
    public int wheels(){
        return 3;
    }
}
public class CycleCompetition {
    public static void ride(Cycle cycle){
        System.out.println(cycle.wheels());
    }
    public static void main(String[] args) {
        Bicycle b = new Bicycle();
        ride(b);
    }
}


6.第六题


package net.mindview.polymorphism.Music3;
import net.mindview.polymorphism.Note;
class Instrument {
    public void play(Note i){
        System.out.println("Instrument.play() ");
    }
    public String toString () { 
        return Instrument.class.getName(); 
    }
    void adjust(){System.out.println("adjust Instrument");}
}
class Wind extends Instrument {
    @Override
    public void play(Note i) {
        System.out.println("Wind.play() ");
    }
    String what (){ return "Wind"; }
    void adjust(){System.out.println("adjust Wind");}
}
class Stringed extends Instrument {
    @Override
    public void play(Note i) {
        System.out.println("Stringed.play() ");
    }
    String what (){ return "Stringed"; }
    void adjust(){System.out.println("adjust Stringed");}
}
class Brass extends Instrument {
    @Override
    public void play(Note i) {
        System.out.println("Brass.play() ");
    }
    String what (){ return "Brass"; }
    void adjust(){System.out.println("adjust Brass");}
}
public class Music3 {
    //曲调
    public static void tune(Instrument i){
        i.play(Note.MIDDLE_C);
    }
    public static void tuneAll(Instrument[] i){
        for(Instrument ins: i){
            tune(ins);
        }
    }
    public static void main(String[] args) {
        Instrument[] i = {
                new Wind(),
                new Stringed(),
                new Brass()
        };
        tuneAll(i);
        Instrument t = new Instrument();
        System.out.println(t);
    }
}


7.第七题


package net.mindview.polymorphism.Music3;
import net.mindview.polymorphism.Note;
class Instrument {
    public void play(Note i){
        System.out.println("Instrument.play() ");
    }
    public String toString () { 
        return Instrument.class.getName(); 
    }
    void adjust(){System.out.println("adjust Instrument");}
}
class Wind extends Instrument {
    @Override
    public void play(Note i) {
        System.out.println("Wind.play() ");
    }
    String what (){ return "Wind"; }
    void adjust(){System.out.println("adjust Wind");}
}
class Stringed extends Instrument {
    @Override
    public void play(Note i) {
        System.out.println("Stringed.play() ");
    }
    String what (){ return "Stringed"; }
    void adjust(){System.out.println("adjust Stringed");}
}
class Brass extends Instrument {
    @Override
    public void play(Note i) {
        System.out.println("Brass.play() ");
    }
    String what (){ return "Brass"; }
    void adjust(){System.out.println("adjust Brass");}
}
class Other extends Instrument {
    @Override
    public void play(Note i) {
        System.out.println("Other.play() ");
    }
    String what (){ return "Other"; }
    void adjust(){System.out.println("adjust Other");}
}
public class Music3 {
    //曲调
    public static void tune(Instrument i){
        i.play(Note.MIDDLE_C);
    }
    public static void tuneAll(Instrument[] i){
        for(Instrument ins: i){
            tune(ins);
        }
    }
    public static void main(String[] args) {
        Instrument[] i = {
                new Wind(),
                new Stringed(),
                new Brass(),
                new Other()
        };
        tuneAll(i);
        Instrument t = new Instrument();
        System.out.println(t);
    }
}


8.第八题


package net.mindview.polymorphism.Music3;
import java.util.Random;
import net.mindview.polymorphism.Note;
class Instrument {
    public void play(Note i){
        System.out.println("Instrument.play() ");
    }
    public String toString () { 
        return Instrument.class.getName(); 
    }
    void adjust(){System.out.println("adjust Instrument");}
}
class Wind extends Instrument {
    @Override
    public void play(Note i) {
        System.out.println("Wind.play() ");
    }
    String what (){ return "Wind"; }
    void adjust(){System.out.println("adjust Wind");}
}
class Stringed extends Instrument {
    @Override
    public void play(Note i) {
        System.out.println("Stringed.play() ");
    }
    String what (){ return "Stringed"; }
    void adjust(){System.out.println("adjust Stringed");}
}
class Brass extends Instrument {
    @Override
    public void play(Note i) {
        System.out.println("Brass.play() ");
    }
    String what (){ return "Brass"; }
    void adjust(){System.out.println("adjust Brass");}
}
class Other extends Instrument {
    @Override
    public void play(Note i) {
        System.out.println("Other.play() ");
    }
    String what (){ return "Other"; }
    void adjust(){System.out.println("adjust Other");}
}
class RandomInstrumentFactory {
    Random rand = new Random(100);
    public Instrument next(){
        switch(rand.nextInt(4)){
            default:
            case 0: return new Wind();
            case 1: return new Stringed();
            case 2: return new Brass();
            case 3: return new Other();
        }
    }
}
public class Music3 {
    //曲调
    public static void tune(Instrument i){
        i.play(Note.MIDDLE_C);
    }
    public static void tuneAll(Instrument[] i){
        for(Instrument ins: i){
            tune(ins);
        }
    }
    public static void main(String[] args) {
        RandomInstrumentFactory factory = new RandomInstrumentFactory();
        Instrument[] instruments = new Instrument[10];
        for(int i=0; i<instruments.length; i++){
            instruments[i] = factory.next();
        }
        tuneAll(instruments);
        Instrument t = new Instrument();
        System.out.println(t);
    }
}


9.第九题


package net.mindview.polymorphism;
//啮(nie四声)齿动物
class Rodent{
    void say(){System.out.println("hi,我是 Rodent");}
}
//老鼠
class Mouse extends Rodent{
    void say(){System.out.println("hi,我是 Mouse");}
}
//鼹鼠
class Gerbil extends Rodent{
    void say(){System.out.println("hi,我是 Gerbil");}
}
//大颊鼠
class Hamster extends Rodent{
    void say(){System.out.println("hi,我是 Hamster");}
}
//啮(nie四声)齿动物大家族
public class RodentHome {
    public static void instroduce(Rodent rodent){
        rodent.say();
    }
    public static void instroduceAll(Rodent[] rodents){
        for(Rodent r: rodents){
            instroduce(r);
        }
    }
    public static void main(String[] args) {
        Rodent[] rodents = {
                new Mouse(),
                new Gerbil(),
                new Hamster()
        };
        instroduceAll(rodents);
    }
}


10.第十题


package net.mindview.polymorphism;
class Base{
    public void method1(){
        System.out.println("method1");
        method2();
    }
    public void method2(){
        System.out.println("Base method2");
    }
}
class Child extends Base{
    @Override
    public void method2() {
        System.out.println("Child method2");
    }
}
public class Test10 {
    public static void up(Base b){
        b.method1();
    }
    public static void main(String[] args) {
        Child c = new Child();
        up(c);
    }
}


11.afd


12.adf


13.第十三题


package net.mindview.polymorphism;
import static net.mindview.util.Print.*;
//这是一个共享类
class Shared {
    private int refCount = 0;
    private static long counter = 0;
    private final long id = counter++;
    public Shared(){
        println("Creating "+this);
    }
    public void addRef(){
        refCount ++;
    }
    protected void dispose(){
        if(--refCount ==0){
            println("Disposing " + this);
        }
    }
    @Override
    public String toString() {
        return "Shared " + id;
    }
    @Override
    protected void finalize() throws Throwable {
        if(refCount != 0){
            println("Error, 引用计数不为0");
        }
        super.finalize();
    }
}
//组成类
class Composing{
    private Shared shared;
    private static long counter = 0;
    private final long id = counter ++;
    public Composing(Shared shared){
        println("Creating "+ this);
        this.shared = shared;
        shared.addRef();
    }
    protected void dispose() {
        println("dispose " + this);
        shared.dispose();
    }
    @Override
    public String toString() {
        return "Composing " + id;
    }
}
//引用计数
public class ReferenceCounting {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Shared shared = new Shared();
        Composing[] composing = {
                new Composing(shared),
                new Composing(shared),
                new Composing(shared),
                new Composing(shared),
                new Composing(shared),
                new Composing(shared)
        };
        for(Composing c:composing){
            c.dispose();
        }
    }
}


14.fa


15.dfa


16.第十六题


package net.mindview.polymorphism;
class AlertStatus {
    @Override
    public String toString() {
        return "AlertStatus";
    }
}
class StartStatus extends AlertStatus {
    @Override
    public String toString() {
        return "StartStatus";
    }
}
class EndStatus extends AlertStatus {
    @Override
    public String toString() {
        return "EndStatus";
    }
}
class PauseStatus extends AlertStatus {
    @Override
    public String toString() {
        return "PauseStatus";
    }
}
class Music4 {
    AlertStatus as = new StartStatus();
    public void pause(){
        as = new PauseStatus();
    }
    public void end(){
        as = new EndStatus();
    }
    public void currentStatus(){
        System.out.println(as);
    }
}
public class Starship {
    public static void main(String[] args) {
        Music4 m = new Music4();
        m.currentStatus();
        m.pause();
        m.currentStatus();
        m.end();
        m.currentStatus();
    }
}


17.第十七题


package net.mindview.polymorphism;
//基类-自行车
class Cycle{
    public int wheels(){
        return 0;
    }
}
//子类-单轮车
class Unicycle extends Cycle{
    public int wheels(){
        return 1;
    }
    public void balance(){
        System.out.println("Unicycle balance");
    }
}
//子类-双轮车
class Bicycle extends Cycle{
    public int wheels(){
        return 2;
    }
    public void balance(){
        System.out.println("Bicycle balance");
    }
}
//子类-三轮车
class Tricycle extends Cycle{
    public int wheels(){
        return 3;
    }
}
public class CycleCompetition {
    public static void ride(Cycle cycle){
        System.out.println(cycle.wheels());
    }
    public static void main(String[] args) {
        Cycle[] cycle = {
                new Cycle(),
                new Unicycle(),
                new Bicycle(),
                new Tricycle()
        };
        //((Cycle)cycle[0]).balance();//编译不通过
        ((Unicycle)cycle[1]).balance();
        ((Bicycle)cycle[2]).balance();
    }
}
文章标签：
Java
关键词：
Java编程
Java习题
Java编程思想
Java编程思想习题
p2jbaco26vdds
目录
相关文章
shuj
|
5天前
|
设计模式 安全 Java
Java编程中的单例模式深入剖析
【10月更文挑战第21天】在Java的世界里，单例模式是设计模式中一个常见而又强大的存在。它确保了一个类只有一个实例，并提供一个全局访问点。本文将深入探讨如何正确实现单例模式，包括常见的实现方式、优缺点分析以及最佳实践，同时也会通过实际代码示例来加深理解。无论你是Java新手还是资深开发者，这篇文章都将为你提供宝贵的见解和技巧。
shuj
89 65
萝卜带泥
|
1天前
|
缓存 Java 调度
Java中的多线程编程：从基础到实践
【10月更文挑战第24天】 本文旨在为读者提供一个关于Java多线程编程的全面指南。我们将从多线程的基本概念开始，逐步深入到Java中实现多线程的方法，包括继承Thread类、实现Runnable接口以及使用Executor框架。此外，我们还将探讨多线程编程中的常见问题和最佳实践，帮助读者在实际项目中更好地应用多线程技术。
萝卜带泥
9 3
ShaFaChuang-36210
|
3天前
|
监控 安全 Java
Java多线程编程的艺术与实践
【10月更文挑战第22天】 在现代软件开发中，多线程编程是一项不可或缺的技能。本文将深入探讨Java多线程编程的核心概念、常见问题以及最佳实践，帮助开发者掌握这一强大的工具。我们将从基础概念入手，逐步深入到高级主题，包括线程的创建与管理、同步机制、线程池的使用等。通过实际案例分析，本文旨在提供一种系统化的学习方法，使读者能够在实际项目中灵活运用多线程技术。
ShaFaChuang-36210
14 5
游客moiomvrp3vyac2
|
4天前
|
存储 安全 Java
Java编程中的对象序列化与反序列化
【10月更文挑战第22天】在Java的世界里，对象序列化和反序列化是数据持久化和网络传输的关键技术。本文将带你了解如何在Java中实现对象的序列化与反序列化，并探讨其背后的原理。通过实际代码示例，我们将一步步展示如何将复杂数据结构转换为字节流，以及如何将这些字节流还原为Java对象。文章还将讨论在使用序列化时应注意的安全性问题，以确保你的应用程序既高效又安全。
游客moiomvrp3vyac2
13 4
萝卜带泥
|
1天前
|
缓存 安全 Java
Java中的多线程编程：从基础到实践
【10月更文挑战第24天】 本文将深入探讨Java中的多线程编程，包括其基本原理、实现方式以及常见问题。我们将从简单的线程创建开始，逐步深入了解线程的生命周期、同步机制、并发工具类等高级主题。通过实际案例和代码示例，帮助读者掌握多线程编程的核心概念和技术，提高程序的性能和可靠性。
萝卜带泥
7 2
叫个什么名字
|
2天前
|
Java
Java中的多线程编程：从基础到实践
本文深入探讨Java多线程编程，首先介绍多线程的基本概念和重要性，接着详细讲解如何在Java中创建和管理线程，最后通过实例演示多线程的实际应用。文章旨在帮助读者理解多线程的核心原理，掌握基本的多线程操作，并能够在实际项目中灵活运用多线程技术。
叫个什么名字
11 3
天下无贼001
|
2天前
|
Java 程序员 开发者
Java编程中的异常处理艺术
【10月更文挑战第24天】在Java的世界里，代码就像一场精心编排的舞蹈，每一个动作都要精准无误。但就像最完美的舞者也可能踩错一个步伐一样，我们的程序偶尔也会遇到意外——这就是所谓的异常。本文将带你走进Java的异常处理机制，从基本的try-catch语句到高级的异常链追踪，让你学会如何优雅地处理这些不请自来的“客人”。
天下无贼001
11 3
萝卜带泥
|
4天前
|
Java 数据处理 开发者
Java多线程编程的艺术：从入门到精通####
【10月更文挑战第21天】 本文将深入探讨Java多线程编程的核心概念，通过生动实例和实用技巧，引导读者从基础认知迈向高效并发编程的殿堂。我们将一起揭开线程管理的神秘面纱，掌握同步机制的精髓，并学习如何在实际项目中灵活运用这些知识，以提升应用性能与响应速度。 ####
萝卜带泥
20 3
叫个什么名字
|
7天前
|
Java API 调度
Java中的多线程编程：理解与实践
本文旨在为读者提供对Java多线程编程的深入理解，包括其基本概念、实现方式以及常见问题的解决方案。通过阅读本文，读者将能够掌握Java多线程编程的核心知识，提高自己在并发编程方面的技能。
叫个什么名字
31 5
游客5fdji2pvmf8888
|
5天前
|
Java
Java中的多线程编程：从入门到精通
本文将带你深入了解Java中的多线程编程。我们将从基础概念开始，逐步深入探讨线程的创建、启动、同步和通信等关键知识点。通过阅读本文，你将能够掌握Java多线程编程的基本技能，为进一步学习和应用打下坚实的基础。
游客5fdji2pvmf8888
19 2

热门文章

最新文章

  • 1
    阿里Java代码规约插件即将全球首发，邀您来发布仪式现场
  • 2
    Java中的内存泄露的几种可能
  • 3
    Java中的定时器
  • 4
    kill -3 PID命令获取java应用堆栈信息
  • 5
    gzip压缩js和html文件java源码
  • 6
    Java程序员需要熟悉的库
  • 7
    java8 不使用循环
  • 8
    JAVA简单的SWING及AWT
  • 9
    Java基本数据类型总结
  • 10
    java获得当前文件路径
  • 1
    flink最新master代码编译出现Java Runtime Environment 问题
    77
  • 2
    【Java】仓库管理系统 SpringBoot+LayUI+DTree（源码）【独一无二】
    79
  • 3
    软件工程设计原理接口隔离原则 ，具体实现及JAVA代码举例
    50
  • 4
    软件工程设计原理依赖倒置原则 ，具体实现及JAVA代码举例
    56
  • 5
    软件工程设计原理开放封闭原则 ，具体实现及JAVA代码举例
    72
  • 6
    Java通过反射获取类调用方法
    49
  • 7
    使用Java代码打印log日志
    311
  • 8
    Java内存管理与调优：释放应用潜能的关键
    79
  • 9
    Java基础(快速排序算法)
    42
  • 10
    Java数据库编程指南：实现高效数据存储与访问
    184

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 阿里云平台上进行Java程序的编译与运行
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月