Object-Oriented Programming Concepts

1
Object-Oriented Programming Concepts
2
Recap from last lecture

• Variables and types
• int count
• Assignments
• count 55
• Arithmetic expressions
• result count/5 max
• Control flow
• if then else
• while do
• do while
• For
• SubPrograms
• Methods

3
Programming

• Programming consists of two steps
• design (the architects)
• coding (the construction workers)
• Object oriented design
• Object oriented programming

4
What Is an Object?

• Real world examples bicycle dog dinosaur
  table rectangle color.
• Objects have two characteristics state
  (attributes) and behavior
• Software objects maintain its state in variables
  or data, and implement the behavior using methods.

An Object
5
What Is an Object?

• Real-world objects can be represented using
  software objects
• e.g., electronic dinosaur, bicycle
• Software objects may correspond to abstract
  concepts
• e.g., an event

A Bicycle Object
6
What Is an Object?

• Methods to brake, change the pedal cadence, and
  change gears.
• Concept of encapsulation hiding internal details
  from other objects
• you do not need to know how the gear mechanism
  works.
• In Java, both methods and variables can be hidden

A Bicycle Object
7
What Are Messages?

• Software objects interact and communicate with
  each other using messages (method invocation)

A message with parameters
8
What Are Messages?

• Three components comprise a message
• 1.The object to whom the message is addressed
  (Your Bicycle)
• 2.The name of the method to perform
  (changeGears)
• 3.Any parameters needed by the method (lower
  gear)

9
What Are Classes?

• A class is a blueprint or prototype that defines
  the variables and the methods common to all
  objects of a certain kind.
• Instantiation of a class create an instance
  (object) according to the blueprint specification.

10
What Are Classes?

• Consist of public API and private implementation
  details

11
Object vs Class

• Each object has its own instance variables
• e.g., each bicycle has its own (x,y) position.

12
Object vs Class

• Usually no memory is allocated to a class until
• instantiation, whereupon memory is allocated to
  an object
• of the type.
• Except when there are class variables. All
  objects of the same class share the same class
  variables
• e.g., extinct variable of dinosaur class tax
  rate of certain
• class of goods.

13
What Is Inheritance?
Software Reuse

• A class inherits state and behavior from its
  superclass.
• A subclass can define additional variables and
  methods.
• A subclass can override methods of superclass
  (e.g., change gear method might be changed if an
  additional gear is provided.)
• Can have more than one layer of hierarchy

14
What is an Interface?

• Definition An interface is a device that
  unrelated objects use to interact with each
  other. An object can implement multiple
  interfaces.

Interface B
Object
Object 1
Interface C
Interface A
15
Primitive and Reference Data Type
Point p1, p2 p1 new Point() p2 p1
int x x 5
5
x
Primitive Data Type
Reference Data Type
16
Brief Introduction to Classes

• A point in 2-D space
• public class SimplePoint
• public int x 0
• public int y 0

Upon instantiation
17
Brief Introduction to Classes

• A simple rectangle class
• public class SimpleRectangle
• public int width 0
• public int height 0
• public SimplePoint origin new
  SimplePoint()

Reference type vs primitive type
18
A Brief Introduction to Classes

• A Point Class with a constructor
• public class Point
• public int x 0
• public int y 0
• // a constructor!
• public Point(int x, int y)
• this.x x
• this.y y
• new Point(44,78)

19
A Brief Introduction to Classes

• More sophisticated Rectangle Class
• public class Rectangle
• public int width 0
• public int height 0
• public Point origin
• // four constructors
• public Rectangle()
• origin new Point(0, 0)
• public Rectangle(Point p)
• origin p

20
A Brief Introduction to Classes

• public Rectangle(int w, int h)
• this(new Point(0, 0), w, h)
• public Rectangle(Point p, int w, int h)
• origin p
• width w
• height h
• // a method for moving the rectangle
• public void move(int x, int y)
• origin.x x
• origin.y y

21
A Brief Introduction to Classes

• // a method for computing the area of the
  rectangle
• public int area()
• return width height
• // clean up!
• protected void finalize() throws Throwable
  
• origin null
• super.finalize()

22
Basic Structures of a Class

• Class Declaration
• Variable
• Instance Variable
• Class Variable
• Constructor
• Method
• Instance Method
• Class Method
• Cleanup
• Rectangle2.java

23
Creating Classes

• A blueprint or prototype that you can use to
  create many objects.
• Type for objects.
• classDeclaration
• classBody

24
The Class Declaration

• Simplest class declaration
• class NameOfClass
• . . .
• e.g.,
• class ImaginaryNumber
• . . .

Start with capital letter by convention
25
The Class Declaration

• Class declaration can say more about the class
• declare what the class's superclass is
• declare whether the class is public, abstract, or
  final (if not specified, then default)
• list the interfaces implemented by the class

26
Declaring a Class's Superclass

• All class has a superclass. If not specified,
  superclass is Object class by default
• To specify an object's superclass explicitly,
• class NameOfClass extends SuperClassName
• . . .
• e.g.,
• class ImaginaryNumber extends Number
• . . .

Part of java.lang package
27
Declare whether the Class is Public, Final, or
Abstract

• Modifier class NameOfClass
• . . .
• Default accessible only by classes within same
  package
• Public accessible by classes everywhere
• Final the class cannot be further subclassed.
• Abstract some methods are defined but
  unimplemented must be further subclassed before
  instantiation.

28
Listing the Interfaces Implemented by a Class

• An interface declares a set of methods and
  constants without specifying the implementation
  for any of the methods.
• e.g.,
• class ImaginaryNumber extends Number implements
  Arithmetic
• . . .

Contains unimplemented methods such as add(),
substract()
29
The Class Declaration
30
The Class Body

• Contains two different sections variable
  declarations and methods.
• classDeclaration
• memberVariableDeclarations
• methodDeclarations
• e.g., class TicketOuttaHere
• Float price String destination Date
  departureDate
• void signMeUp(Float forPrice, String forDest,
  Date forDate)
• price forPrice destination forDest
• departureDate forDate

31
Declaring Member Variables
All variables must have a type classis also a
type

• a member variable declaration
• type variableName
• e.g., class IntegerClass
• int anInteger
• . . .
• // define methods here
• . . .
• IntegerClass anIntergerObject
• anIntegerObject new IntegerClass()

Lowercase by convention
32
Statement for Member Variable Declaration

• accessSpecifier static final
  transientvolatile
• type variableName
• accessSpecifier defines which other classes have
  access to the variable (public, private, or
  protected)
• static indicates that the variable is a class
  member variable, not an instance member variable.
  
• final indicates that the variable is a constant
• class Avo final double AVOGADRO 6.023e23
• transient variables are not part of the object's
  persistent state
• volatile means that the variable is modified
  asynchronously

By convention, all capitals
33
Managing Inheritance
All classes inherit from the Object class.
34
Creating Subclasses

• class SubClass extends SuperClass
• . . .
• A Java class can have only one direct superclass.
  Java does not support multiple inheritance.

35
What Member Variables Does a Subclass Inherit?

• Rule A subclass inherits all of the member
  variables within its superclass that are
  accessible to that subclass.
• Member variables declared as public or protected.
  Do not inherit private member variables.
• Member variables declared with no access modifier
  so long as subclass is in the same package
• If subclass declares a member variable with the
  same name, the member variable of the superclass
  is hidden.

36
Hiding Member Variables

• class Super
• Number aNumber
• class Sub extends Super
• Float aNumber

37
What Methods Does a Subclass Inherit?

• Rule A subclass inherits all of the methods
  within its superclass that are accessible to that
  subclass.
• public or protected methods, but not private
  methods
• no access modifier but in the same package
• If subclass declares a method with the same name,
  the method of the superclass is overridden.

38
Overriding Methods

• A subclass can either completely override the
  implementation for an inherited method or the
  subclass can enhance the method by adding
  functionality to it.

39
Replacing a Superclass's Method Implementation

• An example Thread class has an empty
  implementation of run().
• class BackgroundThread extends Thread
• void run()
• . . .

40
Adding to a Superclass's Method Implementation

• Another Example want to preserve initialization
  done by superclass in constructor
• class MyWindow extends Window
• public MyWindow(Frame parent)
• super(parent)
• . . .
• // MyWindow-specific initialization
  here
• . . .

Superclass constructor
41
Methods a Subclass Cannot Override

• A subclass cannot override methods that are
  declared final in the superclass.

42
Methods a Subclass Must Override

• Subclass must override methods that are declared
  abstract in the superclass, or the subclass
  itself must be abstract.

43
Being a Descendent of Object

• Every class in the Java system is a descendent
  (direct or indirect) of the Object class.
• Your class may want to override
• clone
• equals
• finalize
• toString
• Your class cannot override (they are final)
• getClass
• notify
• notifyAll
• wait
• hashCode

44
Summary

• You should know
• Objects are created from classes
• An object's class is its type
• Difference between reference and primitive types.
  
• You also should have a general understanding or a
  feeling for the following
• How to create an object from a class
• What constructors are
• What the code for a class looks like
• What member variables are
• How to initialize objects
• What methods look like