Introduction to Object-Oriented Programming & Design Principles (TCF 2014)

1
Introduction to OOP
& Design Principles
Trenton Computer Festival
March 15, 2014
Michael P. Redlich
@mpredli
about.me/mpredli/
Sunday, March 16, 14

Who’s Mike?
• BS in CS from
• “Petrochemical Research Organization”
• Ai-Logix, Inc. (now AudioCodes)
• Amateur Computer Group of New Jersey
• Publications
• Presentations
2

Objectives (2)
• Object-Oriented Programming
• Object-Oriented Design Principles
• Live Demos (yea!)
3

Object-Oriented
Programming (OOP)
4

Some OOP Languages
• Ada
• C++
• Eiffel
• Java
• Modula-3
• Objective C
• OO-Cobol
• Python
• Simula
• Smalltalk
• Theta
5

What is OOP?
• A programming paradigm that is focused on
objects and data
• as opposed to actions and logic
• Objects are identiﬁed to model a system
• Objects are designed to interact with each
other
6

OOP Basics (1)
• Procedure-Oriented
• Top Down/Bottom Up
• Structured programming
• Centered around an
algorithm
• Identify tasks; how
something is done
• Object-Oriented
• Identify objects to be
modeled
• Concentrate on what an
object does
• Hide how an object
performs its task
• Identify behavior
7

OOP Basics (2)
• Abstract Data Type (ADT)
• user-deﬁned data type
• use of objects through functions (methods)
without knowing the internal representation
8

OOP Basics (3)
• Interface
• functions (methods) provided in the ADT that
allow access to data
• Implementation
• underlying data structure(s) and business logic
within the ADT
9

OOP Basics (4)
• Class
• Deﬁnes a model
• Declares attributes
• Declares behavior
• Is an ADT
• Object
• Is an instance of a class
• Has state
• Has behavior
• May have many unique
objects of the same class
10

OOP Attributes
• Four (4) Main Attributes:
• data encapsulation
• data abstraction
• inheritance
• polymorphism
11

Data Encapsulation
• Separates the implementation from the
interface
• A public view of an object, but
implementation is private
• access to data is only allowed through a deﬁned
interface
12

Data Abstraction
• A model of an entity
• Deﬁnes a data type by its functionality as
opposed to its implementation
13

Inheritance
• A means for deﬁning a new class as an
extension of a previously deﬁned class
• The derived class inherits all attributes and
behavior of the base class
• “IS-A” relationship
• Baseball is a Sport
14

Polymorphism
• The ability of different objects to respond
differently to the same function
• From the Greek meaning “many forms”
• A mechanism provided by an OOP
language as opposed to a programmer-
provided workaround
15

Advantages of OOP
• Interface can (and should) remain
unchanged when improving implementation
• Encourages modularity in application
development
• Better maintainability of code
• Code reuse
• Emphasis on what, not how
16

Classes (1)
• A user-deﬁned abstract data type
• Extension of C structs
• Contain:
• constructor
• destructor
• data members and member functions (methods)
17

Classes (2)
• Static/Dynamic object instantiation
• Multiple Constructors:
• Sports(void);
• Sports(char *,int,int);
• Sports(float,char *,int);
18

Classes (3)
• Class scope (C++)
• scope resolution operator (::)
• Abstract Classes
• contain at least one pure virtual member
function (C++)
• contain at least one abstract method (Java)
19

Classes (3)
• Abstract Classes
• contain at least one pure virtual member
function (C++)
• contain at least one abstract method (Java)
20

Abstract Classes
• Pure virtual member function (C++)
• virtual void draw() = 0;
• Abstract method (Java)
• public abstract void draw();
21

Class Inheritance
22

Static Instantiation
(C++)
• Object creation:
• Baseball mets(“Mets”,97,65);
• Access to public member functions:
• mets.getWin(); // returns 97
23

Dynamic Instantiation
(C++)
• Baseball *mets = new
Baseball(“Mets”,97,65);
• mets->getWin(); // returns 97
24

Dynamic Instantiation
(Java)
• Baseball mets = new
• mets.getWin(); // returns 97
25

Deleting Objects (C++)
Baseball mets(“Mets”,97,65);
// object deleted when out of scope
Baseball *mets = new
delete mets; // required call
26

Deleting Objects (Java)
Baseball mets = new
// automatic garbage collection or:
System.gc(); // explicit call
27

Object-Oriented
Design Principles
28

What are OO Design
Principles?
• A set of underlying principles for creating
ﬂexible designs that are easy to maintain
and adaptable to change
• Understanding the basics of OOP isn’t
enough
29

Some OO Design
Principles (1)
• Encapsulate WhatVaries
• Program to Interfaces, Not
Implementations
• Favor Composition Over Inheritance
• Classes Should Be Open for Extension, But
Closed for Modiﬁcation
30

Some OO Design
Principles (2)
• Strive for Loosely Coupled Designs
Between Objects That Interact
• A Class Should Have Only One Reason to
Change
31

Encapsulate What
Varies
• Identify and encapsulate areas of code that
vary
• Encapsulated code can be altered without
affecting code that doesn’t vary
• Forms the basis for almost all of the
original Design Patterns
32

33
// OrderCars class
public class OrderCars {
public Car orderCar(String model) {
Car car;
if(model.equals(“Charger”))
car = new Dodge(model);
else if(model.equals(“Corvette”))
car = new Chevrolet(model);
else if(model.equals(“Mustang”))
car = new Ford(model);
car.buildCar();
car.testCar();
car.shipCar();
}
}

Program to Interfaces,
Not Implementations
• Eliminates being locked-in to a speciﬁc
implementation
• An interface declares generic behavior
• Concrete class(es) implement methods
deﬁned in an interface
34

35
// Dog class
public class Dog {
public void bark() {
System.out.println(“woof”);
}
// Cat class
public class Cat {
public void meow() {
System.out.println(“meow”);
}
}

36
// Animals class - main application
public class Animals {
public static void main(String[] args) {
Dog dog = new Dog();
dog.bark();
Cat cat = new Cat();
cat.meow();
}
}
// output
woof
meow

37
// Animal interface
public interface Animal {
public void makeNoise();
}

38
// Dog class (revised)
public class Dog implements Animal {
public void makeNoise() {
bark();
}
public void bark() {
System.out.println(“woof”);
}
// Cat class (revised)
public class Cat implements Animal {
public void makeNoise() {
meow();
}
public void meow() {
System.out.println(“meow”);
}
}

39
// Animals class - main application (revised)
public class Animals {
public static void main(String[] args) {
Animal dog = new Dog();
dog.makeNoise();
Animal cat = new Cat();
cat.makeNoise();
}
}
// output
woof
meow

Favor Composition
Over Inheritance
• “HAS-A” can be better than “IS-A”
• Eliminates excessive use of subclassing
• An object’s behavior can be modiﬁed
through composition as opposed through
inheritance
• Allows change in object behavior at run-
time
40

Classes Should Be
Open for Extension...
• ...But Closed for Modiﬁcation
• “Come in,We’re Open”
• extend the class to add new behavior
• “Sorry,We’re Closed”
• the code must remain closed to modiﬁcation
41

A Simple Hierarchy...
42

...That Quickly
Becomes Complex!
43

Refactored Design
44

Live Demo!
45

Strive for Loosely
Coupled Designs...
• ...Between Objects That Interact
• Allows you to build ﬂexible OO systems
that can handle change
• interdependency is minimized
• Changes to one object won’t affect another
object
• Objects can be used independently
46

Live Demo!
47

A Class Should Have...
• ...Only One Reason to Change
• Classes can inadvertently assume too many
responsibilities
• interdependency is minimized
• cross-cutting concerns
• Assign a responsibility to one class, and
only one class
48

Local C++ User
Groups
• ACGNJ C++ Users Group
• facilitated by Bruce Arnold
• acgnj.barnold.us
49

Local Java User Groups
(1)
• ACGNJ Java Users Group
• facilitated by Mike Redlich
• javasig.org
• Princeton Java Users Group
• facilitated byYakov Fain
• meetup.com/NJFlex
50

Local Java User Groups
(2)
• NewYork Java SIG
• facilitated by Frank Greco
• javasig.com
• Capital District Java Developers Network
• facilitated by Dan Patsey
• cdjdn.com
51

Introduction to Object-Oriented Programming & Design Principles (TCF 2014)

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Introduction to Object-Oriented Programming & Design Principles (TCF 2014) (20)

More from Michael Redlich (18)

Recently uploaded (20)

Introduction to Object-Oriented Programming & Design Principles (TCF 2014)