Question

我一直在努力通过创建一个练习Android应用程序来提高我（目前很差）的java技能。在我的应用程序中，每个屏幕由一个管理处理输入，逻辑和渲染的类管理。

对于某些类，它变得太大而不易理解，因此我决定将代码移动到几个分类中，这些类在主屏幕类中称为对象。例如：

public class Screen {

 ScreenA a;
 ScreenB b;
 ScreenC c;

 public Screen() {
  a = new ScreenA();
  b = new ScreenB();
  c = new ScreenC();
 }

 public void doStuff() {
  a.method();
  b.method();
  c.method();
 }
}

我想要了解的是，这是否是提高代码易读性的正确方法，以及它是否对内存使用/处理速度有任何影响。例如，调用静态方法会是更好的选择吗？

此外，当课程相互依赖时，答案会改变吗？例如。如果ScreenB中的方法需要在ScreenA中调用变量或方法？虽然下面两个例子中的任何一个都适合，但我不知道最佳做法是什么：

public class Screen {

 ScreenA a;
 ScreenB b;
 ScreenC c;

 public Screen(){
  a = new ScreenA();
  b = new ScreenB(a);
  c = new ScreenC(a,b);
 }

 public void doStuff(){
  a.method();
  b.method();
  c.method();
 }
}

public class ScreenB {

 ScreenA a;

 public ScreenB(ScreenA a) {
  this.a = a;
 }
}

或：

public class Screen {

 ScreenA a;
 ScreenB b;
 ScreenC c;

 public Screen(){
  a = new ScreenA();
  b = new ScreenB();
  c = new ScreenC();
 }

 public void doStuff(){
  a.method();
  b.method(a);
  c.method(a,b);
 }
}

Answer 1

我想要了解的是这是否是正确的方法提高代码易读性，以及它是否对内存有任何影响使用/处理速度。例如，调用静态方法会是更好的选择吗？

你所做的实际上是在不同的阶级中分配不同的责任并包含行为。这就是OOP的全部内容，而Java是为OOP而构建的。与调用静态方法相比，实例化对象具有成本，但您绝不应该害怕这样做。静态方法不允许封装，继承，依赖注入以及许多其他使OO应用程序成为优秀软件的东西。

此外，当课程依赖时，答案是否会改变彼此？例如。如果ScreenB中的方法需要调用变量或 ScreenA中的方法？不过我会想到两个例子中的任何一个以下是合适的，但我不知道什么是最佳实践

决定参数与类属性的一条经验法则如下：您是否总是使用相同的参数？如果是，它们不是参数，它们是状态，应该传递给构造函数。如果不是，那么它们可以用作参数。

另一个好的指标是：有多少方法需要相同的参数来实现它们的功能？如果有许多方法需要这些参数，那么属性可能比参数更有意义。

初始化共同依赖对象时的最佳做法是什么？

1 个答案: