2

我有一个对象将一些工作委托给另一个正在实现接口的对象。然后，我正在创建实现这个接口的匿名类，我想从这些类中获取信息。

可以使用大小为 1 的最终数组作为指向基元的指针来与匿名类共享数据吗？

这是我的意思的一个工作示例：

public class ExampleClass
{
    public static final int INVALID_VALUE = -1;

    public static void main(final String[] args)
    {       
        final int[] buffer = { INVALID_VALUE }; // buffer is created
        final InterfaceA iaObject = new InterfaceA()
        {
            @Override
            public void doStuff(final String paramA)
            {
                buffer[0] = paramA.length(); // buffer is filled in anonymous class
            }
        };

        final ClassA objA = new ClassA(iaObject);
        objA.doStuff("hello, world");

        if (buffer[0] == INVALID_VALUE) // buffer is used
        {
            System.err.println("Invalid length !");
        }
        else
        {
            System.err.println("The length is : " + Integer.toString(buffer[0]));
        }
    }

    public static class ClassA
    {
        private final InterfaceA iaObject;

        public ClassA(final InterfaceA iaObject)
        {
            this.iaObject = iaObject;
        }

        public void doStuff(final String paramA)
        {
            this.iaObject.doStuff(paramA);
        }
    }

    public static interface InterfaceA
    {
        void doStuff(String paramA);
    }
}

谢谢

4

3 回答 3

2

建议：为什么不使用泛型作为输出参数？

interface InterfaceA {

   public <T> void doStuff( String paramA, Holder<T> holder );
}

class Holder<T> {

    public T t;
}

完整示例：

public class ExampleClass
{
   public static final int INVALID_VALUE = -1;

   public static void main(final String[] args)
   {       
      final InterfaceA< Integer > iaObject = new InterfaceA< Integer >() {
         @Override
         public Integer doStuff( String paramA, Holder<Integer> holder ) {
            return holder.value = paramA.length();
         }
      };

      final ClassA<Integer> objA = new ClassA<>( iaObject );
      int result = objA.doStuff("hello, world", new Holder<>( INVALID_VALUE ));
      if( result == INVALID_VALUE ) {
         System.err.println("Invalid length !");
      }
      else {
         System.err.println("The length is : " + Integer.toString( result ));
      }
   }

   public static class ClassA<T> {
      private final InterfaceA<T> iaObject;

      public ClassA( final InterfaceA<T> iaObject_ ) {
         this.iaObject = iaObject_;
      }

      public T doStuff( final String paramA, Holder<T> holder ) {
         return this.iaObject.doStuff( paramA, holder );
      }
   }

   public static interface InterfaceA<T> {
      public T doStuff( String paramA, Holder<T> resultHolder );
   }

   public static class Holder<T> {

      public T value;

      public Holder( T value_ ) {
         value = value_;
      }
   }
}
于 2013-04-16T19:41:30.117 回答
0

如果我理解您的问题的要点，您想知道使用最终数组作为包装器在匿名内部类与其封闭类之间共享内存是否是好的设计原则。

以我的经验，这是在两个对象之间共享数据的一种非常糟糕的方式。以不同的方式声明接口可能更明智。返回一个对象或使用泛型来指定您期望从匿名类返回的类型。

于 2013-04-16T19:43:06.623 回答
0

我认为你的方法最大的问题之一是缺乏封装——你的 InterfaceA 实现使用了一些“全局”数据持有者（数组），并且没有办法阻止这个数组可以在其他地方使用，这反过来可以导致各种问题（竞争条件或其他）。

更简洁的方法是使用 getInt() 方法或类似方法定义一些单独的类（或接口）。

于 2013-04-16T19:43:36.547 回答