Java Language and OOP

Part IV
By Hari Christian
Agenda
01 Enum
02 Final
03 Static
04 Variable Args
05 Encapsulation
06 Inheritance
07 Polymorphism
08 Interfaces
09 Abstract Class
10 Nested class
11 JAR
Enum
Old approach
class Bread {
static final int wholewheat = 0;
static final int ninegrain = 1;
static final int rye = 2;
static final int french = 3;
}

int todaysLoaf = Bread.rye;
Enum
New approach
public enum Bread {
wholewheat,
ninegrain,
rye,
french
}

Bread todaysLoaf = Bread.rye;
Enum
Enum with Constructor
public enum Egg {
small(10),
medium(20),
large(30);

Egg(int size) { this.size = size; }

private int size;
// Setter Getter
}

Enum
Enum with Constructor
public enum JobCategory {
staff(Staff),
nonstaff(Non Staff);

JobCategory(String name) { this.name = name; }

private String name;
// Setter Getter
}

Final
When a reference variable is declared final, it
means that you cannot change that variable to
point at some other object.

You can, however, access the variable and
change its fields through that final reference
variable.

The reference is final, not the referenced object.
Final
Example:
void someMethod(final MyClass c, final int a[]) {
c.field = 7; // allowed
a[0] = 7; // allowed
c = new MyClass(); // NOT allowed
a = new int[13]; // NOT allowed
}
Static
Field which is only one copy

Also called class variable

What you can make static:
1. Fields
2. Methods
3. Blocks
4. Class
Static - Fields
Example:
class Employee {
int id; // per-object field
int salary; // per-object field
static int total; // per-class field (one only)
}
Static - Fields
Example:
class EmployeeTest {
public static void main(String[] args) {
Employee h = new Employee();
h.id = 1;

Employee r = new Employee();
r.id = 2;

Employee.total = 10;
h.total; // 10
r.total; // 10
}
}
Static - Methods
Also called class method

Example:
public static int parseInt(String s) {
// statements go here.
}

int i = Integer.parseInt("2048");
Variable Arity Var Args
Var Args is optional

Var Args is an Array

Var Args
public class VarArgs {
public static void main(String[] args) {
sum();
sum(1, 2, 3, 4, 5);
}
public static void sum(int numbers) {
int total = 0;
for (int i = 0; i < numbers.length; i++) {
total += numbers[i];
}
return total;
}
}
Encapsulation
Imagine if you made your class with public instance
variables, and those other programmers were setting the
instance variables directly

public class BadOO {
public int size;
}

public class ExploitBadOO {
public static void main (String [] args) {
BadOO b = new BadOO();
b.size = -5; // Legal but bad!!
}

Encapsulation
OO good design is hide the implementation
detail by using Encapsulation

How do you do that?
Keep instance variables protected (with an access
modifier, often private)
Make public accessor methods, and force calling
code to use those methods rather than directly
accessing the instance variable
For the methods, use the JavaBeans naming
convention of set<someProperty> and
get<someProperty>
Encapsulation
Rewrite the class
public class GoodOO {
private int size;
public void setSize(int size) {
if (size < 0) this.size = 0; // does not accept negative
else this.size = size;
}
public void getSize() {
return size;
}
}

public class ExploitGoodOO {
public static void main (String [] args) {
GoodOO g = new GoodOO();
g.setSize(-5); // its safe now, no need to worry
}

Encapsulation
Inheritance
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)
Inheritance
Every class has one and only one direct
superclass (single inheritance), Object

Classes can be derived from classes that are
derived from classes that are derived from
classes, and so on, and ultimately derived from
the topmost class, Object
Inheritance
The idea of inheritance is simple but powerful:
When you want to create a new class and there
is already a class that includes some of the code
that you want, you can derive your new class
from the existing class

In doing this, you can reuse the fields and
methods of the existing class without having to
write them yourself
Inheritance
A subclass inherits all the members (fields,
methods, and nested classes) from its
superclass

Constructors are not members, so they are not
inherited by subclasses, but the constructor of
the superclass can be invoked from the subclass
Inheritance
At the top of the hierarchy, Object is the most
general of all classes. Classes near the bottom
of the hierarchy provide more specialized
behavior

Inheritance
public class Bicycle { // PARENT or SUPERCLASS
// the Bicycle class has three fields
private int cadence;
private int gear;
private int speed;
// the Bicycle class has one constructor
public Bicycle(int startCadence, int startSpeed, int startGear) {
gear = startGear; cadence = startCadence; speed = startSpeed;
}
// the Bicycle class has two methods
public void applyBrake(int decrement) {
speed -= decrement;
}
public void speedUp(int increment) {
speed += increment;
}
// Setter Getter
}
Inheritance
public class MountainBike extends Bicycle { // CHILD or SUBCLASS
// the MountainBike subclass adds one field
private int seatHeight;

// the MountainBike subclass has one constructor
public MountainBike(int startHeight, int startCadence, int startSpeed, int startGear) {
super(startCadence, startSpeed, startGear);
seatHeight = startHeight;
}

// the MountainBike subclass add one method
public void setHeight(int newValue) {
seatHeight = newValue;
}
}
Inheritance
Has a is a member of class
Example:
class Vehicle {
int wheel;
}

In above example, Vehicle has a wheel
Inheritance
Is a is a relation of class
Example:
class Vehicle { }
class Bike extends Vehicle { }
class Car extends Vehicle { }

In above example,
Bike is a Vehicle
Car is a Vehicle
Vehicle might be a Car, but not always
Polymorphism
The dictionary definition of polymorphism refers
to a principle in biology in which an organism or
species can have many different forms or stages

This principle can also be applied to object-
oriented programming and languages like the
Java language

Subclasses of a class can define their own
unique behaviors and yet share some of the
same functionality of the parent class
Polymorphism
public class Bicycle { // PARENT or SUPERCLASS
// the Bicycle class has three fields
private int cadence;
private int gear;
private int speed;
// the Bicycle class has one constructor
public Bicycle(int startCadence, int startSpeed, int startGear) {
gear = startGear; cadence = startCadence; speed = startSpeed;
}
// the Bicycle class has three methods
public void printDescription() {
System.out.println(Gear=" + gear + " cadence=" + cadence + " and speed=" + speed);
}
public void applyBrake(int decrement) {
speed -= decrement;
}
public void speedUp(int increment) {
speed += increment;
}
// Setter Getter
}
Polymorphism
public class MountainBike extends Bicycle { // CHILD or SUBCLASS
// the MountainBike subclass adds one field
private String suspension;

// the MountainBike subclass has one constructor
public MountainBike(String suspension,int startCadence,int
startSpeed,int startGear){
super(startCadence, startSpeed, startGear);
setSuspension(suspension);
}
public void printDescription() { // Override
super. printDescription();
System.out.println("MountainBike has a" + getSuspension());
}
// Setter Getter
}
Polymorphism
public class RoadBike extends Bicycle { // CHILD or SUBCLASS
// the RoadBike subclass adds one field
private int tireWidth;

// the RoadBike subclass has one constructor
public RoadBike(int tireWidth,int startCadence,int startSpeed,int
startGear){
super(startCadence, startSpeed, startGear);
setTireWidth(tireWidth);
}
public void printDescription() { // Override
super. printDescription();
System.out.println(RoadBike has a" + getTireWidth());
}
// Setter Getter
}
Polymorphism
public class TestBikes {
public static void main(String[] args) {
Bicycle bike01, bike02, bike03;

bike01 = new Bicycle(20, 10, 1);
bike02 = new MountainBike(20, 10, 5, "Dual");
bike03 = new RoadBike(40, 20, 8, 23);

bike01.printDescription();
bike02.printDescription();
bike03.printDescription();
}
}
Interface
There are a number of situations in software
engineering when it is important for disparate
groups of programmers to agree to a "contract"
that spells out how their software interacts

Each group should be able to write their code
without any knowledge of how the other group's
code is written

Generally speaking, interfaces are such
contracts
Interface
For example, imagine a futuristic society where
computer-controlled robotic cars transport
passengers through city streets without a human
operator

Automobile manufacturers write software (Java,
of course) that operates the automobilestop,
start, accelerate, turn left, and so forth
Interface
The auto manufacturers must publish an
industry-standard interface that spells out in
detail what methods can be invoked to make the
car move (any car, from any manufacturer)

The guidance manufacturers can then write
software that invokes the methods described in
the interface to command the car
Interface
Neither industrial group needs to know how the
other group's software is implemented

In fact, each group considers its software highly
proprietary and reserves the right to modify it at
any time, as long as it continues to adhere to the
published interface
Interface
public interface OperateCar {
void moveForward();
void applyBrake();
void shiftGear();
void turn();
void signalTurn();
}
Interface
public class Bmw implements OperateCar {
void moveForward() { }
void applyBrake() { }
void shiftGear() { }
void turn() { }
void signalTurn() { }
}
Interface
public class Jeep implements OperateCar {
void moveForward() { }
void applyBrake() { }
void shiftGear() { }
void turn() { }
void signalTurn() { }
}
Abstract Class
An abstract class is an incomplete class.

A class that is declared abstractit may or may
not include abstract methods

Abstract classes cannot be instantiated, but they
can be subclassed
Abstract Class
An abstract method is a method that is declared
without an implementation (without braces, and
followed by a semicolon), like this:
abstract void moveTo(int x, int y);

If a class includes abstract methods, then the
class itself must be declared abstract, as in:
public abstract class GraphicObject {
abstract void draw();
}
Abstract Class
When an abstract class is subclassed, the
subclass usually provides implementations for
all of the abstract methods in its parent class

However, if it does not, then the subclass must
also be declared abstract

Abstract classes are similar to interfaces, we
cannot instantiate them

Abstract Class
However, with abstract classes, you can declare
fields that are not static and final, and define
public, protected, and private concrete methods

With interfaces, all fields are automatically
public, static, and final, and all methods that you
declare or define (as default methods) are public

In addition, you can extend only one class,
whether or not it is abstract, whereas you can
implement any number of interfaces

Abstract Class
First you declare an abstract
class, GraphicObject, to provide member
variables and methods that are wholly shared by
all subclasses. GraphicObject also declares
abstract methods for such as draw or resize, that
need to be implemented by all subclasses but
must be implemented in different ways
Abstract Class
abstract class GraphicObject {
int x, y;
void moveTo(int newX, int newY) { }
abstract void draw();
abstract void resize();
}

Abstract Class
class Circle extends GraphicObject {
void draw() { }
void resize() { }
}

class Rectangle extends GraphicObject {
void draw() { }
void resize() { }
}
Abstract Class
abstract class X implements Y {
// implements all but one method of Y
}

class XX extends X {
// implements the remaining method in Y
}
Nested Class
The name "nested class" suggests you just write
a class declaration inside a class

Actually, there are four different kinds of nested
classes specialized for different purposes, and
given different names
Nested Class
All classes are either:
Top-level or nested
Nested classes are:
Static classes or inner classes
Inner classes are:
Member classes or local classes or anonymous classes
Nested Class
Represents the hierarchy and terminology
of nested classes in a diagram


Nested Class Nested Static
Example:
class Top {
static class MyNested { }
}

A static nested class acts exactly like a
top-level class
Nested Class Nested Static
The only differences are:
The full name of the nested static class
includes the name of the class in which it is
nested, e.g. Top.MyNested
Instance declarations of the nested class
outside Top would look like:
Top.MyNested myObj = new Top.MyNested();
The nested static class has access to all the
static methods and static data of the class it is
nested in, even the private members.
Nested Class Nested Static
class Top {
int i;
static class MyNested {
Top t = new Top();
{
t.i = 3; // accessing Top data
}
}
}

This code shows how a static nested class can access instance data
of the class it is nested within
Nested Class Nested Static
Where to use a nested static class:
Imagine you are implementing a complicated
class. Halfway through, you realize that you
need a "helper" type with some utility
methods. This helper type is self-contained
enough that it can be a separate class from
the complicated class. It can be used by other
classes, not just the complicated class. But it
is tied to the complicated class. Without the
complicated class, there would be no reason
for the helper class to exist
Nested Class Nested Static
Before nested classes, there wasn't a
good solution to this, and you'd end up
solving it by making the helper class a top-
level class, and perhaps make some
members of the complicated class more
public than they should be

Today, you'd just make the helper class
nested static, and put it inside the
complicated class

Nested Class Inner Class
Java supports an instance class being
declared within another class, just as an
instance method or instance data field is
declared within a class

The three varieties of inner class are
Member class
Local class
Anonymous class
Nested Class Inner Class Member Class
Example:
class Top {
class MyMember { }
}

Member class will have fields and
methods
Nested Class Inner Class Member Class
public class Top {
int i = 10;

class MyMember {
int k = i;
int foo() {
return this.k;
}
}

void doCalc() {
MyMember m1 = new MyMember();
MyMember m2 = new MyMember();

m1.k = 10 * m2.foo();
System.out.println("m1.k = " + m1.k);
System.out.println("m2.k = " + m2.k);
}

public static void main(String[] args) {
Top t = new Top();
t.doCalc();
}
}
Nested Class Inner Class Local Class
public class Top {
void doCalc() {
class MyLocal {
int k = 5;
int foo() {
return this.k * 10;
}
}
MyLocal m = new MyLocal();
System.out.println("m.k = " + m.k);
System.out.println("m.foo = " + m.foo());
}

public static void main(String[] args) {
Top t = new Top();
t.doCalc();
}
}
Nested Class Inner Class Anonymous Class
public abstract class MyAbstract {
public abstract void print();
}

public class MyAnonymous {
public static void main(String[] args) {
MyAbstract m = new MyAbstract() {
@override
public void print() {
System.out.println(TEST);
}
}
}
}
Nested Class Inner Class Anonymous Class
public class MyAnonymous {
public void print() {
System.out.println(PRINT IN ANONYMOUS);
}
}

public class Test {
public static void main(String[] args) {
MyAnonymous m = new MyAnonymous() {
public void print() {
System.out.println(PRINT IN MAIN);
}
};
m.print();
}
}
JAR
JAR = Java Archive

JAR = Zip File

To make JAR running, we create a manifest
which is the main class to start
JAR
How to make JAR:
1. Right click in root project
2. Click Export
3. Choose Runnable JAR file
4. Choose the main class and export destination
5. Finish
JAR
How to make JAR:

JAR
How to run JAR:
1. Open command prompt
2. Type java jar jartest.jar
Thank You