JAVA编程思想第八章练习题

已于 2022-04-02 17:14:40 修改
阅读量385 收藏
点赞数
文章标签： java
于 2022-04-02 17:10:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a360521/article/details/123906556
版权 

package Cycle1;

public class Application {
    public static void main(String[] args) {
        Cycle bi = new Bicycle();
        bi.ride();
        Cycle tr = new Tricycle();
        tr.ride();
        ((Tricycle) tr).run();
        Cycle un = new Unicycle();
        un.ride();
    }
}

练习3：

package Eshape;

public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Circle.draw()");
    }
    @Override
    public void erase() {
        System.out.println("Circle.erase()");
    }

    @Override
    public void printf() {
        System.out.println("Circle Print");
    }
}

练习4：一样

练习5：

package Cycle1;

import java.util.Random;

public class Cycle {
    public int wheels(){
        Random w = new Random();
        return w.nextInt(4);
    }
    public void ride(){
        System.out.println("Ride");
        System.out.println(wheels());
    }
}

 

练习9：

package Cycle1;
class Rodent{
    public void hop(){
        System.out.println("Rodent hopping");
    }
    public void scurry(){
        System.out.println("Rodent scurrying");
    }
    public void reproduce(){
        System.out.println("Making more Rodents");
    }

    @Override
    public String toString() {
        return "Rodent{}";
    }
}
class Mouse extends Rodent{
    @Override
    public void hop() {
        System.out.println("Mouse1");
    }

    @Override
    public void scurry() {
        System.out.println("Mouse2");
    }

    @Override
    public void reproduce() {
        System.out.println("Mouse3");
    }

    @Override
    public String toString() {
        return "Mouse{}";
    }
}
class Gerbil extends Rodent{
    @Override
    public void hop() {
        System.out.println("Gerbil1");
    }

    @Override
    public void scurry() {
        System.out.println("Gerbil2");
    }

    @Override
    public void reproduce() {
        System.out.println("Gerbil3");
    }

    @Override
    public String toString() {
        return "Gerbil{}";
    }
}
class Hamster extends Rodent{
    @Override
    public void hop() {
        System.out.println("Hamster1");
    }

    @Override
    public void scurry() {
        System.out.println("Hamster2");
    }

    @Override
    public void reproduce() {
        System.out.println("Hamster3");
    }

    @Override
    public String toString() {
        return "Hamster{}";
    }
}
public class E09 {
    public static void main(String[] args) {
        Rodent[] rodents = {
                new Mouse(),new Gerbil(),new Hamster(),
        };
        for (Rodent r :
                rodents) {
            r.hop();
            r.scurry();
            r.reproduce();
            r.toString();
        }
    }
}

 练习10：

package Cycle1;
class TwoMethods{
    public void m1(){
        System.out.println("Inside m1,calling m2");
        m2();
    }
    public void m2(){
        System.out.println("Inside m2");
    }
}
class Inherited extends TwoMethods{
    @Override
    public void m2() {
        System.out.println("Inside Inherited m2");
    }
}
public class E10 {
    public static void main(String[] args) {
        TwoMethods x = new Inherited();
        x.m1();
    }
}


class Pickle{
    Pickle() {
        System.out.println("Pickle");
    }
}
class Sandwich2 extends PortableLunch{
    Bread b = new Bread();
    Cheese c = new Cheese();
    Lettuce l = new Lettuce();
    Pickle p = new Pickle();
    Sandwich2(){
        System.out.println("Sandwich");
    }
}

public class E11 {
    public static void main(String[] args) {
        new Sandwich2();
    }
}


class Member{
    public Member(String id) {
        System.out.println("Member constructor " + id);
    }
}
class Rodent2{
    Member m1 = new Member("r1"),m2 = new Member("r2");

    public Rodent2() {
        System.out.println("Rodent constructor");
    }
    public void hop(){
        System.out.println("Rodent hopping");
    }
    public void scurry(){
        System.out.println("Rodent scurry");
    }
    public void reproduce(){
        System.out.println("Making more Rodents");
    }

    @Override
    public String toString() {
        return "Rodent";
    }
}
class Mouse2 extends Rodent2{
    Member m1 = new Member("m1"),m2 = new Member("m2");

    public Mouse2() {
        System.out.println("Mouse constructor");
    }

    @Override
    public void hop() {
        System.out.println("Mouse1");
    }

    @Override
    public void scurry() {
        System.out.println("Mouse2");
    }
    @Override
    public void reproduce() {
        System.out.println("Mouse3");
    }

    @Override
    public String toString() {
        return "Mouse{}";
    }
}
class Gerbil2 extends Rodent2{
    Member m1 = new Member("g1"), m2 = new Member("g2");
    @Override
    public void hop() {
        System.out.println("Gerbil1");
    }

    @Override
    public void scurry() {
        System.out.println("Gerbil2");
    }

    @Override
    public void reproduce() {
        System.out.println("Gerbil3");
    }

    @Override
    public String toString() {
        return "Gerbil{}";
    }
}
class Hamster2 extends Rodent2{
    Member m1 = new Member("h1"), m2 = new Member("h2");

    public Hamster2() {
        System.out.println("Hamster constructor");
    }

    @Override
    public void hop() {
        System.out.println("Hamster1");
    }

    @Override
    public void scurry() {
        System.out.println("Hamster2");
    }

    @Override
    public void reproduce() {
        System.out.println("Hamster3");
    }

    @Override
    public String toString() {
        return "Hamster{}";
    }
}
public class E12 {
    public static void main(String[] args) {
        new Hamster2();
    }

}

 练习13：（不会）

class Shared{
    private int refcount = 0;
    private static long counter = 0;
    private final long id = counter++;

    public Shared() {
        System.out.println("Creating" + this);
    }
    public void addRef(){
        refcount++;
    }
    protected void finalize(){
        if (refcount != 0)
            System.out.println("Error");
    }
    protected void dispose(){
        if (--refcount == 0){
            System.out.println("Disposing " + this);
        }
    }

    @Override
    public String toString() {
        return "Shared " + id;
    }
}

class Composing{
    private Shared shared;
    private static long counter = 0;
    private final long id = counter++;

    public Composing(Shared shared) {
        System.out.println("Creating " + this);
        this.shared = shared;
        this.shared.addRef();
    }

    protected void dispose(){
        System.out.println("disposing" + this);
        shared.dispose();
    }

    @Override
    public String toString() {
        return "Composing{" +
                + id +
                '}';
    }
}

public class ReferenceCounting {
    public static void main(String[] args) {
        Shared shared = new Shared();
        Composing[] composing = {
                new Composing(shared),
                new Composing(shared),
                new Composing(shared),
                new Composing(shared),
                new Composing(shared),
                new Composing(shared),
                new Composing(shared),
        };
        for (Composing c :
                composing) {
            c.dispose();
        }
        System.gc();
        new Composing((new Shared()));
        System.gc();
    }
}

练习14：（不会）

class RectangularGlyph extends Glyph{
    private int width = 4;
    private int height = 5;

    public RectangularGlyph(int width, int height) {
        this.width = width;
        this.height = height;
        System.out.println("RectangularGlyph.RectangularGlyph(), width = " + width + ", height = " + height);
    }
    void draw(){
        System.out.println("RectangularGlyph.draw(), area = " + width * height);
    }
}
public class E15 {
    public static void main(String[] args) {
        new RoundGlyph(5);
        new RectangularGlyph(2,2);
    }
}

引用，此引用可以指示三种不同的状态。纳入一些可以改变这些状态的方法。

class AlertStatus{
    public String getStatus(){return "None";}
}
class RedAlertStatus extends AlertStatus{
    public String getStatus(){return "Red";}
}
class YelloAlertStatus extends AlertStatus{
    public String getStatus(){return "Yello";}
}
class BlueAlertStatus extends AlertStatus{
    public String getStatus(){return "Blue";}
}
class Starship{
    private AlertStatus status = new BlueAlertStatus();
    public void setStatus(AlertStatus istatus){
        status = istatus;
    }

    @Override
    public String toString() {
        return status.getStatus();
    }
}

public class E16 {
    public static void main(String[] args) {
        Starship eprise = new Starship();
        System.out.println(eprise);
        eprise.setStatus(new RedAlertStatus());
        System.out.println(eprise);
        eprise.setStatus(new YelloAlertStatus());
        System.out.println(eprise);
    }
}

 

package Cycle1;

public class Application {
    public static void main(String[] args) {
        Cycle bi = new Bicycle();
        bi.ride();
        ((Bicycle) bi).balance();
        Cycle tr = new Tricycle();
        tr.ride();
        //((Bicycle)tr).balance();
        Cycle un = new Unicycle();
        un.ride();
        ((Unicycle) un).balance();
    }
}

士千i
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java编程思想练习答案（官方pdf版）
07-31
这个是官方的PDF版答案，非扫描，可复制里面代码
Thinking in Java 中文第四版+习题答案
06-29
第8章 对象的容纳 8.1 数组 8.1.1 数组和第一类对象 8.1.2 数组的返回 8.2 集合 8.2.1 缺点：类型未知 8.3 枚举器（反复器） 8.4 集合的类型 8.4.5 再论枚举器 8.5 排序 8.6 通用集合库 8.7 新集合 8.7.1 使用 8.7.2...
JAVA编程练习50题超详细
热门推荐
殇的不悔
05-13 2万+
java小白
JAVA编程思想第七章练习题
哈喽
03-31 796
package java7; 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...
《Java程序设计基础》第8章习题
weixin_52334299的博客
09-28 657
另一种是委托某个父接口的默认方法。重载是指在同一个类内定义名称相同，但参数个数或者类型不同的方法，而覆盖则是指在子类中，定义名称、参数个数与类型均与父类相同的方法，用以重写父类里同名方法的功能。（4）如果一个类继承一个父类并实现了多个接口，而从父类和接口中继承了同名的方法，此时采用“类比接口优先”的原则，即只继承父类的方法，而忽略来自接口的默认方法。（3）如果多个父接口中的同名方法都是抽象方法，则不会发生名字冲突，实现这些接口的类可以实现该同名方法即可，或者不实现该方法而将自己也声明为抽象类。
java编程思想第四版 第8章习题
qq_36625612的博客
08-11 583
java编程思想第四版 第8章指北
JAVA编程50题及答案
08-05
JAVA编程50题及答案 题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一 对兔子，假如兔子都不死，问每个月的兔子总数为多少？ 1.程序分析： 兔子的规律为数列1...
thinkinjava源码-Thinking-in-Java:ThinkingInJava源代码和练习题
05-20
Java编程思想（第四版） Thinking in Java （Forth Edition） 包含了很多书本中的源代码，因为从官网提供的资源中无法获取源代码。为了更好的学习，决定，手打源代码。一方面练习编程速度，同时记忆代码，学习编程...
亚信java笔试题--:编程资料自行翻译
06-03
亚信java笔试题 ...如果读者们想获得书本之外更多的知识，我们也非常乐意看到你们去读练习题的解决方法。 准确来说，这是一本教科书而不仅仅是一本教程。它专注于解释概念而不是教你怎么一步步去实现的教
JAVA第一阶段基础测试题,java变量,运算符,分支,循环测试题.pdf
10-07
JAVA基础知识点总结 本资源总结了 JAVA 基础知识点，涵盖变量、运算符、分支结构、循环结构和...通过本资源的学习和实践，初学者可以对 JAVA 基础知识有一个系统的了解和掌握，提高自己的编程能力和解决问题的能力。
Java编程思想练习题答案
01-18
学Java一定会看Java编程思想，其练习题更才是精华所在！
Java编程思想练习题
11-10
看到别人共享的15积分，所以我下载下来送给大家，但是积分默认好像最少2积分，所以设置了一下。原本该免费的。
《JAVA编程思想》第四版课后习题答案及书中源代码
09-19
声明一下，我是转载别人的转载，上传在这只是方便大家 买这本书的人一定会想办法弄到书中源代码和课后习题答案，网上关于第四版的还真不多，所以就拿出来共享一下。 其实我也是从别人那里下载下来的，那个课后习题答案我还没有验证是不是正确，不过源代码是没有问题的。 源代码是有ant脚本文件的，如果你安装了ant的话，他会帮你运行一遍这些代码，我也尝试了一下，可是很烦，它的jdk版本要求是1.5，可是我的是1.6的，后来修改了ant脚本文件，但是有些章节的代码还需要其他支持，最后就放弃了，有愿意继续尝试的同志可以继续。 书中的代码第一行都有“//: initialization/Mugs.java”类似这样的注释，这句话是书源代码在initialization文件夹下的Mugs.java文件中。
使用Java理解程序逻辑第8章.zip
04-20
【原创作者田超凡，未经许可请勿转发，侵权仿冒必究】
java编程思想练习答案 the think in Java Annotated Solution Guide
04-12
这是 《java编程思想》（think in java）的章节练习答案。 文件为 pdf 格式，英文版。
【Java】《Java编程思想》笔记（含练习题答案代码）-第二章 一切都是对象
HHLab
03-09 2269
2.1 用引用操纵对象【String】 遥控器（引用）- 电视机（数据）创建String引用，如果向无对象的引用发送信息会返回一个运行时错误，所以安全的做法是：创建一个引用的同时便进行初始化String s =  “asdf”（Java特性：字符串可以用带引号的文本初始化） 2.2 必须由你创建所有对象【new】 New关键字：“给我一个新对象” String s = new
JAVA 编程 练习题
qq_41398448的博客
06-17 1万+
题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？ public class lianxi1 { public static void main(String[] args) { int f1=1,f2=1,f; //f1 f2 分别代表 1月兔子...
JAVA编程思想练习题答案
Mr_yuntuo的博客
04-14 661
最近在学习JAVA编程思想，突然发现好多练习题答案都要积分以及各种要求，所以在这里给大家发一下练习题答案连接，希望对各位有用！ 链接如下： JAVA编程思想练习题答案
java第五章练习题
最新发布
10-19
Java第五章练习题包括数独、矩阵转置、杨辉三角、推箱子游戏、五子棋游戏、统计学生成绩、模拟客车售票和自动批卷程序等八个练习题。这些练习题旨在帮助学习者巩固和提高Java编程的能力。其中，数独、矩阵转置、杨辉...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值