Visibility of domains, methods, classes in Java

1. Polymorphism is a special problem in the domain. I can not understand the Chinese version of the book directly called the domain, read the original English, the original writing is fields, direct translation Although correct, but the problem of the variable is not a domain. Specifically checked what's the meaning of field in Java? Many people think of it as a range enclosed in curly braces. In fact, there is a kind of thing inside the frame--domain model, which is also called domain, domain models.

   and find this post.

   What's a field in Java?

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

   [Java]View PlainCopy
   2. Class bike{
   4. static int bikes;
   6. int gear;
   8. int cadence;
   12. void Create ( int newgear, int newcadence) {
   14. Bikes = bikes + 1;
   16. Gear = Newgear;
   18. Cadence = newcadence;}
   20. int GetSpeed () {
   22. int speed = gear*cadence*5*3.141;
   24. return speed;
   26. }
   28. }
   
   ' Bikes ' is a class ' s variable (class variable) (static field).
   The ' gear ' and ' cadence ' could is an object's variables (instance variables) (non-static fields).
   ' Speed ' was an object ' s method ' s variable (local variable).
   ' Newgear ' and ' newcadence ' are parameters of a function (parameters).
   

   field, a field is a property that can be a class variable, an object variable, an object method variable, or a parameter to a function. (Supplemental, class's variables, instance variables and static variables of classes are called class ' s variables, generic variables, also known as class variables or data fields, actually translated into properties can also, class properties, sounds not weird, from Baidu Encyclopedia).

   [Java]View PlainCopy
   2. Class bike{
   4. static int bikes;
   6. int gear;
   8. int cadence;
   12. void Create ( int newgear, int newcadence) {
   14. Bikes = bikes + 1;
   16. Gear = Newgear;
   18. Cadence = newcadence;}
   20. int GetSpeed () {
   22. int speed = gear*cadence*5*3.141;
   24. return speed;
   26. }
   28. }

   
   Bikes is a class variable (static field).

   Gear and Cadence are object variables (instance variables) (non-static domains).

   (Here is a little bit of a contradiction, in fact, according to the encyclopedia, so bikes, gear and cadence are class variables, bikes is a static variable in the class variable, and gear and cadence are the instance variables in the class variable.) ）

   Speed is the variable (local variable) of the object method.

   (see no, local Variable,java does not appear gobal variable, global variables, to say that the scope of the class variable is the same as the global variable, but not called).

   Newgear and Newcadence are parameters (parameters) of a function (method).

7. **
9. * public class, visible in all packages
11. * @author OOS
13. *
15. */
17. Public class Publicclass {
19. /** 
21. * Public domain, visible in all sub-classes
23. */
25. public int publicnum;
29. /** 
31. * Private domain, current class visible
33. */
35. private int privatenum;
39. /** 
41. * Protected domain, visible in all subclasses
43. */
45. protected int protectednum;
49. /** 
51. * Default domain, visible in sub-class of current package
53. */
55. int defaultnum;
59. /** 
61. * Public method
63. * Available: All classes
65. * Inheritable: All sub-classes
67. */
69. public void Publicmethod () {};
73. /** 
75. * Private Method
77. * Available: Current class
79. * Inheritable: None
81. */
83. private void Privatemethod () {};
87. /** 
89. * Protection method
91. * Available: Current package
93. * Inheritable: All sub-classes
95. */
97. protected void Protectedmethod () {};
101. /** 
103. * Default method
105. * Available: Current package
107. * Inheritable: Sub-class of the current package
109. */
111. void Defaultmethod () {};
115. /** 
117. * Private class, only visible in the class in which it is defined
119. * @author OOS
121. *
123. */
125. private class privateclass{
129. }
133. /** 
135. * Protection class, visible only in current package, current class, and so subclasses
137. * @author OOS
139. *
141. */
143. protected class protectedclass{
145. protected Protectedclass ()
147. {
151. }
153. }
157. /** 
159. * Default class, only visible in current package
161. * @author OOS
163. *
165. */
167. class Defaultclass {
171. }
173. }

Test class Currentpackagetest in the same package as Publicclass, as follows:

[Java] View plaincopy

2. Public class Currentpackagetest extends publicclass{
4. public static void Main (string[] args)
6. {
8. Publicclass pc = new Publicclass ();
10. //Current package can use protection method and default method
12. Pc.protectedmethod ();
14. Pc.defaultmethod ();
16. //Protection class visible in current package
18. Publicclass.protectedclass Protectedclass = new Publicclass ().   New Protectedclass ();
20. //default class is visible in current package
22. Defaultclass Defaultclass = new Publicclass ().   New Defaultclass ();
24. }
28. Public currentpackagetest ()
30. {
32. System.out.println (super.publicnum);
34. System.out.println (super.protectednum);
36. //publicclass and current similarity belong to a package, so defaultnum can inherit
38. System.out.println (super.defaultnum);
40. }
42. }

Unlike Publicclass, a test class in a package is Otherpackagetest, as follows:

[Java] View plaincopy

2. Public class Otherpackagetest extends publicclass{
4. public static void Main (string[] args)
6. {
8. Publicclass pc = new Publicclass ();
10. //publicclass does not belong to the same package as the current class, only public methods can be used
12. Pc.publicmethod ();
14. }
18. Public otherpackagetest ()
20. {
22. System.out.println (super.publicnum);
24. System.out.println (super.protectednum);
26. }
28. }

Visibility of domains, methods, classes in Java