تشريح الكلاس

Private fields still need checked methods

• A Student has a private score, but public void setScore(int s) { score = s; } still lets a caller supply -5. Private access alone does not enforce a non-negative score.
• A guarded setter can reject that update. Check the constructor and every other method that writes the field too; encapsulation makes a validation policy easier to enforce but does not create it automatically.

The three parts of a class

• The class designs here contain instance fields for data, constructors for initial setup, and methods for behavior. These are three useful parts to identify; formally, Java does not classify constructors as class members.
• Trace a Student from construction to an update: the constructor initializes its score field, and an instance method later reads or changes that object's score. A static method instead has no implicit current object.

A class diagram: private attributes and public methods

Instance variables hold state

• Instance variables 实例变量 store each object's own state.
• private String name; private int score; — declared inside the class, outside any method.
• Every object gets its own copy — one student's score is separate from another's.
• These persist for the life of the object (unlike local variables).

private and public

• Access modifiers control who can reach a member.
• private — usable only inside the class; public — exposed to other code that can access the class.
• Instance variables are usually private; methods that form the interface are public.
• This hiding of internal data is called encapsulation 封装.

Why keep data private

• Encapsulation prevents unrelated external code from directly assigning a private field. Code inside Student can still read or write private fields, including those of another explicitly referenced Student.
• Outsiders interact only through public methods, which can validate and control access.
• You could reject a negative score in a method; a public variable has no such guard.
• Private fields with a deliberately chosen public interface support controlled updates. Each method and constructor must still implement the intended rules; returning a mutable internal object can also expose changes indirectly.

Separate field storage from shared objects

• If two Student objects both store a reference to the same ArrayList, their list fields are separate but the referenced list is shared. Adding an item through either reference changes that one list.
• Reassigning one student's list field to a new ArrayList changes only that field. Follow reference arrows when predicting state; private access and object identity answer different questions.