Java OOP

Intro

  • Coding paradigm of the 90s
  • Many OO languages now (Java, Eiffel, SmallTalk)
  • Or OO aspects (Basic, Pascal, ADA)
  • Scripting langs with OO aspects (JavaScript, Python)
  • Better code base, less bugs/errors
  • Abstraction
    • Seperation between concept and implementation
  • Class - Object
    • Class as blueprint
    • Object as instance of a class

Encapsulation

  • Class contains data and behavior
  • Data given by set of class fields
  • Behavior is given by set of methods
  • So called class members
  • Hide implementation details
  • Only certain interface is visible for consumer

Relations

  • "is-a" relation
    • Triangle is a shape
    • Generalization/Specialization
    • Triangle as specialization of shape
    • Shape as a generalization of a triangle
  • "part-of" relation
    • Bicycle consists of many parts
    • In OOP given by class variable
    • Aggregation/Composition
  • Association
    • E.g. class invokes / uses other class
    • used in local contexts or in method calls

OOP Elements

  • Basic elements: classes, objects, interfaces
  • Classes
    • set of data
    • set of behavior (methods)
  • Object
    • instance of class
    • allocated in memory
    • multiple instances possible
  • Class inheritance
    • subclasses may inherit class members from base classes
  • Class visibility (encapsulation)
    • inner details should be private
    • accessible data should be public (getter/setter)

Class Syntax

/*
 * [javaModifiers] class className [extends someSuperClass] 
 *        [implements someInterfaces sep by commas] 
 * {
 *    // Data members
 *    // Constructors
 *    // Methods
 * } 
 */

public class Candidate { // ... }

class Stats extends ToolSet { // ... }

public class Report extends ToolSet implements Runnable { // ... }
  • Class signature, optional constructors, data members and methods
  • Class instance (object)
    • Candidate cand = new Candidate();

Class Members

/*
 * [javaModifier] type dataMemberName;
 * [javaModifiers] type methodName (parameterList) 
 *   [throws listOfExceptionsSepByComas] {
 *   // ...
 * }
 *
 */

public class Candidate {
    private String firstName;
    private String lastName;
    private int year;
    public void setYear(int y) { year = y; }
    public String getLastName() { return lastName; }
}
  • Access data members and methods
    • candidate1.setYear(2016);
    • String name = getFirstName() + getLastName();

Overloading

  • Methods and constructors can be overloaded
  • Two or more methods have same name but different signature
  • Method signature: return value, method name and parameters
  • Having only different return type is not overloading
  • Access methods can be different of overloaded methods
  • May throw different exceptions
public class VotingMachine {
    // ...
    public void startUp() { // ... }
    public void startUp(int delay) { // ... }
    private String startUp(District d) throws new IOException { // ... }
}

Overriding

  • Subclass may override methods that it inherits
  • Must have same signature
  • final, static or private methods cannot be overriden
  • protected methods may override methods that have no access modifiers
  • Overriding method cannot have more restrictive access modifiers
  • May not throw any new checked exceptions
public class Display {
    void startUp() {
        // ...
    }
}

public class TouchScreenDisplay extends Display { 
    void startUp() {
       	// ... 
    }
} 

Constructors

  • Called upon object creation
  • Used to initialize data in created object
  • Is optional, has same name as class
  • no return statement in body
  • Classes have implicit no-arg constructors
  • If explicit constructor with args is added, there is no std constructor
public class Candidate {
    Candidate(int id) {
        this.identification = id;   
    }

    Candidate(int id, int age) {
     	this.identification = id;
	this.age = age;
    }
}

Superclasses and Subclasses

  • A class can inherit from a single base class
  • Subclass inherits data members and methods
  • No direct access to private members of superclass
  • super keyword
    • Used to access overriden methods from base class
    • Use super to class constructor of superclass
    • Must be first statement in constructor
public class Machine { 
    boolean state;
    void setState(boolean s) { state = s; }
    boolean getState() { return state; }
}

public class VotingMachine extends Machine { // ... }

This keyword

  • Refer to current object with this keyword
  • Call constructor within other constructor
  • Pass reference of current object to another object
  • Assign a parameter variable to instance variable
public class Curtain {
    public Curtain(int length, int width) { // ... }
    public Curtain() { this(10,9); }
}

public void setColor(String color) {
    this.color = color;
}

Abstract Classes

  • Used as base class
  • Contains abstract methods
  • All abstract methods must be defined by deriving class
  • Otherwise derived class is also abstract
  • Abstract methods just have method declaration
public abstract class Shape {
    public abstract void draw();
}
    
public class Triangle extends Shape {
    public void draw() {
        // ...            
    }
}

Static Members

  • Reside inside class, no instance needed
public class Voter {
    static int count = 0;

    // static constants
    static final int AGE_IMIT;

    static {
	// init static members
        AGE_IMIT = 18;
    }

    public Voter() { counter++; }
    
    public static int getVoterCount() {
	return count;
    }
}

Interfaces

  • Set of public signatures
  • Class that implements interface must provide implementations
  • Otherwise must be declared abstract
  • Classes may implement multiple interfaces
  • Interfaces may extend multiple interfaces
public interface Reportable {
    void genReport(String repType);
    void printReport(String repType);
}

public abstract class A implements Reportable {
    // ...
} 

Polymorphism

  • Variables may hold objects of different classes
  • Variable of type X can hold objects of type X or derived objects
  • Late binding: decide during run-time which method to call
public abstract class Shape {
    public abstract void draw();
}

public class Triangle extends Shape { // ... }
public class Rectangle extends Shape { // ... }
public class Circle extends Shape { // ... }

public class Main {
    public static void main(String[] args){
        ArrayList<Shape> myShapes = new ArrayList<Shape>();
        myShapes.add(new Circle());
        myShapes.add(new Triangle());
        myShapes.add(new Rectangle());

        for(int ii = 0; ii < myShapes.size(); ii++) {
            myShapes.get(ii).draw();
        }
    }
}

Enumerations

  • Set of object that represent related set of choices
  • enum is a class of type enum and it is singleton
  • enum classes can have methods, constructors and members
enum DisplayButton {
    ROUND (.50f),
    SQUARE (.40f);
    private final float size;
    DisplayButton(float size) { this.size = size; }
    private float size() { return size; }
}

DisplayButton round = DisplayButton.ROUND;

Annotation Types

  • Associate metadata with program elements at compile/run-time
  • Packages, classes, methods, fields, parameters, variables, constructors can be annotated
  • Built-in annotations
    • @Override, @Deprecated, @SuppressWarnings
  • Must be placed before the annotated item
// @Override is a marker annotation
// compile warning will be returned if method cannot be found
@Override public String toString() { // ... }

Developer-Defined Annotations

  • Devs may define own annotations
  • 3 annotation types
    • Marker annotation has no params
    • Single value annotation has single param
    • Multi value annotation has multiple params
// @interface annotationName { ... } // defines annotation
public @interface Feedback {
    String reportName();
    String comment default "None";
}

@Feedbaack(reportName="Report 1")
public void myMethod() { // ... } 

 

 

References

 

Handbuch der Java-Programmierung

(5. Auflage)

 

 

 

 

 

Thank you for your attention!

 

Made with Slides.com