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

Design Pattern

By Behnam Hatami

Made with Slides.com

Design Pattern

Design Pattern / Advanced Programming Course @ SUT, Spring 2019

  • 961

More from Behnam Hatami