© Amir Kirsh Object Oriented Programming with Java Written by Amir Kirsh.
42
© Amir Kirsh Object Oriented Programming with Java Written by Amir Kirsh
-
Upload
scot-martin -
Category
Documents
-
view
240 -
download
2
Transcript of © Amir Kirsh Object Oriented Programming with Java Written by Amir Kirsh.
© Amir Kirsh
Object Oriented Programming with Java
Written by Amir Kirsh
Age
nda • All that is to know on class syntax
• Constructors and Initializers
• Inheritance and Polymorphism
• Interfaces
• Nested Classes
• Enums
• Exercise
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
Accessibility Options
Example:
public class Person {
private String name;
protected java.util.Date birthDate;
String id; // default accessibility = package
public Person() {}
}
Four accessibility options:– public – (default) = “package” **– protected * – private
* protected is also accessible by package** called also “package-private” or “package-friendly”
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
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 reference to 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
Defining constants
Example:
public class Thingy {public final static doodad = 6; // constant public final id; // constant variablepublic Thingy(int id) {this.id = id;} // OK// public set(int id) {this.id = id;} // error!
}
Though const is a reserved word in Javait's actually not in use!
However the final keyword let's you define constants and const variables
Age
nda • All that is to know on class syntax
• Constructors and Initializers
• Inheritance and Polymorphism
• Interfaces
• Nested Classes
• Enums
• Exercise
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 parameteris called “empty constructor”
– You may prefer not to have a constructor at all,in which case it is said that you have by defaultan “empty constructor”
– A constructor can call another constructorof the same class using the ‘this’ keyword
– Calling another constructor can be done onlyas the first instruction of the calling constructor
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
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
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
Static Initializer
Static initializer is a block of instructions performed the first time a class is loaded
Static initializer may be useful to performa 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…
Age
nda • All that is to know on class syntax
• Constructors and Initializers
• Inheritance and Polymorphism
• Interfaces
• Nested Classes
• Enums
• Exercise
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 class or 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 descended from all the classes in its inheritance chain stretching back to Object.
16
Inheritance
Examples in following slides…
– Class Object is the ancestor base class of all classes in Java
– There is no multiple inheritance in 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 super keyword
– Constructor may send parameters to its base using 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
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
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
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
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
Inheritance
Example:abstract public class Shape {
…
final public void setFillColor(Color color){<some implementation>}
}
The final keyword 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 final keyword 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?)
Age
nda • All that is to know on class syntax
• Constructors and Initializers
• Inheritance and Polymorphism
• Interfaces
• Nested Classes
• Enums
• Exercise
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 extended by 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
Interfaces
Example 1 – using interface Comparable:
// a generic max functionstatic public Object max(Comparable... comparables) {
int length = comparables.length;if(length == 0) { return null; }Comparable max = comparables[0];for(int i=1; i<length; i++) {
if(max.compareTo(comparables[i]) < 0) {max = comparables[i];
}}return max;
}
// calling the function can go like this:String maxStr = (String) max("hello", "world", "!!!");
25
Interfaces
Example 2 – supporting foreach on our own type:
public interface Iterable<T> {
Iterator<T> iterator();
}
// example
public interface Collection<E> extends Iterable<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
Interfaces
Example 3 – supporting clone on our own type:
public interface Cloneable {}
Exercise:
Implement clone for class Person
To have your own class support the clone methodthe class should implement the marker interface Cloneable:
27
Interfaces
Example 4 – new IHaveName interface:
public interface IHaveName {
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:
Age
nda • All that is to know on class syntax
• Constructors and Initializers
• Inheritance and Polymorphism
• Interfaces
• Nested Classes
• Enums
• Exercise
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 calledstatic nested classes
Non-static nested classes are called inner classes
Inner classes that are defined without having their own nameare called anonymous classes
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 a1) {
a = a1; // we have access to a !!!
}
}
}
31
Nested Classes
Example 1 (cont’):
OuterClass.InnerStaticClass obj1 =
new OuterClass.InnerStaticClass();
OuterClass.InnerClass obj2 =
new OuterClass().new InnerClass();
obj2.setA(3); // we modify a of OuterClass!!!
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"; }
});
}
Age
nda • All that is to know on class syntax
• Constructors and Initializers
• Inheritance and Polymorphism
• Interfaces
• Nested Classes
• Enums
• Exercise
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
Enums
Example 1:public class Card {
public enum Rank {DEUCE, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE,TEN, JACK, QUEEN, KING, ACE
}
public enum Suit { CLUBS, DIAMONDS, HEARTS, SPADES
}
private final Rank rank;
private final Suit suit;
private Card(Rank rank, Suit suit) {this.rank = rank;this.suit = suit;
}
…
36
Enums
Example 1 (cont’):public class Card {
…public String toString() { return rank + " of " + suit; }
private static final List<Card> _deck =new ArrayList<Card>();
// Initialize the static deckstatic {
for (Suit suit : Suit.values())for (Rank rank : Rank.values())
_deck.add(new Card(rank, suit));}
public static ArrayList<Card> newDeck() {// Return copy of prototype deckreturn new ArrayList<Card>(_deck);
}
}
37
Enums
Example 2:
public enum Operation {
PLUS, MINUS, TIMES, DIVIDE;
// Do arithmetic op represented by this constantdouble eval(double x, double y) {
switch(this) {
case PLUS: return x + y;
case MINUS: return x - y;
case TIMES: return x * y;
case DIVIDE: return x / y;
}
throw new AssertionError("Unknown op: " + this);
}
}
38
Enums
Example 3:public enum Operation {
PLUS {double eval(double x, double y) { return x + y; }
},
MINUS {double eval(double x, double y) { return x - y; }
},
TIMES {double eval(double x, double y) { return x * y; }
},
DIVIDE {double eval(double x, double y) { return x / y; }
};
// Do arithmetic op represented by this constantabstract double eval(double x, double y);
}
Age
nda • All that is to know on class syntax
• Constructors and Initializers
• Inheritance and Polymorphism
• Interfaces
• Nested Classes
• Enums
• Exercise
40
Exercise 1
This exercise is called the Object Oriented Rectangles 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
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
That concludes this chapter
amirk at mta ac il
