Java思想之容器implements与接口interface处理


Java




0x01.About

查了一些国内资料,都说java中extended与implements的区别是,一个类只能有一个继承,一个类可以有多个容器。

后来去看了些国外资料。

在我理解上,interface就是一个公共的类,可以包含公共函数、变量。

Java接口是用于指定一组抽象方法的类来实现一个抽象类型。

当一个类实现一个接口,它必须继承所有的内声明的抽象方法,好像签订了一份合同,并履行协议。



0x02.Example

先来看看怎么声明一个接口,文件保存为 InterFace.java

public class InterFace {
    public static void main(String[] args) {
        MyTest x = new MyTest();
        x.speak();
        x.say();
        x.fuck();
    }
}
class MyTest implements MyInterface2, MyInterface3 {
    @Override
    public void speak() {
        System.out.println("MyTest Called => jump() =>"+MyInterface.hello);
    }
    @Override
    public void fuck() {
        System.out.println("MyTest Called => fuck()");
    }
    @Override
    public void say() {
        System.out.println("MyTest Called => say()");
    }    
}
interface MyInterface1{
    public String hello = "hello";
    public void speak();
}
interface MyInterface2{
    public int num = 1;
    public void fuck();
}
// 接口之间可以相互继承
interface MyInterface3 extends MyInterface1{
    public void say();
}

输出如下:

$javac InterFace.java
$java InterFace

MyTest Called => jump() =>hello
MyTest Called => say()
MyTest Called => fuck()

这里我们声明了3个接口,并且interface3继承自interface1,所以当类容器导入接口interface3就会导入父类接口interface1。

只要添加了容器implements,就会包含接口中的所有东西,所以必须在MyTest类中添加该重写函数,否则找不到该函数会报错。


再看下面一个例子,多个类共同使用一个interface接口,保存为Account.java

interface Transaction {
    int BALANCE = 500;
    Object transaction(Object input);
}
class CurrentAccount implements Transaction {
    int bal;
    public Object transaction(Object input) {
        this.bal = BALANCE - (int)input;
        return bal;
    }
    public String toString() { return "Current acc"; }
}
class SavingsAccount implements Transaction {
    int bal;
    public Object transaction(Object input) {
        this.bal = BALANCE + (int)input;
        return bal;
    }
    public String toString() { return "Savings acc"; }
}
public class Account {
    public static void payment(Transaction t, Object input) {
        System.out.println(t + " is debited:   " +  t.transaction(input));
    }
    public static void deposit(Transaction t, Object input) {
        System.out.println(t + " is credited:   " +  t.transaction(input));
    }
    public static void main(String[] args) {
        Integer input = new Integer(600);
        deposit(new SavingsAccount(), input);
        payment(new CurrentAccount(), input);
    }
}

代码输出:

$javac Account.java
$java Account

Savings acc is credited:   1100
Current acc is debited:   -100

一个接口可以供多个类共同使用,并且多个类之间使用不冲突,这样看来,interface倒有点像是静态函数了。

观察一下这两个实现类活期账户和储蓄账户自动的向上转型在接受Transaction接口Account类中的方法。

payment()和deposit()方法利用我们所讲的战略设计模式,代表了接口的实现完全脱钩的一个实例。

从理论上说,你可以适应任何类,只需使它们符合的界面,使用这些方法。


对于接口与容器,我见过的一个更具有实用价值的地方,在于类之间的监听函数调用。

类似于js中的事件驱动函数,当有事件发生时候,通过回调函数,通知主函数。

实例代码如下,文件命名为Homeway.java:

public class Homeway {
    public static void main(String[] args) {
        System.out.println("\n=======================Implements======================\n");
        ClassImplements mClassImplements = new ClassImplements();
        mClassImplements.run();
    }
}
class ClassImplements implements Implements1.Listener {
    public Implements1 mImplements1 = null;
    public ClassImplements(){
        mImplements1 = new Implements1();
        mImplements1.setListener(this);
    }
    @Override
    public void onCallStart(){
        System.out.println("ClassImplements => onCallStart()");
    }
    @Override
    public void onCallStop(){
        System.out.println("ClassImplements => onCallStop()");
    }
    public void run(){
        mImplements1.run();
    }
}
//test 2level implements for class
class Implements1 implements Implements2.Listener {
    private Listener mListener;
    private Implements2 mImplements2;
    public Implements1(){
        mImplements2 = new Implements2();//把当前类传给下个类
        mImplements2.setListener(this);
        System.out.println("Init Implements1 =>...");
    }
    public static interface Listener {
        void onCallStart();
        void onCallStop();
    }
    public void setListener(Listener listener) {
        mListener = listener;
    }
    @Override
    public void onCallStart(){
        System.out.println("Implements1 => onCallStart()");
        mListener.onCallStart();//call at Implements1 and then throw to ClassImplements
    }
    @Override
    public void onCallStop(){
        System.out.println("Implements1 => onCallStop()");
        mListener.onCallStop();//call at Implements1 and then throw to ClassImplements
    }
    public void run(){
        this.mImplements2.run();
    }
}

//3 level implement test
class Implements2{
    private Listener mListener;
    public Implements2(){
        System.out.println("Init Implements2 =>...");
    }
    public static interface Listener {
        void onCallStart();
        void onCallStop();
    }
    public void setListener(Listener listener) {
        mListener = listener;
    }
    public void onCallStart(){
        System.out.println("Implements2 => onCallStart()");
    }
    public void onCallStop(){
        System.out.println("Implements2 => onCallStop()");
    }
    public void run() {
        System.out.println("Run some functions and then callback from Listener...");
        mListener.onCallStart();
        mListener.onCallStop();
    }

}

输出如下:

$javac Homeway.java
$java Homeway
=======================Implements======================
Init Implements2 =>...
Init Implements1 =>...
Run some functions and then callback from Listener...
Implements1 => onCallStart()
ClassImplements => onCallStart()
Implements1 => onCallStop()
ClassImplements => onCallStop()

我们先是声明了类ClassImplements,这个是我们的主类,并且implements了Implements1.Listener通过一个Listener建立了监听接口,

然后Implements1又implements了Implements2.Listener建立了第2级的监听。

一旦Implements1Implements2内的某个函数触发了某个事件,就能通过监听接口发送给主函数ClassImplements,类似js中的事件回调函数。

父类与子类通过Listener实现接口调用,此时Listener即为父类本身。

大致的模型如下:

模型

implements容器与interface接口在java类中有很多很好用的模型,有时间该多去研究研究。



参考资料:




本文出自 夏日小草,转载请注明出处: http://homeway.me/2015/04/13/java-implements-and-interface/

by 小草

2015-04-13 20:10:20

Fork me on GitHub