Study guide
12.3 Classes, Objects, Instance Variables, Methods, and Encapsulation
Praxis Computer Science 5652
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: Praxis 5652 Exam Overview and ETS Pseudocode
1.1 Praxis 5652 Test Facts, Scoring, and Registration 1.2 Official ETS Pseudocode Notation and Tracing Strategy
2 Chapter 2: Impacts of Computing: Innovation, Access, and Effects
2.1 Computing for Creativity, Problem Solving, Communication, and Innovation 2.2 Equal Access, the Digital Divide, and Accessibility 2.3 Beneficial and Harmful Effects of Computing Innovations
3 Chapter 3: Impacts of Computing: Intellectual Property, Ethics, Privacy, and Security
3.1 Intellectual Property: Copyright, Open Source, and Creative Commons 3.2 Ethical and Unethical Computing Practices and Their Implications 3.3 Privacy, Security, Data Collection, and Local vs. Cloud Storage
4 Chapter 4: Algorithms and Computational Thinking: Abstraction, Decomposition, Number Bases, and Representation
4.1 Abstraction and Abstraction Hierarchies 4.2 Decomposition, Pattern Recognition, and Developing Algorithms 4.3 Number Bases: Binary, Octal, Decimal, and Hexadecimal 4.4 Algorithm Formats: Natural Language, Flowcharts, Pseudocode, and Tracing
5 Chapter 5: Algorithms: Efficiency, Limits of Computing, and Randomization
5.1 Algorithm Efficiency: Linear, Quadratic, Exponential, and Logarithmic Growth 5.2 Limits of Computing: Unsolvable Problems, Intractability, and Heuristics 5.3 Randomization, Random vs. Pseudorandom Numbers, and Scaling to a Range
6 Chapter 6: Algorithms: Searching, Sorting, and Recursion
6.1 Searching Algorithms: Linear Search and Binary Search 6.2 Sorting Algorithms: Tracing, Comparisons, Correctness, and Efficiency 6.3 Recursion: Base Cases, Tracing, Errors, and Iterative Equivalents
7 Chapter 7: Programming: Variables, Data Types, Strings, and Expressions
7.1 Variables, Data Types, and Type Conversion 7.2 Strings and String Operations 7.3 Operators, Precedence, Expressions, and Formulas 7.4 Boolean Expressions, Truth Tables, and Boolean Algebra
8 Chapter 8: Programming: Selection, Iteration, and Writing Code
8.1 Sequence and Selection: if, else, Chained and Nested Conditions 8.2 Iteration: for, while, do … while, and repeat … until Loops 8.3 Reading, Completing, and Modifying Code
9 Chapter 9: Programming: Procedures, Arrays, and Data Structures
9.1 Procedures, Parameters, Return Values, Nested Calls, and Scope 9.2 Arrays, Lists, and Two-Dimensional Arrays 9.3 Stacks, Queues, and Dictionaries (Maps)
10 Chapter 10: Programming: Correctness, Errors, Testing, and Code Quality
10.1 Program Correctness: Preconditions, Postconditions, Invariants, and Testing vs. Proof 10.2 Error Types and Debugging Techniques 10.3 Choosing Useful Test Cases: Boundaries, Partitions, Coverage, and Regression 10.4 Extensibility, Modifiability, and Reusability: Constants and Parameterization 10.5 Documentation, Code Reviews, Peer Feedback, and End-User Feedback
11 Chapter 11: Programming: Events, Usability, Input Validation, and APIs
11.1 Event-Driven Programming, Asynchronous Events, and Concurrency 11.2 Usability, Meaningful Error Messages, and Input Validation vs. Verification 11.3 Libraries and APIs: Reading Definitions, Making Calls, and Weighing Trade-offs
12 Chapter 12: Programming: Languages, Tools, Paradigms, and Object-Oriented Design
12.1 Low- and High-Level Languages, Compilers and Interpreters, and IDEs 12.2 Programming Paradigms: Procedural, Object-Oriented, and Others 12.3 Classes, Objects, Instance Variables, Methods, and Encapsulation 12.4 Inheritance, Polymorphism, and Overloading vs. Overriding
13 Chapter 13: Data: Bits, Encoding, Compression, and Encryption
13.1 Bits and Bytes: Why Binary, Storage Calculations, and Signed Integers 13.2 Encoding Text, Images, and Sound 13.3 Lossless and Lossy Compression: Run-Length Encoding, Huffman Coding, and Media Formats 13.4 Encoding vs. Encryption, Symmetric and Public-Key Encryption, and Their Trade-offs
14 Chapter 14: Data: Analysis Tools, Simulation, Storage, and Collection
14.1 Analyzing Data with Spreadsheets: Cleaning, Transforming, and Visualizing 14.2 Simulation and Modeling 14.3 Files, Databases, and Storage Requirements: Scale, Redundancy, and Backup 14.4 Collecting, Aggregating, and Generating Data: Public Data Sets, Surveys, Sensors, and Crowdsourcing
15 Chapter 15: Computing Systems: Hardware, Operating Systems, and Computing Environments
15.1 Hardware Components and the Fetch–Decode–Execute Cycle 15.2 Operating Systems, Software Components, and Resource Issues 15.3 Embedded Systems, the Internet of Things, and Types of Computing Systems 15.4 Local, Network, and Cloud Computing and Storage; How Binary Data Are Stored
16 Chapter 16: Networks, the Internet, the Web, and Cybersecurity
16.1 Network Types and Wired and Wireless Communication 16.2 Network Hardware and Layered Network Models (OSI and TCP/IP) 16.3 Network Performance: Bandwidth, Latency, Load, and Estimating Needs 16.4 How the Internet Works: Protocols, IP Addressing, DNS, URLs, and Reliability 16.5 The Web: HTTP, HTML and Markup Languages, Browsers, Servers, and Clients 16.6 Cybersecurity: The Five Pillars, Strong Passwords, Security Strategies, and Trade-offs
12.3 Classes, Objects, Instance Variables, Methods, and Encapsulation
Key Takeaways Explain This Topic AI
A class defines the instance variables (data) and methods (behavior) shared by all its objects; each object created with new has its own values for the instance variables.
In a UML class diagram, the top box is the class name, the middle box lists instance variables, and the bottom box lists methods; − means private and + means public.
Encapsulation makes instance variables private and provides public methods, so every change to an object's data passes through code that can validate it.
Benefits of encapsulation include protecting data integrity, hiding implementation details, and allowing internal changes without breaking code that uses the class.
A constructor initializes a new object's instance variables when the object is created.
Last updated: September 2026
What this competency asks
Under object-oriented programming, ETS asks you to:
Identify classes, instance variables, and methods given a diagram.
Identify the benefits of inheritance and encapsulation (inheritance is covered in Section 12.4).
Identify distinctions between overloading and overriding (Section 12.4).
The ETS notation includes class className … end class className and the keywords extends , new , public , and private .
- Classes and objects
- A class is a blueprint. An object (instance) is one concrete thing built from it. class Counter
- private int count // instance variable
- public Counter ( ) // constructor
- count ← 0
- end Counter
- public void increment ( ) // method
- count ← count + 1
- end increment
- public int getCount ( ) // method
- return count
- end getCount
- end class Counter
(ETS's notation table does not show a constructor. The form above, a method named like the class, is the common Java-style convention.) Counter a ← new Counter ( )
- Counter b ← new Counter ( )
- a.increment ( )
- a.increment ( )
- b.increment ( )
- print a.getCount ( ) + " " + b.getCount ( )
Output: 2 1 . Each object has its own count , so incrementing a does not affect b .
- Term Meaning In Counter
- Class Blueprint for a type of object Counter
- Object / instance One thing created from the class with new a , b
- Instance variable (field, attribute) Data stored in each object count
- Method Procedure that belongs to the class and works on an object's data increment , getCount
- Constructor Runs when an object is created; sets initial values Counter ( )
- State The current values of an object's instance variables a's count is 2
- Behavior What the object's methods can do Increase and report the count
A method is called on a specific object with dot notation : a.increment ( ) changes a's count and nobody else's.
Class (static) members
Some languages also let a variable or method belong to the class itself rather than to each object. Java marks these static . One copy is shared by all objects, for example a counter of how many objects have been created, or a utility method such as Math.sqrt . They are not in ETS's keyword list, but you will meet them in Java.
Reading a class diagram
UML class diagrams show a class as a box with three compartments.
- Compartment Contents Example for Book
- Top Class name Book
- Middle Instance variables, as name : type − title : String , − pages : int
- Bottom Methods, as name(parameters) : return type + getTitle ( ) : String , + read ( n : int ) : void
Symbols: − private, + public, # protected (visible to subclasses). An arrow with a hollow triangle points from a subclass to its superclass (inheritance; Section 12.4).
When a question asks you to "identify the instance variables," list the middle compartment. For the methods, list the bottom compartment. The class name is the top. Parameters listed inside a method, such as n in read ( n : int ) , are not instance variables.
Encapsulation
Encapsulation bundles an object's data with the methods that use it and restricts direct access to the data. Instance variables are private , and access goes through public methods. class BankAccount
private double balance
- public double getBalance ( ) // accessor ("getter")
- return balance
- end getBalance
- public boolean withdraw ( double amount ) // mutator with validation
- if ( ( amount > 0 ) and ( amount ≤ balance ) )
- balance ← balance - amount
- return true
- end if
- return false
- end withdraw
- end class BankAccount
If balance were public , any code could write acct.balance ← -50000 . Because it is private, the only way to reduce the balance is withdraw , which refuses invalid amounts.
Benefits of encapsulation
Benefit Explanation
Data integrity Every change passes through methods that enforce the rules (the class invariants), such as "balance is never negative"
Information hiding Users of the class see what it does, not how , which is abstraction
Easier change The internal representation can change, for example storing cents in an int instead of dollars in a double, without changing code that calls the public methods
- Easier debugging If a value is wrong, only the class's own methods could have changed it
- Clear interface The public methods document how the class is meant to be used
- Access levels
- Modifier Accessible from
- private Only code inside the same class
- public Any code
- protected (Java, C++) The class and its subclasses (in Java, also classes in the same package)
ETS's pseudocode lists only public and private .
Designing a simple class
To model a real entity, ask:
What does each object need to remember? Those become the instance variables, usually private .
What should an object be able to do, or report? Those become the public methods.
What must always be true? Enforce it in the constructor and the mutators.
For a Student : instance variables name , id , and gpa ; methods getName ( ) , updateGpa ( newGpa ) (which rejects values outside 0.0–4.0), and toString ( ) .