Download Object: software bundle of related state and behavior

Java Notes12
Introduction:
Object: software bundle of related state and behavior.
Class: blueprint or prototype from which objects are created.
Inheritance: organizing and structuring your software.
Interface: contract between a class and the outside world.
Package: namespace for organizing classes and interfaces in a logical manner.
OBJECTS
Objects: key to understanding object-oriented programming
Real world objects all have a state and a behavior.
Dog:
state
= name, color, breed, hungry, … (nouns)
behavior = barking, fetching, wagging, … (verbs)
Bicycles:
state
= current gear, current pedal cadence, current speed, …
(nouns)
behavior = changing gear, changing pedal cadence, applying brakes, … (verbs)
state = how does it exist?
behavior = what is it doing?
Indeed, “state” is a noun and “behavior” is a verb.
-9/24/08 Objects – cont’d –
But this really sound as if an object is an element in a set – as in set theory. However, the java set (Class) gives
instructions how to build the object. Just like a manufacturing plant. They build objects according to the
instructions they have on hand in their plant.
1
2
From: Trail: Learning the Java Language http://java.sun.com/docs/books/tutorial/java/index.html
Note: all software is copyrighted: http://java.sun.com/docs/books/tutorial/java/concepts/examples/BicycleDemo.java
A software object.
An object has its state stored in fields (aka “variables” in other programming languages).
An object has its behavior stored in methods (aka “functions” in other programming languages).
Methods act on an object’s state and perform object-to-object communication.
What is going on in the foreground (the code of the program) is happening in the method, which is not seen by
anyone who reads the code. It seems that what is going on is that Java is loaded with what are called
“subroutines” in other programming languages. Indeed,
“Hiding internal state and requiring all interaction to be performed through an object's methods is known as
data encapsulation – …”
Example: the bicycle
A bicycle modeled as a software object.
The above software model of a bicycle (object) represents how the methods allow the object (bicycle) to be
used. “changeGears” could be the method which tests that the value of the gear does not exceed the bicycle’s
gear design. So the method acts as the go-between the outside world and the object’s state. (Pictured above in
“A software object”.)
OO Advantages:
1 – modular: the object can be maintained separately from the source code which uses it,
2 – hiding: the object’s implementation remains hidden from the casual viewer,
3 – re-use: the reverse of #1 above, namely other written objects can be used in your code – easily,
4 – pluggable: objects can be plugged in or unplugged from the code w/o damage to your code, and
5 – debugging: b/c of #1 and #4, debugging a massive code reduces to debugging only 1, small, object.
CLASSES
Classes: if you have many bicycles made from the same blueprint then the one you use is called an instance of
that class of bicycle. E.g. have the object (blueprint) in your code, then using one of it is an instance of that
object. “A class is the blueprint from which individual objects are created.”
The basic relation is:
Instance < Object < Class < Package
class Bicycle {
// the class of bicycles
int cadence = 0;
int speed = 0;
int gear = 1;
// the states of the bicycle
void changeCadence(int newValue) {
cadence = newValue;
}
// the behaviors of the bicycle
void changeGear(int newValue) {
gear = newValue;
}
void speedUp(int increment) {
speed = speed + increment;
}
void applyBrakes(int decrement) {
speed = speed - decrement;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}
See the code BicycleDemo.java which is an application that creates two new bicycle instances: bike1 and bike2.
“You may have noticed that the Bicycle class does not contain a main method.
That's because it's not a complete application; it's just the blueprint for bicycles
that might be used in an application. The responsibility of creating and using new
Bicycle objects belongs to some other class in your application.”
INHERITANCE
Inheritance: this occurs when one class of objects contains the same states and behaviors of other classes. We
normally think of one class as the larger, or “mother” (my word) class, since it has none of the specific features
which make the “smaller” classes the sub-classes in the relationship. The “larger” class is the supeclass of the
subclasses. E.g. “bicycle” is generic for: road bike, tandem bike, and mountain bike. All of the bicycles share
the same states as those present in the class “bicycle” yet the road bike has drop handlebars; the tandem bike has
two handlebars; and the mountain bike has performance handlebars. All of them have gears, change of speed,
etc. Thus “bicycle” is the superclass of the subclasses: road, tandem, and mountain bikes.
Again, a little knowledge of sets is a good thing. :)
BICYCLE
drop-down handlebars
two handlebars
road
performance handlebars
tandem
mountain
Now, how do you relate the subclass to the superclass? It’s best said by Sun:
class MountainBike extends Bicycle {
// new fields and methods defining a mountain bike would go here
}
Basically you are making the superclass larger by the addition of the subclass – thus you are “extending” the
superclass to now include the new subclass. So “MountainBike extends Bicycle”. And in the new subclass you
will have new fields and methods which make your subclass specific to that class of objects, e.g. mountain
bikes. At the same time your new subclass inherits all the same fileds and methods present in the superclass.
INTERFACE
Interface: since objects talk to the outside world using methods, then a separate place for all these methods
would seem appropriate. This is the purpose of the interface. It allows the methods for a class to be defined as
an interface class. Continuing with the bicycle example, the interface for denoting the bicycle’s behavior would
be:
interface Bicycle {
void changeCadence(int newValue);
void changeGear(int newValue);
void speedUp(int increment);
void applyBrakes(int decrement);
}
These are all the methods which appear in the Bicycle class. Notice that each has a field and each field is named
accordingly to that method: speedUp uses “increment” while applyBrakes uses “decrement”.
Implementing this interface one has to do three things:
1) the class must now be given a new name, say ACMEBicycle, and
2) the new class is defined in the same way but with an “implements” instruction, and
3) since these methods are now defined outside of Bicycle (i.e. they are defined in the bicycle interface –
and not the Bicycle class itself – then you need to let the Bicycle class be public. So a the full line would
read:
public class ACMEBicycle implements Bicycle
Now this interface forms a “contract” with the outside world to deliver these methods from the ACMEBicycle
class to the user.
PACKAGE
Package: a package is similar to a folder. It organizes classes and their interfaces into one group which are made
available as they are separately imported or as a group.
Library: a set of class packages. Java provides an enourmous class library called the API, which is short for
“Application Programming Interface”.
“There are literally thousands of classes to choose from. This allows you, the
programmer, to focus on the design of your particular application, rather than the
infrastructure required to make it work.”
Platform: the list of libraries and all other supporting files for writing Java.
JAVA: Questions and Exercises 01
Questions and Exercises: Object-Oriented Programming Concepts
Questions
1. Real-world objects contain ___ and ___.
2. A software object's state is stored in ___.
3. A software object's behavior is exposed through ___.
4. Hiding internal data from the outside world, and accessing
it only through publicly exposed methods is known as data
___.
5. A blueprint for a software object is called a ___.
6. Common behavior can be defined in a ___ and inherited into
a ___ using the ___ keyword.
7. A collection of methods with no implementation is called an
___.
8. A namespace that organizes classes and interfaces by
functionality is called a ___.
9. The term API stands for ___?
Exercises
1. Create new classes for each real-world object that you
observed at the beginning of this trail. Refer to the
Bicycle class if you forget the required syntax.
2. For each new class that you've created above, create an
interface that defines its behavior, then require your
class to implement it. Omit one or two methods and try
compiling. What does the error look like?
End of Object-Oriented Programming Concepts.
ANSWERS to the Questions:
Questions:
1. states and behavior
2. fields
3. methods
4. encapsulisation
5. classes
6. superclasses, subclasses, and “extends”
7. interface
8. package (e.g. the API)
9. Application Programming Interface
Exercises:
class DeskLamp{
// states
int state;
// behaviors
void switch(int state){
if (state == 1) state = 0
else state = 1;
}
}
class DesktopRadio{
// states
int power;
int volume;
int station;
// behaviors
void switch(power){
if (power == 0) power =1
else power = 0;
}
void volumeUp(volume){
+=volume;
}
void volumeDown(volume){
-=volume;
}
void changeStation(station){
station = ;
}
void seekStation(station){
station = ;
}
}