Java - 选择什么更好,静态方法还是非静态方法
Java - what is better to choose, static or nonstatic methods
所以我想创建 class,其中将创建一些对象,稍后我会将它们添加到 Map。将有三张地图。对象 1 的映射、对象 2 的映射以及对象 2 和对象 1 之间的关系图。就像现在我有这样的东西:
public class SomeClass {
private static final Map<Integer, Object1> OBJECTS1 = new HashMap<>();
private static final Map<Integer, Object2> OBJECTS2 = new HashMap<>();
private static final Map<Integer, List<Integer>> OBJECTS2_IN_OBJECTS1 = new HashMap<>();
static {
Object1 object1 = new Object1(1, "someStringForObject1");
Object2 object2 = new Object2(1, "someStringForObject2");
object1.setObject2(object2);
OBJECTS1.put(object1.getId(), object1);
OBJECTS2.put(object2.getId(), object2);
SomeClass.addObject2ToObject1(object2.getId(), object1.getId());
}
public static Collection<Object1> getObjects1() {
return OBJECTS1.values();
}
public static Object1 getObject1(int id) {
return OBJECTS1.get(id);
}
public static void addObject1(Object1 object1) {
OBJECTS1.put(object1.getId(), object1);
}
public static Collection<Object2> getObjects2() {
return OBJECTS2.values();
}
public static Object2 getObject2(int id) {
return OBJECTS2.get(id);
}
public static void addObject2(Object2 object2) {
OBJECTS2.put(object2.getId(), object2);
}
public static void addObject2ToObject1(int object2Id, int object1Id) {
List<Integer> objects1OfObject2 = OBJECTS2_IN_OBJECTS1.get(object2Id);
if (objects1OfObject2 != null) {
objects1OfObject2.add(object1Id);
OBJECTS2_IN_OBJECTS1.put(object2Id, objects1OfObject2);
} else {
objects1OfObject2 = new ArrayList<>();
objects1OfObject2.add(object1Id);
OBJECTS2_IN_OBJECTS1.put(object2Id, objects1OfObject2);
}
}
}
稍后在其他 class 中,我想将对象添加到地图等。只需对这些地图进行一些操作即可。例如:
class SomeOtherClass{
public Collection getObjects() {
return SomeClass.getObjects1();
}
public Object1 addObject1(int idOfObject1, String someString, int idOfObject2) {
if (SomeClass.getObject1(idOfObject1) != null) {
System.out.prinltn("Object with this id already exists.");
return null;
}
Object1 object1 = new Object1(idOfObject1, someString);
SomeClass.addObject2ToObject1(idOfObject2, idOfObject1);
SomeClass.addObject1(object1);
return object1;
}
}
所以这是我的问题。 "SomeClass" 中的方法应该是静态的或非静态的,所以我将在每个方法中创建 "SomeClass" 对象:
class SomeOtherClass{
public Collection getObjects() {
SomeClass someClass = new SomeClass();
return someClass.getObjects1();
}
public Object1 addObject1(int idOfObject1, String someString, int idOfObject2) {
SomeClass someClass = new SomeClass();
if (someClass.getObject1(idOfObject1) != null) {
System.out.prinltn("Object with this id already exists.");
return null;
}
Object1 object1 = new Object1(idOfObject1, someString);
someClass.addObject2ToObject1(idOfObject2, idOfObject1);
someClass.addObject1(object1);
return object1;
}
}
通用规则是:static 是 OO 设计中的异常。应该是异常。它会导致您的 类 之间极其 紧密耦合 ;它玩起来不好;既没有多态性也没有单元测试。
因此:只有在有充分理由时才使用 static。
看看你的示例代码,我真的没有看到任何需要或前面提到的 "good reasons" 使用静态做任何事情。所以我的建议是:退后一步;并简单地做一些阅读。喜欢 here or there(尤其是 Alfred 的回答)。
所以我想创建 class,其中将创建一些对象,稍后我会将它们添加到 Map。将有三张地图。对象 1 的映射、对象 2 的映射以及对象 2 和对象 1 之间的关系图。就像现在我有这样的东西:
public class SomeClass {
private static final Map<Integer, Object1> OBJECTS1 = new HashMap<>();
private static final Map<Integer, Object2> OBJECTS2 = new HashMap<>();
private static final Map<Integer, List<Integer>> OBJECTS2_IN_OBJECTS1 = new HashMap<>();
static {
Object1 object1 = new Object1(1, "someStringForObject1");
Object2 object2 = new Object2(1, "someStringForObject2");
object1.setObject2(object2);
OBJECTS1.put(object1.getId(), object1);
OBJECTS2.put(object2.getId(), object2);
SomeClass.addObject2ToObject1(object2.getId(), object1.getId());
}
public static Collection<Object1> getObjects1() {
return OBJECTS1.values();
}
public static Object1 getObject1(int id) {
return OBJECTS1.get(id);
}
public static void addObject1(Object1 object1) {
OBJECTS1.put(object1.getId(), object1);
}
public static Collection<Object2> getObjects2() {
return OBJECTS2.values();
}
public static Object2 getObject2(int id) {
return OBJECTS2.get(id);
}
public static void addObject2(Object2 object2) {
OBJECTS2.put(object2.getId(), object2);
}
public static void addObject2ToObject1(int object2Id, int object1Id) {
List<Integer> objects1OfObject2 = OBJECTS2_IN_OBJECTS1.get(object2Id);
if (objects1OfObject2 != null) {
objects1OfObject2.add(object1Id);
OBJECTS2_IN_OBJECTS1.put(object2Id, objects1OfObject2);
} else {
objects1OfObject2 = new ArrayList<>();
objects1OfObject2.add(object1Id);
OBJECTS2_IN_OBJECTS1.put(object2Id, objects1OfObject2);
}
}
}
稍后在其他 class 中,我想将对象添加到地图等。只需对这些地图进行一些操作即可。例如:
class SomeOtherClass{
public Collection getObjects() {
return SomeClass.getObjects1();
}
public Object1 addObject1(int idOfObject1, String someString, int idOfObject2) {
if (SomeClass.getObject1(idOfObject1) != null) {
System.out.prinltn("Object with this id already exists.");
return null;
}
Object1 object1 = new Object1(idOfObject1, someString);
SomeClass.addObject2ToObject1(idOfObject2, idOfObject1);
SomeClass.addObject1(object1);
return object1;
}
}
所以这是我的问题。 "SomeClass" 中的方法应该是静态的或非静态的,所以我将在每个方法中创建 "SomeClass" 对象:
class SomeOtherClass{
public Collection getObjects() {
SomeClass someClass = new SomeClass();
return someClass.getObjects1();
}
public Object1 addObject1(int idOfObject1, String someString, int idOfObject2) {
SomeClass someClass = new SomeClass();
if (someClass.getObject1(idOfObject1) != null) {
System.out.prinltn("Object with this id already exists.");
return null;
}
Object1 object1 = new Object1(idOfObject1, someString);
someClass.addObject2ToObject1(idOfObject2, idOfObject1);
someClass.addObject1(object1);
return object1;
}
}
通用规则是:static 是 OO 设计中的异常。应该是异常。它会导致您的 类 之间极其 紧密耦合 ;它玩起来不好;既没有多态性也没有单元测试。
因此:只有在有充分理由时才使用 static。
看看你的示例代码,我真的没有看到任何需要或前面提到的 "good reasons" 使用静态做任何事情。所以我的建议是:退后一步;并简单地做一些阅读。喜欢 here or there(尤其是 Alfred 的回答)。