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

1. 第三题

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

   输出结果:

   调用基类构造方法的时候, 只是给子类的成员变量分配了一块内存空间, 并将内存空间的值设置为默认值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 = ; //定义在接口中的成员是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();
       public Instrucment next(){
           switch(rand.nextInt()){
               default:
               case : return new Wind();
               case : return new Purcussion();
               case : return new Stringed();
               case : return new Brass();
               case : return new WoodWind();
               case : 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[];
           for(int i=; 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 - ; i >= ; 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();
       Random count = new Random();
       private static final char[] captials = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray();
       public char[] make(){
           StringBuffer sb = new StringBuffer("");
           for(int i=; i<count.nextInt(); 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-- == ){
               return -;
           }
           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(), ));
           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();
       public ThrowCorn(){
           if(rand.nextInt() % ==){
               System.out.println("硬币的正面");
           }else{
               System.out.println("硬币的反面");
           }
       }
   }
   
   class ThrowDice implements ThrowProduct{
       Random rand = new Random();
       public ThrowDice(){
           System.out.println("掷的骰子数是"+rand.nextInt());
       }
   }
   
   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