OO programming introduction

OO Programming - Introduction

João Pereira
October 2012

OO Programming - Introduction by João Miguel Pereira is licensed under a Creative Commons Attribution-
NonCommercial-ShareAlike 3.0 Unported License.

OO Programming- Introduction

Refreshing OO programming concepts

OO Programming - Introduction is licensed under a Creative Commons Attribution- 2

OO Programming Concepts

Why do I need objects ?


• I can easily model real world concepts.

Car


• I can focus on the data and behavior of
the atoms of my system
Focus on
grouping the
Wheel
state for a
Diameter
wheel Weight
Model
supporting Load

Move()
autoCalibrate()
checkPressure() Focus on
currentLoad() grouping the
behavior


• I can share objects and still have everything I
need to use them in other systems

Machine A Machine B

Object Object
Object’s Object’s
state Network state
Object’s Object’s
behavior behavior


• I can build small, manageable, self-
contained objects and use them as
building blocks for bigger things

Wheel
Wheel Wheel
Seat
Belt
Wheel Wheel
Tire

Objects Car OO Program


• I can reuse objects to build different
systems

Wheel
Wheel Wheel
Seat

Seat

Objects Bike OO Program



More?


Programming OO

How I design and code?


Programming OO
• I don’t try to build the perfect solution
• Tend to be creative
• Brainstorm, sometimes with myself
• Implement alternatives
• Refactor my code
• Get a bird-eye view on the whole system,
frequently
• Focus my effort on small parts of the system (a
Class at a time)

Programming OO
• Know the differences between the interface
and the implementation
• Think abstractly
• Give users of my objects the minimal interface
possible
• And….
– Know the design principles
– Reuse knowledge (Patterns)


Programming OO
possible


Programming OO
Interface and Implementation interface
Services that my objects expose to my object’s clients
public class Computer {
private PowerSupply powerSupply;

public void turnOn() {
turnOnPowerSupply();
}
public void turnOff() {
turnOffPowerSupply();
}

private void turnOffPowerSupply() {
powerSupply.turnOff();
}
private void turnOnPowerSupply() {
powerSupply.turnOn();
}
}


Programming OO
Interface and Implementation implementation
Implementation is how the object realize
the services expected by the clients

}
}

private void turnOffPowerSupply() {
powerSupply.turnOff();
}
private void turnOnPowerSupply() {
powerSupply.turnOn();
}
}


Programming OO
Interface and Implementation

• Object’s clients can be other objects


Programming OO
Interface and Implementation

• If an implementation change, clients don’t
care, as long as the interface provides them the
service they expect

PowerSupply.on();
}
PowerSupply.off();
}}


Programming OO
possible


Programming OO
Think Abstractly

• Design interfaces as abstract as
possible
• Abstraction allows reuse
• Foundation of many design
guidelines


Programming OO
Think Abstractly

Which interface is more abstract?

1 public class Computer {
public void positionDiskHead(int sector) {
}
public void startDiskRotation() {
}
public Byte[] readBytes(int endSector) {
}
public void endDiskRotation() {
}
}

public Byte[] readFromMedium(MediumIdentifier id, ReadInstructions instructions) {
return null;
}
}


Programming OO
Think Abstractly

Which interface is more reusable?

public void positionDiskHead(int sector) {
}
public void startDiskRotation() {
}
public Byte[] readBytes(int endSector) {
}
public void endDiskRotation() {
}
}

public Byte[] readFromMedium(MediumIdentifier id, ReadInstructions instructions) {
return null;
}
}


Programming OO
• Give users of my objects the minimal
interface possible


You Ain’t
Programming OO Gonna Need It
Minimal interface

• Tend to follow the YAGNI principle
• Give clients only the strictly needed
interfaces
• Only add new interfaces if object’s clients
really require it


Programming OO
Minimal interface
I give this interface to the client of my object. (In reality, I’m giving no
1 interface at all)
}

2 The client asks, “Hey, now what? How do I turn it on?”

I give an interface to allow the client to turn on the computer
public void turnOn() {}
}

4 The client then asks, “Thanks, but… How do I turn it off?”

5 Story goes on…


OO Concepts
• Encapsulation and Data Hiding
• Inheritance
• Polymorphism
• Composition


OO Concepts
Encapsulation and Data Hiding

• Hide implementation details, such as state and
behavior pertaining only the implementation
of interface.
• Give users only access to interfaces
public void turnOn() { What a user see
}
} public class Computer {
private void turnOffPowerSupply() { turnOnPowerSupply();
powerSupply.turnOff(); }
} public void turnOff() {
private void turnOnPowerSupply() { turnOffPowerSupply();
powerSupply.turnOn(); }
} }
}


OO Concepts
Inheritance

• Allows me to reuse code by abstracting
common behavior and state of a set of classes


OO Concepts
Polymorphism

• I can have a have a type that assumes multiple forms
ElectronicEquipment computer = new Computer();
ElectronicEquipment phone = new Phone();
computer.turnOn();
phone.turnOn();

• An ElectronicEquipment can assume the form of a
Computer or a Phone
• A user with a reference to an ElectronicEquipment
don’t care if it’s a Computer or a Phone


OO Concepts
Composition

• Can reuse code by factor in common behavior
and state to a separate class and use that class
as a building block of other classes.
– Both Printer and Computer have a PowerSupply
and a motherborad.


João Pereira
March 2012

OO Design Principles - Introduction by João Miguel Pereira is licensed under a Creative Commons Attribution-

OO programming introduction

Recomendados

Recomendados

Más contenido relacionado

Último

Último (20)

Destacado

Destacado (20)

OO programming introduction