TIJ-4Edition-接口

1、抽象类和抽象方法

　　包含抽象方法的类叫做抽象类。只要类中包含抽象方法，就要声名为抽象类。

　　导出类会继承基类的所有方法，因此如果没有覆写（实现）基类中的所有抽象方法，

　　就必须声名为抽象类。

2、接口

　　interface声名一个接口，接口是比抽象类更加抽象的存在。

　　除了默认方法和静态方法，接口中的其他方法都没有提供实现。

　　接口中的方法默认是public的。实现接口方法时，必须将其声名为public的。

　　接口可以包含域，但是这些域隐式地是public、static 和 final的。

　　一个类只能继承一个基类，但是能实现多个接口。extends在前，implement在后。

　　接口允许多重继承。

　　接口可以嵌套，但是由于接口中元素必须是public的，因此嵌套接口自动（只能）是public的。

　　实现接口时，不需要实现它内部嵌套的接口。

3、接口与工厂

　　更准确地说，这是工厂方法的实现。

　　在工厂方法设计模式中，每一个类都有自己的工厂。

　　而不是简单工厂一样，一个工厂就实现了所有类的对象创建。

//: interfaces/Factories.java
import static net.mindview.util.Print.*;

interface Service {
  void method1();
  void method2();
}

interface ServiceFactory {
  Service getService();
}

class Implementation1 implements Service {
  Implementation1() {} // Package access
  public void method1() {print("Implementation1 method1");}
  public void method2() {print("Implementation1 method2");}
}    

class Implementation1Factory implements ServiceFactory {
  public Service getService() {
    return new Implementation1();
  }
}

class Implementation2 implements Service {
  Implementation2() {} // Package access
  public void method1() {print("Implementation2 method1");}
  public void method2() {print("Implementation2 method2");}
}

class Implementation2Factory implements ServiceFactory {
  public Service getService() {
    return new Implementation2();
  }
}    

public class Factories {
  public static void serviceConsumer(ServiceFactory fact) {
    Service s = fact.getService();
    s.method1();
    s.method2();
  }
  public static void main(String[] args) {
    serviceConsumer(new Implementation1Factory());
    // Implementations are completely interchangeable:
    serviceConsumer(new Implementation2Factory());
  }
}
/* Output:
Implementation1 method1
Implementation1 method2
Implementation2 method1
Implementation2 method2
*///:~

 

4、接口之间的转换——适配器模式

　　接口使得设计更加的灵活，但是也有一个限制，接口只能接受该接口类型的参数。

　　怎么把没有实现该接口的类用于接受该接口的方法呢？

　　这就需要适配器模式来实现了。

　　设目标接口为A，要转换的类为B；

　　那么，可以创建一个类C，

　　C实现了A接口，而继承了B类（也可以使用代理）。

　　在C中，A接口的方法委托给B类中的方法来完成。　

　　这样，C既是A类型的，又是B类型的，同时还实现了B方法向A方法的转换。

import java.nio.*;
import java.util.*;

public class RandomDoubles {
  private static Random rand = new Random(47);
  public double next() { return rand.nextDouble(); }
  public static void main(String[] args) {
    RandomDoubles rd = new RandomDoubles();
    for(int i = 0; i < 7; i ++)
      System.out.print(rd.next() + " ");
  }
}

public class AdaptedRandomDoubles extends RandomDoubles
implements Readable {
  private int count;
  public AdaptedRandomDoubles(int count) {
    this.count = count;
  }
  public int read(CharBuffer cb) {
    if(count-- == 0)
      return -1;
    String result = Double.toString(next()) + " ";
    cb.append(result);
    return result.length();
  }    
  public static void main(String[] args) {
    Scanner s = new Scanner(new AdaptedRandomDoubles(7)); //Scanner构造器接收一个Readable接口对象，Readable接口只要求实现一个read方法
    while(s.hasNextDouble())
      System.out.print(s.nextDouble() + " ");
  }
} 
/* Output:
0.7271157860730044 0.5309454508634242 0.16020656493302599 0.18847866977771732 0.5166020801268457 0.2678662084200585 0.2613610344283964
*///:~

 

5、接口与策略设计模式

　　策略设计模式属于行为型模式。

　　在策略模式中，一个类的行为或其算法可以在运行时更改。（根据代理对象或参数的改变）

　　

/**
 * 策略接口
 */
interface Processor {
    String name();
    Object process(Object input);
}

/**
 * 使用策略的类
 */
class Apply {
    public static void process(Processor p, Object s) {
        System.out.println("Using Processor " + p.name());
        System.out.println(p.process(s));
    }

    public static void main(String[] args) {
        String s="adaf adfds sdf sdfd sfs s q";
        Apply.process(new Upcase(), s);
        Apply.process(new Downcase(), s);
        Apply.process(new Splitter(), s);
    }
}

/**
 * 策略抽象类
 */
abstract class StringProcessor implements Processor{
    public String name() {
        return getClass().getSimpleName();
    }
    public abstract String process(Object input);
}

/**
 * 策略1
 * 将字符串转换为大写
 */
class Upcase extends StringProcessor {
    public String process(Object input) { // Covariant return
        return ((String)input).toUpperCase();
    }
}

/**
 * 策略2
 * 将字符串转化为小写
 */
class Downcase extends StringProcessor {
    public String process(Object input) {
        return ((String)input).toLowerCase();
    }
}

/**
 * 策略3
 * 将字符串分割为数组
 */
class Splitter extends StringProcessor {
    public String process(Object input) {
        return Arrays.toString(((String)input).split(" "));
    }
}

 

　　

　　

　　

 

标签：4Edition,String,void,接口,class,TIJ,new,public
来源： https://www.cnblogs.com/lqblala/p/15170923.html