如果你还不太清楚看看这段描述合和代码：

声明一个接口，另外一个类有方法里面有个参数以是这个接口类型的，而后在另外类中实现这个接口(java中多用的是匿名内部类)，而且以这个匿名的类生成的对象为参数传到上面提到类中，而后实现回调.......这种用法可以参考java里面常用到的数据库操作所用到的几个接口.....

注：匿名内部类 的说明可以见 http://dev.csdn.net/author/CMTobby/339cbab3897f4106bed2fe2ecd75470a.html

//声明一个接口

public interface ICallBack(){

  void postExec();

}



    //另外一个类有方法里面有个参数以是这个接口类型的

public class FooBar..{

  private ICallBack callBack;

  public void setCallBack(ICallBack callBack){

    this.callBack=callBack;

  }

  public void doSth(){

     .

     callBack.postExec();

  }

  ..

}

---------------------------------------

回调的实现

public class Test{

   public static void main(String[] args){

     FooBar foo=new FooBar();

     foo.setCallBack(new ICallBack(){

        public void postExec(){System.out.println("method executed.");}

     });

   }

}

/**//*
 * Classname       : NetComm.java
 * Create Date     : 5:04:00 PM
 * Author          : Administrator
 * Product Name    : tagApp

 */

package jdom;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.InetAddress;
import java.net.Socket;

public class NetComm implements ActionListener {

    javax.swing.Timer timer = new javax.swing.Timer(3000, this);

    Socket sock;

    private EventNotifier en;

    public static int net_state = 0;

    InetAddress ServerAddr;

    int ServerPort;

    public NetComm(InetAddress addr, int port) {
        ServerAddr = addr;
        ServerPort = port;
    }

    //初始化并创建socket连接
    public void NetComm_Init() {

        net_state = 1;
        try {
            sock = new Socket(ServerAddr, ServerPort);
        } catch (IOException e) {
            net_state = 0;
        }
        timer.start();
    }
    
    //创建socket连接
    public void NetComm_Data() {

        try {
            OutputStream outputstream = sock.getOutputStream();
            BufferedWriter out = new BufferedWriter(new OutputStreamWriter(
                    outputstream));

            out.write("java by ghf@china.com");
            out.flush();

            BufferedReader in = new BufferedReader(new InputStreamReader(sock
                    .getInputStream()));

            boolean more = true;
            while (more) {
                String str = in.readLine();
                if (str == null) {
                    more = false;
                } else {
                    // 处理数据
                    System.out.println(str);
                }
            }
            in.close();

        } catch (IOException e) {
            NetComm_Close();
            net_state = 0;
        }
        timer.start();
    }

    public void NetComm_Close() {
        if (sock != null)
            try {
                sock.close();
            } catch (IOException e) {
            }
    }

    public void actionPerformed(ActionEvent e) {
        if (net_state == 0) {
            NetComm_Init();
        } else {
            NetComm_Data();
        }
    }
}

在以上程序中，也可以为外部应用提供一个回调函数，以便在网络异常或恢复正常时通知应用。服务应用的网络通信类类似，可以放在同一类中。

分层结构是目前复杂应用系统开发时普遍使用的模式，软件中层之间的依赖关系约束是比较宽松的，并不要求上层仅可以依赖于直接下层，而是上层可以依赖于它的所有下层。

设计中我们会把各种系统的各种组件映射至不同层中，而在我所接触的一些实际项目中设计人员在映射这种组件和层间的关系时经常无意中破坏了层结构的依赖关系约束。

图表 1典型分层结构

设计中的常见问题

问题一:数据传输对象（DTO）是否应该属于业务层？

在J2EE开发的经典著作《Core J2EE Patterns》中数据传输对象被划分在业务层模式中，那么是否数据传输对象应该被映射到业务层呢？

数据访问对象（DAO）在该著作中是被映射到整合层的，这样就会出现一个违反层依赖约束的问题，因为数据访问对象是要依赖于数据传输对象的，因此下层就会出现对上层的依赖了。

所以本人认为DTO是在各层中传输数据的，我们可以不必强求的把他们映射到上述层次中，可以把他们放置在一个公共包中。

问题二:使用POJO作业务对象的轻量级架构与上述层模型的映射

在使用POJO的轻量级结构中我们通常会使用持久化框架（如Hibernate/JPA）同时会在架构中引入仓库对象(Repository Object)，负责业务对象的获取和保存。（注意：他的功能和DAO是有区别的，仓库对象中通常只应包括业务对象的获取和保存逻辑）。

通常设计人员会把业务对象映射至业务层，而将仓库对象映射至整合层。由于仓库对象对于业务对象的依赖关系就会破坏依赖关系约束，所以这种映射方式显然不正确。

下图是作者推荐的映射方式

图表 2轻量级架构参考模型

可以看到业务对象和仓库对象都被映射至业务层，而持久化框架被映射到了整合层。

总结

因此大家在设计过程中不要仅仅将分层结构留于形式，而要时刻注意设计是否符合这种架构模式，这样才能真正发挥这种架构模式的优势。 

public boolean add(java.lang.Object element)

public java.lang.Object get(int index) throws IndexOutOfBoundsException

List stringList1 = new ArrayList();

stringList1.add("Java 5");

stringList1.add("with generics");

String s1 = (String) stringList1.get(0);

boolean add<E o>

E get(int index)

List<String> myList;

List<String> myList = new ArrayList<String>();

public interface Map<K,V>

V put(K key, V value)

Collection<V> values()

package com.brainysoftware.jdk5.app16;

import java.util.List;

import java.util.ArrayList;



public class GenericListTest {

  public static void main(String[] args) {

    // in JDK 1.4

    List stringList1 = new ArrayList();

    stringList1.add("Java 1.0 - 5.0");

    stringList1.add("without generics");

    // cast to java.lang.String

    String s1 = (String) stringList1.get(0);

    System.out.println(s1.toUpperCase());



    // now with generics in JDK 5

    List<String> stringList2 = new ArrayList<String>();

    stringList2.add("Java 5.0");

    stringList2.add("with generics");

    // no need for type casting

    String s2 = stringList2.get(0);

    System.out.println(s2.toUpperCase());

  }

}

List<List<String>> myListOfListsOfStrings;

String s = myListOfListsOfStrings.get(0).get(0);

package com.brainysoftware.jdk5.app16;

import java.util.ArrayList;

import java.util.List;

public class ListOfListsTest {

  public static void main(String[] args) {

    List<String> listOfStrings = new ArrayList<String>();

    listOfStrings.add("Hello again");

    List<List<String>> listOfLists = new ArrayList<List<String>>();

    listOfLists.add(listOfStrings);

    String s = listOfLists.get(0).get(0);

    System.out.println(s); // prints "Hello again"

  }

}

package com.brainysoftware.jdk5.app16;

import java.util.HashMap;

import java.util.Map;

public class MapTest {

  public static void main(String[] args) {

    Map<String, String> map = new HashMap<String, String>();

    map.put("key1", "value1");

    map.put("key2", "value2");

    String value1 = map.get("key1");

  }

}

List stringList1 = new ArrayList();

stringList1.add("Java 1.0 - 5.0");

stringList1.add("without generics");

String s1 = (String) stringList1.get(0);

List<Object> list1 = new ArrayList<Object>();

List<String> list2 = new ArrayList<String>();

package com.brainysoftware.jdk5.app16;

import java.util.ArrayList;

import java.util.List;



public class AllowedTypeTest {

  public static void doIt(List<Object> l) {

  }

  public static void main(String[] args) {

    List<String> myList = new ArrayList<String>();

    // 这里将产生一个错误

    doIt(myList);

  }

}

public static void doIt(List<?> l) {}

package com.brainysoftware.jdk5.app16;

import java.util.ArrayList;

import java.util.List;



public class WildCardTest {



  public static void printList(List<?> list) {

    for (Object element : list) {

      System.out.println(element);

    }

  }

  public static void main(String[] args) {

    List<String> list1 = new ArrayList<String>();

    list1.add("Hello");

    list1.add("World");

    printList(list1);



    List<Integer> list2 = new ArrayList<Integer>();

    list2.add(100);

    list2.add(200);

    printList(list2);

  }

}

List<?> myList = new ArrayList<?>(); // 不合法

List<Object> myList = new ArrayList<Object>();

package com.brainysoftware.jdk5.app16;

import java.util.ArrayList;

import java.util.List;

public class BoundedWildcardTest {

  public static double getAverage(List<? extends Number> numberList)

  {

    double total = 0.0;

    for (Number number : numberList)

      total += number.doubleValue();

    return total/numberList.size();

  }



  public static void main(String[] args) {

    List<Integer> integerList = new ArrayList<Integer>();

    integerList.add(3);

    integerList.add(30);

    integerList.add(300);

    System.out.println(getAverage(integerList)); // 111.0

    List<Double> doubleList = new ArrayList<Double>();

    doubleList.add(3.0);

    doubleList.add(33.0);

    System.out.println(getAverage(doubleList)); // 18.0

  }

}