javaStatic

Headline

Modular programming with static methods in Java

Operations on companies are implemented as families of static methods with a class designated to each operation. This is straightforward if the operations are not polymorphic. This is the case for the given object model which only uses object composition as opposed to class inheritance or interface polymorphism.

Illustration

The data model is implemented with object composition. For example Companies:

/**
 * A company has a name and consists of (possibly nested) departments.
 */
public class Company implements Serializable {

    private static final long serialVersionUID = -200889592677165250L;

    private String name;
    private List<Department> depts = new LinkedList<Department>();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<Department> getDepts() {
        return depts;
    }

}

Feature:Closed serialization is implemented using Language:Java Technology:Object Streams:

    /*
     * Read (say, deserialize) a company.
     */
    public static Company deserializeCompany(String filename) {

        Object o = null;

        try {
            FileInputStream fis = new FileInputStream(filename);
            ObjectInputStream in = new ObjectInputStream(fis);
            o = in.readObject();
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return (Company) o;
    }

    /*
     * Write (say, serialize) a company.
     */
    public static boolean serializeCompany(Company c, String filename) {

        FileOutputStream fos = null;
        ObjectOutputStream out = null;

        try {
            fos = new FileOutputStream(filename);
            out = new ObjectOutputStream(fos);
            out.writeObject(c);
            out.close();
            return true;
        } catch (IOException ex) {
            ex.printStackTrace();
            return false;
        }
    }

Feature:Total and Feature:Cut are implemented as static mathods iterating over departments and employees:

    public static Double total(Company that) {
        double total = 0;
        for (Department d : that.getDepts())
            total += total(d);
        return total;
    }

    public static void cut(Company that) {
        for (Department d : that.getDepts())
            cut(d);
    }

Test cases are implemented for all Namespace:Features.

Relationships

For basic OO without inheritance see Contribution:javaComposition.

For basic OO with inheritance see Contribution:javaInheritance.

For modular OO programming with static methods see Contribution:javaStatic.

For use of Java reflection see Contribution:javaReflection (data processing) and Contribution:javaSyb (SYB-style generic programming).

For design patterns see Contribution:javaTemplate (template design pattern), Contribution:javaVisitor (visitor design pattern) and Contribution:javaExorcism (excessive illustration of design patterns).

Architecture

The contribution follows a standardized structure:

inputs contains input files for tests
src/main/java contains the following packages:
- org.softlang.company.features for implementations of Functional requirements.
- org.softlang.company.model for implementations of Feature:Company.
src/test/java contains the following packages:
- org.softlang.company.tests for Technology:JUnit test cases for Namespace:Features.