Air Force Institute of Technology

Electrical and Computer Engineering

Object-Oriented Programming Design

Topic :
Objects and Classes
 Java
Programming 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.

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

3
 Java
Programming 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

4
 Java
Programming 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

5
 Java
Programming 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

6
 Java
Programming 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

7
 Java
Programming 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()

8
 Java
Programming 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

9
 Java
Programming 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;
}
}

10
 Java
Programming 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

11
 Java
Programming 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”);
}

12
 Java
Programming 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

13
 Java
Programming 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;
}

14
 Java
Programming 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;
}
}

15
 Java
Programming 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

16
 Java
Programming 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++)

17
 Java
Programming 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)

18
 Java
Programming 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

19
 Java
Programming 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;
}

20
 Java
Programming 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);
}

21
 Java
Programming 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.

22
 Java
Programming 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>

23
 Java
Programming 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

24
 Java
Programming 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

25
 Java
Programming 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

26
 Java
Programming 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

27
 Java
Programming 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

28
 Java
Programming 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

29
 Java
Programming 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

30