Changes between Version 1 and Version 2 of DesignPatterns

Timestamp:

Jan 27, 2015, 3:14:36 PM (10 years ago)

Author:

Timothy Lin

Comment:

info on singletons & chain of responsibility pattern

DesignPatterns

@@ -3 +3 @@
 == Overarching Structural Patterns
 
-=== Command-Based FRC Robot (Event-Based)
+=== Command-Based FRC Robot (Event-Driven)
 Please see the [http://wiki.raidtech.net/wiki/Command%20Based%20Robot%20Notes Command Based Robot Notes] for detailed information on how to implement this design pattern.
 
@@ -23 +23 @@
 This entails that inside the loop, there cannot be anything that requires a large amount of processing power or time. Each instruction should be relatively short and not take up not. '''There should be no while loops, or lengthy for loops.'''
 
+Arduinos, for example, use this pattern. There is usually some sort of an initialization function, as well as a periodic, or repeated function.
+{{{
+#!div style="font-size: 80%"
+  {{{#!java
+  void init() {
+    // initialization code
+  }
+
+  void loop() {
+    // periodically repeating code
+  }
+  }}}
+}}}
+
 == Communication-Related Patterns
+
+=== Chain of Responsibility
+This pattern is a method of processing data using multiple classes. Each class is responsible for dealing with a particular type of data or output, and passes along any data it doesn't know how to deal with to the next class(es).
+
+See example:
+{{{
+#!java
+public class ClawPolicy {
+  /* instance variables declared; not shown */
+
+  public void execute() {
+    if (modeBtn == AUTOMATED)
+      clawAlgorithmPolicy.execute();
+    else if (modeBtn == MANUAL)
+      clawHandler.execute();
+    else
+      System.out.println("[ERROR: ClawPolicy] IllegalStateException for the mode button");
+  }
+}
+}}}
 
 === !Observer/Listener Pattern
 
 === Singletons
+A singleton is a class which can only ever have one instance of it, generally created by the class itself and accessed through a public accessor method.
+
+{{{
+#!div class="important"
+'''Reasons for Making a Class a Singleton'''
+- class contains objects that should not be instantiated more than once
+- instances of the class require a lot of processing power, time, or other machine resources
+}}}
+
+See the following sections for various methods of implementing a singleton class in the Java programming language:
+==== Singleton from Enum
+A singleton can be written as an java enum with one constant: the instance.
+
+{{{
+#!java
+public enum DatabaseAccessObject {
+  INSTANCE;
+  
+  private DatabaseModel dm;
+  private SQLConnector sqlconnect = new SQLConnector(/* arguments not shown */);
+
+  private DatabaseAccessObject() {
+    /* implementation not shown, but will take a long time with a large strain on the machine */
+  }
+
+  /* other accessor and modifier methods not shown */
+  
+}
+}}}
+
+Then, to access this object:
+
+{{{
+#!java
+...
+DatabaseAccessObject dao = DatabaseAccessObject.INSTANCE;
+
+dao.find(/* args not shown*/);
+...
+}}}
+
+==== Private Constructor and Public getInstance()
+A singleton can also be made using a static getInstance() method and setting the constructor to private.
+
+{{{
+#!java
+public class DAO {
+  public static DAO instance = new DAO();
+
+  /**
+   * Time consuming and resource intensive constructor.
+   */
+  private DAO() {
+    // implementation not shown
+  }
+
+  public static DAO getInstance() {
+    return instance;
+  }
+
+  /* other methods not shown */
+}
+}}}
+
+Then, to access the object:
+
+{{{
+#!java
+...
+DAO dao = DAO.getInstance();
+
+dao.<some method>();
+...
+}}}
 
 == Abstraction Patterns