T03 Objects and Classes

Air Force Institute of Technology
Electrical and Computer Engineering
Object-Oriented Programming Design
Topic :
Objects and Classes
Maj Joel Young

Joel.Young@afit.edu
Apr 2, 2024 Maj Joel Young

Object-Oriented
Programming
Design
Object-Oriented Programming Principles
• Organize program into a set of objects with certain

properties and operations that the objects perform.
• State of objects may change over time, but you can depend
on objects not interacting with each other in an
undocumented way
• Objects communicate with other objects via messages which
call methods defined in the public interface of the other
object -- i.e. clients send messages to server objects which
then perform a task for the client object.

Apr 2, 2024 Electrical and Computer Engineering 2
Object-Oriented
Programming
Design
Characteristics of an Object
• State
– The internal attributes of a thing, and their values
• Behavior
– Operations that affect the state of a thing
– Operations a thing performs based on its state
– Methods describe how objects behave and how objects from other classes
can interact with an object
– Mutator methods change state of object -- setAttribute
– Accessor methods return state of object -- getAttribute
• Identity
– Given any two things, we can tell them apart from each other
– Implementation: Record ID, SS#, memory address, etc.

Object-Oriented
Programming
Design
Object
• Real-world Example
– Cruise Control
– User Interface
– On/Off
– Set
– Increase
– Decrease
– Implementation
– State
– Desired speed
– Actual speed
– Operations
– Activate
– Deactivate
– Accelerate
– Decelerate
– Identity
– Unique instance for each vehicle

Object-Oriented
Programming
Design
• Class
– Template from which an object is actually made
– Specifies operations and states for a type of object
– An object that conforms to a class description is an instance of that class
– There may be multiple instances (objects) created from a class
– Classes themselves are not “objects”
– It’s the difference between saying
– “Colleges offer courses” and “AFIT offers CSCE694”
– One is a general statement true for all colleges; the other is a specific
example
– Classes describe the general case,
– Objects are the specific instances

Object-Oriented
Programming
Design
• Encapsulation (aka data hiding)

– Hiding implementation of data from user of object
– Data in object are instance variables
– Functions and procedures in Java class are methods
– Encapsulation implemented by preventing other classes from accessing
instance variables in a class except through the class methods

Object-Oriented
Programming
Design
Class Relationships
• Association (uses)
– A class uses another class if it manipulates objects of that class
– Method of class A sends message to an object of class B
– Method of A creates, receives, or returns objects of class B
• Aggregation (has-a)
– Objects of class A contain objects of class B
– Special case of use
• Inheritance (is-a) (more on this later)
– If class A extends class B, class A inherits methods from class B
– Class A is a specialization of class B
GasStation Automobile Employee
* 1
uses has
is-a
* 4
Automobile Tire Manager

Object-Oriented
Programming
Design
Class Relationships
Course
-name: String
-credits: int
+printRoster()
+enroll(newStudent: Student)
attends teaches
1..*
Student Professor
-name: String -name: String
-studentID: long -title: String
+printSchedule() +printCourseLoad()

Object-Oriented
Programming
Design
Java Classes
• A Java class contains:

– Attributes (variable declarations, a.k.a. “fields”)
– Operations (a.k.a. “methods”)
• General Rules:
– A class is given a name using normal identifier rules
– Generally only one class per file
– The file must be named the same as the class
– File/Class names are case sensitive
• At least one class in an application must contain a “main”
method
– Starting point for program execution
– Legal to have several classes with a “main” method

Object-Oriented
Programming
Design
Java Classes
class Person
{
// Attributes
private String m_name;
private int m_age;
Person
// Operations name: String
Person(String name, int age) age: integer
{
m_name = name;
m_age = age; printPerson()
} getAge()
public void printPerson()
{
System.out.print(“Name:”);
System.out.print(m_name);
System.out.print(“ Age:”);
System.out.println(m_age);
}
public int getAge()
{
return m_age;
}
}

Object-Oriented
Programming
Design
Attributes
• Attributes
• Java’s primitive data types

– Integer types
– Reals
• References to class instances

– Java-supplied types (e.g. String)
– User-defined types (e.g. Aircraft, Car)
• Inner classes (not discussed in this course)
• Can be initialized in the declaration

Object-Oriented
Programming
Design
Java Classes – Attributes
class ExampleClass
{
// Valid class attributes (default initialization)
private short m_attackFlag; // Defaults to 0
private float Burst_Rate; // Defaults to 0.0
private boolean moving; // Defaults to false
// Valid class attributes

private int m_age = 30;
private double $gpa = 1.7;
private boolean meetsStandard2167a = false;
private char m_initial = ‘c’;
String m_name = “Mathias”;
Aircraft m_acRef = new Aircraft(“F-117”,”Stinkbug”);
}

Object-Oriented
Programming
Design
Methods
• Elements of an operation (“method”) declaration:

– Visibility: public, protected, private (default: private)
– Return type:
– Any valid primitive type
– Class type
– void
– Class method declaration (static)
– Name
– Same rules as naming a variable
– Parameters
– All parameters are passed by value
– Yes, that includes references (they just pass a pointer)
– Body

Object-Oriented
Programming
Design
Methods
Basic format: <visibility><type><name>(<params>)
{
<body>
}
class Employee
{
public Employee(String n, double s)
{
_name = n;
_salary = s;
}
public double salary()
{
return _salary;
}
public void raiseSalary(double percent)
{
_salary *= 1 + percent/100;
}
private String _name;
private double _salary;
}
Object-Oriented
Programming
Design
Methods
• All parameters are passed by value
– must use objects to pass by reference
class Employee
{ …
public void swapSalary(Employee b)
{ double temp = _salary;
_salary = b.salary
b._salary = temp;
}
}
– cannot change the value passed as b, but can change the contents
– Wrong:
class Employee
{ …
public void assign(Employee b, Employee a)
{
b = a;
}
}

Object-Oriented
Programming
Design
Scope/Visibility
• Java classes limit the visibility of operations/attributes

– public: Anyone can access
– private: Only methods in this class can access
– protected: Methods in this class+child classes can access
private public
protected

Object-Oriented
Programming
Design
Using Class Instances (objects)
• Creating an object
– Use the keyword new followed by a constructor
Employee newGuy = new Employee( “Tim”, 1000 );
– Constructors
– Default constructor used if none supplied by user
– User-defined constructors may be supplied
– Objects created using new are called “references”
• References
– Essentially a pointer without the C/C++ notation
– No explicit memory deallocation is required
– When used as function parameters, copies memory addresses … not the
objects (like C/C++)

Object-Oriented
Programming
Design
Using Class Instances
• Accessing an instance method:

newGuy.raiseSalary( 10.0 );
• Accessing an instance attribute:
double hisSalary = newGuy._salary;
newSalary = this._salary * ( 1 + percent/100);
//”this” refers to current instance
• Note: direct access to other object’s attributes is discouraged
– (and in fact it is not allowed in above case due to private attribute)

Object-Oriented
Programming
Design
Constructors
• Automatically called when object is created
• Same name as class -- e.g. Date();
• No return value
• May be more than one constructor per class
• Default constructor with no arguments should be specified
– initialize to reasonable default value
public Date()
{
_day = 1;
_month = 1;
_year = 1;
}
• Constructor with arguments -- initialize to user specified values
public Date( int d, int m, int y)
{
_day = d;
_month = m;
_year = y;
}
• Cannot be invoked on existing objects
Object-Oriented
Programming
Design
Constructors
• A quick quiz on constructors– can you spot the error?
class Employee
{
public Employee( String n, double s )
{
String _name = n;
double _salary = s;
}
…
private String _name;
private double _salary;
}

Object-Oriented
Programming
Design
Java Example
class Person static public void
{ main(String args[])
// Attributes {
int m_age; // Create a Person instance
double m_gpa; Person p1 =
String m_name; new
Person("Pyle",27,1.9);
// Operations Person p2;
public Person(String name,
// Print the name of
int age, double // the person
gpa) System.out.print("Name: ");
{ p1.printName();
m_age = age; p2 = p1;
m_name = name;
m_gpa = gpa; // Print the same name again
} System.out.print(" Name: ");
p2.printName();
private void printName() }
{
} // End class Person
System.out.print(m_name);
}

Object-Oriented
Programming
Design
Class Attributes/Methods
• Class methods/attributes
– Use static keyword in front of declaration
Class MyMath
{…
static void add( int val1, int val2 );
}
– May be accessed by using ClassName.method() or ClassName.attribute notation
MyMath.add( 1, 3 );
– An instance of the class is not required for access
• Class-wide Attributes
– An attribute shared by all instances of a class
– If one instance changes it … all others see the change
– Analog: Global Variable … use SPARINGLY
• Class-wide Operation
– A “meta operation” … operates on the class, not instances of the class
– Typical application:
– Creating new class members, assigning class ID numbers, etc.

Object-Oriented
Programming
Design
Packages
• Java code is distributed in separate packages (you can also

create your own packages)
• To access code in a package
– refer to class by full name
java.util.Vector v = new java.util.Vector();
– or import class into your program
import java.util.Vector
Vector v = new Vector();
– or import entire package
import java.util.*
• Package paths map to directory structure
java.util.Vector 
<CLASSPATH>\java\util\<vector package files>

Object-Oriented
Programming
Design
Development Process
• Analysis
– Transform vague understanding of a problem into a precise description of
the tasks to be solved
– Concerned with description of what must be done, not how it should be
done
• Design
– Structure programming tasks into classes and packages (logically
grouped clusters of objects)
– Specify operations and attributes of each class
– Specify relationships with other classes in the system
• Implementation
– Classes and operations are coded, tested, and integrated
– Object-orientation encourages evolutionary development since behavior
and state is encapsulated into objects with predefined interfaces – thus
objects or packages can be incrementally added and tested more easily

Object-Oriented
Programming
Design
Object-Oriented Design
• Goal: decompose a programming task into data types or

class and define the functionality of these classes
• Sub-goals
– Identify classes
– Identify functionality of classes
– Identify relationships among classes
• A good design greatly reduces time required for
implementation and testing

Object-Oriented
Programming
Design
Object-Oriented Design
• Finding classes
– Look for nouns in problem analysis
– Many are good choices for classes
– Other classes may be necessary
• Finding operations
– Look for verbs in problem analysis
– Each operation must have exactly one class responsible for carrying it out
• Finding class relationships
– Association  uses; a class uses another class if manipulates objects of
that class in any way; should be minimized
– Aggregation  “has-a”, contains;
– Inheritance  “is-a”, specialization; useful in select places

Object-Oriented
Programming
Design
Object-Oriented vs. Traditional Design
Traditional Object-Oriented
• Decomposition into sub-tasks • Decomposition into objects with

– Often results in numerous associated tasks
procedures or functions – Convenient clustering
– Data encapsulation helps
– Difficult to manage and
debugging
understand
– Multiple instances with similar
• Task modules can simulate
behavior
objects by organizing related – Inheritance captures
tasks and attributes
commonalities among related
– Only one instance (e.g. queue) classes of objects
• Encapsulation achieved with
opaque types (e.g. Unix file
interface)
– No inheritance

Object-Oriented
Programming
Design
Design Hints
• Always keep data private
– If user of the class has a need to both read and change a field (attribute),
the following 3 items must be implemented in the class
– A private data field
– A public field accessor method
– A public field mutator method
– Benefits
– Internal implementation can be changed without affecting any code
outside of the class
– Mutator methods can perform error-checking to ensure field is set
properly
– Accessors to fields with mutable objects
– Should return clone of object so that calling object can not modify
the field object contained in the class instance
• Always initialize data
– Avoids unexpected results
– Simplifies debugging

Object-Oriented
Programming
Design
Design Hints
• Don't use too many basic types in a class
– Group related types into a separate class and use that class instead
– Bad – Good
class Employee class Employee
{ {
– private String _lname; private Name _name;
– private String _fname; private Address _address;
– private char _initial; private Date _hiredate;
– private String _street; }
– private String _city;
– private String _state;
– private long _zip;
}
• Not all fields need individual field accessors and mutators
• Use a standard format for class definitions
• Break up classes with too many responsibilities
• Make the names of your classes and methods reflect their responsibilities

Object-Oriented
Programming
Design
Homework
• Compile and run the Person example code
• Analyze the requirements for a Calculator program
– Identify the classes, the operations, and the relationships
between classes
– Make stub code for all your classes and operations with
definitions
for the has-a relationships
– Remember each class goes in a separate file
• Write and test a swap method
– Create a simple class with one int data member
– Write a swap method for that class that swaps values:
– : static public void swap(mytype a, mytype b);
– Such that after swap(a,b) is called a looks like b looked and b looks
like a looked


T03 Objects and Classes

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

T03 Objects and Classes

Uploaded by

Copyright:

Available Formats

Air Force Institute of Technology

Electrical and Computer Engineering

Object-Oriented Programming Design

Maj Joel Young

Apr 2, 2024 Maj Joel Young

• Organize program into a set of objects with certain

Air Force Institute of Technology

Air Force Institute of Technology

Air Force Institute of Technology

Air Force Institute of Technology

• Encapsulation (aka data hiding)

Air Force Institute of Technology

GasStation Automobile Employee

Air Force Institute of Technology

Air Force Institute of Technology

• A Java class contains:

Air Force Institute of Technology

Air Force Institute of Technology

• Java’s primitive data types

• References to class instances

• Inner classes (not discussed in this course)

• Can be initialized in the declaration

Air Force Institute of Technology

// Valid class attributes

Air Force Institute of Technology

• Elements of an operation (“method”) declaration:

Air Force Institute of Technology

Air Force Institute of Technology

• Java classes limit the visibility of operations/attributes

Air Force Institute of Technology

Air Force Institute of Technology

• Accessing an instance method:

Air Force Institute of Technology

• A quick quiz on constructors– can you spot the error?

Air Force Institute of Technology

Air Force Institute of Technology

Air Force Institute of Technology

• Java code is distributed in separate packages (you can also

Air Force Institute of Technology

Air Force Institute of Technology

• Goal: decompose a programming task into data types or

Air Force Institute of Technology

Air Force Institute of Technology

• Decomposition into sub-tasks • Decomposition into objects with

Air Force Institute of Technology

Air Force Institute of Technology

Air Force Institute of Technology

Air Force Institute of Technology

You might also like