thinking in java test chapter9接口（11）~（19）适配器模式,工厂模式

练习（11）：创建一个类，它有一个方法用于接受一个String类型的参数，生成的结果是将该参数中每一个字符进行互换。对该类进行适配，使得它可以用于interfaceprocessor.Apply.process()。

适配器设计模式，就是接受你所拥有的接口，并产生你所需要的接口。

这里我们可以写一个adapter类，它继承了interfaceprocessor里的processor接口，并且有一个你所编写的类成员对象，在他的process方法里，调用了你所编写的类的转换方法。

public class StringChange {
public String name(){
return getClass().getSimpleName();
}
public String change(String str){
char[] chars = str.toCharArray();

int length = chars.length - 1;
for (int i = 0; i < length/2; i++) {
char a = chars[i];
chars[i] = chars[length -i];
chars[length - i] = a;
}
StringBuilder builder = new StringBuilder();
for (char a :
chars) {
builder.append(a);
}
return builder.toString();
}
public static void main(String[] args){
String str = "abcdefg";
Apply.process(new StringAdapter(new StringChange()),str);
}
}
class StringAdapter implements Processor{
StringChange sc;
public StringAdapter(StringChange stringChange){
sc = stringChange;
}
@Override
public String name() {
return sc.name();
}
@Override
public Object process(Object input) {//关键部分，连接你的接口与提供的接口
return sc.change((String) input);
}
}

练习（12）：在Adventure.java中，按照其他接口的样式，增加一个CanClimb接口。

练习（13）：创建一个接口，并从该接口继承两个接口，然后从后面两个接口多重继承第三个接口。

public class Adventure {
}
interface CanDo{//1，创建一个接口
void dodo();
}
interface CanFight extends CanDo,CanFly{//2，继承，多重继承第三个接口
void fight();
}
interface CanSwim extends CanDo,CanFly{//接口是可以多重继承的,因为接口是完全抽象的，没有任何具体实现
void swim();
}
interface CanFly{
void fly();
}
interface CanCimb{//创建一个新接口
void climb();
}
class ActionCharacter{
public void fight(){}//该方法与接口CanFight中的方法同名，所以Hero类继承该类与CanFight接口但不需要显示的写fight方法
}
class Hero extends ActionCharacter implements CanFight,CanFly,CanSwim,CanCimb{
@Override
public void swim() {}
@Override
public void fly() {}
@Override
public void climb() {}
@Override
public void dodo() {}
}

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

public class Test14 {
public static void main(String[] args){
CanDoAll cda = new CanDoAll();
cda.doFirst(cda);
cda.doSecond(cda);
cda.doThird(cda);
cda.doAll(cda);
}
}
interface First{
void doF();
void drawF();
}
interface Second{
void doS();
void drawS();
}
interface Third{
void doT();
void drawT();
}
interface All extends First,Second,Third{
void doAll();
}
class CanDoAll extends Test1 implements All{
public void doFirst(First f){
System.out.println("doFirst");
}
public void doSecond(Second s){
System.out.println("doSecond");
}
public void doThird(Third t){
System.out.println("doThird");
}
public void doAll(All a){
System.out.println("doAll");
}
@Override
public void doF() {}
@Override
public void drawF() {}
@Override
public void doS() {}
@Override
public void drawS() {}
@Override
public void doT() {}
@Override
public void drawT() {}
@Override
public void doAll() {
}
}

可以看到，虽然java中没有类似c++继承多个类，接口使我们可以将一个类向上转型为多种类型，也可认为是多重继承。

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

public class Test14 {
public static void main(String[] args){
CanDoAll cda = new CanDoAll();
cda.doFirst(cda);
}
}
abstract class First{
void doF(){};
void drawF(){};
}
class CanDoAll extends First{
public void doFirst(First f){
System.out.println("doFirst");
}
}

练习（16）：创建一个类，它将生成一个char序列，适配这个类，使其可以成为Scanner对象的一种输入.

public class Test16 {
public static void main(String[] args){
Scanner s = new Scanner(new CharAdapter(10));
while (s.hasNext()){
System.out.println(s.next());
}
}
}
class MyChar {
private static Random rand = new Random(1000);
public char next(){
return (char) rand.nextInt(50);
}
}
class CharAdapter extends MyChar implements Readable{
private int count ;
public CharAdapter(int i){
count = i;
}
@Override
public int read(CharBuffer cb) throws IOException {
if (count -- == 0){
return -1;
}
cb.append(next());
return cb.length();
}
}

练习（17）：证明在接口中的域隐式的是static和final的。

在Java SE5之前，没有enum，所以那时候都是用接口来实现类似enum的功能。

public class Test17 {
public static void main(String[] args){
ceshi c = new ceshi();
System.out.println(c.j);
ceshi c1 = new ceshi();
System.out.println(c1.j);
//两个输出一样，证明是static的
}
}
interface yu{
int i = 10;
int j = 20;
}
class ceshi implements yu{
void add(){
//        i++;//编译器报错，can not assign a value to final variable
}
}

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

public class Test18 {
public static void main(String[] args){
new UniFactory().getUnicycle();
new BiFactory().getBicy();
new TriFactory().getTri();
}
}
interface Cycle{
void ride();
}
class Unicycle implements Cycle{
@Override
public void ride() {
System.out.println("Unicycle");
}
}
class UniFactory {
public Unicycle getUnicycle(){
return new Unicycle();
}
}
class Bicycle implements Cycle{
@Override
public void ride() {
System.out.println("Bicycle");
}
}
class BiFactory {
public Bicycle getBicy(){
return new Bicycle();
}
}
class Tricycle implements Cycle{
@Override
public void ride() {
System.out.println("Tricycle");
}
}
class TriFactory {
public Tricycle getTri(){
return new Tricycle();
}
}

练习（19）：使用工厂方法来创建一个框架，它可以执行抛硬币和掷骰子功能。

public class PlayGame {
public static void main(String[] args){
PlayYingBi yingBi = new PlayYingBi();
PlayShaiZi shaiZi = new PlayShaiZi();
gameFactory factory = new gameFactory();
factory.play(yingBi);
factory.play(shaiZi);
}
}
interface Play{
void game();
}
interface PlayFactory{
void play(Play play);
}
class PlayYingBi implements Play {
@Override
public void game() {
System.out.println("抛硬币");
}
}
class PlayShaiZi implements Play{
@Override
public void game() {
System.out.println("掷骰子");
}
}
class gameFactory implements PlayFactory{
@Override
public void play(Play p) {
p.game();
}
}