Object Oriented Programming with Java Enosis Learning Agenda

Object Oriented Programming with Java Enosis Learning

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

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

Accessibility Options Four accessibility options: – public – protected * * – (default) = “package” ** – private protected is also accessible by package Example: public class Person { private String name; protected java. util. Date birth. Date; String id; // default accessibility = package public Person() {} } 4

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

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

Defining constants Though const is a reserved word in Java it's actually not in use! However the final keyword let's you define constants and const variables 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! } 7

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

Constructors – 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 Examples in following slides… 9

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

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

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… 12

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"; } } 13

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

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. 15

Inheritance – 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 Examples in following slides… 16

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

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 to. String in class Person public String to. String() { return super. to. String() + (manager!=null? ", reporting to: " + manager : " - I'm the big boss!"); } } 18

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 is. Point. Inside(Point p); } 19

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 Graphics 2 d public boolean is. Point. Inside(Point p) { return (p. distance(center) < radius); } } 20

Inheritance 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 Example: of course, final and abstract don‘t go together (why? ) abstract public class Shape { … final public void set. Fill. Color(Color color) {<some implementation>} } 21

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

Interfaces – 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 Examples in following slides… 23

Interfaces Example 1 – using interface Comparable: // a generic max function static 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. compare. To(comparables[i]) < 0) { max = comparables[i]; } } return max; } // calling the function can go like this: String max. Str = (String) max("hello", "world", "!!!"); 24

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

Interfaces Example 3 – supporting clone on our own type: To have your own class support the clone method the class should implement the marker interface Cloneable: public interface Cloneable {} Exercise: Implement clone for class Person 26

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

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

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 Examples in following slides… 29

Nested Classes Example 1: public class Outer. Class { private int a; static public class Inner. Static. Class { public int b; } public class Inner. Class { public void set. A(int a 1) { a = a 1; // we have access to a !!! } } } 30

Nested Classes Example 1 (cont’): Outer. Class. Inner. Static. Class obj 1 = new Outer. Class. Inner. Static. Class(); Outer. Class. Inner. Class obj 2 = new Outer. Class(). new Inner. Class(); obj 2. set. A(3); // we modify a of Outer. Class!!! 31

Nested Classes Example 2 – anonymous class: public interface IHave. Name { String get. Name(); } void some. Function(IHave. Name someone. With. Name) { System. out. println(someone. With. Name. get. Name()); } public static void main(String[] args) { some. Function(new IHave. Name() { public String get. Name() { return "Momo"; } }); } 32

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

Enums 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) Examples in following slides… 34

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; } … 35

Enums Example 1 (cont’): public class Card { … public String to. String() { return rank + " of " + suit; } private static final List<Card> _deck = new Array. List<Card>(); // Initialize the static deck static { for (Suit suit : Suit. values()) for (Rank rank : Rank. values()) _deck. add(new Card(rank, suit)); } public static Array. List<Card> new. Deck() { // Return copy of prototype deck return new Array. List<Card>(_deck); } } 36

Enums Example 2: public enum Operation { PLUS, MINUS, TIMES, DIVIDE; // Do arithmetic op represented by this constant double 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 Assertion. Error("Unknown op: " + this); } } 37

Enums Example 3: public enum PLUS { double }, MINUS { double }, TIMES { double }, DIVIDE { double }; Operation { eval(double x, double y) { return x + y; } eval(double x, double y) { return x - y; } eval(double x, double y) { return x * y; } eval(double x, double y) { return x / y; } // Do arithmetic op represented by this constant abstract double eval(double x, double y); } 38

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

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: x 1=1, y 1=1, x 2=10, y 2=10) Rectangle B: 5 5 10 10 (which means: x 1=5, y 1=5, x 2=10, y 2=10) The winner is Rectangle B (contained in A!) 40

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

That concludes this chapter 42