今天学习了接口。
首先和接口相似的是抽象类。只要含有抽象方法就必须定义为抽象类，但抽象类中不一定必须有抽象方法。
若继承一个抽象类，则导出类必须实现该抽象类的全部抽象方法，否则导出类也必须定义为抽象类。
接口可以说是一个完全抽象的类，它内部定义的方法都是抽象方法。
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();
}
}