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

2021/6/4 14:21:17

本文主要是介绍java编程思想第四版第九章习题,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

  1. 第三题
    package net.mindview.interfaces;
    abstract class Base{
        public Base(){
            print();
        }
        abstract void print();
    }
    public class Test3 extends Base{
        private int i = 5;
        @Override
        void print() {
            System.out.println(i);
        }
        public static void main(String[] args) {
            Test3 t = new Test3();
            t.print();
        }
    }

    输出结果:

    0
    5

    调用基类构造方法的时候, 只是给子类的成员变量分配了一块内存空间, 并将内存空间的值设置为默认值0. 当真正调用子类构造方法之前才会为成员变量赋值.

  2. 第七题
    package net.mindview.interfaces;
    
    //啮(nie四声)齿动物
    interface Rodent{
      void say();
    }
    
    //老鼠
    class Mouse implements Rodent{
      public void say(){System.out.println("hi,我是 Mouse");}
    }
    
    //鼹鼠
    class Gerbil implements Rodent{
      public void say(){System.out.println("hi,我是 Gerbil");}
    }
    
    //大颊鼠
    class Hamster implements Rodent{
      public void say(){System.out.println("hi,我是 Hamster");}
    }
    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);
        }
    
    }

     

  3. 第八题
    package net.mindview.interfaces;
    
    import java.util.Random;
    
    
    /** 定义一个乐器类 */
    interface Instrucment {
        int value = 5; //定义在接口中的成员是static&final的
        void play(Note n);
        void adjust();
    }
    
    /**抽象类*/
    abstract class PublicMethod implements Instrucment{
        public abstract void play(Note n);
        //这个方法不用谢,以为继承自Object的类都有toString()方法
        //public abstract String toString();
        public abstract void adjust();
    }
    
    /**定义n个子类*/
    class Wind extends PublicMethod {
        public void play(Note n){ System.out.println("Wind.play() " + n);}
        
        public String toString(){ return "Wind.what()";}
        
        public void adjust(){ System.out.println("Wind.adjust()");}
    }
    
    class Purcussion extends PublicMethod{
        public void play(Note n){ System.out.println("Purcussion.play() " + n);}
        
        public String toString(){ return "Purcussion.what()";}
        
        public void adjust(){ System.out.println("Purcussion.adjust()");}
    }
    
    class Stringed extends PublicMethod{
        public void play(Note n){ System.out.println("Stringed.play() " + n);}
        
        public String toString(){ return "Stringed.what()";}
        
        public void adjust(){ System.out.println("Stringed.adjust()");}
    }
    
    class Brass extends Wind{
        public void play(Note n){ System.out.println("Brass.play() " + n);}
        
        public void adjust(){ System.out.println("Brass.adjust()");}
    }
    
    class WoodWind extends Wind{
        public void play(Note n){ System.out.println("WoodWind.play() " + n);}
        
        public String toString(){ return "WoodWind.what()";}
    }
    
    class Other extends Wind{
        public void play(Note n){ System.out.println("Other.play() " + n);}
        
        public String toString(){ return "Other.what()";}
    }
    
    /** 定义一个随机乐器生成器 */
    class RandomInstrucmentGenerator {
        Random rand = new Random(100);
        public Instrucment next(){
            switch(rand.nextInt(6)){
                default:
                case 0: return new Wind();
                case 1: return new Purcussion();
                case 2: return new Stringed();
                case 3: return new Brass();
                case 4: return new WoodWind();
                case 5: return new Other();
                
            }
        }
    }
    
    public class Music5 {
    
        public static void tune(Instrucment i){
            i.play(Note.MIDDLE_C);
            i.toString();
        }
        
        public static void tuneAll(Instrucment[] e){
            for(Instrucment i : e){
                tune(i);
            }
        }
        
        private static RandomInstrucmentGenerator gen = new RandomInstrucmentGenerator();
        public static void main(String[] args) {
            
            
            /*Instrucment[] orchestra = {
                new Wind(),
                new Purcussion(),
                new Stringed(),
                new Brass(),
                new WoodWind(),
                new Other()
            };*/
            Instrucment[] ins = new Instrucment[10];
            for(int i=0; i<ins.length; i++){
                ins[i] = Music5.gen.next();
            }
            
            tuneAll(ins);
        }
    }

     

  4. 练习11--这个练习是巩固如何写适配器设计模式
    package net.mindview.interfaces;
    
    /**
     * 字符串反转类
     */
    public class StringReverse {
        public String name(){
            return getClass().getSimpleName();
        }
        //反转
        public String reverse(String s) {
            char[] array = s.toCharArray();
            String reverse = "";
            for (int i = array.length - 1; i >= 0; i--) {
                reverse += array[i];
            }
            return reverse;
        }
    }
    package net.mindview.interfaces;
    
    public class StringReverseAdapter implements Processor{
        StringReverse stringReverse;
        public StringReverseAdapter(StringReverse stringReverse){
            this.stringReverse = stringReverse;
        }
        @Override
        public String name() {
            // TODO Auto-generated method stub
            return stringReverse.name();
        }
    
        @Override
        public Object process(Object input) {
            // TODO Auto-generated method stub
            return stringReverse.reverse((String)input);
        }
    }

    在使用的时候,可以直接调用Apply的process方法

    public static void main(String[] args) {
            Apply.process(new StringReverseAdapter(new StringReverse()), "i am lily");
        }

    Apply方法没有写出来,这个类实在课文内部定义的,可以参考http://www.cnblogs.com/ITPower/p/8550627.html中第二点:解耦的案例一,案例二和案例三. 其中Apply类定义在案例一中。

  5. 第十二题
    package net.mindview.interfaces;
    
    
    interface CanFight {
        void fight();
    }
    
    interface CanSwim {
        void swim();
    }
    
    interface CanFly {
        void fly();
    }
    
    interface CanClimb {
        void climb();
    }
    
    //行为特征
    class ActionCharacter {
        public void fight(){ }
    }
    
    class Hero extends ActionCharacter implements CanFight,CanSwim,CanFly,CanClimb{
        @Override
        public void fly() { }
        
        @Override
        public void swim() { }
    
        @Override
        public void climb() { }
    } 
    
    
    //冒险
    public class Adventure {
        public static void f(CanFly fly){
            fly.fly();
        }
        public static void s(CanSwim swim){
            swim.swim();
        }
        public static void v(CanFight fight){
            fight.fight();
        }
        public static void m(ActionCharacter ac){
            ac.fight();
        }
        public static void p(CanClimb c){
            c.climb();
        }
        public static void main(String[] args) {
            Hero hero = new Hero();
            f(hero);
            s(hero);
            v(hero);
            m(hero);
            p(hero);
    
        }
    
    }

     

  6. 第十四题:这道题的思想和书上p180页的案例思想一样.继承+多次实现接口
    package net.mindview.interfaces;
    
    interface BaseInterface1 {
        public void a();
        public void b();
    }
    
    interface BaseInterface2 {
        public void c();
        public void d();
    }
    
    interface BaseInterface3 {
        public void e();
        public void f();
    }
    
    interface Interface4 extends BaseInterface1,BaseInterface2,BaseInterface3{
        public void g();
        
    }
    
    class Specific implements Interface4{
        public void h(){ }
    
        @Override
        public void a() { }
    
        @Override
        public void b() { }
    
        @Override
        public void c() { }
    
        @Override
        public void d() { }
    
        @Override
        public void e() { }
    
        @Override
        public void f() { }
    
        @Override
        public void g() { }
    }
    
    
    public class Test14 extends Specific implements Interface4{
        public static void aa(BaseInterface1 b1){
            b1.a();
            b1.b();
        }
        
        public static void bb(BaseInterface2 b){
            b.c();
            b.d();
        }
        
        public static void cc(BaseInterface3 b){
            b.e();
            b.f();
        }
        
        public static void dd(Interface4 b){
            b.g();
        }
        public static void main(String[] args) {
            Specific specific = new Specific();
            aa(specific);
            bb(specific);
            cc(specific);
            dd(specific);
        }
    }

     

  7. 第十六题
    package net.mindview.interfaces;
    
    import java.io.IOException;
    import java.nio.CharBuffer;
    import java.util.Random;
    import java.util.Scanner;
    
    class RandomChar {
        Random rand = new Random(47);
        Random count = new Random(47);
        private static final char[] captials = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray(); 
        public char[] make(){
            StringBuffer sb = new StringBuffer("");
            for(int i=0; i<count.nextInt(10); i++){
                sb.append(captials[rand.nextInt(captials.length)]);
            }
            return sb.toString().toCharArray();
        }
        
        public static void main(String[] args) {
            RandomChar rc = new RandomChar();
            char[] c = rc.make();
            System.out.println(c);
            
            for(char ch:c){
                System.out.print(ch);
            }
        }
    }
    
    public class AdapterRandomChar implements Readable{
        RandomChar rc;
        private int count;
        public AdapterRandomChar(RandomChar rc, int count){
            this.rc = rc;
            this.count = count;
        }
        @Override
        public int read(CharBuffer cb) throws IOException {
            if(count-- == 0){
                return -1;
            }
            StringBuffer sb = new StringBuffer("");
            for(char c:rc.make()){
                sb.append(c);
            }
            String result = sb.toString() + " " ;
            cb.append(result);
            return result.length();
        }
    
        public static void main(String[] args) {
            Scanner s = new Scanner(new AdapterRandomChar(new RandomChar(), 5));
            while(s.hasNext()){
                System.out.print(s.next()+" ");
            }
        }
    }

     

  8. 第十八题
    package net.mindview.interfaces;
    //产品
    interface Cycle {
    }
    
    class Unicycle implements Cycle{
        public Unicycle(){
            System.out.println("我是一个Unicycle");
        }
    }
    
    class Bicycle implements Cycle{
        public Bicycle(){
            System.out.println("我是一个Bicycle");
        }
    }
    
    class Tricycle implements Cycle{
        public Tricycle(){
            System.out.println("我是一个Tricycle");
        }
    }
    
    //工厂类
    interface CycleFactory{
        public Cycle make();
    }
    
    class UnicycleFactory implements CycleFactory{
        @Override
        public Cycle make() {
            return new Unicycle();
        }
        
    }
    
    class BicycleFactory implements CycleFactory{
        @Override
        public Cycle make() {
            return new Bicycle();
        }
        
    }
    
    class TricycleFactory implements CycleFactory{
        @Override
        public Cycle make() {
            return new Tricycle();
        }
        
    }
    
    
    public class CycleCustomer {
        public static Cycle serviceCustoemr(CycleFactory fact){
            return fact.make();
        }
        public static void main(String[] args) {
            Cycle u = serviceCustoemr(new UnicycleFactory());
            Cycle b = serviceCustoemr(new BicycleFactory());
            Cycle t = serviceCustoemr(new TricycleFactory());
    
        }
    
    }

     

  9. 第十九题
    package net.mindview.interfaces;
    
    import java.util.Random;
    
    /**
     * 这时一个抛硬币和掷骰子等类型的框架
     */
    
    interface ThrowProduct {}
    
    class ThrowCorn implements ThrowProduct{
        Random rand = new Random(47);
        public ThrowCorn(){
            if(rand.nextInt(100) %2 ==0){
                System.out.println("硬币的正面");
            }else{
                System.out.println("硬币的反面");
            }
        }
    }
    
    class ThrowDice implements ThrowProduct{
        Random rand = new Random(47);
        public ThrowDice(){
            System.out.println("掷的骰子数是"+rand.nextInt(7));
        }
    }
    
    interface ThrowFactory{
        ThrowProduct throwOut();
    }
    
    class ThrowCornFactory implements ThrowFactory{
        public ThrowCornFactory(){
            System.out.print("开始抛硬币:");
        }
        @Override
        public ThrowProduct throwOut() {
            return new ThrowCorn();
        }
    }
    
    class ThrowDiceFactory implements ThrowFactory{
        public ThrowDiceFactory(){
            System.out.print("开始掷骰子:");
        }
        @Override
        public ThrowProduct throwOut() {
            return new ThrowDice();
        }
    }
    
    
    public class ThrowFrame {
        public static ThrowProduct service(ThrowFactory f){
            return f.throwOut();
        }
        public static void main(String[] args) {
            service(new ThrowCornFactory());
            service(new ThrowDiceFactory());
    
        }
    
    }

    结果:

    开始抛硬币:硬币的正面
    开始掷骰子:掷的骰子数是6

     



这篇关于java编程思想第四版第九章习题的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程