Because there is no function overloading, there can be only one constructor with the class name (the so-called main constructor). So if we want more, we must use named constructors, which take the form ClassName.constructorName. If the main constructor does not have any parameters, it is called a default constructor. If the default constructor does not have a body of statements such as BankAccount();, it can be omitted. If you don't declare a constructor, a default constructor is provided for you. Suppose we want to to create a new bank account for a person by copying data from another of his/her bank accounts, for example, the owner's name. We could do this with the named constructor BankAccount.sameOwner (refer to banking_v3.dart):

BankAccount.sameOwner(BankAccount acc)  {
  owner = acc.owner;
}

We could also do this with the initializer version:

BankAccount.sameOwner(BankAccount acc): owner = acc.owner;

When we make an object via this constructor and print it out, we get:

Bank account from John Gates with number null and balance null

A constructor can also redirect to the main constructor by using the this keyword like so:

BankAccount.sameOwner2(BankAccount acc): this(acc.owner, "000-0000000-00", 0.0);

We initialize the number and balance to dummy values, because this() has to provide three arguments for the three parameters of the main constructor.

Sometimes we don't want a constructor to always make a new object of the class; perhaps we want to return an object from a cache or create an object from a subtype instead. The factory constructor provides this flexibility and is extensively used in the Dart SDK. In factory_singleton.dart, we use this ability to implement the singleton pattern, in which there can be only one instance of the class:

class SearchEngine {
  static SearchEngine theOne;                             (1)
  String name;

  factory SearchEngine(name) {                            (2)
    if (theOne == null) {
      theOne = new SearchEngine._internal(name);
    }
    return theOne;
  }
// private, named constructor
  SearchEngine._internal(this.name);                      (3)
// static method:
   static nameSearchEngine () => theOne.name;             (4)
}

main() {
  //substitute your favorite search-engine for se1:
  var se1 = new SearchEngine('Google');                   (5)
  var se2 = new SearchEngine('Bing');                     (6)
  print(se1.name);                        // 'Google'
  print(se2.name);                        // 'Google'
  print(SearchEngine.theOne.name);        // 'Google'     (7)
  print(SearchEngine.nameSearchEngine()); // 'Google'     (8)
  assert(identical(se1, se2));                            (9)
}

In line (1), the static variable theOne (here of type SearchEngine itself, but it could also be of a simple type, such as num or String) is declared: such a variable is the same for all instances of the class. It is invoked on the class name itself, as in line (7); that's why it is also called a class variable. Likewise, you can have static methods (or class methods) such as nameSearchEngine (line (4)) called in the same way (line (8)).

In lines (5) and (6), two SearchEngine objects se1 and se2 are created through the factory constructor in line (2). This checks whether our static variable theOne already refers to an object or not. If not, a SearchEngine object is created through the named constructor SearchEngine._internal from line (3); if it had already been created, nothing is done and the object theOne is returned in both cases. The two SearchEngine objects se1 and se2 are in fact the same object, as is proven in line (9). Note that the named constructor SearchEngine._internal is private; a factory invoking a private constructor is also a common pattern.

Two squares created with the same length are different objects in memory. If you want to make a class where each object cannot change, provide it with const constructors and make sure that every property is const or final, for example, class ImmutableSquare in square_v1.dart:

class ImmutableSquare {
  final num length;
  static final ImmutableSquare ONE = const ImmutableSquare(1);
  const ImmutableSquare(this.length);
}

Objects are created with const instead of new, using the const constructor in the last line of the class to give length its value:

var s4 = const ImmutableSquare(4);
var s5 = const ImmutableSquare(4);
assert(identical(s4,s5));

Looking for parent classes is an abstraction process, and this can go so far that the parent class we have decided to work with can no longer be fully implemented; that is, it contains methods that we cannot code at this point, so-called abstract methods. Extending the previous example to square_v3.dart, we could easily abstract out a parent class, Shape. This could contain methods for calculating the area and the perimeter, but they would be empty because we can't calculate them without knowing the exact shape. Other classes such as Rectangle and Square could inherit from Shape and provide the implementation for these methods.

main() {
  var s1 = new Square(2);
  print('${s1.area()}');       // 4
  print('${s1.perimeter()}');  // 8
  var r1 = new Rectangle(2, 3);
  print('${r1.area()}');       // 6
  print('${r1.perimeter()}');  // 10
  assert(s1 is Shape);
  assert(r1 is Shape);
  // warning + exception in checked mode: Cannot instantiate// abstract class Shape
  // var f = new Shape();
}

abstract class Shape {
  num perimeter();
  num area();
}

class Rectangle extends Shape {
  num width, height;
  Rectangle(this.width, this.height);
  num perimeter() => 2 * (height + width);
  num area() => height * width;
}

class Square extends Shape {
  num length;
  Square(this.length);
  num perimeter() => 4 * length;
  num area() => length * length;
}

Also, making instances of Shape isn't very useful, so it is rightfully an abstract class. An abstract class can also have properties and implemented methods, but you cannot make objects from an abstract class unless it contains a factory constructor that creates an object from another class. This can be useful as a default object creator for that abstract class. A simple example can be seen in factory_abstract.dart:

void main() {
  Animal an1 = new Animal();                (1)
  print('${an1.makeNoise()}'); // Miauw
}

abstract class Animal {
  String makeNoise();
  factory Animal() => new Cat();            (2)
}

class Cat implements Animal {
  String makeNoise() => "Miauw";
}

Animal is an abstract class; because we most need cats in our app, we decide to give it a factory constructor to make a cat (line (2)). Now we can construct an object from the Animal class (line (1)) and it will behave like a cat. Note that we must use the keyword implements here to make the relationship between the class and the abstract class (this is also an interface, as we discuss in the next section). Many of the core types in the Dart SDK are abstract classes (or interfaces), such as num, int, String, List, and Map. They often have factory constructors that redirect to a specific implementation class for making an object.

In Java and .NET, an abstract class without any implementation in its methods is called an interface—a description of a collection of fields and methods—and classes can implement interfaces. In Dart, this concept is greatly enhanced and there is no need for an explicit interface concept. Here, every class implicitly defines its own interface (also called API) containing all the public instance members of the class (and of any interfaces it implements). The abstract classes of the previous section are also interfaces in Dart. Interface is not a keyword in the Dart syntax, but both words are used as synonyms. Class B can implement any other class C by providing code for C's public methods. In fact, the previous example, square_v3.dart, continues to work when we change the keyword extends to implements:

class Rectangle implements Shape {
  num width, height;
  Rectangle(this.width, this.height);
  num perimeter() => 2 * (height + width);
  num area() => height * width;
}

This has the additional benefit that class Rectangle could now inherit from another class if necessary. Every class that implements an interface is also of that type as is proven by the following line of code (when r1 is an object of class Rectangle):

assert(r1 is Shape);

extends is much less used than implements, but it also clearly has a different meaning. The inheritance chain is searched for a called method, not the implemented interfaces.

Implementing an interface is not restricted to one interface. A class can implement many different interfaces, for example, class Cat implements Mammal, Pet { ... }. In this new vision, where every class defines its own interface, abstract classes (that could be called explicit interfaces) are of much less importance (in fact, the keyword abstract is optional; leaving it off only gives a warning of unimplemented members). This interface concept is more flexible than in most OO languages and doesn't force us to define our interfaces right from the start of a project. The dynamic type, which we discussed briefly in the beginning of this chapter, is in fact the base interface that every other class (also Object) implements. However, it is an interface without properties or methods and cannot be extended.

In summary, interfaces are used to describe functionality that is shared (implemented) by a number of classes. The implementing classes must fulfill the interface requirements. Coding against interfaces is an excellent way to provide more coherence and structure in your class hierarchy.

How can we check the type of the items in a List or Map? A List created either as a literal or with the default constructor can contain items of any type, as the following code shows (refer to generics.dart):

var date = new DateTime.now();
// untyped List (or a List of type dynamic):
var lst1 = [7, "lucky number", 56.2, date];
print('$lst1'); // [7, lucky number, 56.2,// 2013-02-22 10:08:20.074]
var lst2 = new List();
lst2.add(7);
lst2.add("lucky number");
lst2.add(56.2);
lst2.add(date);
print('$lst2'); // [7, lucky number, 56.2,// 2013-02-22 10:08:20.074]

While this makes for very versatile Lists most of the time, you know that the items will be of a certain type, such as int or String or BankAccount or even List, themselves. In this case, you can indicate type E between < and > in this way: <E>. An example is shown in the following code:

var langs = <String>["Python","Ruby", "Dart"];
var langs2 = new List<String>();                        (1)
langs2.add("Python");
langs2.add("Ruby");
langs2.add("Dart");
var lstOfString = new List<List<String>>();             (2)

(Don't forget the () at the end of lines (1) and (2) because this calls the constructor!

With this, Dart can control the items for us; langs2.add(42); gives us a warning and a TypeErrorImplementation exception when run in checked mode:

type 'int' is not a subtype of type 'String' of 'value'

Here, value means 42. However, when we run in production mode, this code runs just fine. Again, indicating the type helps us to prevent possible errors and at the same time documents your code.

Why is the special notation <> also used as List<E> in the API documents for List? This is because all of the properties and methods of List work for any type E. That's why the List<E> type is called generic (or parameterized). The formal type parameter E stands for any possible type.

The same goes for Maps; a Map is in fact a generic type Map<K,V>, where K and V are formal type parameters for the types of the keys and values respectively, giving us the same benefits as the following code demonstrates:

var map = new Map<int, String>();
map[1] = 'Dart';
map[2] = 'JavaScript';
map[3] = 'Java';
map[4] = 'C#';
print('$map'); // {1: Dart, 2: JavaScript, 3: Java, 4: C#}
map['five'] = 'Perl'; // String is not assignable to int  (3)

Again, line (3) gives us a TypeError exception in checked mode, not in production mode. We can test the generic types like this:

print('${langs2 is List}'); // true
print('${langs2 is List<String>}'); // true              (4)
print('${langs2 is List<double>}'); // false             (5)

We see that, in line (5), the type of the List is checked; this check works even in production mode! (Uncheck the Run in Checked Mode checkbox in Run | Manage Launches and click on Apply to see this in action.) This is because generic types in Dart (unlike in Java) are reified; their type info is preserved at runtime, so you can test the type of a collection even in production mode. Note, however, that this is the type of the collection only. When adding the statement langs2.add(42); (which executes fine in production mode), the check in line (4) still gives us the value true. If you want to check the types of all the elements in a collection in production mode, you have to do this for each element individually, as shown in the following code:

for (var s in langs2) {
  if (s is String) print('$s is a String');
  else             print ('$s is not a String!');
}
// output:
//  Python is a String
//  Ruby is a String
//  Dart is a String
//  42 is not a String!

Checking the types of generic Lists gives mostly expected results:

print(new List
<String>() is List<Object>);   // true  (1)
print(new List<Object>() is List<String>);   // false (2)
print(new List<String>() is List<int>);      // false (3)
print(new List<String>() is List);           // true  (4)
print(new List() is List<String>);           // true  (5)

Line (1) is true because Strings (as everything) are Objects. (2) is false because not every Object is a String. (3) is false because Strings are not of type int (4) is true because Strings are also of the general type dynamic. Line (5) can be a surprise: dynamic is String. This is because generic types without type parameters are considered substitutable (subtypes of) for any other version of that generic type.

Apart from List and Map, there are other important collection classes, such as Queue and Set, among others specified in the dart:collection library; most of them are generic. We can't review them all here but the most important ones have the following relations (an arrow is UML notation for "is a subclass of" (extends in Dart):

The collection hierarchy

List and Queue are classes that inherit from Iterable, and Set inherits from IterableBase; all these are abstract classes. The Map class is also abstract and forms on its own the root of a whole series of classes that implement containers of values associated with keys, sometimes also called dictionaries. Put simply, the Iterable interface allows you to enumerate (or iterate, that is, read but not change) all items of a collection one-by-one using what is called an Iterator. As an example, you can make a collection of the numbers 0 to 9 by making an Iterator with:

var digits = new Iterable.generate(10, (i) => i);

The iteration can be performed with the for ( item in collection ) statement:

for (var no in digits) {
  print(no);
} // prints 0 1 2 3 4 5 6 7 8 9 on successive lines

This prints all the numbers from 0 to 9 successively. Members such as isEmpty, length, and contains(), which we saw in action with List (refer to lists.dart) are already defined at this level, but there is a lot more. Iterable also defines very useful methods for filtering, searching, transforming, reducing, chaining, and so on. This shows that Dart has a lot of the characteristics of a functional language: we see lots of functions taking functions as parameters or returning functions. Let us look at some examples applied to a list by applying toList() to our Iterable object digits:

var digList = digits.toList();

An even shorter and more functional version than for...in is forEach, which takes as parameter a function that is applied to every item i of the collection in turn. In the following example, an anonymous function that simply prints the item is shown:

digList.forEach((i) => print('$i'));

Use forEach whenever you don't need the index of the item in the loop. This also works for Maps, for example, to print out all the keys in the following map:

Map webLinks =   {  'Dart': 'http://www.dartlang.org/','HTML5': 'http://www.html5rocks.com/' };
webLinks.forEach((k,v) => print('$k')); // prints: Dart   HTML5

If we want the first or last element of a List, use the corresponding functions.

If you want to skip the first n items use skip(n), or skip by testing on a condition with skipWhile(condition):

var skipL1 = digList.skip(4).toList();
print('$skipL1'); // [4, 5, 6, 7, 8, 9]
var skipL2 = digList.skipWhile((i) => i <= 6).toList();
print('$skipL2'); // [7, 8, 9]

The functions take and takeWhile do the opposite; they take the given number of items or the items that fulfill the condition:

var takeL1 = digList.take(4).toList();
print('$takeL1'); // [0, 1, 2, 3]
var takeL2 = digList.takeWhile((i) => i <= 6).toList();
print('$takeL2'); // [0, 1, 2, 3, 4, 5, 6]

If you want to test whether any of the items fulfill a condition, use any; to test whether all of the items do so, use every:

var test = digList.any((i) => i > 10);
print('$test');  // false
var test2 = digList.every((i) => i < 10);
print('$test2');  // true

Suppose you have a List and you want to filter out only these items that fulfill a certain condition (this is a function that returns a Boolean, called a predicate), in our case the even digits; here is how it's done:

var even = (i) => i.isEven;                           (1)
var evens = digList.where(even).toList();             (2)
print('$evens');  // [0, 2, 4, 6, 8]                  (3)
evens = digList.where((i) => i.isEven).toList();      (4)
print('$evens');  // [0, 2, 4, 6, 8]

We use the isEven property of int to construct an anonymous function in line (1). It takes the parameter i to test its evenness, and we assign the anonymous function to a function variable called even. We pass this function as a parameter to where, and we make a list of the result in line (2). The output in line (3) is what we expect.

It is important to note that where takes a function that for each item tests a certain condition and thus returns true or false. In line (4), we write it more tersely in one line, appropriate and elegant for short predicate functions. Why do we need the call toList() in this and the previous functions? Because where (and the other Iterable methods) return a so-called lazy Iterable. Calling where alone does nothing; it is toList() that actually performs the iteration and stuffs the results in a List (try it out: if you leave out toList(), in line (4), then the right-hand side is an instance of WhereIterable).

If you want to apply a function to every item and form a new List with the results, you can use the map function; in the following example, we triple each number:

var triples = digList.map((i) => 3 * i).toList();
print('$triples'); // [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

Another useful utility is to apply a given operation with each item in succession, combined with a previously calculated value. Concretely, say we want to sum all elements of our List. We can of course do this in a for loop, accumulating the sum in a temporary variable:

var sum = 0;
for (var i in digList) {
  sum += i;
}
print('$sum'); // 45

Dart provides a more succinct and functional way to do this kind of manipulation with the reduce function (eliminating the need for a temporary variable):

var sum2 = digList.reduce((prev, i) => prev + i);
print('$sum2'); // 45

We can apply reduce to obtain the minimum and maximum of a numeric List as follows:

var min = digList.reduce(Math.min);
print('minimum: $min'); // 0
var max = digList.reduce(Math.max);
print('maximum: $max'); // 9

For this to work, we need to import the math library:

import 'dart:math' as Math;

We could do this because min and max are defined for numbers, but what about other types? For this, we need to be able to compare two List items: i1 and i2. If i2 is greater than i1, we know the min and max of the two and we can sort them. Dart has this intrinsically defined for the basic types int, num, String, Duration, and Date. So in our example, with types int we can simply write:

var lst = [17, 3, -7, 42, 1000, 90];
lst.sort();
print('$lst'); // [-7, 3, 17, 42, 90, 1000]

If you look up the definition of sort(), you will see that it takes as optional argument a function of type int, compare(E a, E b), belonging to the Comparable interface. Generally, this is implemented as follows:

In the following code, we use the preceding logic to obtain the minimum and maximum of a List of Strings:

var lstS = ['heg', 'wyf', 'abc'];
var minS = lstS.reduce((s1,s2) => s1.compareTo(s2) < 0 ? s1 : s2);
print('Minimum String: $minS'); // abc

In a general case, we need to implement compareTo ourselves for the element type of the list, and it turns out that the preceding code lines can then be used to obtain the minimum and maximum of a List of a general type! To illustrate this, we will construct a List of persons; these are objects of a very simple Person class:

class Person {
  String name;
  Person(this.name);
}

We make a List of four Person objects and try to sort it as shown in the following code:

var p1 = new Person('Peeters Kris');
var p2 = new Person('Obama Barak');
var p3 = new Person('Poetin Vladimir');
var p4 = new Person('Lincoln Abraham');
var pList = [p1, p2, p3, p4];
pList.sort();

We then get the following exception:

type 'Person' is not a subtype of type 'Comparable'.

This means that class Person must implement the Comparable interface by providing code for the method compareTo. Because String already implements this interface, we can use the compareTo method for the person's names:

lass Person implements Comparable{
  String name;
  Person(this.name);
  // many other properties and methods
 compareTo(Person p) => name.compareTo(p.name);
}

Then we can get the minimum and maximum and sort our Person List in place simply by:

var minP = pList.reduce((s1,s2) => s1.compareTo(s2) < 0 ? s1 : s2);
print('Minimum Person: ${minP.name}'); // Lincoln Abraham
var maxP = pList.reduce((s1,s2) => s1.compareTo(s2) < 0 ? s2 : s1);
print('Maximum Person: ${maxP.name}'); // Poetin Vladimir

pList.sort();
pList.forEach((p) => print('${p.name}'));

The preceding code prints the following output (on successive lines):

Lincoln Abraham   Obama Barak   Peeters Kris   Poetin Vladimir

For using Queue, your code must import the collection library by using import 'dart:collection'; because that's the library this class is defined in. It is another collection type, differing from a List in that the first (head) or the last item (tail) are important here. You can add an item to the head with addFirst or to the tail with add or addLast; or you can remove an item with removeFirst or removeLast:

var langsQ = new Queue();
langsQ.addFirst('Dart');
langsQ.addFirst('JavaScript');
print('${langsQ.elementAt(1)}'); // Dart
var lng = langsQ.removeFirst();
assert(lng=='JavaScript');
langsQ.addLast('C#');
langsQ.removeLast();
print('$langsQ'); // {Dart}

You have access to the items in a Queue by index with elementAt(index), and forEach is also available. For this reason, Queues are ideal when you need a first-in first-out data structure (FIFO), or a last-in first-out data structure (LIFO, called a stack in most languages).

Lists and Queues allow duplicate items. If you don't need ordering and your requirement is to only have unique items in a collection, use a Set type:

var langsS = new Set();
langsS.add('Java');
langsS.add('Dart');
langsS.add('Java');
langsS.length == 2;
print('$langsS'); // {Dart, Java}

Again, Sets allow for the same methods as List and Queue from their place in the collection hierarchy (see the The collection hierarchy figure). They also have the specific intersection method that returns the common elements between a Set and another collection.

Here is a handy flowchart to decide which data structure to use:

Choosing a collection type

To show how we can use our newly made library in another app, create a new application app_breeding; in its startup file (app_breeding.dart), we can call our library as shown in the following code:

import '../../breeding/bin/breeding.dart'; (1)

int years;

void main() {
  years = 5;
  print("The number of rabbits has attained:");
  print("${calculateRabbits(years)}");
}
// Output:
//The number of rabbits has attained:
//After 5 years:   1518750 rabbits

The import statement in line (1) points to the main file of our library, relative in the file system to the .dart file we are in (two folder levels up with two periods (..) and then into subfolder bin of breeding). As long as your libraries retain the same relative position to your client app (while deploying it in production), this works. You can also import a library from a (remote) website using a URL in this manner:

import 'http://www.breeding.org/breeding.dart';

Absolute file paths in import are not recommended because they break too easily when deploying. In the next section, we discuss the best way of importing a library by using the package manager called pub.

If you only want one or a few items (variables, functions, or classes) from a library, you have the option of only importing these by enumerating them after show:

import 'library1.dart' show var1, func1, Class1;

The inverse can also be done; if you want to import everything from the library excluding these items, use hide:

import 'library1.dart' hide var1, func1, Class1;

We know that everything in a Dart app must have a unique name; or, to put it another way, there can be no name conflicts in the app's namespace. What if we have to import into our app two libraries that have the same names for some of their objects? If you only need one of them, you can use show and/or hide. But what if you need both? In such a case, you can give one of the libraries an alias and differentiate between both by using this alias as a prefix. Suppose library1 and library2 both have an object A; you can use this as follows:

import 'library1.dart';          // contains class A
import 'library2.dart' as libr2; // contains class A

var obj1 = new A();             // Use A from library1.
var obj2 = new libr2.A();       // Use A from library2.

Use this feature only when you really have to, for example, to solve name conflicts or aid in readability. Finally, the export command (possibly combined with show or hide) gives you the ability to combine (parts of) libraries. Refer to the app export.

Suppose liba.dart contains the following code:

library liba;
abc() => 'abc from liba';
xyz() => 'xyz from liba';

Additionally, suppose libb.dart contains the following code:

library libb;
import 'liba.dart';
export 'liba.dart' show abc;

Then, if export.dart imports libb, it knows method abc but not method xyz:

import 'libb.dart';
void main() {
  print('${abc()}'); // abc from liba
  // xyz();  // cannot resolve method 'xyz'
}

In the A touch of class – how to use classes and objects section, we mentioned that starting a name with _ makes it private at library level (so it is only known in the library itself not outside of it). This is the case for all objects: variables, functions, classes, methods, and so on. Now we will illustrate this in our breeding library.

Suppose breeding.dart now contains two top-level variables:

String s1 = 'the breeding of cats';               (1)
var _s2   = 'the breeding of dogs';               (2)

We can use them both in main() but also anywhere else in the library, for example, in rabbits.dart:

String calculateRabbits(int years) {
  print('$s1 and $_s2');
  //…
  return out;
}

But if we try to use them in the app breeding.dart, which imports breeding, we get a warning in line (3) of the following code in the Editor; it says cannot resolve _s2; s1 is visible but _s2 is not.

void main() {
  years = 5;
  // …
  print('$s1 and $_s2');                          (3)
}

An exception occurs when the code is run (both in checked and production mode). Note that, in lines (1) and (2), we typed the public variable s1 as String, while the private variable _s2 was left untyped. This is a general rule: give the publicly visible area of your library strong types and signatures. Privacy is an enhancement for developers used to JavaScript but people coming from the OO arena will certainly ask why there is no class privacy. There are probably a number of reasons: classes are not as primordial in Dart as in OO languages, Dart has to compile to JavaScript, and so on. Class privacy is not needed to the extent usually imagined, and if you really want to have it in Dart you can do it. Let the library only contain the class that has some private variables; these are visible only in this class because other classes or functions are outside this library.