© Amir Kirsh Object Oriented Programming with Java Written by Amir Kirsh, Edited by Liron Blecher

© Amir Kirsh

Object Oriented Programming with Java

Written by Amir Kirsh, Edited by Liron Blecher

Age

nda

• All that is to know on class syntax

• Constructors and Initializers

• Inheritance and Polymorphism

• Interfaces

• Nested Classes

• Casting

• Enums

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 = packagepublic Person() {}

}

Four accessibility options:– public – (default) = “package” **– protected * – private

* protected is also accessible by package** called also “package-private” or “package-friendly”

5

Static

Static member can be accessed without an instance (same as in C++)

Called sometimes “class variable” as opposed to “instance variable”

Example:

public class Widget {static private int counter;static public getCounter() {return counter;}

}

int number = Widget.getCounter();

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 int doodad = 6; // constant public final int id; // constant variablepublic Thingy(int id) {this.id = id;} // OK

//public void 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

• Casting

• Enums

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;public Person() {} // empty constructorpublic Person(String name) {

this(name, new Date()); //must be in first line} public Person(String name, Date birthDate) {

this.name = name;this.birthDate = birthDate;

}}

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; // OKp = new Person(); // not good – compilation error

12

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 initializerstatic { s="Hello"; }

} Usually static initializer would do a more complex job…

DEMO

examples.commandline

13

Age

nda

• All that is to know on class syntax

• Constructors and Initializers

• Inheritance and Polymorphism

• Interfaces

• Nested Classes

• Casting

• Enums

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 firstthis.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 {protected Color line = Color.Black;protected Color fill = Color.White;protected 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 Graphics2dpublic 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?)

DEMO

examples.inheritance

22

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();

}

// examplepublic interface Collection<E> extends Iterable<E> {

…Iterator<E> iterator();…

}

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 {}

To have your own class support the clone methodthe class should implement the marker interface Cloneable:

27

Interfaces

Example 4 – new HasName interface:

public interface HasName {String getName();

}

To allow name investigation we want to create a new HasName interface:

DEMO

examples.interfaces

28

Age

nda

• All that is to know on class syntax

• Constructors and Initializers

• Inheritance and Polymorphism

• Interfaces

• Nested Classes

• Casting

• Enums

30

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

31

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 !!!

}}

}

32

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!!!

33

Nested Classes

Example 2 – anonymous class:

public interface HaveName {String getName();

}

void someFunction(HaveName someoneWithName) {System.out.println(someoneWithName.getName());

}

public static void main(String[] args) {someFunction(new HaveName() {

public String getName() { return "Momo"; }});

}

DEMO

examples.innerstaticclass

34

Age

nda

• All that is to know on class syntax

• Constructors and Initializers

• Inheritance and Polymorphism

• Interfaces

• Nested Classes

• Casting

• Enums

36

Casting

Examples in following slides…

• When you want to convert an object of a superclass to one of its

subclasses

•Use only if you know for sure what the objects’ class type

•Use instanceof method to check the class type (can also be an

interface or any class in the inheritance line)

•If you fail to check, you might get a ClassCastException

37

Casting

Example 1:

void foo() {Object obj = new String(“Hiding in an object”);boo (obj);

}

void boo(Object argument) {if (argument instanceof String) {

String myString = (String)argument;System.out.println (myString.toUpperCase());

}}

Age

nda

• All that is to know on class syntax

• Constructors and Initializers

• Inheritance and Polymorphism

• Interfaces

• Nested Classes

• Casting

• Enums

39

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)

40

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;

}

…

41

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);

}}

42

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);

}}

43

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);

}

DEMO

examples.enums

44

Links

Core Java Interview Questions:

http://www.javacodegeeks.com/2013/09/core-java-interview-questions.html

45