025466482929 -OOP with Java Development Kit.ppt

OOP With Java.

1. © Amir Kirsh
Object Oriented Programming with Java
Written by Amir Kirsh

2. Agenda
•All that is to know on class syntax
•Constructors and Initializers
•Inheritance and Polymorphism
•Interfaces
•Nested Classes
•Enums
•Exercise

3. 3
Classes and Objects
A class will look like this:
<Access-Modifier> class MyClass{
// field, constructor, and method declarations
}
To instantiate an object we will do:
MyClass instance = new MyClass(<constructor params>);

4. 4
Accessibility Options
Example:
public class Person {
privateStringname;
protectedjava.util.DatebirthDate;
Stringid; // defaultaccessibility = package
publicPerson() {}
}
Four accessibility options:
–public –(default) = “package” **
–protected * –private
*protected is also accessible by package
**called also “package-private” or “package-friendly”

5. 5
Static
Example:
public class Widget {
static private int counter;
static public getCounter() {return counter;}
}
int number = Widget.getCounter();
Static member can be accessed without an instance
(same as in C++)
Called sometimes “class variable”
as opposed to “instance variable”

6. 6
The ‘this’ keyword
Example:
public class Point {
private int x, y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}
In Java ‘this’is a referenceto myself
(in C++ it is a pointer…)
The ‘this’keyword is also used to call another constructor of
the same class –we will see that later

7. 7
Defining constants
Example:
public class Thingy {
public final static doodad = 6; // constant
public final id; // constant variable
public Thingy(int id) {this.id = id;} // OK
// public set(int id) {this.id = id;} // error!
}
Though constis a reserved word in Java
it's actually not in use!
However the finalkeyword let's you define
constants and const variables

8. Agenda
•All that is to know on class syntax
•Constructors and Initializers
•Inheritance and Polymorphism
•Interfaces
•Nested Classes
•Enums
•Exercise

9. 9
Constructors
Examples in following slides…
–Constructors in Java are very similar to C++
–You can overload constructors (like any other method)
–A constructor which doesn't get any parameter
is called “empty constructor”
–You may prefer not to have a constructor at all,
in which case it is said that you have by default
an “empty constructor”
–A constructor can call another constructor
of the same class using the ‘this’keyword
–Calling another constructor can be done only
as the first instruction of the calling constructor

10. 10
Constructors
Example 1:
public class Person {
String name = ""; // fields can be initialized!
Date birthDate = new Date();
public Person() {} // empty constructor
public Person(String name, Date birthDate) {
this(name); // must be first instruction
this.birthDate = birthDate;
}
public Person(String name) {
this.name = name;
}
}

11. 11
Constructors
Example 2:
public class Person {
String name = "";
Date birthDate = new Date();
public Person(String name, Date birthDate) {
this.name = name;
this.birthDate = birthDate;
}
}
Person p; // OK
p = new Person(); // not good –compilation error

12. 12
Initializer
Initializer is a block of instructions performed
right after the fields creation and before calling
the constructor
A class does not have to have an initializer and
indeed it usually doesn't
Example:
public class Thingy {
String s;
// the block underneath is an initializer
{s="Hello"; }
}
Usually initializer would do
a more complex job…

13. 13
Static Initializer
Static initializer is a block of instructions
performed the first time a class is loaded
Static initializer may be useful to perform
a one time initializations of static members
Example:
public class Thingy {
static String s;
// the block underneath is a static initializer
static {s="Hello"; }
}
Usually static initializer would
do a more complex job…

14. Agenda
•All that is to know on class syntax
•Constructors and Initializers
•Inheritance and Polymorphism
•Interfaces
•Nested Classes
•Enums
•Exercise

15. 15
Inheritance
Some Terms
A class that is derived from another class is called a subclass
(also a derived class, extended class, or child class).
The class from which the subclass is derived is called a
superclass(also a base classor a parent class).
Excepting java.lang.Object, which has no superclass,
every class has exactly one and only one direct superclass
(single inheritance).
In the absence of any other explicit superclass, every class is
implicitly a subclass of Object.
A class is said to be descendedfrom all the classes in its
inheritance chain stretching back to Object.

16. 16
Inheritance
Examples in following slides…
–Class Objectis the ancestor base class of all classes in Java
–There is no multiple inheritancein Java
–Inheritance is always “public”thus type is not stated
(no private or protected inheritance as in C++)
–Class can implement several interfaces(contracts)
–Class can be abstract
–Access to base class is done using the superkeyword
–Constructor may send parameters to its baseusing the
‘super’keyword as its first instruction
–If the base class does not have an empty constructor then
the class is required to pass parameters to its super

17. 17
Inheritance
Example 1:
public class Person {
private String name;
public Person(String name) {
this.name = name;
}
// Override toString in class Object
public String toString() {
return name;
}
}

18. 18
Inheritance
Example 1 (cont’):
public class Employee extends Person {
private Employee manager;
public Employee(String name, Employee manager) {
super(name);// must be first
this.manager = manager;
}
// Override toString in class Person
public String toString() {
return super.toString() +
(manager!=null? ", reporting to: " + manager :
" -I'm the big boss!");
}
}

19. 19
Inheritance
Example 2:
abstract public class Shape {
// private Color line = Color.Black;
// private Color fill = Color.White;
public Shape() {}
/* public Shape(Color line, Color fill) {
this.line = line;
this.fill = fill;
} */
abstract public void draw();
abstract public boolean isPointInside(Point p);
}

20. 20
Inheritance
Example 2 (cont’):
public class Circle extends Shape {
private Point center;
private double radius;
public Circle(Point center, double radius) {
this.center = center; this.radius = radius;
}
public void draw() {…} // use Graphics or Graphics2d
public boolean isPointInside(Point p) {
return (p.distance(center) < radius);
}
}

21. 21
Inheritance
Example:
abstract public class Shape {
…
final public void setFillColor(Color color)
{<some implementation>}
}
The finalkeyword is used to forbid a method from being
override in derived classes
Above is relevant when implementing a generic algorithm in the
base class, and it allows the JVM to linkage the calls to the
method more efficiently
The finalkeyword can also be used on a class to prevent the
class from being subclassed at all
of course, final and abstract
don‘t go together (why?)

22. Agenda
•All that is to know on class syntax
•Constructors and Initializers
•Inheritance and Polymorphism
•Interfaces
•Nested Classes
•Enums
•Exercise

23. 23
Interfaces
Examples in following slides…
–Interface is a contract
–An interface can contain method signatures
(methods without implementation) and static constants
–Interface cannot be instantiated, it can only be implemented
by classes and extendedby other interfaces
–Interface that do not include any method signature is called
a marker interface
–Class can implement several interfaces(contracts)
–Class can announce on implementing an interface,
without really implementing all of the declared methods,
but then the class must be abstract

24. 24
Interfaces
Example 1–using interface Comparable:
// a generic max function
staticpublicObject max(Comparable... comparables) {
intlength = comparables. length;
if(length == 0) { returnnull; }
Comparable max = comparables[ 0];
for(inti=1; i<length; i++) {
if(max.compareTo(comparables[i]) < 0) {
max = comparables[i];
}
}
returnmax;
}
// calling the function can go like this:
String maxStr = (String) max("hello", "world", "!!!");

25. 25
Interfaces
Example 2–supporting foreachon our own type:
publicinterfaceIterable<T> {
Iterator<T> iterator();
}
// example
publicinterfaceCollection<E> extendsIterable<E> {
…
Iterator<E> iterator();
…
} Exercise:
Write class NewString that will allow
iterating over its chars using "foreach"
To have your own class support iterating, using the "foreach“
syntax, the class should implement the interface Iterable:

26. 26
Interfaces
Example 3–supporting cloneon our own type:
publicinterfaceCloneable {}
Exercise:
Implement clone for class Person
To have your own class support the clone method
the class should implement the marker interfaceCloneable:

27. 27
Interfaces
Example 4–new IHaveNameinterface:
publicinterfaceIHaveName {
String getName();
}
Exercise:
Create the IHaveName interface and
let class Person implement it
To allow name investigation we want to create a new IHaveName
interface:

28. Agenda
•All that is to know on class syntax
•Constructors and Initializers
•Inheritance and Polymorphism
•Interfaces
•Nested Classes
•Enums
•Exercise

29. 29
Nested Classes
Examples in following slides…
Nested Classes are divided into two categories:
static and non-static.
Nested classes that are declared static are simply called
static nested classes
Non-static nested classes are called inner classes
Inner classes that are defined without having their own name
are called anonymous classes

30. 30
Nested Classes
Example 1:
public class OuterClass {
private int a;
static public class InnerStaticClass {
public int b;
}
public class InnerClass {
public void setA(int a 1) {
a = a1; // we have access to a !!!
}
}
}

31. 31
Nested Classes
Example 1(cont’):
OuterClass.InnerStaticClass obj 1 =
new OuterClass.InnerStaticClass();
OuterClass.InnerClass obj 2 =
new OuterClass().new InnerClass();
obj2.setA(3); // we modify a of OuterClass!!!

32. 32
Nested Classes
Example 2 –anonymous class:
public interface IHaveName {
String getName();
}
void someFunction(IHaveName someoneWithName) {
System.out.println(someoneWithName.getName());
}
public static void main(String[] args) {
someFunction(new IHaveName() {
public String getName() { return "Momo"; }
});
}

33. Agenda
•All that is to know on class syntax
•Constructors and Initializers
•Inheritance and Polymorphism
•Interfaces
•Nested Classes
•Enums
•Exercise

34. 34
Enums
Examples in following slides…
Structure for Constant Enumeration
Not an integer!
-May represent data (= have fields)
-May implement methods (member and static)
Automatically extends the Enum abstract type
Cannot extend other Classes or Enums,
but can implement interfaces
Cannot be extended (Enums are final)

35. 35
Enums
Example 1:
publicclassCard {
publicenumRank {
DEUCE, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE,
TEN, JACK, QUEEN, KING, ACE
}
publicenumSuit {
CLUBS, DIAMONDS, HEARTS, SPADES
}
privatefinalRank rank;
privatefinalSuit suit;
privateCard(Rank rank, Suit suit) {
this.rank= rank;
this.suit= suit;
}
…

36. 36
Enums
Example 1(cont’):
publicclassCard {
…
publicString toString() { returnrank+ " of "+ suit; }
privatestaticfinalList<Card> _deck =
newArrayList<Card>();
// Initialize the static deck
static{
for(Suit suit : Suit.values())
for(Rank rank : Rank.values())
_deck.add(newCard(rank, suit));
}
publicstaticArrayList<Card> newDeck() {
// Return copy of prototype deck
returnnewArrayList<Card>(_deck);
}
}

37. 37
Enums
Example 2:
publicenumOperation {
PLUS, MINUS, TIMES, DIVIDE;
// Do arithmetic op represented by this constant
doubleeval(doublex, doubley) {
switch(this) {
casePLUS: returnx + y;
caseMINUS: returnx -y;
caseTIMES: returnx * y;
caseDIVIDE: returnx / y;
}
thrownewAssertionError("Unknown op: "+ this);
}
}

38. 38
Enums
Example 3:
publicenumOperation {
PLUS{
doubleeval(doublex, doubley) { returnx + y; }
},
MINUS{
doubleeval(doublex, doubley) { returnx -y; }
},
TIMES{
doubleeval(doublex, doubley) { returnx * y; }
},
DIVIDE{
doubleeval(doublex, doubley) { returnx / y; }
};
// Do arithmetic op represented by this constant
abstractdoubleeval(doublex, doubley);
}

39. Agenda
•All that is to know on class syntax
•Constructors and Initializers
•Inheritance and Polymorphism
•Interfaces
•Nested Classes
•Enums
•Exercise

40. 40
Exercise 1
This exercise is called the Object OrientedRectangles game.
Get from the command line the coordinates of two rectangles.
The “winning rectangle” is set according to these rules:
•If a rectangle is contained (even partially) in the other, the
contained (=inner) rectangle wins
•If no one contains the other, the bigger by both area and
perimeter wins
•If no one is bigger by both area and perimeter, we have a tie
Example
Rectangle A: 1 1 10 10 (which means: x1=1, y1=1, x2=10, y2=10)
Rectangle B: 5 5 10 10 (which means: x1=5, y1=5, x2=10, y2=10)
The winner is Rectangle B (contained in A!)

41. 41
Exercise 2
Write the necessary classes to support the following main:
static public void main(String[] args) {
Expression e =
new Sum(
new Exponent(
new Number(2.0), new Number(3.0)),
new Sum(
new Number(1.0), new Number(-3.0)));
System.out.println(e + " = " + e.evaluate());
}

42. 42
Thatconcludes this chapter
amirk at mta ac il