1. Phil Tayco San Jose City College Slide version 1.2 Updated Sep 9, 2019
Classes and Objects
Phil Tayco
San Jose City College
Slide version 1.2
Updated Sep 9, 2019

2. Primitive Data Types
All variables are defined with a data type and variable name
int age = 21;
double gpa = 3.9;
Memory for age and gpa is instantly allocated and contents are initialized
Process is automatically done because the language already knows these simple data types
All variables in memory have a location
Managing how these memory locations are used is the next step
age 21
gpa
3.9

3. Memory References
Memory locations can be referred to by other variables (in C/C++, this is called a “pointer”)
A memory reference is essentially a variable that contains a memory address as its value
The value refers to a memory location where information is stored
When memory references are defined, the location it is pointing to must be reserved (a.k.a. memory must be “allocated”)
Modern programming languages have “no pointers”, but in fact they are handling a lot of the pointer process automatically for you
C and C++ gives you more memory management control, which can be both a blessing and a curse!

4. Memory References
Memory references are useful when handling complex data
In Java, memory reference management is automatically done by default when you use data types that are not primitive
Exception: String data types are technically considered to be complex data types, but can be treated the same way as primitives
Java manages memory references for simple and complex data types and does a lot of the behind the scenes work
It is important to know the process that occurs behind the scenes as it will become useful to understand later with advanced concepts

5. Memory References
When we declare a variable with a complex data type, the memory location it is referring to is yet to be defined
Student me; me ?

6. Memory References
To allocate the memory, we request it with the “new” keyword
Student me = new Student();
When the compiler sees “new Student()” it uses what it knows a Student looks like and looks in memory for a location large enough to store that data
0x1234abcd is an example of a numeric location where the Student data could reside
“me” is the variable that now refers to the location of the Student data. In Java, this is transparent to us, but we should know that this structure exists me
0x1234abcd
(Student data)

7. Complex Data Types But how does Java know what “a Student looks like”?
Integers and doubles are simple data types because they store one value. (age stores 21 and gpa stores 3.9)
Conceptually, a Student can store much more types of information. Think of every Student that you may want to model in a program. Every Student has:
First name
Last name
Age
Gpa ID
Each one of these elements of a Student is called a “property” (also called an “attribute”)

8. Complex Data Types
These properties make up the template for defining a Student
In the example, we declared a variable “me” whose data type is “Student” (this is the same as when we declared a variable “age” whose data type is an integer)
We assigned age a value of 21 after we declared it. Similarly, we will want to assign values to me’s properties
This means Student’s properties are like variables grouped together within (or “encapsulated”) the overall Student variable (“me”)
me has its own first name, last name, ID, etc.
As such, each property is defined like a variable

9. Complex Data Types
public class Student {
public String firstName;
public String lastName;
public int age;
public int id;
public double gpa; }
These properties are defined in a separate Java file called a “class”
The file is separate because a class is designed to be a “stand-alone” data type
In true Object-Oriented design, a class is intended to be used by any number of other programs

10. Complex Data Types
In another program (such as in the “main” function), we can assign values to these properties for the “me” variable
In memory, technically the location where the Student data was allocated is found through the memory address – a process called “dereferencing”
Student me = new Student();
me.id = 1234;
me.age = 21;
me.firstName = “Phil”; me
0x1234abcd
firstName
“Phil”
lastName id
1234
age 21
gpa

11. Complex Data Types
You can define as many different variables defined with primitive data types as memory allows (int x, int y, int z, etc.)
Similarly, you can define as many different variables with classes (Student me, Student you, Student[] roster, etc.)
Variables with primitive types are commonly referred to as just variables. A variable whose data type is a class is called an “object”
Objects are seen as “instances” of a class. Creating objects is also called “instantiation”
Object-oriented programming is the study of designing solutions primarily through the manipulation of such objects (variables with complex data types)

12. Accessing Properties
When a class is designed with the data members public, a binding occurs between the code creating the object of that class and the class’ design
Class example:
public class Student {
public String firstName;
public String lastName;
public int age;
public int id;
public double gpa; }

13. Accessing Properties
Using that class, objects in other programs set property values directly:
Student example = new Student();
example.firstName = “John”;
example.id = 123;
This makes the object and class code somewhat dependent on each other
Changes in code on the use of the object are ok as they won’t affect the class code design
More importantly, the class code shouldn’t be aware how it’s used! The class is simply providing capabilities to object creators.

14. Programming Exercise 1 Create a class that models a simple Car
For your Car class, create 5 properties that will utilize at least 1 String, 1 int and 1 double. The properties are:
Make (e.g. “Toyota”)
Model (e.g. “Corolla”)
Year (e.g. 2016)
Price (e.g )
Some other property of your choosing
Next, write a main program that creates at least 2 Car objects and assigns values to each one’s properties
You can hard code the values in the code and display them on the screen – the purpose of this exercise is to get you used to creating classes

15. Accessing Properties
The relationship from this exercise and example can be referred to as “high coupling” or “weak encapsulation”
Weak encapsulation means that the property information is not hidden because it is available for all to use (they are public)
Is this high coupling bad?
What if the code in main changes (example.id = 456;), does that impact the code in the class?
What about the other way? What happens if we change any of the code in the class. Does it affect the code in main?

16. Accessing Properties Absolutely!
public class Student {
public String first_name;
public String lastName;
public int age;
public String id;
public double gpa; }
These simple code changes affects the example object
example.firstName has to change to example.first_name
example.id = 123 has to change to example.id = “123”

17. Accessing Properties
In small amounts of code, this can be manageable, but as programs get larger and object use increases, any change in class code design has more downstream effects
Property usage is also a highly performed activity – programs are fundamentally designed to manipulate the variable values and make logical decisions from them
It is also hard to predict what complex programs actually need as they evolve (i.e. class designs change often)
Classes are also supposed to be stand-alone. New programs using the class may have different needs than as the class originally was designed
As requirements change, data types used will evolve

18. Strong Encapsulation
Because class properties have such high usage and evolution, another approach is to hide that information from other programs
public class Student {
private String firstName;
private String lastName;
private int age;
private int id;
private double gpa; }
This now means any object created as type Student cannot directly access the properties (example.id = 123 would result in a compile error)

19. Strong Encapsulation
How are property values manipulated if they are marked as private? Something else has to be marked as public…
In order to see how that is typically done, we must first discuss another aspect to all class designs
To this point, our classes have properties that define “what objects of that class type will have”
In addition, we can define “behaviors” that define “what you can do with objects of that class type”
Set the Student’s name
Check if the Student has a passing grade
Determine if the Student is an adult based on their age
These behaviors are also referred to as “methods” and they define actions

20. Class Methods
We’ve already seen code that define actions such as “calculateArea” or “println”
These actions are defined in the form of a function. Recall that a function is defined with 3 parts: function name, return type and input parameters
public double calculateArea(double length, double width) {
return length * width; }
This function is defined with the name “calculateArea”, a return type of “double” and has 2 input parameters that are each “double” data types

21. Class Methods
We call the definition of a function a “function signature” and all signatures have these 3 elements
Within the function contains the code for performing the overall action it is intended to define
We learned that such code is also designed to be stand-alone and hidden. This means whomever calls the function with their code, they don’t see what the code actually does (nor should they!)
Key concept: a function caller should only know how to use a function properly and that it performs as expected
We can take advantage of this by defining functions in classes designed to handle property value usage

22. Class Methods
public class Student {
private String firstName;
public void setFirstName(String f)
firstName = f; }
In this example, the method signature is “setFirstName”. It takes a String as an input parameter and returns nothing (return type is void)
Within the function, “f” is a local String variable initialized by the input value where the function was called
The goal of this method is to set the firstName property to a given value (stored in f)

23. Class Methods Typical questions arise from this approach
How is this function called?
Where and how is “firstName” used?
Remember that these functions live within the context of a class
A class is used when an object is instantiated of its type
Once an object is created, anything defined as public within the class design is usable and will apply to that specific object

24. Class Methods
Student me = new Student();
me.setFirstName(“John”);
In this example, an object “me” is created of type Student
The only thing defined as public in the Student class is the “setFirstName” method
When the method is used, it will be in the context of a created object – this means in this case, the setFirstName method will be applied to the “me” object
Since the method is a public function, we use it like a function call, sending in a String and not expecting a return value because of the way the method signature is defined

25. Class Methods
When the method is called, “John” comes in as an input value that will be assigned to the “f” variable in the setFirstName function
public void setFirstName(String f) {
firstName = f; }
Now the important part: the only line of code in the method is “firstName = f;”. Where is firstName defined?
Since it is not defined within the function, we have to look outside the function but still within the code module the function is defined

26. Class Methods That code module is the class itself!
public class Student {
private String firstName;
public void setFirstName(String f)
firstName = f; }
That code module is the class itself!
This means firstName is accessible to all functions defined within the class
Now note that firstName is treated like a variable – we call it a class property, but it is essentially a variable
By itself, firstName is definition. It is not a physical variable, until when…?

27. Class Methods …when an instance of the class is created!
“firstName” doesn’t become a physical element in memory until “Student me = new Student();” was created
Once that object was instantiated, me.firstName = “John”; could be done to assign “John” to the firstName property of the “me” instance
But remember, we made firstName private, so that line of code is not allowed
setFirstName is a method that is public, so we will use that
By calling the function setFirstName(“John”):
“John” is used in the function (through f)
f is assigned to the variable firstName
firstName represents the property of the me object (because we called it with “me.setFirstName(…”)

28. Class Methods This approach can be used with all class properties
public void setGpa(double g) {
gpa = g; }
Some questions to note:
“gpa” property name is part of the function name “setGpa” – what would the function name be for the id or lastName properties?
The input parameter type is “double” which matches the gpa property data type definition. What would the input parameter types be for id and lastName?
Why is the return type void? Could the return type be something else? If so, what could it signify?

29. Class Methods
This approach promotes code reuse as well. If we create multiple objects, the same code is used within the context of each object:
Student one = new Student();
Student two = new Student();
one.setFirstName(“Susan”);
two.setFirstName(“Alex”);
One and two are physically two separate objects with their own property values
Both are using the same code instructions to set their individual firstName properties respectively
These particular methods are frequently used and commonly referred to as “setters” or “mutators” – they are functions designed to change object property values

30. Class Methods
Could you create set methods that change more than one property at a time? Yes!
public void setName(String f, String l) {
firstName = f;
lastName = l; }
What are pros/cons to doing so?
Remember, any function created doesn’t always have to be used…
Mutators are needed for changing object property values. What about when we need to view the data?

31. Accessing Data
Previously, we could look at an object’s property value at any time directly:
System.out.println(me.firstName);
However, the firstName property is now private
We need another way to retrieve that value
Put another way, we need a “method” that is designed to “return” the firstName value to us
This leads to designing another function. Based on the information here, what would the method signature for seeing the object’s firstName value?

32. Accessing Data
Remember the 3 parts to the function signature: name, input parameter types and return type
public String getFirstName() {
return firstName; }
The name of this function (which also states its purpose) is appropriately entitled “getFirstName”
The return type is a String meaning that when the function is called, we will get what represents the firstName of the Student object as a String
Why are there no input parameters?

33. Accessing Data
Just like with the set methods, these get methods are designed to be used for each class property
Because the value coming back is through a return value of a function, the get methods are designed to return one property value
The return type in this example is a String which matches the definition of firstName in the class. This usually is the case, but remember:
The class is encapsulating the definition of the firstName property. This means we can change the name and the type at any time (what would we have to change if we did that?)
There are usually no input parameters with get methods because their job is to return existing (and known) information. No new information from the object method call is needed to perform this action

34. Setters and Getters
Like setters/mutators, these functions are commonly referred to as “getters” or “accessors”
You typically see a get and a set function for each property (a class with 4 properties will usually have 4 accessors and 4 mutators)
Their function signatures usually follow a pattern based on the property name and its data type
Some classes may not want to have certain accessors/mutators defined – this will depend on the class designer’s intent of use
Any number of setter functions can occur. Typically you see one get function per class property

35. Changing Design
Why go through the of creating set and get methods when making the properties public seems so much easier?
Recall the dependency between the modules and when class code changes – the change impacted the code in main in our previous examples
If we wanted to, we can change a property name or a property data type, without impacting main because that code is marked as private

36. Changing Design We changed the property from firstName to first_name
public class Student {
private String first_name;
public void setFirstName(String f)
first_name = f; }
We changed the property from firstName to first_name
Because of that, we also had to change its use in the setFirstName method
Important: the main program still calls the method with me.setFirstName(“John”); - this code does not change! (it doesn’t even know the code in method changed!)

37. Changing Design
This puts in a foundation such that your class code can now change with minimal to no impact to other programs using it
This emphasizes the importance of a function signature – because it is public (it is the interface for the application programmer), once it is in use, great care must be taken if you decide to change it
This also emphasizes trying to get the signature well defined before releasing for use
Once established, code changes within the methods and anything marked private can be done within the class code file itself

38. Programming Exercise 2
Update your Car class so that all the properties are now private
Add the appropriate set/get methods to your class
Update the main program to have each Car object call all set/get functions you created to test your code