看了汤阳光老师的俄罗斯游戏视频，上面有一个监听类，它并没有实现什么接口，而是自定义的监听器接口，自己实现，自己写一个add添加监听器方法，不是太懂，有知道的请赐教！！

没看过啊   ....看看jdk，看看add方法可接收的参数就知道能不能自定义或者怎么定义了

刚才大致查了一下，参数好像必须实现接口....  你可以自己查查去

谢谢，我去查查资料

经过查阅资料研究，对于自定义监听器，基本掌握，现在做个例子，主要是：一个人回来后，触发了个事件，而事件的监听是由狗来进行的，然后狗做出了汪汪的反应。看例子体会吧


1、定义AlertEvent事件类

import java.util.EventObject;
//定义AlertEvent事件类
public class AlertEvent extends EventObject {
public AlertEvent(Object source){
   super(source);
}
}

2、AlertListener接口，用于监听AlertEvent事件

import java.util.EventListener;
//AlertListener接口，用于监听AlertEvent事件
public interface AlertListener extends EventListener {
public void dog(AlertEvent e);
}

3、//Dog类实现了AlertListener接口，用于监听事件
public class Dog implements AlertListener {

        @Override
        public void dog(AlertEvent e) {


                System.out.println("wang wang somebody come back!");
        }

}

4、
//定义Person类
public class Person {
private AlertListener listener;


public void addAlertListener(AlertListener listener){//注册监听器
   this.listener=listener;
}


public void comeBack(){//此方法将创建AlertEvent事件，并把此事件传递给监听器
       
   AlertEvent event=new AlertEvent(this);
   listener.dog(event);
   
}

}
5、
public class TestListener {

        /**
        * @param args
        */
        public static void main(String[] args) {

          Person bob=new Person();
           Dog mike=new Dog();
          
           bob.addAlertListener(mike);//将Person对象注册监听器
           bob.comeBack();//将触发监听事件


        }

        }

package  com.Demo;
import java.util.EventListener;

//Title:监听器接口
public interface DemoListener extends EventListener
{
   public void demoEvent(DemoEvent dm);
}


package  com.Demo;
import java.util.EventObject;
//事件处理类，继承了事件基类
public class DemoEvent extends EventObject
{
private static final long serialVersionUID=-8352051534142982085L;
private Object obj;
private String sName;
public DemoEvent(Object source,String sName)
{
   super(source);
   obj=source;
   this.sName=sName;
}
public Object getSource()
{
   return obj;
}
public void say()
{
   System.out.println("这个是say方法....");
}
public String getName()
{
   return sName;
}
}

package  com.Demo;
import java.util.Enumeration;
import java.util.Vector;
/**
*Title:使用事件的类Description：该类实现了监听器的添加和监听器方法的执行，
并且实现了由于属性的改变而执行事件
*Description：在添加、删除、执行监听器的时候都要注意同步问题
*/
public class DemoSource
{
    private Vector<DemoListener> repository =new Vector<DemoListener>();
    private DemoListener dl;
    private String sName="";
    public DemoSource()
    {}
      //注册监听器，如果这里没有使用Vector而是使用ArrayList那么注意同步问题
       public void addDemoListener (DemoListener dl)
         {
            repository.addElement(dl);//这步要注意同步问题
         }
     //如果这里没有使用Vector而是使用ArrayList那么注意同步问题
       public void notifyDemoEvent(DemoEvent event)
         {
              Enumeration<DemoListener> en=repository.elements();//这步要注意同步
              while(en.hasMoreElements())
               {
                    dl=(DemoListener)en.nexElement();
                    dl.demoEvent(event);
               }
         }
    //删除监听器
      public void removeDemoListener(DemoListener dl)
        {
            respository.remove(dl);
        }

   //设置属性
      public   void setName(String str1)
       {
             boolean bool=false;
             if(str1==null &&sName!=null)
             bool=true;
             else if(str1=null&& sName==null)
             bool=true;
             else if(!sName.equals(str1))
             bool=true;
             this.sName=str1;
             //如果改变执行事件
             if(bool)
             notifDemoEvent(new DemoEvent(this.sName));
       }
       public String getName()
        {
           return sName;
        }
  }


/**
*Title:测试类Description：测试了由于改变属性而引起的事件发生
*/
public class TestDemo implements DemoLister
{
    private DemoSource ds;
    public TestDemo()
     {
        ds=new DemoSource();
        ds.addDemoListener(this);
        System.out.println("添加监听器完毕");
        try {
               Thread.sleep(3000);
                //改变属性，触发事件
               ds.setName("改变属性，触发事件");
            }
        catch(Exception e)
           {
               e.printStackTrace();
           }
        ds.addDemoListener(this);
        System.out.println("添加监听器完毕2");
        try {
               Thread.sleep(3000);
                //改变属性，触发事件
               ds.setName("改变属性，触发事件2");
            }
        catch(Exception e)
           {
               e.printStackTrace();
           }

         ds.removeDemoListener(this);
        System.out.println("添加监听器完毕3");
        try {
               Thread.sleep(3000);
                //改变属性，触发事件
               ds.setName("改变属性，触发事件3");
            }
        catch(Exception e)
           {
               e.printStackTrace();
           }
     }
    public static void main(String args[])
      {
          new TestDemo();
      }
    public void demoEvent(DemoEvent dm)
      {
         System.out.println("事件处理方法");
         System.out.println(dm.getName());
         dm.say();
      }
}

兄弟，俄罗斯方块的游戏中关于自定义图形监听器ShapeListener，我的理解是：1、关于继承接口：接口里的方法本来就是抽象方法，你ShapeListener就算继承Listener也不覆盖它的抽象方法，因为ShapeListener里的方法必须也是抽象的，所以不需要继承什么接口。
2、整个游戏摘要流程：前提Shape中添加了addShapeListener接口的方法，Controller类实现了ShapeListener接口，并覆盖它的方法isShapeMoveDownable，所以Controller是ShapeListener的子类（1）主函数Game中语句controller.newGame();
（2）而Controller中的public void newGame(){
                shape = shapeFactory.getShape(this);
        }该方法调用getShape方法，传入的参数是this，即是Controller
（3）ShapeFactory中getShape(ShapeListener listener)方法new了新图形，并对图形添加shape.addShapeListener(listener)
自此可看出，shape.addShapeListener（listener)添加的监听器其实是Controller