Question

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

是否可以使用大小为1的final数组作为指向primitve的指针与匿名类共享数据？

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

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);
    }
}

由于

Answer 1

建议：为什么不在out参数中使用泛型？

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_;
      }
   }
}

Answer 2

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

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

Answer 3

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

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

如何从匿名类中获取不同类型的数据

3 个答案: