Introduce an OOP approach for Simple-Java-Calculator based on Design Patterns

src/simplejavacalculator/AbsCalc.java

@@ -0,0 +1,7 @@
+package simplejavacalculator;
+
+public class AbsCalc implements Calculator {
+	public double calculate(Buffer buffer) {
+		return Math.abs(buffer.num1);
+	}
+}

src/simplejavacalculator/AddCalc.java

@@ -0,0 +1,9 @@
+package simplejavacalculator;
+
+public class AddCalc implements Calculator {
+
+	public double calculate(Buffer buffer) {
+
+		return buffer.num1 + buffer.num2;
+	}
+}

src/simplejavacalculator/BinaryCommand.java

@@ -0,0 +1,23 @@
+package simplejavacalculator;
+
+import javax.swing.JTextArea;
+
+import simplejavacalculator.Buffer.PreviouslyPressed;
+
+public class BinaryCommand extends Command {
+
+	public void execute(Buffer buffer, String label) {
+		this.sub = CommandSubtype.COM_BINARY;
+		Buffer.pp = PreviouslyPressed.PRESSED_BINARY;
+		// Calculation with an abstraction manner
+	}
+
+	public void show(JTextArea text, Buffer buffer, Calculator calc, String label) {
+		buffer.c = calc; // save the pointer globally
+		text.setText(label);
+		   if (buffer.c != null && (buffer.num1 != null && buffer.num2 != null)) {
+			   buffer.num1 = (calc.calculate(buffer));
+			   writer(buffer.num1, text);
+		   }
+	}
+}

src/simplejavacalculator/Buffer.java

@@ -0,0 +1,19 @@
+package simplejavacalculator;
+
+public class Buffer {
+	public Double num1 = null, num2 = null;
+	public Double buffered_res = null;
+
+	public enum PreviouslyPressed {
+		PRESSED_NONE,
+		PRESSED_NUMBER,
+		PRESSED_UNARY,
+		PRESSED_BINARY,
+		PRESSED_EQUAL,
+		PRESSED_CLEAR
+	};
+
+	public static PreviouslyPressed pp = PreviouslyPressed.PRESSED_NONE;
+	public Object c = null;
+
+}

src/simplejavacalculator/Calculator.java

@@ -1,130 +1,6 @@
-/**
- * @name        Simple Java Calculator
- * @package     ph.calculator
- * @file        Main.java
- * @author      SORIA Pierre-Henry
- * @email       [email protected]
- * @link        http://github.com/pH-7
- * @copyright   Copyright Pierre-Henry SORIA, All Rights Reserved.
- * @license     Apache (http://www.apache.org/licenses/LICENSE-2.0)
- */
-
-package simplejavacalculator;
-
-import static java.lang.Double.NaN;
-import static java.lang.Math.log;
-import static java.lang.Math.log10;
-import static java.lang.Math.pow;
-
-public class Calculator {
-
-    public enum BiOperatorModes {
-        normal, add, minus, multiply, divide , xpowerofy 
-    }
-
-    public enum MonoOperatorModes {
-        square, squareRoot, oneDividedBy, cos, sin, tan, log, rate, abs, ln,
-    }
-
-    private Double num1, num2;
-    private BiOperatorModes mode = BiOperatorModes.normal;
-
-    private Double calculateBiImpl() {
-        if (mode == BiOperatorModes.normal) {
-            return num2;
-        }
-        if (mode == BiOperatorModes.add) {
-            if (num2 != 0) {
-                return num1 + num2;
-            }
-
-            return num1;
-        }
-        if (mode == BiOperatorModes.minus) {
-            return num1 - num2;
-        }
-        if (mode == BiOperatorModes.multiply) {
-            return num1 * num2;
-        }
-        if (mode == BiOperatorModes.divide) {
-            return num1 / num2;
-        }
-        if (mode == BiOperatorModes.xpowerofy) {
-            return pow(num1,num2);
-        }
-
-        // never reach
-        throw new Error();
-    }
-
-    public Double calculateBi(BiOperatorModes newMode, Double num) {
-        if (mode == BiOperatorModes.normal) {
-            num2 = 0.0;
-            num1 = num;
-            mode = newMode;
-            return NaN;
-        } else {
-            num2 = num;
-            num1 = calculateBiImpl();
-            mode = newMode;
-            return num1;
-        }
-    }
-
-    public Double calculateEqual(Double num) {
-        return calculateBi(BiOperatorModes.normal, num);
-    }
-
-    public Double reset() {
-        num2 = 0.0;
-        num1 = 0.0;
-        mode = BiOperatorModes.normal;
-
-        return NaN;
-    }
-
-
-    public Double calculateMono(MonoOperatorModes newMode, Double num) {
-        if (newMode == MonoOperatorModes.square) {
-            return num * num;
-        }
-        if (newMode == MonoOperatorModes.squareRoot) {
-            return Math.sqrt(num);
-        }
-        if (newMode == MonoOperatorModes.oneDividedBy) {
-            return 1 / num;
-        }
-        if (newMode == MonoOperatorModes.cos) {
-            return Math.cos(Math.toRadians(num));
-        }
-        if (newMode == MonoOperatorModes.sin) {
-            return Math.sin(Math.toRadians(num));
-        }
-        if (newMode == MonoOperatorModes.tan) {
-            if (num == 0 || num % 180 == 0) {
-                return 0.0;
-            }
-            if (num % 90 == 0 && num % 180 != 0) {
-                return NaN;
-            }
-
-            return Math.tan(Math.toRadians(num));
-        }
-        if (newMode == MonoOperatorModes.log) {
-            return log10(num);
-        }
-        if (newMode == MonoOperatorModes.ln) {
-            return log(num);
-        }
-        if (newMode == MonoOperatorModes.rate) {
-           return num / 100;
-        }
-        if (newMode == MonoOperatorModes.abs){
-            return Math.abs(num);
-        }
-
-        // never reach
-        throw new Error();
-    }
-
-}
+package simplejavacalculator;
+
+public interface Calculator {		
+	public abstract double calculate(Buffer buffer);
+
+}

src/simplejavacalculator/ClearCommand.java

@@ -0,0 +1,19 @@
+package simplejavacalculator;
+
+import javax.swing.JTextArea;
+
+import simplejavacalculator.Buffer.PreviouslyPressed;
+
+public class ClearCommand extends Command{
+	public void execute(Buffer buffer, String label) {
+		this.sub = CommandSubtype.COM_CLEAR;
+
+		Buffer.pp = PreviouslyPressed.PRESSED_NONE;
+		buffer.num1 = null;
+		buffer.num2 = null;
+	}
+
+	public void show(JTextArea text, Buffer buffer, Calculator calc, String label) {
+		 writer(Double.NaN, text);
+	}
+}

src/simplejavacalculator/Command.java

@@ -0,0 +1,27 @@
+package simplejavacalculator;
+
+import javax.swing.JTextArea;
+
+public abstract class Command {
+
+	public enum CommandSubtype {
+		COM_NUMBER,
+		COM_UNARY,
+		COM_BINARY,
+		COM_EQUAL,
+		COM_CLEAR
+	}
+
+	public CommandSubtype sub;
+
+	public abstract void execute(Buffer buffer, String label);
+	public abstract void show(JTextArea text, Buffer buffer, Calculator calc, String label);
+
+	public static void writer(final Double num, JTextArea text) {
+	   if (Double.isNaN(num)) {
+		   text.setText("");
+	   } else {
+		   text.setText(Double.toString(num));
+	   }
+   }
+}

src/simplejavacalculator/CosCalc.java

@@ -0,0 +1,8 @@
+package simplejavacalculator;
+
+public class CosCalc implements Calculator {
+	public double calculate(Buffer buffer) {
+
+		return Math.cos(Math.toRadians(buffer.num1));
+	}
+}

src/simplejavacalculator/DivideCalc.java

@@ -0,0 +1,11 @@
+package simplejavacalculator;
+
+public class DivideCalc implements Calculator {
+
+	public double calculate(Buffer buffer) {
+
+		// FIXME
+		return buffer.num1 / buffer.num2;
+	}
+
+}

src/simplejavacalculator/EqualCommand.java

@@ -0,0 +1,21 @@
+package simplejavacalculator;
+
+import javax.swing.JTextArea;
+
+import simplejavacalculator.Buffer.PreviouslyPressed;
+
+public class EqualCommand extends Command {
+	public void execute(Buffer buffer, String label) {
+		this.sub = CommandSubtype.COM_EQUAL;
+		Buffer.pp = PreviouslyPressed.PRESSED_EQUAL;
+	}
+
+	public void show(JTextArea text, Buffer buffer, Calculator calc, String label) {
+		 if (buffer.c != null && (buffer.num1 != null && buffer.num2 != null)) {
+			   buffer.num1 = ((Calculator)(buffer.c)).calculate(buffer);
+			   writer(buffer.num1, text);
+			   buffer.num2 = null;
+
+		 }
+	}
+}

src/simplejavacalculator/LnCalc.java

@@ -0,0 +1,10 @@
+package simplejavacalculator;
+import static java.lang.Math.log;
+
+public class LnCalc implements Calculator {
+
+	public double calculate(Buffer buffer) {
+
+		return log(buffer.num1);
+	}
+}

src/simplejavacalculator/LogCalc.java

@@ -0,0 +1,11 @@
+package simplejavacalculator;
+
+import static java.lang.Math.log10;
+
+public class LogCalc implements Calculator {
+
+	public double calculate(Buffer buffer) {
+
+		 return log10(buffer.num1);
+	}
+}

src/simplejavacalculator/MinusCalc.java

@@ -0,0 +1,8 @@
+package simplejavacalculator;
+
+public class MinusCalc implements Calculator {
+	public double calculate(Buffer buffer) {
+
+		return buffer.num1 - buffer.num2;
+	}
+}

src/simplejavacalculator/MultiplyCalc.java

@@ -0,0 +1,10 @@
+package simplejavacalculator;
+
+public class MultiplyCalc implements Calculator {
+
+	public double calculate(Buffer buffer) {
+
+		return buffer.num1 * buffer.num2;
+	}
+
+}

src/simplejavacalculator/NumberCommand.java

@@ -0,0 +1,49 @@
+package simplejavacalculator;
+
+import javax.swing.JTextArea;
+
+import simplejavacalculator.Buffer.PreviouslyPressed;
+
+public class NumberCommand extends Command {
+
+	private double get_new_buff_after_num_pressed(Double buffer, Double new_num)
+	{
+		Double res = null;
+
+		Double temp2 	= (double)(buffer * 10 + new_num);
+
+		if (temp2 < Integer.MAX_VALUE) {
+			res = temp2;
+		}
+		return res; 
+	}
+
+	public void execute(Buffer buffer, String label) {
+
+		this.sub = CommandSubtype.COM_NUMBER;
+
+		Double temp1 = Double.parseDouble(label);
+
+		if (Buffer.pp == PreviouslyPressed.PRESSED_NONE || Buffer.pp == PreviouslyPressed.PRESSED_EQUAL) {
+			buffer.num1 = temp1;
+			Buffer.pp = PreviouslyPressed.PRESSED_NUMBER;
+		} else if (Buffer.pp == PreviouslyPressed.PRESSED_NUMBER) {
+			if (buffer.num2 != null) {
+				buffer.num2 = get_new_buff_after_num_pressed(buffer.num2, temp1);
+			} else {
+				buffer.num1 = get_new_buff_after_num_pressed(buffer.num1, temp1);
+			}
+		} else  if (Buffer.pp == PreviouslyPressed.PRESSED_BINARY) {
+			buffer.num2 = temp1;
+			Buffer.pp = PreviouslyPressed.PRESSED_NUMBER;
+		}
+	}
+
+	public void show(JTextArea text, Buffer buffer, Calculator calc, String label) {
+		if (buffer.num2 != null) {
+			writer((double)buffer.num2, text);
+		} else {
+			writer((double)buffer.num1, text);
+		}
+	}
+}

src/simplejavacalculator/OneDivideByCalc.java

@@ -0,0 +1,8 @@
+package simplejavacalculator;
+
+public class OneDivideByCalc implements Calculator {
+	public double calculate(Buffer buffer) {
+
+		return 1 / buffer.num1;
+	}
+}