Java-Java编程思想第四版 第九章 练习

练习

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 main(String[] args){
        Ja9_1_3 j=new Ja9_1_3();
        j.print();
    }
}
/*
 *output:
 0
 5
 * */

练习4：

import static net.mindview.util.Print.*;
abstract class Dad {}

class Son extends Dad {
	protected void print() { System.out.println("Son"); }
}

abstract class SecondDad {
	abstract protected void print();
}

class SecondSon extends SecondDad {
	protected void print() { System.out.println("SecondSon"); }
}

public class Ja9_1_4 {
	public static void testPrint(Dad d) {
		((Son)d).print();//it's necessary
	}
	public static void secondTestPrint(SecondDad sd) {
		sd.print();//don't need ((SecondSon)sd)
	}
	public static void main(String[] args) {
		Son s = new Son();
		Ja9_1_4.testPrint(s);
		SecondSon ss = new SecondSon();
		Ja9_1_4.secondTestPrint(ss);			
	}
}

练习5：

package net.mindview.util;
public interface Ja9_2_5b{
    void first();
    void second();
    void third();
}

import net.mindview.util.Ja9_2_5b;
import static net.mindview.util.Print.*;
public class Ja9_2_5 implements Ja9_2_5b{
    public void first(){print("first()");}
    public void second(){print("second()");}
    public void third(){print("third()");}
    public static void main(String[] args){
        Ja9_2_5 ja=new Ja9_2_5();
        ja.first();
        ja.second();
        ja.third();
    }
}

练习7：

import static net.mindview.util.Print.*;
public class Ja9_2_7{
    public static void main(String[] args) {
         Mouse m=new Mouse();
         Gerbil[] gb={new Gerbil(m),new Gerbil(m),new Gerbil(m),new Gerbil(m),};
         for(Gerbil g:gb){g.dispose();}
    }
}
 interface Rodent{
    public void hop();
    public void scurry();
    public void reproduce();
    public String toString();
}
class Mouse implements Rodent{
    private static int refcount=0;
    private static int count=0;
    private final int id=count++;
    public void refAdd(){refcount++;}
    protected void dispose(){if(--refcount==0)print("Disposing "+this);}
    public String toString(){return "Mouse "+id;}
    public Mouse(){print("Creating "+this);}

    public void hop() {System.out.println("Mouse hopping");}
    public void scurry() {System.out.println("Mouse scurrying");}
    public void reproduce() {System.out.println("Making more Mice");}
}
class Gerbil implements Rodent{
    private static int count=0;
    private final int id=count++;
    private Mouse m;
    public String toString(){return "Gerbil "+id;}
    public Gerbil(Mouse m){this.m=m; m.refAdd(); print("Creating "+this);}
    protected void dispose(){print("Disposing "+this);m.dispose();}

    public void hop() {System.out.println("Gerbil hopping");}
    public void scurry() {System.out.println("Gerbil scurrying");}
    public void reproduce() {System.out.println("Making more Gerbil");}
}
class Hamster implements Rodent{
    public void hop() {System.out.println("Hamster hopping");}
    public void scurry() {System.out.println("Hamster scurrying");}
    public void reproduce() {System.out.println("Making more Hamster");}
    public String toString() {return "Hamster";}
}

练习8：

import static net.mindview.util.Print.*;

class Meal {
  Meal() { print("Meal()"); }
}

class Bread {
  Bread() { print("Bread()"); }
}

class Cheese {
  Cheese() { print("Cheese()"); }
}

class Lettuce {
  Lettuce() { print("Lettuce()"); }
}

class Lunch extends Meal {
  Lunch() { print("Lunch()"); }
}

class PortableLunch extends Lunch {
  PortableLunch() { print("PortableLunch()");}
}
interface FastFood{
    void first();
    void second();
    void third();
}
public class Ja9_2_8 extends PortableLunch implements FastFood{
  private Bread b = new Bread();
  private Cheese c = new Cheese();
  private Lettuce l = new Lettuce();
 // public Sandwich() { print("Sandwich()"); }
  public void first(){print("first()");}
    public void second(){print("second()");}
    public void third(){print("third()");}
  public static void main(String[] args) {
    Ja9_2_8 ja=new Ja9_2_8();
    ja.first();ja.second();ja.third();
  }
}

练习10：

import polymorphism.music.Note;
import static net.mindview.util.Print.*;

interface Playable{
     void play(Note n); // Automatically public
}
interface Instrument {
  int VALUE = 5; // static & final
 
  void adjust();
}

class Wind implements Instrument,Playable{
  public void play(Note n) {
    print(this + ".play() " + n);
  }
  public String toString() { return "Wind"; }
  public void adjust() { print(this + ".adjust()"); }
}

class Percussion implements Instrument,Playable{
  public void play(Note n) {
    print(this + ".play() " + n);
  }
  public String toString() { return "Percussion"; }
  public void adjust() { print(this + ".adjust()"); }
}

class Stringed implements Instrument,Playable{
  public void play(Note n) {
    print(this + ".play() " + n);
  }
  public String toString() { return "Stringed"; }
  public void adjust() { print(this + ".adjust()"); }
}

class Brass extends Wind {
  public String toString() { return "Brass"; }
}	

class Woodwind extends Wind {
  public String toString() { return "Woodwind"; }
}

public class Ja9_2_10{
  static void tune(Playable i) {
    i.play(Note.MIDDLE_C);
  }
  static void tuneAll(Playable[] e) {
    for(Playable i : e)
      tune(i);
  }	
  public static void main(String[] args) {
    Playable[] orchestra = {
      new Wind(),
      new Percussion(),
      new Stringed(),
      new Brass(),
      new Woodwind()
    };
    tuneAll(orchestra);
  }
}

练习11：

import  interfaces.interfaceprocessor.*; 
import static net.mindview.util.Print.*;
import java.util.*;
class A {
    public String name(){
        return getClass().getSimpleName();
    }
    public String process(Object input){return (String)input;}
}
class AAdapter implements Processor{
    A a;
    public AAdapter(A a){
        this.a=a;
    }
    public String name(){return a.name();}
    public String process(Object input){return a.process(input);}
}
class B extends A{
    public String process(Object input){
        String m[]=((String)input).split(" ");
        for(int i=0;i<m.length-1;i=i+2){String temp; temp=m[i];m[i]=m[i+1];m[i+1]=temp;}
        return Arrays.toString(m);
    }
}
public class Ja9_3_11{
    public static void main(String[] args){
        String s="Thinking in Java!";
        Apply.process(new AAdapter(new B()),s);
    }
}
/*Using Processor B
[in, Thinking, Java!]*/

练习12：

//: interfaces/Adventure.java
// Multiple interfaces.

interface CanClim{
    void play();
}

interface CanFight {
  void fight();
}

interface CanSwim {
  void swim();
}

interface CanFly {
  void fly();
}

class ActionCharacter {
  public void fight() {}
  public void play(){}
}	

class Hero extends ActionCharacter
    implements CanFight, CanSwim, CanFly, CanClim{
  public void swim() {}
  public void fly() {}
}

public class Ja9_3_12{
  public static void t(CanFight x) { x.fight(); }
  public static void u(CanSwim x) { x.swim(); }
  public static void v(CanFly x) { x.fly(); }
  public static void w(ActionCharacter x) { x.fight(); }
  public static void p(CanClim x){x.play();}
  public static void main(String[] args) {
    Hero h = new Hero();
    t(h); // Treat it as a CanFight
    u(h); // Treat it as a CanSwim
    v(h); // Treat it as a CanFly
    w(h); // Treat it as an ActionCharacter
    p(h);
  }
} ///:~

练习13：

import static net.mindview.util.Print.*;
interface A{void aa();}
interface B extends A{void bb();}
interface C extends A{void cc();}
interface D extends B,C{void dd();} //extends can be variable
public class Ja9_3_13 implements D {
    public void aa(){print("aa");}
    public void bb(){print("bb");}
    public void cc(){print("cc");}
    public void dd(){print("dd");}
    public static void main(String[] args){
        Ja9_3_13 ja=new Ja9_3_13();
        ja.aa();
        ja.bb();
        ja.cc();
        ja.dd();
    }
}

练习14：

import static net.mindview.util.Print.*;
interface A{void a1(); void a2();}
interface B{void b1(); void b2();}
interface C{void c1(); void c2();}
interface D extends A,B,C{void d();}

public class Ja9_5_14 implements D{
    public void a1(){print("a1");}
    public void a2(){print("a2");}
    public void b1(){print("b1");}
    public void b2(){print("b2");}
    public void c1(){print("c1");}
    public void c2(){print("c2");}
    public void d(){print("d");}
    public static void main(String[] args){
        Ja9_5_14 ja=new Ja9_5_14();
        ja.a1();
        ja.a2();
        ja.b1();
        ja.b2();
        ja.c1();
        ja.c2();
        ja.d();
    }

}

练习15：

import static net.mindview.util.Print.*;
abstract class A{
    abstract void a1();
    abstract void a2();
    abstract void b1();
    abstract void b2();
    abstract void c1();
    abstract void c2();
    abstract void d();

}
public class Ja9_5_15 extends A{
    void a1(){print("a1");}
    void a2(){print("a2");}
    void b1(){print("b1");}
    void b2(){print("b2");}
    void c1(){print("c1");}
    void c2(){print("c2");}
    void d(){print("d");}
    public static void main(String[] args){
        Ja9_5_15 ja=new Ja9_5_15();
        ja.a1();
        ja.a2();
        ja.b1();
        ja.b2();
        ja.c1();
        ja.c2();
        ja.d();
    }
}

练习16：

import java.util.*;
import java.nio.*;
import static net.mindview.util.Print.*;
class RandomChars{
    private static Random rd=new Random();
    public char next(){return (char)(rd.nextInt(100)+2);}//the way to produce random between [2,100-2+1]; turn int to char
}
public class Ja9_6_16 extends RandomChars implements Readable{
    private int count; 
    public Ja9_6_16(int count){this.count=count;}
    public int read(CharBuffer cb){
        if(count--==0){return -1;}
        String result=Character.toString(next())+" ";// method next() can be inferred directly!
        cb.append(result);
        return result.length();
    }

    public static void main(String[] args){
        Scanner s=new Scanner(new Ja9_6_16(7));
        while(s.hasNext()){
            print(s.next()+" ");//the difference between next() and nextInt()
        }
    }
} 

PS：这一题明确了产生随机数的方法；明确了导出类可以直接调用基类的方法； Scanner的next（）方法比nextInt()等方法更强大；Readable接口的read()方法会被Scanner反复调用直到返回值为-1；产生char的方法是产生int序列，再转型成char序列。

练习17：

import static net.mindview.util.Print.*;
interface A{
    int a=1,b=2;
}
public class Ja9_7_17 implements A{
    public static void main(String[] args){
    print(a+"  "+b);   
    //!a=2;
    }
}

练习18：

import static net.mindview.util.Print.*;
interface Cycle{void produce();}
interface CycleFactory{Cycle getCycle();}
class Unicycle implements Cycle{public void produce(){print("it's Unicycle");}}
class Bicycle implements Cycle{public void produce(){print("it's Bicycle");}}
class Tricycle implements Cycle{public void produce(){print("it's Tricycle");}}
class UnicycleFactory implements CycleFactory{
    public Cycle getCycle(){return new Unicycle();}
}
class BicycleFactory implements CycleFactory{
    public Cycle getCycle(){return new Bicycle();}
}
class TricycleFactory implements CycleFactory{
    public Cycle getCycle(){return new Tricycle();}
}
public class Ja9_9_18{
    static void make(CycleFactory cf){
        Cycle c=cf.getCycle();
        c.produce();
    }
    public static void main(String[] args){
        make(new UnicycleFactory());
        make(new BicycleFactory());
        make(new TricycleFactory());
    }
}