The analysis of object-oriented and class of Dark horse Programmer _

First, object-oriented overview:

Java is an object-oriented programming language, which means that the object is the basis of the language, no object, there is no java. Any function is implemented by object, which is to encapsulate the function into the object and let the object invoke these functions. The idea is to use the data as the first bit, and the method (function or algorithm) as the second. I personally think that this is an optimization of the data, security is higher, the operation of data to a more convenient.

Then the idea of ascension to a state is that all things are objects.

1, the object-oriented understanding:

1) Object-oriented is relative to process-oriented, and is based on process-oriented.

2) Object-oriented is an idea.

3) object-oriented to encapsulate the function into the object, emphasizing the function of the object, the subject is the object, the process is simplified

4) in the actual development, to the object as the core, the first clear good objects, in the implementation of specific functions, or use existing objects.

5) Object-oriented three features: encapsulation, inheritance, polymorphism.

Ii. Overview of Classes and objects

1, class: Can be understood as a blueprint or template for constructing objects, is an abstract concept, on the other hand, the object is a class as a model to create concrete instances, is a kind of embodiment, visualization.

Class: The description of things in life

Object: A concrete implementation of a class, a real entity.

A class is a description of an object.
An object is an entity that exists that can be manipulated.


Requirement: describe a car.
Describes two aspects: properties, behavior.
Properties: Number of tires. Color.
Behavior: Run.

In fact, the classes are defined as members:
The member variable-----property.
The member function-----behavior.

[Java]View Plaincopy

2. Class Car
4. {
6. //1, describes the property.
8. int num;
10. String color;
12. void Run ()
14. {
16. System.out.println (num+"::" +color);
18. }
22. }
26. The purpose of describing the object is to create the entity.
30. Class Cardemo
32. {
34. public static void Main (string[] args)
36. {
38. //Create an Entity object for car.
40. new Car ();
42. }
44. }

2. Anonymous objects

[Java]View Plaincopy

2. Class Cardemo
4. {
6. public static void Main (string[] args)
8. {
10. //Create objects.
12. Car c = new car ();
14. C.num= 4;
16. C.color = "Red";
18. C.run ();
22. Car C1 = new car ();
24. C1.num = 4;
26. C1.color = "Red";
28. C1.run ();
32. Show (c);
34. Show (C1);
42. /* 
44. An anonymous object.
48. Car c = new car ();
50. C.run ();
56. Simplified into:
58. New Car (). run ();
60. Creating an object is called only once, and can be done using an anonymous object.
62. An anonymous object can be passed as an argument.
68. Car c = new car ();
70. C.num = 4;
72. C.color = "Red";
74. C.run ();
78. New Car (). num = 5;
80. New Car (). Color = "Blue";
82. New Car (). run ();
86. */
88. Show (new Car ());
90. }
94. public static void Show (Car c)
96. {
98. C.num = 3;
100. C.color = "BLACK";
102. C.run ();
104. }

3. Object-oriented-the difference between a member variable and a local variable

[Java]View Plaincopy

1. /*
2. 1. Location of source code:
3. The member variable is defined in the class, and the variable is valid throughout the class access.
4. A local variable is defined in a method, and the variable is valid only within the method.
6. 2, in-memory location:
7. Member variables are stored in the object of the heap memory. The member variable belongs to the object.
8. Local variables are stored in the method of stack memory. The local variable belongs to the method.
10. 3, initialize.
11. Member variables have default initialization. Different initialization values are different depending on the type.
12. Local variables are not initialized by default. When used, it must be initialized before it can be used.
13. */

4. Object-oriented-encapsulation and privatization and encapsulation benefits

[Java]View Plaincopy

2. /*
4. Encapsulation: Hide implementation Details and provide public access to the outside.
8. 1, security.
10. 2, reusability.
12. 3, the change of isolation. Later applied to layered design.
20. */
22. /*
24. Description Person:
26. Attribute: Name, age.
28. Behavior: Speak.
30. */
34. Class Person
36. {
38. private String name;
40. Private */personal */ int age;
42. /* 
44. The member variable is privatized and the set get method is provided externally, and the reason for its access is that the property can be controlled.
48. The Private keyword private is a permission modifier that can only be decorated with members (member variables, member functions).
54. Note: Private is only one form of encapsulation!
58. */
62. public void SetName (String s)
64. {
66. name = S;
68. }
70. Public String getName ()
72. {
74. return name;
76. }
80. public void Setage (int a)
82. {
86. / * You can add robustness to your judgment.
88. if (a<=0 | | a>120)
90. Throw
92. */
94. age = A;
98. }
100. public int getage ()
102. {
104. return age;
106. }
112. void Speak ()
114. {
116. System.out.println (name+":" +age);
118. }
120. }
126. Class Persondemo
128. {
130. public static void Main (string[] args)
132. {
134. Person p = new person ();
136. P.name = "Eastern evil";
138. P.age =-20;
140. P.setname ("eastern Evil");
142. P.setage (20);
144. P.speak ();
146. }
148. }

The analysis of object-oriented and class of Dark horse Programmer _