java - 内部类使用外部类的方法。那是循环引用吗？如何避免

Question

我想知道在内部类中调用外部类的方法然后在外部类中使用内部类的方法是否被认为是不好的做法。

在这种情况下: 在BidParser 中，我调用属于外部类的方法updateMaps()。此外，我在 BidParser 中调用了第二个内部类 InputSanityChecker 的方法。

这是不好的做法和反模式吗？我在这里创建了一个 God 对象吗？(不过在其他外部类中还有更多功能要遵循)

编辑:我有两个变量 Var1，Var2(比方说)，它们属于 Outer，但是 updateX 和 checkX 方法需要它们。

public class Outer{


    public static void main( String[] args ){
        if(args.length == 1){
            File file = new File(args[0]);
            BidParser.parseBids(file);//<--- Question refers here
        }else{
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            BidParser.parseBids(br);  //<--- and here
        }
    }


    private static void updateMaps(String[] elements){
        //.....blah blah
    }

    static class BidParser{
        public static void parseBids(File file){
            //.....blah blah
            InputSanityChecker.checkInput(elems);//<---second inner class method
            InputSanityChecker.checkMaps(elems);    //<---second inner class method
            updateMaps(elems);  //<-----outer class method

        }
        public static void parseBids(Reader reader){
            //.....blah blah
            InputSanityChecker.checkInput(elems);//<---second inner class method
            InputSanityChecker.checkMaps(elems);    //<---second inner class method
            updateMaps(elems);  //<-----outer class method

        }
      }
    static class InputSanityChecker{

        public static boolean checkInput(String[] elements){
              //.....blah blah
        }

        public static boolean checkMaps(String[] elements){
              //.....blah blah
        }   
    }
}

Answer 1

它不是循环引用。所有类——外部类和嵌套静态类——对编译器都是同等独立的。当您调用静态方法时，没有实例引用。

这种设计违反了单一职责原则:BidParser应该负责解析出价，仅此而已。 IE。这个类应该接受输入 - 甚至不是 File，只是 Reader， - 并产生一些 Bids 对象，它应该返回给调用者。

然后调用者有责任 1) 以任何 Reader 的形式准备输入和 2) 获取生成的 Bids 对象并用它做一些事情。 Reader 可以是 FileReader、BufferedReader、StringReader 等的实例...参见 Java IO Documentation

另外，这种设计违反了不要重复自己原则。您可以在 BidParser 中看到重复的代码。一旦您将类设计为仅使用更抽象的输入，这种违规行为就会自动修复。

考虑到 InputChecker，如果每个元素独立于其他元素进行检查，则此类应负责一次仅检查一个可检查 block (元素)。迭代元素并根据需要调用 InputChecker 应该是解析器的责任。

如果外部类中有一些变量需要解析和检查出价，则应将它们作为参数传递。如果失败的检查不能阻止解析，那么你最好将检查器从解析器中排除。所以它看起来像:

try{
     Bids bids = BidParser.parse( bidsInput );
     BidChecker.check(bids, var1);
     Maps.update(bids, var2);
} catch (...){
}

概括:这样的设计很糟糕，因为它向 BidParser 类注入(inject)了有关其客户端内部的知识，即应该避免的紧耦合，因为它不是可测试并导致可维护性差。除了通过参数传递之外，你的类(class)不应该知道任何关于它的客户的信息。并且(在这个简短的例子中这有点矫枉过正)控制反转的概念(以及随后的依赖注入(inject))在追求松散耦合和产生更可测试和更简洁的设计方面走得更远。

考虑 SOLID principles of Object-Oriented Design .还有关于 Don't Repeat Yourself 的维基百科文章链接到另一个有用的原则，它介绍了某种编程哲学。