04 Java Language And OOP Part IV

Java Language and OOP Part IVBy 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 Constructorpublic enum Egg {

small(10),

medium(20),

large(30);

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

private int size;

// Setter Getter

}

Enum

• Enum with Constructorpublic 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 classpublic 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); // it’s 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

Inheritancepublic 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

}

Inheritancepublic 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

Polymorphismpublic 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

}

Polymorphismpublic 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

}

Polymorphismpublic 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

}

Polymorphismpublic 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 automobile—stop, 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 abstract—it 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 Classpublic 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