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

已于 2022-08-14 23:28:54 修改
阅读量560 收藏 5
点赞数
分类专栏： java 文章标签： java 开发语言 jvm
于 2022-08-14 12:27:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36625612/article/details/126295092
版权

第9章 多态

练习1：

修改第8章练习9中的Rodent，使其成为一个抽象类。只要有可能就将Rodent的方法声明为抽象方法。

package rodent;
import static testPackage.MyPrint.*;

public abstract class Rodent {

    public Rodent(TotalNum totalNum){
        totalNum.addTotal();
    }

    public abstract void predation();
}

练习2：

创建一个不包含任何抽象方法的抽象类，并验证我们不能为该类创建任何实例。

代码

package rodent;

public abstract class AbstractCompletely {

    public static void main(String[] args) {
//        new AbstractCompletely();
    }
}

编译器报错

练习3：

创建一个基类，让他包含抽象方法print()，并在导出类中覆盖该方法。覆盖后的方法版本可以打印导出类中定义的某个整形变量的值。在第一该变量之处，赋予它非零值。在基类的构造器中调用这个方法。现在，在main()方法中，创建一个导出类对象，然后调用它的print()方法。解释发生的情形。
代码

package rodent;

public abstract class AbstractCompletely {

    public AbstractCompletely(){
        print();
    }

    abstract void print();


    public static class PrintClass extends AbstractCompletely {
        int a = 12;

        public PrintClass() {
            print();
        }

        @Override
        void print() {
            System.out.println(a);
        }
    }

    public static void main(String[] args) {
        PrintClass printClass = new PrintClass();
        printClass.print();
    }
}

输出

0
12
12

输出顺序和运行顺序有关，详见第八章，继承类的执行流程。导出类调用的为覆盖后的方法。

练习4：

创建一个不包含任何方法的基类，从它那里导出一个类，并添加一个方法。创建一个静态方法，它可以接受指向基类的引用，将其向下转型到导出类，然后再调用该静态方法。在main()中，展现它的运行情况。然后，为基类中的方法加上abstract声明，这样就不在需要进行向下转型。

代码


package rodent;

abstract class A {
}

class B extends A {
    void show() {
        System.out.println("B is calling");
    }
}

abstract class C {
    abstract void show();
}

class D extends C {
    @Override
    void show() {
        System.out.println("C is calling");
    }
}

public class Main {
    static void getShow1(A a) {
        ((B) a).show();//必须需要向下转型
    }

    static void getShow2(C c) {
        c.show();//不需要向下转型
    }

    public static void main(String[] args) {
        A a = new B();
        getShow1(a);
        C c = new D();
        getShow2(c);
    }

}

输出

B is calling
C is calling

练习5：

在某个包内创建一个接口，内含三个方法，然后在另一个包中实现此接口。
同练习6；

练习6：

证明接口内所有的方法自动是public
代码

package testInterface;

public interface Instrument {

    void toning();

    void play();

    void maintain();
}
package testPackage;

import testInterface.Instrument;

public class Piano implements Instrument {

    @Override
    public void toning() {

    }

    @Override
    public void play() {

    }

    @Override
    public void maintain() {

    }
}

其他包仍可访问，说明是public。

练习7：

修改第8章中的练习9，使Rodent成为一个接口。
略，修改为接口，然后去掉Rodent构造器，将extend关键字修改为implement即可。

练习8：

在polymorphism.Sandwich.java中，创建接口FastFood并添加合适的方法，然后修改Sandwich以实现FastFood接口。
略。

练习9：

重构Music5.java，将在Wind、Pecussion和Stringed中的公共方法移入一个抽象类中。
略。

练习10：

略。

练习11：

创建一个类，它有一个方法用于接受一个Sting类型的参数，生成的结果是将该参数的每一对字符串进行互换。对该类进行适配，使得它可以用于interfaeprocessor.Apply.process。
代码

package processor;

public interface Processor {
    String name();

    Object process(Object input);
}
package processor;

public class SwapStringAdapter implements Processor {

    @Override
    public String name() {
        return toString();
    }

    @Override
    public Object process(Object input) {
        String s = "";
        try {
            char temp;
            char[] chars = ((String) input).toCharArray();
            for (int i = 0; i < chars.length; i += 2) {
                temp = chars[i];
                chars[i] = chars[i + 1];
                chars[i + 1] = temp;
            }
            s = String.copyValueOf(chars);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return s;
    }
}
package processor;

public class Apply {
    public static void process(Processor processor,Object s){
        System.out.println("using processor: "  + processor.name());
        System.out.println(processor.process(s));
    }
}
package processor;

public class Main {
    public static void main(String[] args) {
        Apply.process(new SwapStringAdapter(),"new String");
    }
}

输出

using processor: processor.SwapStringAdapter@4554617c
en wtSirgn

此题看起有些复杂，实际上只需要将Apply方法理解为一个黑盒，接受Processor工具对象，和待处理对象，产生对应的输出，还是很简单的。

练习12：

在Adventure.java中，按照其他接口的样式，增加一个CanClimb接口。
代码

package adventure;

public interface CanClimb {
    void climb();
}
package adventure;

public interface CanFight {
    void fight();
}
package adventure;

public interface CanFly {
    void fly();
}
package adventure;

public interface CanSwim {
    void swim();
}
package adventure;

public class ActionCharacter {
	//和CanFight相同特征签名的方法
    public void fight() {
        System.out.println("ActionCharacter fight");
    }
}
package adventure;

import static testPackage.MyPrint.*;

public class Hero extends ActionCharacter implements CanClimb, CanFight, CanFly, CanSwim {
    @Override
    public void climb() {
        println("Hero climb");
    }

    @Override
    public void fly() {
        println("Hero climb");
    }

    @Override
    public void swim() {
        println("Hero climb");
    }
}
package adventure;

public class Adventure {
    public static void t(CanFight canFight) {
        canFight.fight();
    }

    public static void u(CanClimb canClimb) {
        canClimb.climb();
    }

    public static void v(CanFly canFly) {
        canFly.fly();
    }

    public static void w(CanSwim canSwim) {
        canSwim.swim();
    }

    public static void x(ActionCharacter character) {
        character.fight();
    }

    public static void main(String[] args) {
        Hero hero = new Hero();
        t(hero);
        u(hero);
        v(hero);
        w(hero);
        x(hero);
    }
}

输出

ActionCharacter fight
Hero climb
Hero climb
Hero climb
ActionCharacter fight

练习13：

创建一个接口，并从该接口继承两个接口，然后从后面两个接口多重继承第三个接口。（c++菱形问题，java对于相同名称的方法认为是同一个方法）。
代码

package multipleInheritance;

public interface First {
    void output();
}
package multipleInheritance;

public interface SecondA extends First {
    @Override
    void output();
}
package multipleInheritance;

public interface SecondB extends First{
    @Override
    void output();
}
package multipleInheritance;

public interface Third extends SecondA,SecondB{
    @Override
    void output();
}
package multipleInheritance;

public interface Fourth extends Third{
    @Override
    void output();
}
package multipleInheritance;

public class Main implements Fourth {

    @Override
    public void output() {
        System.out.println("Main output");
    }

    public static void main(String[] args) {
        Main main = new Main();
        main.output();
    }
}

输出

Main output

练习14：

创建三个接口，每个接口都包含两个方法。继承出一个接口，它组合了这三个接口并添加了一个新方法。创建一个实现了该新接口并且继承了某个具体类的类现在编写四个方法，每一个都接受这四个接口之一作为参数。在main()方法中，创建这个类的对象，并将其传递给这四个方法。
略，此题类似于将练习12和练习13组合起来。

练习15：

将前一个练习修改为：创建一个抽象类，并将其继承到一个导出类中。
略。

练习16：

创建一个类，它将生成一个char序列，适配这个类，使其可以成为Scanner对象的一种输入。
代码

package scannerAdapter;

import java.util.Random;

public class RandomChar {
    private static final Random random = new Random(47);

    public char next() {
        return (char) random.nextInt();
    }
}

package scannerAdapter;

import java.io.IOException;
import java.nio.CharBuffer;
import java.util.Scanner;

public class RandomCharAdapter extends RandomChar implements Readable {

    private int count;

    public RandomCharAdapter(int count) {
        this.count = count;
    }

    @Override
    public int read(CharBuffer cb) throws IOException {
        if (count-- == 0) {
            return -1;
        }
        String a = next() + " ";
        cb.append(a);
        return cb.length();
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(new RandomCharAdapter(10));
        while (scanner.hasNext()) {
            System.out.println(scanner.next());
        }
    }
}

输出

䊕
Ԗ
ફ
汊
䰃
ꛛ
⍨
榱
ࢴ

应该是对应int值的原因，输出一堆火星文，Random类不熟悉。
测试发现，输出int都是这样的：

-1172028779
1717241110
-2014573909
229403722
688081923
-1812486437
809509736
1791060401
-2076178252
-1128074882

有时间还要研究一下。

练习17：

证明在接口中的域隐式地是static和final的。
略。这个很显然。

练习18：

创建一个Cycle接口及其Unicycle、Bicycle和Tricycle实现。对每种类型的Cycle都创建相应的工厂，然后编写代码使用这些工厂。
代码

package testPackage;

import static testPackage.MyPrint.*;

public interface Cycle {

    public void produce();


    public static class Unicycle implements Cycle {
        @Override
        public void produce() {
            println("Unicycle produce");
        }
    }

    public static class Bicycle implements Cycle {
        @Override
        public void produce() {
            println("Bicycle produce");
        }

    }

    public static class Tricycle implements Cycle {
        @Override
        public void produce() {
            println("Tricycle produce");
        }
    }

    interface ProduceFactory {
        Cycle produceCycle();
    }

    class UnicycleFactory implements ProduceFactory {

        @Override
        public Cycle produceCycle() {
            println("UnicycleFactory");
            return new Unicycle();
        }
    }

    class BicycleFactory implements ProduceFactory {

        @Override
        public Cycle produceCycle() {
            println("BicycleFactory");
            return new Unicycle();
        }
    }

    class TricycleFactory implements ProduceFactory {

        @Override
        public Cycle produceCycle() {
            println("TricycleFactory");
            return new Tricycle();
        }
    }

    class Cycles {
        static void produceCycle(ProduceFactory produceFactory) {
            produceFactory.produceCycle().produce();
        }

        public static void main(String[] args) {
            produceCycle(new UnicycleFactory());
            produceCycle(new BicycleFactory());
            produceCycle(new TricycleFactory());
        }
    }
}

输出

UnicycleFactory
Unicycle produce
BicycleFactory
Unicycle produce
TricycleFactory
Tricycle produce

练习19：

使用工厂方法编写一个框架，它可以执行抛硬币和掷骰子功能。
代码

package testPackage;

import static testPackage.MyPrint.*;

public interface Game {
    void play();

    class Coins implements Game {

        @Override
        public void play() {
            println("tossing");
        }
    }

    class Throw implements Game {
        @Override
        public void play() {
            println("throwing");
        }
    }

    interface GameFactory {
        Game getGame();
    }

    class CoinsFactory implements GameFactory {
        @Override
        public Game getGame() {
            return new Coins();
        }
    }

    class ThrowFactory implements GameFactory {
        @Override
        public Game getGame() {
            return new Throw();
        }
    }

    class Player {
        static void playGames(GameFactory factory) {
            factory.getGame().play();
        }

        public static void main(String[] args) {
            playGames(new CoinsFactory());
            playGames(new ThrowFactory());
        }
    }
}

输出

tossing
throwing

第九章备注

优先使用类而不是接口。如果设计中需要某个接口，则必须了解它。否则不到迫不得已，不要将其放到设计中。

enjoy蓝影
关注
专栏目录
Java编程思想第四版读书笔记——第九章 接口
severusyue的博客
06-27 1645
这章介绍了适配器设计模式和策略设计模式。 第九章  接口 接口和内部类为我们提供了一种将接口与实现分离的更加结构化的方法。 1、抽象类和抽象方法 public abstract void f(); 创建抽象类是希望通过这个通用接口操纵一系列类。如果一个类包含大于等于一个抽象方法，那么这个类就是抽象类，必须用abstract关键字来限定这个抽象类。 如果试图直接创
Java编程思想第四版第十五章习题（一）
Jieker的博客
08-13 591
1Use Holder3 with the typeinfo.pets library to show that a Holder3 that isspecified to hold a base type can also hold a derived type. package job; import typeinfo.pets.*; class Holder<T> { ...
Java-Java编程思想第四版 第九章 练习
VimGuy的博客
02-12 474
练习abstract class A{ abstract void print(); public A(){print();} } public class Ja9_1_3 extends A{ int i=5; void print(){ System.out.println(i); } public static void mai...
JAVA-编程思想-第四版-第九章个人练习
小甜甜专栏
12-15 1481
练习14： package inter; public class Test { public static void main(String[] args) { D d=new D(); d.a(d); d.b(d); d.c(d); d.abc(d); } } interface A{ void a1(); void a2(); }; interfac
Java编程思想第九章"接口与工厂"的部分练习题
hi__study的博客
04-10 336
因为练习题18和练习题19差不多，所以这里我决定实现练习题19。 练习题19：使用工厂方法来创建一个框架，它可以执行抛硬币和掷骰子功能。 实现如下： 游戏抽象接口及实现类如下： public interface Game { void play(); } public class TossACoin implements Game { private Random r...
JAVA编程思想第九章练习
哈喽
04-04 348
练习1： package Cycle1; abstract class Rodent1{ public abstract void hop(); public abstract void scurry(); public abstract void reproduce(); } class Mouse1 extends Rodent1{ @Override public void hop() { System.out.print..
读书笔记：《Java编程思想第四版》练习题答案.zip
最新发布
07-23
读书笔记：《Java编程思想第四版》练习题答案
java变成思想第四版中文版 练习题答案
07-19
通过《Java编程思想》第四版的中文版练习题答案，你可以对照书中内容，逐一解决练习中的问题，加深对Java语言的理解，提高编程技能。同时，理论知识结合实际练习，将有助于你更好地掌握这些关键知识点。
Java编程思想第四版第十二章习题(中）
Jieker的博客
08-02 559
10.Create a class with two methods, f() and g(). In g(), throw an exception of a new type that you define. In f(), call g(), catch its exception and, in the catch clause, throw a different exception (...
Java编程思想第9章答案（2）
returnadsss的博客
12-07 212
11、 package interfaces.interfaceprocessor; class Re{ String get(String c) { int l=c.length(); char[] ch=new char[l]; if(l%2==0) { for(int i=0;i<l;i+=2) { ch[i]=c.charAt(i+1); ch[i+1]=c.charAt(i); } return new String(ch); } else { for(
java编程思想第四版第9章学习笔记
小甜甜专栏
11-18 1438
练习3： public class MainTest { public static void main(String args[]){ Bcycle b=new Bcycle(); b.print(); } /** * 输出： * --Bcycle-------47 * ----print---
Java编程思想第九章总结+练习
weixin_54932155的博客
10-21 222
1.抽象类 java提供一个叫做抽象类。若类中包含抽象方法，该类必须限定为抽象的。 编译器不会为抽象类创建对象。 如果继承了一个抽象类，那么导出类必须实现继承的抽象方法。如果不这样，那么导出类也是抽象类，必须有abstract关键字。 练习一： import java.util.Random; abstract class Rodent{ abstract void voice(); abstract void eat(); } class Mouse extends Rodent { .
《java编程思想——第九章(接口)》
ByteX的博客
12-11 376
接口 接口与内部类为我们提供了一种将接口与实现分离的更加结构化的方法。 9.1 抽象类和抽象方法 抽象方法：仅有声明没有方法体。 抽象类：包含抽象方法的类叫抽象类。包含抽象方法的类必须是抽象的。 抽象类特性：不能为抽象类创建对象；继承抽象类必须覆盖基类所有抽象方法；抽象类可以没有抽象方法。 抽象方法：abstract void f() 抽象类使类的抽象性明确起来，重构...
Java编程思想第四章练习题9：斐波那契数列
hi__study的博客
03-25 337
习题：一个斐波那契数列是由数字1、1、2、3、5、8、13、21、34等等组成的，从第3个数字起每个数字都是前两个数字的和，创建一个方法，接受一个整数参数，并显示从第1个元素开始总共由该参数指定的个数所构成的所有斐波那契数字。 解答： /** * 斐波那契数列的前n项 * * @param n */ public void fibona...
java程序编程题答案第九章,Java语言程序设计(一)课后习题第九章(附答案)
weixin_30316287的博客
03-11 564
九、Java Applet概述1．下列方法中，哪一个不是Applet的基本方法()A、init()B、run()C、stop()D、start()2．在Java中判定Applet的来源的方法有()A、getcodebase()B、get文档base()C、getCodeBase()D、get文档Bade()3.下面关于Applet的说法正确的是A、 Applet也需要main方法B、 Applet...
JAVA编程思想学习总结：第9章接口
kkk6285137的专栏
05-20 984
（1）抽象和接口 Java提供一个叫做抽象方法的机制，这种方法是不完整的，仅有声明而没有方法体。在方法声明前加关键字abstract。包含抽象方法的类叫做抽象类。如果一个类包含一个或多个抽象方法，该类必须被限定为抽象的（在其定义前添加abstract关键字）。 抽象类不允许直接创建新对象，必须通过通过继承抽象类后，并为所有抽象方法提供方法定义后，才能创建该导出类对象，如果不为所有抽象方法提供方
Java编程思想第九章习题（1）
returnadsss的博客
12-06 215
1、 package ch8; import java.util.*; abstract class Rodent{ abstract void shout(); } class Mouse extends Rodent{ void shout() { System.out.println("Mouse"); } } public class UseRodent { public static void main(String[] args) { Mouse m=new Mouse(); m.s
【JAVA】 抽象类和接口
loyd3的博客
03-21 339
抽象类和抽象方法 抽象方法只有声明没有方法体，其语法如下： abstract void f() 含有抽象方法的类叫抽象类，要被abstract修饰 抽象类中可以没有抽象方法 抽象类不能新建对象 如果继承了抽象类并想要新建新类的对象，必须实现基本类的所有抽象方法（完成方法体）。如果没有实现，则衍生类也是抽象类，且编译器会强迫在类名前加abstract关键字 见下图： 见下面抽象类和抽象方法的例子： //: Music4.java // Abstract classes and methods impo
《Java编程思想》第四版解读书籍
"《Java编程思想》第四版答案解析" 《Java编程思想》是 Bruce Eckel 所著的一本经典 Java 编程教材，第四版在2006年出版，其对应的解答指南于2007年发布。这本书深入浅出地介绍了 Java 语言的核心概念和技术，旨在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值