Classes?

peopleA Object[2] = [ ["dave" 45] ["freddy" 16] ["monica" 33]]

class Person(name String, age int){
  def incAge() => age++;;
}
peopleB = [Person("dave", 45) Person("freddy", 16) Person("monica", 33)]

for(person Object[] in peopleA){//approach 1
  person[1]++
}

for(person Person in peopleB){//approach 2
  person.incAge()
}

class MyClass

inst = new MyClass() //create a new instance object of class 'MyClass'

class MyClass

inst = MyClass() //create a new instance object of class 'MyClass'

from java.util import ArrayList
from java.util import ArrayList as ARList

ar1 = ArrayList<String>()
ar2 = ARList<String>()
ar3 = java.util.ArrayList<String>()

class MyClass1//class with no block

class MyClass2{}//class with an empty block

class MyClass3{//class with a method defined
  def amethod() => 12
}

class MyClass{
  count int = 0
  name = "Fred"
}

class Myclass{
  val name = "dave"//this field cannot be reassigned
  val age int//this field must be assigned a value in a constructor chain - otherwise it's a compilation error
  this(age int){
    this.age = age
  }
}

open class SuperClass{
  aField = "super"
  anotherField = "super"
}

class Child < SuperClass{
  aField = "child"
  override anotherField = "child"
}

child = new Child()
asSuper = child as SuperClass
[child.aField child.anotherField ; asSuper.aField asSuper.anotherField]

//== [child child ; super child]

open class SuperClass{
  aField = "super"
  anotherField = "super"
}

class Child(aField = "child", override anotherField = "child") < SuperClass

child = new Child()
asSuper = child as SuperClass
[child.aField child.anotherField ; asSuper.aField asSuper.anotherField]

//== [child child ; super child]

class Person(name String, age int){
  def nameLength(){
    this.name.length()
  }
	
  def nameLengthandAge() (int, int) {
    this.nameLength(), this.age
  }
}

class Person(name String, age int){
  def nameLength(){
    name.length()
  }
	
  def nameLengthandAge() (int, int) {
    nameLength(), age
  }
}

class Person(age int){
  def setAge(newAge int) void {
    this.age = newAge;
  }
	
  def getAge() int{
    return this.age
  }
}

//client code calling these methods:
person = new Person(20)
age = person.getAge()
person.setAge(23)

nowYear = java.time.Year.now().getValue()

class Person(yearOfBirth int){
  def setAge(newAge int) void {
    this.yearOfBirth = nowYear - newAge;
  }
	
  def getAge() int{
    nowYear - this.yearOfBirth
  }
}

//our client code calling these methods does not need to change...
age = person.getAge()
person.setAge(23)

age = person.age
person.age = 23

//is internally mapped to and is is equivalent to...
age = person.getAge()
person.setAge(23)

class Person1(-name String){
  ~age int
}

class Person2(name String){
  age int
	
  def getName() String {
    return this.name
  } 
	
  def getAge() int {
    return this.age
  }
	
  def setAge(age int)void {
    this.age = age
  }
}

class Person{
  name String
  age int
  this(name String, age int){
    this.name = name
    this.age = age
  }
}

class Person{
  name String
  age int
  this(name String, age int){
    this.name = name
    this.age = age
  }
	
  this(age int){
    this("fred", age)//call another constructor
  }
}

obj1 = new Person("dave", 23)
obj2 = new Person(56)

class Person(forename String, surname String, age int)

class Person2{
  forename String
  surname String
  age int
	
  this(forename String, surname String, age int){
    this.forename = forename
    this.surname  = surname 
    this.age = age
  }
}

open class Animal{
  def livingState() => "is alive"
}

class Dog < Animal

class Cat extends Animal

animals = [new Dog(), new Cat()]

res = animals^livingState()

//res == [is alive, is alive]

open class Animal{
  def livingState() => "is alive"
}

open class LeggedAnimal(legs int) < Animal

class Dog < LeggedAnimal{
  this(){
    super(4)
  }
}

class Bird < LeggedAnimal{
  this(){
    super(2)
  }
}

open class Animal{
  def livingState() => "is alive"
}

class Dog < Animal{
  this(){
    super()//this is ok, but unecsary
  }
}

class Cat extends Animal{
  int lives
  this(lives int){
    //super() is not called this is fine
    this.lives = lives
  }
}

class MyClass1{
  this(){
    super()
  }
}

class MyClass2

open class SuperClass{
  def aMethod(a int) => a+1
}

class ChildClass < SuperClass{
  def anotherMethod(a int) => super.aMethod(a)
  override aMethod(a int) => super.aMethod(a)+1//using 'super' here lets us call the superclass version of 'aMethod' and not this method
}

open class SuperClass{
  def aMethod(a int) => a+1
}

class ChildClass < SuperClass{
  def anotherMethod(a int) => aMethod(a)
  override aMethod(a int) => super.aMethod(a)+1 //we cannot omit super here as this would result in an infinite stack call loop to 'aMethod'
}

If no modifier is specified then the defaults are:

• Fields - protected

• Methods - public

The modifiers can be used as follows:

class MyClass{
  private field1 int = 9
  package field2 int = 9
  protected field3 int = 9
  public field4 int = 9
  field5 int = 9//defaults to protected
	
  private def aMethod1() => 12
  package def aMethod2() => 12
  protected def aMethod3() => 12
  public def aMethod4() => 12
  def aMethod5() => 12//defaults to public
}

Overriding methods?

If we wish to override a method defined in a superclass we must use the override keyword. The keyword must be used so as to prevent us from accidentally overriding a method defined in a superclass. For example:

open class A{
  def aMethod1() => 0
  def aMethod2() => 0
}

class B < A{
  override def aMethod1() => 1000//we can choose to include the 'def' keyword or omit it
  override aMethod2() => 1000
}

If one wishes to prevent subclasses from overriding a method then postfixing its declared name with a dot . will prevent this from being possible. For example:

open class A{
  def aMethod.() => 0 //this method is now final and cannot be overridden
}

class B < A{
  override aMethod() => 1000//this will throw a compilation error
}

An overriding method may not narrow the accessibility of a method being overridden. So the following is not valid:

open class Parent{
  public def aMethod() => 12
}

class Child < Parent{
  private def aMethod() => 14//this is not permitted since the accessibility modifier is being narrowed.
}

As above we cannot override a public method to be private, but it is ok to override a private method to be public in a subclass.

Abstract classes?

Abstract classes allow us to define 'intermediate' or 'prototype' classes which are designed to be extended by 'concrete'/non-abstract classes. They are partially implemented classes and can have methods and state. Abstract classes cannot be directly instantiated to make instance objects, only their (non abstract) subclasses can. Abstract classes can extend any class including abstract classes.

Since abstract classes cannot be instantiated, they cannot have constructors.

A class can be made abstract via one of two methods:

1. Using the abstract keyword:

     abstract class LeggedAnimal(legs int)
   

   When a class is declared abstract it's not necessary to declared it being an open class, as this is implicit (the purpose of abstract classes is to be extended).

2. By having at least one abstract method defined. Abstract methods are defined in the same way as normal methods, but they do not have a body:

     abstract class LeggedAnimal(legs int){
       def howFeels() String //this is an abstract method
     }
   

   If an abstract class declares any abstract methods (which is the normal case), then these must be implemented in any concrete extending classes:

     open class Animal{//implicitly an abstract class since we have an abstract method declared below
       def reportFoodEaten() String //this method is abstract and must be implemented by all concrete sub classes of Animal
     }
   	
     class Panda < Animal{
       def reportFoodEaten() => "bamboo"
     }
   

Note above that we do not need to use the override keyword when we define reportFoodEaten. This is because we are not overriding an existing implementation of reportFoodEaten.

Abstract methods may override concrete method implementations from super classes. The following is valid:

open class A{
  def aMethod() => 12
}

class AbstractClass < A{
  def aMethod() int
}

In the case above subclasses of AbstractClass must implement the aMethod. Note, direct subclasses of class A do not need to implement this method since it's already been implemented.

An abstract class that extends an abstract class is not obliged to provide a concrete implementation of its abstract superclass's abstract methods. So the following is perfectly valid:

abstract class Animal{
  def reportFoodEaten() String
}

abstract class FurryAnimal < Animal//not obliged to implement reportFoodEaten

Class Declaration Arguments with superclasses?

We can use our one line approach to class declaration with class declaration arguments when we need to call a super constructor as follows:

open class Animal(favFood String, color String, age int)

class Panda(page int) < Animal('bamboo', 'blackAndWhite', page)

Above as we are implicitly creating the constructor for Panda, we are instructing Concurnas to add a super constructor invocation to the Animal superclass constructor with the body ('bamboo', 'blackAndWhite', page). Any expression is permissible in the super constructor argument list. In cases where a field name from the main class declaration arguments is referenced as a superclass super constructor argument, then this argument is not translated into a field for the class being declared. So for Panda above, field page is not created - it would if page were not referenced in the superclass super constructor argument list.

Automatically generated equals and hashcode methods?

Concurnas implements equality by value by default for instance objects. It achieves this by auto generating a method equals with the following signature: equals(Object) boolean for every class declared. This makes the following code possible:

class Person(String name)

p1 = Person("dave")
p2 = Person("dave")

assert p1 == p2

Equality is tested via use of the == (and <>) operator. We see above that although p1 and p2 are separate instances objects, their value is the same, therefore they are considered equal.

Concurnas will also generate a hashCode method with signature hashCode () int which is unique per the value of the class. This is useful for data structures such as HashSet's and HashMaps. For example:

class Person(String name)

p1 = Person("dave")
p2 = Person("dave")

pset = new java.util.HashSet<Person>()
pset.add(p1)
pset.add(p2)//p2 will not be added as its value matches p1 which is already in the set

assert p1.hashCode() == p2.hashCode()//hashcode's match
assert pset.size() == 1

One is of course free to implement the equals and hashCode methods manually and override the automatically generated versions. For example here is and example of referential equality:

class MyClass{
  override hashCode() => System.identityHashCode(this)
  override equals(an Object) => this &== an
}

init block?

Concurnas provides an init block that can be useful in cases where one is using class definition arguments but needs to include extra code in the generated constructor. For example:

pCount = 0

class Person(String name){
  init{
    System out println "Created a Person with name {name}"
    pCount++
  }
}

The code within the init block is added to the end of any generated constructors, as such they have access to all the fields/methods of the class as par a normal method. More than one init block may be specified and they are executed in the linear order in which they were defined.

Nested Classes?

Nested classes are classes defined within classes. They have access to all the methods and fields of their parent nestors scopes in which they are defined. For example:

class Outerclass{
  def outerMethod()=> 11
	
  public class InnerClass{
    def innerMethod(){
      outerMethod() + 1
    }
  }
}

If no accessibility modifier is provided when declaring a nested class then it will default to private (this is because most of the time nested classes are best suited for intra class algorithms which do not require exposure outside the parent nestor class).

Nested classes require a reference to their parent nestor in order to create instances of them, we may optionally use the new keyword:

oc = new Outerclass()
inst1 = oc.new InnerClass()
inst2 = oc.InnerClass()

In cases of multiple levels of nesting, the qualified this syntax is appropriate for dealing with situations in which we need an reference to a specific parent nestor. The qualified this syntax is as follows, this[X] where X is the class name for which we wish to obtain a reference to the corresponding parent nestor of, the return type will be of type X. For example:

class Outerclass{
  private variable = 'outer variable'
  def aMethod(){
    "outer method"
  }
	
  public class Innerclass{
		
    public class Innerclass2{ }
    private variable = 'inner variable'
		
    def aMethod(){
      "inner method"
    }
		
    def work(){
      outer = this[Outerclass] //here we use the qualified this syntax!
      inner = this[Innerclass] //and here!
      ""+[outer.aMethod(), outer.variable, inner.aMethod(), inner.variable]
    }
  }
}

outer = Outerclass()
inst = outer.Innerclass()
res = inst.work()

//res == [outer method, outer variable, inner method, inner variable]

All the other normal operations on classes can be performed on inner classes provided that an instance of the outer class is specified:

constructorRefernce  = outer.new Innerclass&//constructor refence
classRefernce  = outer.Innerclass&//class refence
actorInstance = outer.actor Innerclass()//actor of Innerclass

Local Classes?

Local classes are classes defined within functions or methods, they are declarable just like ordinary classes. They are limited in terms of instantiation by the scope in which they are declared.

open class SuperClass

def makeLocalClass() SuperClass {
  class MyClass < SuperClass
  return new MyClass()
}

We cannot make use of MyClass directly (i.e. instantiate an instance of it via the new operator) outside the scope of the method in which it is defined, hence the type returned in the above example has to be either a superclass or trait which it implements.

Anonymous Classes?

Anonymous classes provides a means by which classes can be both defined and instance objects derived from the in one relatively compact step. They are useful for implementing SAM types see here and when working with traits see here.

Anonymous classes are easy to define, here is an example:

class AbstractClass{
  def operation(a int) int//child classes must implement this method or be declared abstract
}

instance AbstractClass = new AbstractClass{ def operation(a int) => a*2 }

instance.operation(2)

//== 4

Anonymous classes may be defined without bodies

abstract class AbstractClass{
  def operation(a int) int => a
}

instance = new AbstractClass

instance.operation(2)

//== 2

Anonymous classes can be used any place where an expression is required:

class AbstractClass{
  def operation(a int) int
}

def doOperation(apTo int, an AbstractClass) => an.operation(apTo)

doOperation(2, new AbstractClass{ def operation(a int) int => a*2 })

//== 4

Anonymous classes may refer to variables and methods defined outside of the scope of the class:

class AbstractClass{
  def operation(a int) int
}

def doOperation(apTo int, an AbstractClass) => an.operation(apTo)

mul = 4
doOperation(2, new AbstractClass{def operation(a int) int => a*mul })

//== 8

Generics may be used in anonymous classes as normal:

class AbstractClass<X>{
  def operation(a X) X
}

def doOperation(apTo int, an AbstractClass<Integer>) => an.operation(apTo)

mul = 4
doOperation(2, new AbstractClass<Integer>{ def operation(a Integer) Integer => a*mul })

//== 8

Note that for an anonymous class definition both a class (inaccessible) and object of the anonymous class are created. As such the anonymous class may only have a zero arg constructor defined (if at all), it may not use augmented constructors.