JAVA中域、方法、类的可见性

1. 多态在域的问题上是特殊的。我理解不了中文版的书直接叫域，看了英文原版，原版写的是fields，直接翻译虽然没错，但是出问题的变量不是域。特地查了what is the meaning of field in java？很多人把它看成是由花括号括起来的一个范围。其实框架里面也有一种东西——domain model，这个也叫域，域模型。

   然后找到这篇文章

   What is a field in java?

   A field is an attribute. A field may be a class's variable, an object's variable, an object's method's variable, or a parameter of a function.

   1. class bike{
   2. static int bikes;
   3. int gear;
   4. int cadence;
   5. void create( int newGear, int newCadence ){
   6. bikes = bikes + 1;
   7. gear = newGear;
   8. cadence = newCadence;}
   9. int getSpeed(){
   10. int speed = gear*cadence*5*3.141;
   11. return speed;
   12. }
   13. }

   'bikes' is a class's variable (class variable) (static field).
   'gear' and 'cadence' could be an object's variables (instance variables) (non-static fields).
   'speed' is an object's method's variable (local variable). 
   'newGear' and 'newCadence' are parameters of a function (parameters).

   field，域是一种属性，可以是一个类变量，一个对象变量，一个对象方法变量或者是一个函数的参数。（补充，class‘s variables，类的实例变量和静态变量称为class's variables，类属变量，也称类变量或数据域，其实翻译成属性也可以，类属性，听起来不会怪怪的，来自百度百科）。

   1. class bike{
   2. static int bikes;
   3. int gear;
   4. int cadence;
   5. void create( int newGear, int newCadence ){
   6. bikes = bikes + 1;
   7. gear = newGear;
   8. cadence = newCadence;}
   9. int getSpeed(){
   10. int speed = gear*cadence*5*3.141;
   11. return speed;
   12. }
   13. }

   bikes是一个类变量(静态域)。

   gear 和 cadence 是对象变量（实例变量）（非静态域）。

   （这里有一点点小矛盾，其实这样照百科这样说，那么bikes、gear和cadence都是类变量，bikes是类变量中的静态变量，而gear和cadence是类变量中的实例变量。）

   speed是对象方法的变量(局部变量)。

   （看到没有，local variable，java没有出现gobal variable，全局变量，要说的话类变量的作用范围和全局变量一样，只不过不那样叫）。

   newGear和newCadence是函数(方法)的参数(参数)。

2. **
3. * 公共类，在所有包中可见
4. * @author OOS
5. *
6. */
7. public class PublicClass {
8. /**
9. * 公共域，所有子类中可见
10. */
11. public int publicNum;
12. /**
13. * 私有域，当前类可见
14. */
15. private int privateNum;
16. /**
17. * 保护域，所有子类中可见
18. */
19. protected int protectedNum;
20. /**
21. * 默认域，当前包的子类中可见
22. */
23. int defaultNum;
24. /**
25. * 公共方法
26. * 可使用：所有类
27. * 可继承：所有子类
28. */
29. public void publicMethod(){};
30. /**
31. * 私有方法
32. * 可使用：当前类
33. * 可继承：无
34. */
35. private void privateMethod(){};
36. /**
37. * 保护方法
38. * 可使用：当前包
39. * 可继承：所有子类
40. */
41. protected void protectedMethod(){};
42. /**
43. * 默认方法
44. * 可使用：当前包
45. * 可继承：当前包的子类
46. */
47. void defaultMethod(){};
48. /**
49. * 私有类，仅在定义它的类中可见
50. * @author OOS
51. *
52. */
53. private class PrivateClass{
54. }
55. /**
56. * 保护类，仅在当前包、当前类和所以子类中可见
57. * @author OOS
58. *
59. */
60. protected class ProtectedClass{
61. protected ProtectedClass()
62. {
63. }
64. }
65. /**
66. * 默认类，仅在当前包中可见
67. * @author OOS
68. *
69. */
70. class DefaultClass {
71. }
72. }

与PublicClass同一个包中的测试类CurrentPackageTest，如下：

1. public class CurrentPackageTest extends PublicClass{
2. public static void main(String[] args)
3. {
4. PublicClass pc = new PublicClass();
5. //当前包可以使用保护方法和默认方法
6. pc.protectedMethod();
7. pc.defaultMethod();
8. //保护类在当前包可见
9. PublicClass.ProtectedClass protectedClass = new PublicClass().new ProtectedClass();
10. //默认类在当前包可见
11. DefaultClass defaultClass = new PublicClass().new DefaultClass();
12. }
13. public CurrentPackageTest()
14. {
15. System.out.println(super.publicNum);
16. System.out.println(super.protectedNum);
17. //PublicClass和当前类同属于一个包，所以defaultNum可继承
18. System.out.println(super.defaultNum);
19. }
20. }

与PublicClass不同一个包中的测试类OtherPackageTest，如下：

1. public class OtherPackageTest extends PublicClass{
2. public static void main(String[] args)
3. {
4. PublicClass pc = new PublicClass();
5. //PublicClass与当前类不属于同一个包，仅能使用公共方法
6. pc.publicMethod();
7. }
8. public OtherPackageTest()
9. {
10. System.out.println(super.publicNum);
11. System.out.println(super.protectedNum);
12. }
13. }