[design pattern] [java] Decorator pattern

這種模式讓你不用修改現有的interface，
並且對其新添加功能，

重點在於Employee.java的第七行，
除了複寫walk的method，還添加了
run的method在裡面.




Human.java

package com.test.decoratorpattern;

public interface Human {

 void walk(String msg);
}

Man.java

package com.test.decoratorpattern;

public class Man implements Human{

 @Override
 public void walk(String msg) {
  System.out.println("class is Man , "+msg);
 }

}

ManDecorator.java

package com.test.decoratorpattern;

public class ManDecorator implements Human {

 protected Human decoratedHuman;

 public ManDecorator(Human decoratedHuman) {
  this.decoratedHuman = decoratedHuman;
 }

 public void walk(String msg) {
  decoratedHuman.walk("class is ManDecorator:"+msg);
 }

}

Employee.java

package com.test.decoratorpattern;

public class Employee extends ManDecorator {

 public Employee(Human decoratedHuman) {
  super(decoratedHuman);
  // TODO Auto-generated constructor stub
 }

 @Override
 public void walk(String msg) {
  decoratedHuman.walk(msg);
  run(decoratedHuman);
 }

 private void run(Human decoratedHuman) {
  System.out.println("class is Employee: Run");
 }

}

testDecorator.java

package com.test.decoratorpattern;

public class testDecorator {

 public static void main(String[] args) {
  // TODO Auto-generated method stub

  Human man = new Man();
  man.walk(" man ");
  
  Human employee = new Employee(new Man());
  employee.walk(" employee ");

        
 }

}

Console

class is Man ,  man 
class is Man ,  employee 
class is Employee: Run

[design pattern] [java] Chain of Responsibility Pattern

責任鏈模式在物件導向程式設計裡是一種軟體設計模式，
它包含了一些命令對象和一系列的處理對象。
每一個處理對象決定它能處理哪些命令對象，
它也知道如何將它不能處理的命令對象傳遞給該鏈中的下一個處理對象。
該模式還描述了往該處理鏈的末尾添加新的處理對象的方法



AbstractLogger.java

package com.test.chainofresponsibilitypattern;

public abstract class AbstractLogger {
 public static int INFO = 1;
 public static int DEBUG = 2;
 public static int ERROR = 3;

 protected int level;

 // next element in chain or responsibility
 protected AbstractLogger nextLogger;

 public void setNextLogger(AbstractLogger nextLogger) {
  this.nextLogger = nextLogger;
 }

 public void logMessage(int level, String message) {
  System.out.println("current class :"+this.getClass().getSimpleName()+"  "+
                     "current(this).level : " + this.level + "  " + 
               "level(from function) = "+ level);

  if (this.level <= level) {
   write(message);
  }
  if (nextLogger != null) {
   //find out whether there have "next"
   nextLogger.logMessage(level, message);
  }
 }

 abstract protected void write(String message);

}

FileLogger.java

package com.test.chainofresponsibilitypattern;

public class FileLogger extends AbstractLogger {

 public FileLogger(int level) {
  this.level = level;
 }

 @Override
 protected void write(String message) {
  System.out.println("File Logger: " + message);
 }
}

ConsoleLogger.java

package com.test.chainofresponsibilitypattern;

public class ConsoleLogger extends AbstractLogger {

 public ConsoleLogger(int level) {
  this.level = level;
 }

 @Override
 protected void write(String message) {
  System.out.println("Console Logger: " + message);
 }
}

ErrorLogger.java

package com.test.chainofresponsibilitypattern;

public class ErrorLogger extends AbstractLogger {

 public ErrorLogger(int level) {
  this.level = level;
 }

 @Override
 protected void write(String message) {
  System.out.println("Error Logger: " + message);
 }
}

ChainPatterntest.java

package com.test.chainofresponsibilitypattern;

public class ChainPatterntest {
 
    private static AbstractLogger getChainOfLoggers(){

       AbstractLogger errorLogger   = new ErrorLogger(AbstractLogger.ERROR);
       AbstractLogger fileLogger    = new FileLogger(AbstractLogger.DEBUG);
       AbstractLogger consoleLogger = new ConsoleLogger(AbstractLogger.INFO);

       errorLogger.setNextLogger(fileLogger);
       fileLogger.setNextLogger(consoleLogger);

       return errorLogger;
       //order is important
       //return the first object you set
    }

    public static void main(String[] args) {
       AbstractLogger loggerChain = getChainOfLoggers();

       loggerChain.logMessage(AbstractLogger.INFO, 
          "This is an information.");

       System.out.println("======================");
       loggerChain.logMessage(AbstractLogger.DEBUG, 
          "This is an debug information.");

       System.out.println("======================");
       loggerChain.logMessage(AbstractLogger.ERROR, 
          "This is an error information.");
    }
 }

console

current class :ErrorLogger  current(this).level : 3  level(from function) = 1
current class :FileLogger  current(this).level : 2  level(from function) = 1
current class :ConsoleLogger  current(this).level : 1  level(from function) = 1
Console Logger: This is an information.
======================
current class :ErrorLogger  current(this).level : 3  level(from function) = 2
current class :FileLogger  current(this).level : 2  level(from function) = 2
File Logger: This is an debug information.
current class :ConsoleLogger  current(this).level : 1  level(from function) = 2
Console Logger: This is an debug information.
======================
current class :ErrorLogger  current(this).level : 3  level(from function) = 3
Error Logger: This is an error information.
current class :FileLogger  current(this).level : 2  level(from function) = 3
File Logger: This is an error information.
current class :ConsoleLogger  current(this).level : 1  level(from function) = 3
Console Logger: This is an error information.

[design pattern] [java] Template Pattern

template pttern:
use abstract class to define template(behavior)
to execute its methods.
And use some class to extend it.
to override the method of superclass.



Programmer

package com.test.templatepattern;

public abstract class Programmer {

 abstract boolean getUP();
 abstract boolean atCompany();
 abstract boolean Home();
 
 public void dailyRoutine(){
  getUP();
  atCompany();
  Home();
 }
}

Seven

package com.test.templatepattern;

public class Seven extends Programmer {

 @Override
 boolean getUP() {
  System.out.println("sleeping");
  return false;
 }

 @Override
 boolean atCompany() {
  System.out.println("coding");
  return false;
 }

 @Override
 boolean Home() {
  System.out.println("sleeping");
  return false;
 }

}

Leo

package com.test.templatepattern;

public class Leo extends Programmer {

 @Override
 boolean getUP() {
  System.out.println("meeting");
  return false;
 }

 @Override
 boolean atCompany() {
  System.out.println("meeting");
  return false;
 }

 @Override
 boolean Home() {
  System.out.println("meeting");
  return false;
 }

}

Lewis

package com.test.templatepattern;

public class Lewis extends Programmer {

 @Override
 boolean getUP() {
  System.out.println("coding");
  return false;
 }

 @Override
 boolean atCompany() {
  System.out.println("coding");
  return false;
 }

 @Override
 boolean Home() {
  System.out.println("coding");
  return false;
 }

}

testTemplatePattern

package com.test.templatepattern;

public class testTemplatePattern {

 public static void main(String[] args) {
  /*
  template pttern:
  use abstract class to define template(behavior) 
  to execute its methods.
  And use some class to extend it.
  to override the method of superclass.
  */
  
    Programmer lewis = new Lewis();
    lewis.dailyRoutine();
       System.out.println();
      
       Programmer leo = new Leo();
       leo.dailyRoutine();
       System.out.println();
       
       Programmer seven = new Seven();
       seven.dailyRoutine();
       System.out.println();
 }

}

console

coding
coding
coding

meeting
meeting
meeting

sleeping
coding
sleeping

[design pattern] [java] Facade Pattern

我認為wiki寫的蠻清楚的，這邊直接貼上說明

A facade is an object that provides a simplified interface to a larger body of code, such as a class library. A facade can:

• make a software library easier to use, understand and test, since the facade has convenient methods for common tasks;
• make the library more readable, for the same reason;
• reduce dependencies of outside code on the inner workings of a library, since most code uses the facade, thus allowing more flexibility in developing the system;
• wrap a poorly designed collection of APIs with a single well-designed API (as per task needs).

The Facade design pattern is often used when a system is very complex or difficult to understand because the system has a large number of interdependent classes or its source code is unavailable. This pattern hides the complexities of the larger system and provides a simpler interface to the client. It typically involves a single wrapper class which contains a set of members required by client. These members access the system on behalf of the facade client and hide the implementation details.

Animal.java

package com.test.facadepattern;

public interface Animal {

 void printMsg();
 void getFeet();
 void life();
}

Bird.java

package com.test.facadepattern;

public class Bird implements Animal{

 @Override
 public void printMsg() {
  // TODO Auto-generated method stub
  System.out.println("bird class");
 }

 @Override
 public void getFeet() {
  // TODO Auto-generated method stub
  
 }

 @Override
 public void life() {
  // TODO Auto-generated method stub
  
 }
 

}

Cat.java

package com.test.facadepattern;

public class Cat implements Animal {

 @Override
 public void printMsg() {
  // TODO Auto-generated method stub
  System.out.println("cat class");
 }

 @Override
 public void getFeet() {
  // TODO Auto-generated method stub
  
 }

 @Override
 public void life() {
  // TODO Auto-generated method stub
  
 }


 
}

Dog.java

package com.test.facadepattern;

public class Dog implements Animal{

 @Override
 public void printMsg() {
  // TODO Auto-generated method stub
  System.out.println("dog class");
 }

 @Override
 public void getFeet() {
  // TODO Auto-generated method stub
  
 }

 @Override
 public void life() {
  // TODO Auto-generated method stub
  
 }
 


}

Zoo.java

package com.test.facadepattern;

public class Zoo {

 private Animal bird ;
 private Animal cat ;
 private Animal dog ;
 
 public Zoo(){
  bird  = new Bird();
  dog   = new Dog();
  cat   = new Cat();
 }
 
 public void imDog(){
  dog.printMsg();
 }
 
 public void imBird(){
  bird.printMsg();
 }
 
 public void imCat(){
  cat.printMsg();
 }
 
}

testFacadePattern .java

package com.test.facadepattern;

public class testFacadePattern {

 public static void main(String[] args) {
  
  Zoo zoo = new Zoo();
  
  zoo.imBird();
  zoo.imCat();
  zoo.imDog();
  
 }

}

console

bird class
cat class
dog class

[java][designPattern] observer pattern

這個用法其實 在android 的 listView or gridview就有被使用
這兩個元件用完都需要呼叫 notifydatachange() 來更新畫面

Color.java

package com.test.observerpattern;

public abstract class Color {
 protected DrawBoard drawBoard;
 public abstract void update();
}

DrawBoard.java

package com.test.observerpattern;

import java.util.ArrayList;
import java.util.List;

public class DrawBoard {
 private List colors = new ArrayList();
 private String state;

 public String getState() {
  return state;
 }

 public void setState(String state) {
  this.state = state;
  notifyAllObservers();
 }

 public void addColor(Color observer) {
  colors.add(observer);
 }

 public void notifyAllObservers() {
  for (Color color : colors) {
   color.update();
  }
 }
}

Pain1.java

package com.test.observerpattern;

public class Pain1 extends Color {
 public Pain1(DrawBoard drawBoard) {
  this.drawBoard = drawBoard;
  this.drawBoard.addColor(this);
 }

 @Override
 public void update() {
  System.out.println("Pain1's color is :"+drawBoard.getState());
 }
}

Pain2.java

package com.test.observerpattern;

public class Pain2 extends Color {
 public Pain2(DrawBoard drawBoard) {
  this.drawBoard = drawBoard;
  this.drawBoard.addColor(this);
 }

 @Override
 public void update() {
  System.out.println("Pain2's color is :"+drawBoard.getState());
 }
}

testObserverPattern.java

package com.test.observerpattern;

public class testObserverPattern {
    public static void main(String[] args) {
     DrawBoard drawBoard = new DrawBoard();

       new Pain1(drawBoard);
       new Pain2(drawBoard);

       System.out.println("Change pain color to red"); 
       drawBoard.setState("red");
       System.out.println("Change pain color to white"); 
       drawBoard.setState("white");
    }
 }

console

Change pain color to red
Pain1's color is :red
Pain2's color is :red
Change pain color to white
Pain1's color is :white
Pain2's color is :white

[java] [designPattern] Null Object Pattern

根據上一篇文章 => java-design-pattern-factory-pattern

這篇做出修改成此篇的標題，

沒列出來的class就同上篇。這篇show出做修改的部分。

NullObject.java

package com.test.nullobjectpattern;
import com.test.factorypattern.animal;
public class NullObject implements animal {

 @Override
 public void printMsg() {
  // TODO Auto-generated method stub
  System.out.println("NullObject class, means i'm null");
 }

 @Override
 public void getFeet() {
  // TODO Auto-generated method stub

 }

 @Override
 public void life() {
  // TODO Auto-generated method stub

 }
}

animalFactory.java

package com.test.factorypattern;

import com.test.nullobjectpattern.NullObject;

public class animalFactory {

 public animal getAnimal(String kind){
  if (null == kind) {
   return null;
  } else if (kind.equalsIgnoreCase("dog")) {
   return new dog();
  } else if (kind.equalsIgnoreCase("cat")) {
   return new cat();
  } else if (kind.equalsIgnoreCase("bird")) {
   return new bird();
  } else {
   return new NullObject();
  }
  
 }
}

TestNullObjectPattern.java

package com.test.nullobjectpattern;

import com.test.factorypattern.animal;
import com.test.factorypattern.animalFactory;


public class TestNullObjectPattern {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  animalFactory animalfactory = new animalFactory();

  animal dog = animalfactory.getAnimal("dog");
  dog.printMsg();
  
  System.out.println("=========================");
  
  animal cat = animalfactory.getAnimal("cat");
  cat.printMsg();
  System.out.println("=========================");
  
  animal bird = animalfactory.getAnimal("bird");
  bird.printMsg();
  System.out.println("=========================");
  
  animal pig = animalfactory.getAnimal("pig");
  pig.printMsg();
  
 }

}

console

dog class
=========================
cat class
=========================
bird class
=========================
NullObject class, means i'm null

[java ] [Design Pattern] Factory Pattern

animal.java

package com.test.factorypattern;

public interface animal {

 void printMsg();
 void getFeet();
 void life();
}

animalFactory.java

package com.test.factorypattern;

public class animalFactory {

 public animal getAnimal(String kind){
  if (null == kind) {
   return null;
  } else if (kind.equalsIgnoreCase("dog")) {
   return new dog();
  } else if (kind.equalsIgnoreCase("cat")) {
   return new cat();
  } else if (kind.equalsIgnoreCase("bird")) {
   return new bird();
  } else {
   System.out.println("out of type");
  }
  
  
  return null;
 }
}

bird.java

package com.test.factorypattern;

public class bird implements animal{

 @Override
 public void printMsg() {
  // TODO Auto-generated method stub
  System.out.println("bird class");
 }

 @Override
 public void getFeet() {
  // TODO Auto-generated method stub
  
 }

 @Override
 public void life() {
  // TODO Auto-generated method stub
  
 }
 

}

cat.java

package com.test.factorypattern;

public class cat implements animal {

 @Override
 public void printMsg() {
  // TODO Auto-generated method stub
  System.out.println("cat class");
 }

 @Override
 public void getFeet() {
  // TODO Auto-generated method stub
  
 }

 @Override
 public void life() {
  // TODO Auto-generated method stub
  
 }


 
}

dog.java

package com.test.factorypattern;

public class dog implements animal{

 @Override
 public void printMsg() {
  // TODO Auto-generated method stub
  System.out.println("dog class");
 }

 @Override
 public void getFeet() {
  // TODO Auto-generated method stub
  
 }

 @Override
 public void life() {
  // TODO Auto-generated method stub
  
 }
 


}

testFactoryPattern.java

package com.test.factorypattern;

public class testFactoryPattern {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  animalFactory animalfactory = new animalFactory();

  animal dog = animalfactory.getAnimal("dog");
  dog.printMsg();
  
  System.out.println("=========================");
  
  animal cat = animalfactory.getAnimal("cat");
  cat.printMsg();
  System.out.println("=========================");
  
  animal bird = animalfactory.getAnimal("bird");
  bird.printMsg();
  System.out.println("=========================");
  
  animal pig = animalfactory.getAnimal("pig");
  pig.printMsg();
  
 }

}

console

dog class
=========================
cat class
=========================
bird class
=========================
out of type
Exception in thread "main" java.lang.NullPointerException
 at com.test.factorypattern.testFactoryPattern.main(testFactoryPattern.java:23)