Here below a little program in Groovy that implements 2 classes (in fact, they are 3 + an extra utility Stopwatch class from my previous post http://carlosqt.blogspot.com/2011/05/stopwatch-class-for-java.html). There is the main class, called Fiborial (Fibo(nnacci)+(Facto)rial) that implements the

*Fibonacci*and the

*Factorial*algorithms in two ways, one

*Recursive*(using recursion) and the other

*Imperative*(using loops and states). The second class is just an instance class that does the same thing, but its there just to show the difference between static and instance classes, and finally the third one (which will not appear in other languages) is the Program class which has the static execution method "main".

You can also find 3 more little examples at the bottom. One prints out the Factorial's Series and Fibonacci's Series, the second one just shows a class that mixes both: static and instance members, and finally the third one that uses different return types (including java.math.BigInteger) for the Factorial method to compare the timing and result.

As with the previous posts, you can copy and paste the code below in your favorite IDE/Editor and start playing and learning with it. This little "working" program will teach you some more basics of the Programming Language.

There are some "comments" on the code added just to tell you what are or how are some features called. In case you want to review the theory, you can read my previous post, where I give a definition of each of the concepts mentioned on the code. You can find it here: http://carlosqt.blogspot.com/2011/01/new-series-factorial-and-fibonacci.html

**The Fiborial Program**

// Factorial and Fibonacci in Groovy package com.series import java.math.BigInteger // Instance Class class StaticFiborial { // Static Field private static className // Class/Static Constructor/Initializer static { className = "Static Constructor" println className } // Class/Static Method - Factorial Recursive static factorialR(int n) { if (n == 1) return BigInteger.ONE else return n * factorialR(n - 1) } // Class/Static Method - Factorial Imperative static factorialI(int n) { def res = BigInteger.ONE for (int i = n; i >= 1; i--) { res *= i } return res } // Class/Static Method - Fibonacci Recursive static fibonacciR(int n) { if (n < 2) return 1 else return fibonacciR(n - 1) + fibonacciR(n - 2) } // Class/Static Method - Fibonacci Imperative static fibonacciI(int n) { def pre, cur, tmp = 0 pre = cur = 1 for (i in 2..n) { tmp = cur + pre pre = cur cur = tmp } return cur } // Class/Static Method - Benchmarking Algorithms static benchmarkAlgorithm(algorithm, values) { def timer = new Stopwatch() def i, testValue def facTimeResult = BigInteger.ZERO def fibTimeResult = 0 i = testValue = 0 // "Switch" Flow Control Statement switch (algorithm) { case 1: println "\nFactorial Imperative:" // "For" Loop Statement for (i = 0; i < values.size(); i++) { testValue = ((Integer)values.get(i)).intValue() // Taking Time timer.start() facTimeResult = factorialI(testValue) timer.stop() // Getting Time println " ($testValue) = ${timer.getElapsed()}" } break case 2: println "\nFactorial Recursive:" // "While" Loop Statement while (i < values.size()) { testValue = ((Integer)values.get(i)).intValue() // Taking Time timer.start() facTimeResult = factorialR(testValue) timer.stop() // Getting Time println " ($testValue) = ${timer.getElapsed()}" i++ } break case 3: println "\nFibonacci Imperative:" // "For" Loop Statement for (j in 0..values.size()-1) { testValue = ((Integer)values.get(j)).intValue() // Taking Time timer.start() fibTimeResult = fibonacciI(testValue) timer.stop() // Getting Time println " ($testValue) = ${timer.getElapsed()}" } break case 4: println "\nFibonacci Recursive:" // "For Each" Loop Statement for (item in values) { testValue = item // Taking Time timer.start() fibTimeResult = fibonacciR(testValue) timer.stop() // Getting Time println " ($testValue) = ${timer.getElapsed()}" } break default: println "DONG!" break } } } // Instance Class class InstanceFiborial { // Instance Field private def className // Instance Constructor def InstanceFiborial() { this.className = "Instance Constructor" println this.className } // Instance Method - Factorial Recursive def factorialR(n) { // Calling Static Method return StaticFiborial.factorialR(n) } // Instance Method - Factorial Imperative def factorialI(n) { // Calling Static Method return StaticFiborial.factorialI(n) } // Instance Method - Fibonacci Recursive def fibonacciR(n) { // Calling Static Method return StaticFiborial.fibonacciR(n) } // Instance Method - Factorial Imperative def fibonacciI(n) { // Calling Static Method return StaticFiborial.fibonacciI(n) } } println "\nStatic Class" // Calling Static Class and Methods // No instantiation needed. Calling method directly from the class println "FacImp(5) = ${StaticFiborial.factorialI(5)}" println "FacRec(5) = ${StaticFiborial.factorialR(5)}" println "FibImp(11)= ${StaticFiborial.fibonacciI(11)}" println "FibRec(11)= ${StaticFiborial.fibonacciR(11)}" println "\nInstance Class" // Calling Instance Class and Methods // Need to instantiate before using. Calling method from instantiated object def ff = new InstanceFiborial() println "FacImp(5) = ${ff.factorialI(5)}" println "FacRec(5) = ${ff.factorialR(5)}" println "FibImp(11)= ${ff.fibonacciI(11)}" println "FibRec(11)= ${ff.fibonacciR(11)}" // Create a list of integer values to test // From 5 to 50 by 5 def values = [] 5.step(55, 5) { values.add(it) } // Benchmarking Fibonacci // 1 = Factorial Imperative StaticFiborial.benchmarkAlgorithm(1, values) // 2 = Factorial Recursive StaticFiborial.benchmarkAlgorithm(2, values) // Benchmarking Factorial // 3 = Fibonacci Imperative StaticFiborial.benchmarkAlgorithm(3, values) // 4 = Fibonacci Recursive StaticFiborial.benchmarkAlgorithm(4, values) // Stop and exit println "Press any key to exit..." def sin = new Scanner(System.in) def line = sin.nextLine() sin.close()

And the Output is:

**Printing the Factorial and Fibonacci Series**

package com.series import java.math.BigInteger import java.lang.StringBuffer class Fiborial { // Using a StringBuffer as a list of string elements static getFactorialSeries(n) { // Create the String that will hold the list def series = new StringBuffer() // We begin by concatenating the number you want to calculate // in the following format: "!# =" series.append("!") series.append(n) series.append(" = ") // We iterate backwards through the elements of the series for (i in n..0) { // and append it to the list series.append(i) if (i > 1) series.append(" * ") else series.append(" = ") } // Get the result from the Factorial Method // and append it to the end of the list series.append(factorial(n)) // return the list as a string return series } // Using a StringBuffer as a list of string elements static getFibonnaciSeries(n) { // Create the String that will hold the list def series = new StringBuffer(); // We begin by concatenating the first 3 values which // are always constant series.append("0, 1, 1") // Then we calculate the Fibonacci of each element // and add append it to the list for (i in 2..n) { if (i < n) series.append(", ") else series.append(" = ") series.append(fibonacci(i)) } // return the list as a string return series } static factorial(n) { if (n == 1) return BigInteger.ONE else return n * factorial(n - 1) } static fibonacci(n) { if (n < 2) return 1 else return fibonacci(n - 1) + fibonacci(n - 2) } } // Printing Factorial Series println "" println Fiborial.getFactorialSeries(5) println Fiborial.getFactorialSeries(7) println Fiborial.getFactorialSeries(9) println Fiborial.getFactorialSeries(11) println Fiborial.getFactorialSeries(40) // Printing Fibonacci Series println "" println Fiborial.getFibonnaciSeries(5) println Fiborial.getFibonnaciSeries(7) println Fiborial.getFibonnaciSeries(9) println Fiborial.getFibonnaciSeries(11) println Fiborial.getFibonnaciSeries(40)

And the Output is:

**Mixing Instance and Static Members in the same Class**

Instance classes can contain both, instance and static members such as: fields, getters/setters, constructors/initializers, methods, etc.

package com.series // Instance Class class Fiborial { // Instance Field private def instanceCount // Static Field private static staticCount // Instance Read-Only Getter // Within instance members, you can always use // the "this" reference pointer to access your (instance) members. def getInstanceCount() { return this.instanceCount } // Static Read-Only Getter // As with Static Methods, you cannot reference your class members // with the "this" reference pointer since static members are not // instantiated. static getStaticCount() { return staticCount } // Instance Constructor def Fiborial() { this.instanceCount = 0 println "\nInstance Constructor ${this.instanceCount}" } // Static Constructor static { staticCount = 0; println "\nStatic Constructor $staticCount" } // Instance Method def factorial(n) { this.instanceCount += 1 println "\nFactorial($n)" } // Static Method static fibonacci(n) { staticCount += 1 println "\nFibonacci($n)" } } // Calling Static Constructor and Methods // No need to instantiate Fiborial.fibonacci(5) // Calling Instance Constructor and Methods // Instance required def fib = new Fiborial() fib.factorial(5) Fiborial.fibonacci(15) fib.factorial(5) // Calling Instance Constructor and Methods // for a second object def fib2 = new Fiborial() fib2.factorial(5) println "" // Calling Static Property println "Static Count = ${Fiborial.getStaticCount()}}" // Calling Instance Property of object 1 and 2 println "Instance 1 Count = ${fib.getInstanceCount()}" println "Instance 2 Count = ${fib2.getInstanceCount()}"

And the Output is:

**Factorial using java.lang.Long, java.lang.Double, java.math.BigInteger**

package com.series import java.math.BigInteger // Long Factorial long factorialInt64(n) { if (n == 1) return 1 else return n * factorialInt64(n - 1) } // Double Factorial double factorialDouble(n) { if (n == 1) return 1 else return n * factorialDouble(n - 1) } // BigInteger Factorial BigInteger factorialBigInteger(n) { if (n == 1) return BigInteger.ONE else return n * factorialBigInteger(n - 1) } def timer = new Stopwatch() long facIntResult = 0 double facDblResult = 0 def facBigResult = BigInteger.ZERO println "\nFactorial using Int64" // Benchmark Factorial using Int64 for (i in (5..50).step(5)) { timer.start() facIntResult = factorialInt64(i) timer.stop() println " ($i) = ${timer.getElapsed()} : ${facIntResult}" } println "\nFactorial using Double" // Benchmark Factorial using Double for (i in (5..50).step(5)) { timer.start() facDblResult = factorialDouble(i) timer.stop() println " ($i) = ${timer.getElapsed()} : ${facDblResult}" } println "\nFactorial using BigInteger" // Benchmark Factorial using BigInteger for (i in (5..50).step(5)) { timer.start() facBigResult = factorialBigInteger(i) timer.stop() println " ($i) = ${timer.getElapsed()} : ${facBigResult}" }

And the Output is: