父类为子类定义静态类

omqzjyyz  于 2021-07-06  发布在  Java
关注(0)|答案(1)|浏览(388)

想知道是否有一种方法可以在java中做到这一点。
假设我想创建一个父类(可能是抽象的)并创建多个不同的子类。我希望所有类都有一个特定的字段,但我需要该字段在子上下文中是静态的。有没有办法在父类中定义这个?
例如,假设我对名为foo的字段有getter和setter。在父类中,静态字段被初始化为字符串“foo”。我有两个儿童班abschildone和ABSCHILDON2。我想做的是:

  1. AbsChildOne absOneA = new AbsChildOne();
  2. AbsChildOne absOneB = new AbsChildOne();
  3. AbsChildTwo absTwo = new AbsChildTwo();
  4. absOneA.setFoo("bar");
  5. System.out.println("absOneB "+absOneB.getFoo());
  6. System.out.println("absTwo "+absTwo.getFoo());

返回

  1. absOne2 bar
  2. absTwo foo

换句话说,静态字段对于子类来说只是静态的,而不是其他子类。

ax6ht2ek

ax6ht2ek1#

事实是 static 在类级别,因此每次都有一个值 classes 包括 subclasses (不要与类示例混淆)。因此,在使用static(甚至init)时,不需要有示例( new ) String s_get_static_value = ClassName.value . 每次,每次 ClassName_instances 一次只有一个值适用于所有情况 instances . 因此,一旦更改(在类级别,instance)将反映到所有示例(隐含的类级别)。
关键是不能保持从同一个静态派生的2个单独的静态(总是有1个值而不是2)。
现在,如果希望有一个扩展字段父级,每个子级有一个单独的值(类级只有1个,所有示例都派生自 Type . Type 也可以是一个不同的子类。 Parent_Type 不等于 Child_type 即使 Child 延伸 Parent ).
考虑逻辑的偶然性。(要求:与你的相同,但没有静态)

  1. //in term of field_value ; all in the same time and just 1 based on Types
  2. parent = A (on Parent class) : Type Parent
  3. parent = A1 (on Child1 at inhereted field from Parent) : Type Child1
  4. parent = A2 (on Child2 at inhereted field from Parent) : Type Child2
  5. //oneInstance is doing that task which is an object based on Singleton
  6. //can hold as may parameters as wanted (mystring in this case)

也许这能帮你。

  1. //adjusted singleton with a map which hold instances
  2. import java.util.HashMap;
  3. import tst.Test02.Child1;
  4. import tst.Test02.Child2;
  5. public class OneInstance
  6. {
  7. String myString = "";
  8. private OneInstance oi ;
  9. public static HashMap<String, OneInstance> hm = new HashMap<String,OneInstance>();
  10. public static OneInstance getInstance(Object o)
  11. {
  12. if(!hm.containsKey(o.getClass().toString()))
  13. hm.put(o.getClass().toString(), new OneInstance("default value for _"+o.getClass().toString()));
  14. return hm.get(o.getClass().toString());
  15. }
  16. public static OneInstance getInstance(Object o,String s)
  17. {
  18. if(!hm.containsKey(o.getClass().toString()))
  19. hm.put(o.getClass().toString(), new OneInstance(s));
  20. return hm.get(o.getClass().toString());
  21. }
  22. public static OneInstance getInstance()
  23. {
  24. if(!hm.containsKey(new Parent().getClass().toString()))
  25. hm.put(new Parent().getClass().toString(), new OneInstance("default value for Parent"));
  26. return hm.get(new Parent().getClass().toString());
  27. }
  28. private OneInstance() {}
  29. private OneInstance(String s)
  30. {
  31. myString = s;
  32. }
  33. }
  1. public class Parent
  2. {
  3. static MyObj sobj = new MyObj("static name");
  4. OneInstance oi;
  5. public String toString()
  6. {
  7. return "myString="+oi.getInstance().myString;
  8. }
  9. }
  1. //usage
  2. import java.util.Set;
  3. public class Test02
  4. {
  5. public static void main(String[] args)
  6. {
  7. Test02 t = new Test02();
  8. Child1 c1;
  9. Child2 c2;
  10. System.out.println("inhereted name for child1:"+Child1.sobj.name);
  11. Child1.sobj.name = "child1_new_name";
  12. System.out.println("child1 new name:"+Child1.sobj.name);
  13. System.out.println("inhereted name for child2:"+Child2.sobj.name);
  14. System.out.println("-----------");
  15. System.out.println(new Parent());
  16. c1 = t.new Child1("child1_string");
  17. //with any specification just init with parent value and keep
  18. System.out.println(c1);
  19. System.out.println(c1.oi.getInstance(c1).myString);
  20. System.out.println("-----------");
  21. System.out.println("dump HashMap");
  22. OneInstance.hm.forEach((k, v) -> System.out.println((k + ":" + v.myString)));
  23. System.out.println("-----------");
  24. c2 = t.new Child2("child2_string from constructor");
  25. c1.oi.getInstance(c1).myString = "changed for child 1";
  26. System.out.println(c1.oi.getInstance(c1).myString);
  27. System.out.println("dump HashMap");
  28. OneInstance.hm.forEach((k, v) -> System.out.println((k + ":" + v.myString)));
  29. System.out.println("-----------");
  30. c2 = t.new Child2("child2_string from constructor");
  31. System.out.println(c2);
  32. //System.out.println(c2.oi.getInstance(c2).myString);
  33. //c2.oi.getInstance(c2).myString = "changed for child 2";
  34. //System.out.println(c2.oi.getInstance(c2).myString);
  35. System.out.println(c1);
  36. System.out.println(c1.oi.getInstance(c1).myString);
  37. System.out.println(c2.oi.getInstance(c2).myString);
  38. System.out.println("dump HashMap");
  39. OneInstance.hm.forEach((k, v) -> System.out.println((k + ":" + v.myString)));
  40. System.out.println("-----------");
  41. }
  42. class Child1 extends Parent
  43. {
  44. //inherited
  45. //OneInstance oi ;
  46. Child1(String s)
  47. {
  48. oi = OneInstance.getInstance(this, s);
  49. }
  50. public String toString()
  51. {
  52. return "myString="+oi.getInstance(this).myString;
  53. }
  54. }
  55. class Child2 extends Parent
  56. {
  57. //OneInstance oi ;
  58. Child2(String s)
  59. {
  60. oi =OneInstance.getInstance(this, s);
  61. }
  62. public String toString()
  63. {
  64. return "myString="+oi.getInstance(this).myString;
  65. }
  66. }
  67. }

输出:

  1. inhereted name for child1:static name
  2. child1 new name:child1_new_name
  3. inhereted name for child2:child1_new_name
  4. -----------
  5. myString=default value for Parent
  6. myString=child1_string
  7. child1_string
  8. -----------
  9. dump HashMap
  10. class tst.Test02$Child1:child1_string
  11. class tst.Parent:default value for Parent
  12. -----------
  13. changed for child 1
  14. dump HashMap
  15. class tst.Test02$Child1:changed for child 1
  16. class tst.Test02$Child2:child2_string from constructor
  17. class tst.Parent:default value for Parent
  18. -----------
  19. myString=child2_string from constructor
  20. myString=changed for child 1
  21. changed for child 1
  22. child2_string from constructor
  23. dump HashMap
  24. class tst.Test02$Child1:changed for child 1
  25. class tst.Test02$Child2:child2_string from constructor
  26. class tst.Parent:default value for Parent
  27. -----------

关于测试,在代码开发之前。如果代码中存在逻辑错误,那么测试会带来什么结果呢(整个测试套件将失败,并且在继续之前有一些关键缺陷需要解决……)很好地了解测试api的各种设置\ujunit,但这不是主要范围。代码设计是为了正常运行,而不是为了测试而进行的代码设计(主要问题来自代码设计 static 而不是来自 how to test )
注意:您必须添加一些逻辑来根据继承进行调整(保留字段),但是为什么不更改逻辑并允许另一个不同的字段作为子字段呢?它很容易实现,也可以使用静态的。

  1. class Parent
  2. {
  3. static String parent;
  4. }
  5. class Child1 extends Parent
  6. {
  7. //inhereted
  8. //static String parent;
  9. //add a new one per subclasses
  10. static String child1;
  11. }

只需比较每个场景所需的代码行,并询问它是否真的值得?度量(即使在代码行内)也在质量代码中起作用。

展开查看全部

相关问题