内部类使用外部类的方法.这是Cyclic参考吗？怎么避免

Question

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

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

这是不好的做法和反模式吗？我在这里创建一个上帝对象吗？(但是在其他外部类中可以使用更多函数)

编辑:我有两个变量Var1,Var2(让我们说)属于外部但是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应负责解析出价,这就是全部.即这个类应该接受输入 - 不是偶数File,只是Reader, - 并产生一些Bids对象,它应该返回给调用者.

然后是调用者的责任1)以任何形式准备输入Reader和2)以获取生成的Bids对象并用它做某事.Reader可以是FileReader,BufferedReader,StringReader等的实例...请参阅Java IO文档

此外,这种设计违反了" 不要重复自己"的原则.你可以看到重复的代码BidParser.一旦您将类设计为仅使用更抽象的输入,就会自动修复此违规.

考虑到InputChecker,如果每个元素都是以其他元素的形式检查的,那么这个类应该负责一次只检查一个可检查的块(元素).它应该是解析器负责迭代元素并InputChecker根据需要调用.

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

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

概括:这样的设计很糟糕,因为它将BidParser关于客户内部的知​​识注入到类中,即紧密耦合应该避免,因为它不可测试并导致可维护性差.除了通过参数传递之外,你的班级不应该知道它的客户.并且(在这个简短的例子中是过度的)控制反转(以及跟随依赖注入)的概念甚至更进一步追求松耦合并产生更可测试和清洁的设计.

考虑面向对象设计的SOLID原则.另外,维基百科关于" 不要重复自己"的文章链接到另一个有用的原则,它引入了某种编程哲学.