JAVA中域方法类的可见性

Posted 2020-11-03

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.
   
   

   [java] view plain copy

    

   1. class bike{   
   2.   static int bikes;  
   3.   int gear;  
   4.   int cadence;  
   5.   
   6.   void create( int newGear, int newCadence ){  
   7.     bikes = bikes + 1;  
   8.     gear = newGear;  
   9.     cadence = newCadence;}  
   10.   int getSpeed(){  
   11.     int speed = gear*cadence*5*3.141;  
   12.     return speed;  
   13.   }  
   14. }  
   
   ‘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，类属变量，也称类变量或数据域，其实翻译成属性也可以，类属性，听起来不会怪怪的，来自百度百科）。

    

    

   [java] view plain copy

    

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

    

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

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

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

    

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

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

    

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

    

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

 

 

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

 

[java] view plaincopy

 

 

 

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.       
14.     public CurrentPackageTest()  
15.     {  
16.         System.out.println(super.publicNum);  
17.         System.out.println(super.protectedNum);  
18.         //PublicClass和当前类同属于一个包，所以defaultNum可继承  
19.         System.out.println(super.defaultNum);  
20.     }  
21. }  

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

 

 

[java] view plaincopy

 

 

 

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.       
9.     public OtherPackageTest()  
10.     {  
11.         System.out.println(super.publicNum);  
12.         System.out.println(super.protectedNum);  
13.     }  
14. }