Design Pattern

Advanced Programming

SUT • Spring 2019

Contents

  • OOP Design

  • Design Patterns

OOP Design

interfaces

  • Defines a protocol

  • an interface promises a certain functionality

  • All the classes implementing the interface provide their own implementations for the promised functionality

  • A class combines the state and the behavior of a real object

  • An interface specifies (only) the behavior of an abstract entity

Famous Java Interfaces

  • Comparable<T>

    • int compareTo(T o)

  • java.io.Serializable

    • No method

    • Sometimes, interfaces have no method

    • The interface itself, is the protocol

  • Collection, Itertable, Iterator

Mechanisms of Code Reuse

  • Generics

  • Inheritance

  • Composition

  • interface

Composition

  • Inheritance: is-a

  • Composition: has-a

  • Circle has a center


  •  

  • Other examples?

public class Circle {
    private Point center;
}

Composition vs. Inheritance

  • You can make a base class

  • And put the common functionality of many classes in it

  • But always check:

    • Whether the is-a relationship exists between the derived classes and the base class

    • If the is-a relationship does not hold, Use composition instead of inheritance

    • Favor Composition over Inheritance

Example

public Class Sorting {
    public list sort(List list) {
        // sort implementation
        return list;
    }
}

class DynamicDataSet extends Sorting {
    // DynamicDataSet implementation
}

class SnapshotDataSet extends Sorting {
    // SnapshotDataSet implementation
}

Problems with this Inheritance

  • is-a    

    • DynamicDataSet is-a Sorting? No.

  • What if the two types of data set classes have a genuine base class, DataSet?

Notes

  • Favor composition over inheritance

    • Use composition to get code that is easy to change

    • and loosely coupled

  • Make your classes dependent on interfaces, not on the actual implementation

    • findBest(List<T>)

    • class DynamicDataSet { Sorting sorting; }

    • Do not depend on MergeSorting

IDE Support

  • Refactoring techniques are widely supported by IDEs

  • Practice it in Intelij

The Two Hats

  • Kent Beck's metaphor of two hats
  • Divide your time between two distinct activities
    • adding function
    • refactoring

Why Should I Refactor?

  • Refactoring Improves the Design of Software
  • Refactoring Makes Software Easier to Understand
  • Refactoring Helps You Find Bugs
  • Refactoring Helps You Program Faster
  • Refactoring makes your code more maintainable

When Should You Refactor?

  • The Rule of Three:

    • Refactor When You Add Function

    • Refactor When You Need to Fix a Bug

    • Refactor As You Do a Code Review

Example

public class Main {
    public void main(String[] args){
        Scanner s = new Scanner(System.in);

        System.out.println("Rectangle Info.");
        System.out.print("Enter the width: ");
        int a1 = s.nextInt();
        System.out.print("Enter the length: ");
        int a2 = s.nextInt();

        System.out.println("Rectangle Info.");
        System.out.print("Enter the width: ");
        int b1 = s.nextInt();
        System.out.print("Enter the length: ");
        int b2 = s.nextInt();

        int x = a1*a2;
        int y = b1*b2;

        if(x == y)
            System.out.println("Equal");
    }
}

Find bad smells!

Refactor the Code!

Example

public class Main {
    public void main(String[] args){
        Scanner scanner = new Scanner(System.in);

        System.out.println("Rectangle Info.");
        System.out.print("Enter the width: ");
        int width1 = scanner.nextInt();
        System.out.print("Enter the length: ");
        int length1 = scanner.nextInt();

        System.out.println("Rectangle Info.");
        System.out.print("Enter the width: ");
        int width2 = scanner.nextInt();
        System.out.print("Enter the length: ");
        int length2 = scanner.nextInt();

        int area1 = width1*length1;
        int area2 = width2*length2;

        if(area1 == area2)
            System.out.println("Equal");
    }
}

Rename…

Example

public  class Rectangle{
    private int length , width;
    public int getLength() {
        return length;
    }
    public void setLength(int length) {
        this.length = length;
    }
    public int getWidth() {
        return width;
    }
    public void setWidth(int width) {
        this.width = width;
    }
    public Rectangle(int length, int width) {
        this.length = length;
        this.width = width;
    }
}

Extract Class…

Example

public class Main {
 public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);

        System.out.println("Rectangle Info.");
        System.out.print("Enter the width: ");
        int width = scanner.nextInt();
        System.out.print("Enter the length: ");
        int length = scanner.nextInt();
        Rectangle rectangle1 = new Rectangle(length, width);

        System.out.println("Rectangle Info.");
        System.out.print("Enter the width: ");
        width = scanner.nextInt();
        System.out.print("Enter the length: ");
        length = scanner.nextInt();
        Rectangle rectangle2 = new Rectangle(length, width);

        int area1 = rectangle1.getWidth()*rectangle1.getLength();
        int area2 = rectangle2.getWidth()*rectangle2.getLength();

        if(area1 == area2)
            System.out.println("Equal");
    }
}

Extract Class…

Example

public class Rectangle {
    private static Rectangle readRectangle(Scanner scanner) {
        int width;
        int length;
        System.out.println("Rectangle Info.");
        System.out.print("Enter the width: ");
        width = scanner.nextInt();
        System.out.print("Enter the length: ");
        length = scanner.nextInt();
        Rectangle rectangle = new Rectangle(length, width);
        return rectangle;
    }
}

Extract Method…

Refactored Code

public class Main{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        
        Rectangle rectangle1 = readRectangle(scanner);
        Rectangle rectangle2 = readRectangle(scanner);
        
        int area1 = rectangle1.area();
        int area2 = rectangle2.area();
        
        if(area1 == area2)
            System.out.println("Equal");
    }
}

Final Refactor ...

References

  • Refactoring: improving the design of existing code, Martin Fowler, Kent Beck, John Brant, William Opdyke, Don Roberts (1999)

Design Pattern

Title Text

Made with Slides.com