自学java 第九章接口

今天学习了接口。

首先和接口相似的是抽象类。只要含有抽象方法就必须定义为抽象类，但抽象类中不一定必须有抽象方法。

若继承一个抽象类，则导出类必须实现该抽象类的全部抽象方法，否则导出类也必须定义为抽象类。

接口可以说是一个完全抽象的类，它内部定义的方法都是抽象方法。

interface关键字前可以加public关键字（但仅限于该接口在与其同名的文件夹中被定义）,否则就是有包访问权限。由于接口中的方法都是隐式的public型的（即不能用private 或protected，否则编译报错），因此实现接口时，在接口中定义的方法在实现该接口的类中必须把它们显示定义为public，否则访问权限降低，编译会报错。

接口中可以包含域，它们隐式地是static和final的。

一个接口可以继承多个接口；一个类可以同时继承另一个类和多个接口。

使用接口的核心原因：

1.能够向上转型为多个基类型（提高灵活性）；

2.确保只是创建一个接口，防止客户端程序员创建它的对象。

接口可以进行嵌套，即可以在一个类中定义接口，或在一个接口中再定义接口。这些内部的接口可是public或protected或private的。

接口中学到的设计模式：

策略设计模式，能够根据所传递参数对象的不同而具有不同行为的方法

下面是一个简单的策略模式例子：

public class Strategy { //一个简单的策略模式
private static String s="This Is A Strategy Class";
public static void main(String[] args){
Processor[] p={
new Upcase(),
new Downcase()
};
for(Processor x:p)
Apply.process(x, s);
}

}

class Processor{
public String name(){
return getClass().getSimpleName();
}
Object process(Object input){
return input;
}
}

class Upcase extends Processor{
String process(Object input){
return ((String)input).toUpperCase();
}
}

class Downcase extends Processor{
String process(Object input){
return ((String)input).toLowerCase();
}
}

class Apply{
public static void process(Processor p,Object s){
System.out.println("Using Processor"+p.name());
System.out.println(p.process(s));
}
}

适配器模式，http://www.cnblogs.com/java-my-life/archive/2012/04/13/2442795.html

自己写的一个例子：

public class Adapter { //适配器策略,简单例子
public static void main(String[] args){
Waveform w=new Waveform();
Apply1.process(new FilterAdapter(new Lowpass()), w);
Apply1.process(new FilterAdapter(new Highpass()), w);
Apply1.process(new FilterAdapter(new Lowpass()), w);
}

}

class Waveform{
private static long count;
private final long id=count++;
public String toString(){
return "waveform"+id;
}
}

class Apply1{
public static void process(Processor1 p,Object s){
System.out.println("Using Processor1"+p.name());
System.out.println(p.process(s));
}
}

interface Processor1{
String name();
Object process(Object input);
}

class Filter{

public String name(){
return getClass().getSimpleName();
}
public Waveform process(Object input){
return (Waveform)input;
}

}

class Lowpass extends Filter{
public Waveform process(Waveform w){
return w;
}
}

class Highpass extends Filter{
public Waveform process(Waveform w){
return w;
}
}

class FilterAdapter implements Processor1{
private Filter filter;
FilterAdapter(Filter f){
filter=f;
}
@Override
public String name() {
return filter.name();
}

@Override
public Object process(Object input) {
return filter.process((Waveform)input);
}

}

工厂方法模式，http://www.cnblogs.com/forlina/archive/2011/06/21/2086114.html

这里有我自己写的一个简单的例子：

import java.util.Random;
import java.util.Scanner;

public class Demo_ninteen {
public static void playGame(GameFactory f){
Game g=f.getGame();
g.play();
}
public static void main(String[] args) {
System.out.println("请选择游戏，抛硬币选1，掷骰子选2:");
Scanner scan=new Scanner(System.in);
if(scan.nextInt()==1)
playGame(new ThrowCoinFactory());
else
playGame(new ThrowDiceFactory());
}

}

interface Game{  //抽象游戏产品
void play();
}

interface GameFactory{  //抽象工厂
Game getGame();
}

class ThrowCoin implements Game{ //抛硬币
private Random rand=new Random();
public void play() {
if(rand.nextInt(2)==1)
System.out.println("您此次抛的是正面");
else
System.out.println("您此次抛的是反面");
}
}

class ThrowCoinFactory implements GameFactory{  //实际工厂
public Game getGame(){
return new ThrowCoin();
}
}

class ThrowDice implements Game{ //掷骰子
private Random rand=new Random();
public void play(){
switch(rand.nextInt(6)+1){
case 1:
System.out.println("您掷的是1");
break;
case 2:
System.out.println("您掷的是2");
break;
case 3:
System.out.println("您掷的是3");
break;
case 4:
System.out.println("您掷的是4");
break;
case 5:
System.out.println("您掷的是5");
break;
case 6:
System.out.println("您掷的是6");
break;
}
}
}

class ThrowDiceFactory implements GameFactory{  //实际工厂
public Game getGame(){
return new ThrowDice();
}
}