网站设计的目标是什么,给别人做网站用什么,珠海网站建设科速,中国建设银行进不了登录网站本章概要
接口适配接口字段 初始化接口中的字段 接口嵌套接口和工厂方法模式
接口适配
接口最吸引人的原因之一是相同的接口可以有多个实现。在简单情况下体现在一个方法接受接口作为参数#xff0c;该接口的实现和传递对象则取决于方法的使用者。
因此#xff0c;接口的…本章概要
接口适配接口字段 初始化接口中的字段 接口嵌套接口和工厂方法模式
接口适配
接口最吸引人的原因之一是相同的接口可以有多个实现。在简单情况下体现在一个方法接受接口作为参数该接口的实现和传递对象则取决于方法的使用者。
因此接口的一种常见用法是前面提到的_策略_设计模式。编写一个方法执行某些操作并接受一个指定的接口作为参数。可以说“只要对象遵循接口就可以调用方法” 这使得方法更加灵活通用并更具可复用性。
例如类 Scanner 的构造器接受的是一个 Readable 接口在“字符串”一章中学习更多相关内容。你会发现 Readable 没有用作 Java 标准库中其他任何方法的参数——它是单独为 Scanner 创建的因此 Scanner 没有将其参数限制为某个特定类。通过这种方式Scanner 可以与更多的类型协作。如果你创建了一个新类并想让 Scanner 作用于它就让它实现 Readable 接口像这样
// interfaces/RandomStrings.java
// Implementing an interface to conform to a method
import java.nio.*;
import java.util.*;public class RandomStrings implements Readable {private static Random rand new Random(47);private static final char[] CAPITALS ABCDEFGHIJKLMNOPQRSTUVWXYZ.toCharArray();private static final char[] LOWERS abcdefghijklmnopqrstuvwxyz.toCharArray();private static final char[] VOWELS aeiou.toCharArray();private int count;public RandomStrings(int count) {this.count count;}Overridepublic int read(CharBuffer cb) {if (count-- 0) {return -1; // indicates end of input}cb.append(CAPITALS[rand.nextInt(CAPITALS.length)]);for (int i 0; i 4; i) {cb.append(VOWELS[rand.nextInt(VOWELS.length)]);cb.append(LOWERS[rand.nextInt(LOWERS.length)]);}cb.append( );return 10; // Number of characters appended}public static void main(String[] args) {Scanner s new Scanner(new RandomStrings(10));while (s.hasNext()) {System.out.println(s.next());}}
}输出 Readable 接口只需要实现 read() 方法注意 Override 注解的突出方法。在 read() 方法里将输入内容添加到 CharBuffer 参数中有多种方法可以实现查看 CharBuffer 文档或在没有输入时返回 -1。
假设你有一个类没有实现 Readable 接口怎样才能让 Scanner 作用于它呢下面是一个产生随机浮点数的例子
// interfaces/RandomDoubles.java
import java.util.*;public interface RandomDoubles {Random RAND new Random(47);default double next() {return RAND.nextDouble();}static void main(String[] args) {RandomDoubles rd new RandomDoubles(){};for (int i 0; i 7; i) {System.out.println(rd.next() );}}
}输出
0.7271157860730044
0.5309454508634242
0.16020656493302599
0.18847866977771732
0.5166020801268457
0.2678662084200585
0.2613610344283964我们可以再次使用适配器模式但这里适配器类可以实现两个接口。因此通过关键字 interface 提供的多继承我们可以创建一个既是 RandomDoubles又是 Readable 的类
// interfaces/AdaptedRandomDoubles.java
// creating an adapter with inheritance
import java.nio.*;
import java.util.*;public class AdaptedRandomDoubles implements RandomDoubles, Readable {private int count;public AdaptedRandomDoubles(int count) {this.count count;}Overridepublic 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));while (s.hasNextDouble()) {System.out.print(s.nextDouble() );}}
}输出
0.7271157860730044 0.5309454508634242
0.16020656493302599 0.18847866977771732
0.5166020801268457 0.2678662084200585
0.2613610344283964因为你可以以这种方式在已有类中增加新接口所以这就意味着一个接受接口类型的方法提供了一种让任何类都可以与该方法进行适配的方式。这就是使用接口而不是类的强大之处。
接口字段
因为接口中的字段都自动是 static 和 final 的所以接口就成为了创建一组常量的方便的工具。在 Java 5 之前这是产生与 C 或 C 中的 enum (枚举类型) 具有相同效果的唯一方式。所以你可能在 Java 5 之前的代码中看到
// interfaces/Months.java
// Using interfaces to create groups of constants
public interface Months {int JANUARY 1, FEBRUARY 2, MARCH 3,APRIL 4, MAY 5, JUNE 6, JULY 7,AUGUST 8, SEPTEMBER 9, OCTOBER 10,NOVEMBER 11, DECEMBER 12;
}注意 Java 中使用大写字母的风格定义具有初始化值的 static final 变量。接口中的字段自动是 public 的所以没有显式指明这点。
自 Java 5 开始我们有了更加强大和灵活的关键字 enum那么在接口中定义常量组就显得没什么意义了。然而当你阅读遗留的代码时在很多场合你还会碰到这种旧的习惯用法。在“枚举”一章中你会学习到更多关于枚举的内容。
初始化接口中的字段
接口中定义的字段不能是“空 final但是可以用非常量表达式初始化。例如
// interfaces/RandVals.java
// Initializing interface fields with
// non-constant initializers
import java.util.*;public interface RandVals {Random RAND new Random(47);int RANDOM_INT RAND.nextInt(10);long RANDOM_LONG RAND.nextLong() * 10;float RANDOM_FLOAT RAND.nextLong() * 10;double RANDOM_DOUBLE RAND.nextDouble() * 10;
}因为字段是 static 的所以它们在类第一次被加载时初始化这发生在任何字段首次被访问时。下面是个简单的测试
// interfaces/TestRandVals.java
public class TestRandVals {public static void main(String[] args) {System.out.println(RandVals.RANDOM_INT);System.out.println(RandVals.RANDOM_LONG);System.out.println(RandVals.RANDOM_FLOAT);System.out.println(RandVals.RANDOM_DOUBLE);}
}输出
8
-32032247016559954
-8.5939291E18
5.779976127815049这些字段不是接口的一部分它们的值被存储在接口的静态存储区域中。
接口嵌套
接口可以嵌套在类或其他接口中。下面揭示一些有趣的特性
// interfaces/nesting/NestingInterfaces.java
// {java interfaces.nesting.NestingInterfaces}
package interfaces.nesting;class A {interface B {void f();}public class BImp implements B {Overridepublic void f() {}}public class BImp2 implements B {Overridepublic void f() {}}public interface C {void f();}class CImp implements C {Overridepublic void f() {}}private class CImp2 implements C {Overridepublic void f() {}}private interface D {void f();}private class DImp implements D {Overridepublic void f() {}}public class DImp2 implements D {Overridepublic void f() {}}public D getD() {return new DImp2();}private D dRef;public void receiveD(D d) {dRef d;dRef.f();}
}interface E {interface G {void f();}// Redundant publicpublic interface H {void f();}void g();// Cannot be private within an interface//- private interface I {}
}public class NestingInterfaces {public class BImp implements A.B {Overridepublic void f() {}}class CImp implements A.C {Overridepublic void f() {}}// Cannot implements a private interface except// within that interfaces defining class://- class DImp implements A.D {//- public void f() {}//- }class EImp implements E {Overridepublic void g() {}}class EGImp implements E.G {Overridepublic void f() {}}class EImp2 implements E {Overridepublic void g() {}class EG implements E.G {Overridepublic void f() {}}}public static void main(String[] args) {A a new A();// Cant access to A.D://- A.D ad a.getD();// Doesnt return anything but A.D://- A.DImp2 di2 a.getD();// cannot access a member of the interface://- a.getD().f();// Only another A can do anything with getD():A a2 new A();a2.receiveD(a.getD());}
}在类中嵌套接口的语法是相当显而易见的。就像非嵌套接口一样它们具有 public 或包访问权限的可见性。
作为一种新添加的方式接口也可以是 private 的例如 A.D同样的语法同时适用于嵌套接口和嵌套类。那么 private 嵌套接口有什么好处呢你可能猜测它只是被用来实现一个 private 内部类就像 DImp。然而 A.DImp2 展示了它可以被实现为 public 类但是 A.DImp2 只能被自己使用你无法说它实现了 private 接口 D所以实现 private 接口是一种可以强制该接口中的方法定义不会添加任何类型信息即不可以向上转型的方式。
getD() 方法产生了一个与 private 接口有关的窘境。它是一个 public 方法却返回了对 private 接口的引用。能对这个返回值做些什么呢main() 方法里进行了一些使用返回值的尝试但都失败了。返回值必须交给有权使用它的对象本例中另一个 A 通过 receiveD() 方法接受了它。
接口 E 说明了接口之间也能嵌套。然而作用于接口的规则——尤其是接口中的元素必须是 public 的——在此都会被严格执行所以嵌套在另一个接口中的接口自动就是 public 的不能指明为 private。
类 NestingInterfaces 展示了嵌套接口的不同实现方式。尤其是当实现某个接口时并不需要实现嵌套在其内部的接口。同时private 接口不能在定义它的类之外被实现。
添加这些特性的最初原因看起来像是出于对严格的语法一致性的考虑但是我通常认为一旦你了解了某种特性就总能找到其用武之地。
接口和工厂方法模式
接口是多实现的途径而生成符合某个接口的对象的典型方式是_工厂方法_设计模式。不同于直接调用构造器只需调用工厂对象中的创建方法就能生成对象的实现——理论上通过这种方式可以将接口与实现的代码完全分离使得可以透明地将某个实现替换为另一个实现。这里是一个展示工厂方法结构的例子
// interfaces/Factories.java
interface Service {void method1();void method2();
}interface ServiceFactory {Service getService();
}class Service1 implements Service {Service1() {} // Package accessOverridepublic void method1() {System.out.println(Service1 method1);}Overridepublic void method2() {System.out.println(Service1 method2);}
}class Service1Factory implements ServiceFactory {Overridepublic Service getService() {return new Service1();}
}class Service2 implements Service {Service2() {} // Package accessOverridepublic void method1() {System.out.println(Service2 method1);}Overridepublic void method2() {System.out.println(Service2 method2);}
}class Service2Factory implements ServiceFactory {Overridepublic Service getService() {return new Service2();}
}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 Service1Factory());// Services are completely interchangeable:serviceConsumer(new Service2Factory());}
}输出
Service1 method1
Service1 method2
Service2 method1
Service2 method2如果没有工厂方法代码就必须在某处指定将要创建的 Service 的确切类型从而调用恰当的构造器。
为什么要添加额外的间接层呢一个常见的原因是创建框架。假设你正在创建一个游戏系统例如在相同的棋盘下国际象棋和西洋跳棋
// interfaces/Games.java
// A Game framework using Factory Methods
interface Game {boolean move();
}interface GameFactory {Game getGame();
}class Checkers implements Game {private int moves 0;private static final int MOVES 3;Overridepublic boolean move() {System.out.println(Checkers move moves);return moves ! MOVES;}
}class CheckersFactory implements GameFactory {Overridepublic Game getGame() {return new Checkers();}
}class Chess implements Game {private int moves 0;private static final int MOVES 4;Overridepublic boolean move() {System.out.println(Chess move moves);return moves ! MOVES;}
}class ChessFactory implements GameFactory {Overridepublic Game getGame() {return new Chess();}
}public class Games {public static void playGame(GameFactory factory) {Game s factory.getGame();while (s.move()) {;}}public static void main(String[] args) {playGame(new CheckersFactory());playGame(new ChessFactory());}
}输出
Checkers move 0
Checkers move 1
Checkers move 2
Chess move 0
Chess move 1
Chess move 2
Chess move 3如果类 Games 表示一段很复杂的代码那么这种方式意味着你可以在不同类型的游戏里复用这段代码。你可以再想象一些能够从这个模式中受益的更加精巧的游戏。
