Abstract type: Difference between revisions

=={{header|Groovy}}==

{{trans|Java}}

As in [[Java]], methods that are declared but not implemented are called "abstract" methods. An interface is a class-level typing construct that can only contain abstract method declarations (well, and constants, but pay no attention to those).

<lang groovy>public interface Interface {

int method1(double value);

int method2(String name);

int add(int a, int b);

}</lang>

An abstract class may implement some of its methods and leave others unimplemented. The unimplemented methods and the class itself must be declared "abstract".

<lang groovy>public abstract class Abstract1 {

abstract public int methodA(Date value);

abstract protected int methodB(String name);

int add(int a, int b) { a + b }

}</lang>

An abstract class may also be used to partially implement an interface. Here class "Abstract2" implements the "add" method from the inherited "Interface", but leaves the other two methods, "method1" and "method2", unimplemented. Abstract methods that an abstract class inherits from an interface or another abstract class do not have to be redeclared.

<lang groovy>public abstract class Abstract2 implements Interface {

int add(int a, int b) { a + b }

}</lang>

Interfaces and abstract classes cannot be instantiated directly. There must be a "concrete subclass" that contains a complete implementation in order to instantiate an object.

<lang groovy>public class Concrete1 implements Interface {

public int method1(double value) { value as int }

public int method2(String name) { (! name) ? 0 : name.toList().collect { it as char }.sum() }

public int add(int a, int b) { a + b }

}

public class Concrete2 extends Abstract1 {

public int methodA(Date value) { value.toCalendar()[Calendar.DAY_OF_YEAR] }

protected int methodB(String name) { (! name) ? 0 : name.toList().collect { it as char }.sum() }

}

public class Concrete3 extends Abstract2 {

public int method1(double value) { value as int }

public int method2(String name) { (! name) ? 0 : name.toList().collect { it as char }.sum() }

}</lang>

Notice that there are no extra descriptive keywords on the interface method declarations. Interface methods are assumed to be both abstract and public.

Obligatory test:

<lang groovy>def c1 = new Concrete1()

assert c1 instanceof Interface

println (new Concrete1().method2("Superman"))

def c2 = new Concrete2()

assert c2 instanceof Abstract1

println (new Concrete2().methodB("Spiderman"))

def c3 = new Concrete3()

assert c3 instanceof Interface

assert c3 instanceof Abstract2

println (new Concrete3().method2("Hellboy"))</lang>

Obligatory test output:

<pre>843

931

719</pre>

Like [[Java]], [[Groovy]] does not allow subclasses to inherit from multiple superclasses, even abstract superclasses, but it does let subclasses inherit from multiple interfaces.