1

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

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

这是不好的做法和反模式吗？我在这里创建了一个上帝对象吗？（虽然在其他外部类中要遵循更多功能）

编辑：我有两个变量 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
        }   
    }
}
4

1 回答 1

5

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

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

然后是调用者的责任 1) 以 any 的形式准备输入Reader2) 获取生成Bids的对象并对其进行处理。Reader 可以是 FileReader、BufferedReader、StringReader 等的实例...参见Java IO 文档

此外，这种设计违反了Don't Repeat Yourself原则。您可以在 中看到重复的代码BidParser。一旦您将类设计为仅使用更抽象的输入，此违规将自动修复。

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

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

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

概括地说：这样的设计是不好的，因为它注入了BidParser关于其客户端内部的类知识，即应该避免的紧密耦合，因为它不可测试并导致可维护性差。除了通过参数传递之外，您的班级不应该知道任何关于它的客户的信息。而且（在这个简短的示例中这有点过分了）控制反转的概念（以及依赖注入之后）在追求松散耦合和产生更可测试和更简洁的设计方面走得更远。

考虑面向对象设计的 SOLID 原则。维基百科关于不要重复自己的文章也链接到另一个有用的原则，它介绍了某种编程哲学。

于 2014-11-25T05:36:07.767 回答