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

2. 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.

3. 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.

4. 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

5. Object-Oriented Programming Principles
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

6. Object-Oriented Programming Principles
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

7. Air Force Institute of Technology Electrical and Computer Engineering
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
Class pattern examples
Tangible things – mailbox, message, document, footnote
System interfaces and devices – displayWindow, inputReader
Agents – change an operation into a class – paginator, inputReader
Events and transactions – records of activities that occur – mouseEvent, customerArrival
Users and roles – administrator, reviewer
Systems – subsystem or overall system – mailSystem
Containers – Store and retrieve information – mailbox
Foundation classes
data types with well understood properties
string, date, matrix, rectangle, address, semaphore
Collaboration patterns – container/iterator, model/view
Class relationships
Association – uses, collaborates with
Aggregation – “has-a”, contains or exclusively manages objects of another class
Inheritance – “is-a”,
subset of parent class (adminMailbox inherits from Mailbox),
similar responsibilities – look for common base class
20 April 2017

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

9. Java Classes A Java class contains: General Rules:
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

10. Java Classes class Person { // Attributes private String m_name;
private int m_age;
// Operations
Person(String name, int age)
m_name = name;
m_age = age; }
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;
Person
name: String
age: integer
printPerson()
getAge()

11. 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

12. 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”); }

13. 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

14. 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;

15. 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:
public void assign(Employee b, Employee a) {
b = a;

16. 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

17. 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++)

18. 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)

19. 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

20. 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;

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

22. 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.

23. 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>

24. Development Process Analysis Design Implementation
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

25. 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

26. 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

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

28. Design Hints Always keep data private Always initialize data
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

29. 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
class Employee {
private String _lname;
private String _fname;
private char _initial;
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
Good
class Employee {
private Name _name;
private Address _address;
private Date _hiredate; }

30. Write and test a swap method
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