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 ClassName.constructorName form. 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 will be 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 BankAccount.sameOwner named constructor (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, as follows:

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, which is extensively used in the Dart SDK. In factory_singleton.dart, we use this ability to implement the singleton design pattern (for a general intro to design patterns, see https://en.wikipedia.org/wiki/Software_design_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 theOne static variable (here, of the SearchEngine type 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 the instances of the class. It is invoked on the class name itself, as in line (7); this is 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 theOne static variable already refers to an object or not. If not, a SearchEngine object is created through the SearchEngine._internal named constructor from line (3); if it was already created, nothing is done and the theOne object 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 SearchEngine._internal named constructor 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 the const constructors and ensure that every property is const or final, for example, the ImmutableSquare class 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));

Inheritance in Dart comes with no surprises if you know the concept from Java or .NET. Its main use is to reduce the codebase by factoring common code (properties, methods, and so on) into a common parent class. In square_v2.dart, the Square class inherits from the Rectangle class indicated by the extends keyword (line (4)). A Square object inherits the properties from its parent class (see line (1)), and you can refer to the constructors or methods from the parent class with the super keyword (like in line (5)):

main() {
  var s1 = new Square(2);
  print(s1.width);                             (1)
  print(s1.height);
  print('${s1.area()}'), // 4
  assert(s1 is Rectangle);                     (2)
}

class Rectangle {
  num width, height;
  Rectangle(this.width, this.height);
  num area() => width * height;                (3)
}

class Square extends Rectangle {               (4)
  num length;
  Square(length): super(length, length) {      (5)
    this.length = length;
  }
  num area() => length * length;               (6)
}

Methods from the parent class can be overridden in the derived class without special annotations, for example, the area()method (lines (3) and (6)). An object of a child class is also of the type of the parent class (see line (2)) and thus it can be used whenever a parent class object is needed. This is the basis of what is called the polymorphic behavior of objects. All classes inherit from Object, but a class can have only one direct parent class (single inheritance). Constructors are not inherited. An object, the class of this object, its parent class, and so on (until Object) are all searched for the method that is called on. A class can have many derived classes, so an application is typically structured as a class hierarchy tree.

In OO programming, the class composition (with properties representing components / objects of other classes) and inheritance are used to support a divide-and-conquer approach toward problem solving. Class A inherits from class B only when A is a subset of B, for example, a square is a rectangle, a manager is an employee; basically when class B is more generic and less specific than class A. It is recommended that inheritance be used with caution, because an inheritance hierarchy is more rigid in the maintenance of programs than a composition.

Looking for parent classes is an abstraction process and it can go so far that the parent class we have decided to work with can no longer be fully implemented. That is, it can contain methods that we cannot code at this point by the so-called abstract methods. Extending the previous example to square_v3.dart, we could easily abstract out a Shape parent class. This could contain methods to calculate 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 this abstract class. A simple example can be seen in the factory_abstract.dart file:

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 and, because we 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 implements keyword here to make the relationship between the class and the abstract class (which is also an interface, as we will 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 to make 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. Dart's interfaces work differently from Java / C# 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 the words are used as synonyms. Class B can implement any other class C by providing the code for C's public methods. In fact, the previous example, square_v3.dart, continues to work when we change the extends keyword 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 the Rectangle class 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);

The extends keyword is much less used than implements, but it clearly has a different meaning too. While using extends, the inheritance chain is searched for a called method, not the implemented interfaces, as is the case while using implements.

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 (which could be called explicit interfaces) are of much less importance (in fact, the abstract keyword is optional; leaving it off only gives a warning of its unimplemented members). This interface concept is more flexible than the one in most OO languages, and it 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 the base interface that every other class (also Object) implements. However, it is an interface without properties or methods and cannot be extended.

To summarize it, 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.

Because Dart fully implements all the OO principles, we are able to write polymorphic code in which an object can be used wherever something of its type, the type of its parent classes, or the type of any of the interfaces it implements is needed. We will see this in action in polymorphic.dart:

main() {
  var duck1 = new Duck();
  var duck2 = new Duck('blue'),
  var duck3 = new Duck.yellow();
  polytest (new Duck()); // Quack   I'm gone, quack!      (1)
  polytest (new Person());// human_quack  I am a person swimming                (2)
}

polytest(Duck duck) {                                     (3)
  print('${duck.sayQuack()}'),
  print('${duck.swimAway()}'),
}

abstract class Quackable {
  String sayQuack();
}

class Duck implements Quackable {
  var color;
  Duck([this.color='red']);
  Duck.yellow() { this.color = 'yellow';}

  String sayQuack() => 'Quack';
  String swimAway() => "I'm gone, quack!";
}

class Person implements Duck {                           (4)
  sayQuack() => 'human_quack';
  swimAway() => 'I am a person swimming';                (5)

  noSuchMethod(Invocation invocation) {                  (6)
    if (invocation.memberName == new Symbol("swimAway"))print("I'm not really a duck!");
  }
}

The top-level polytest function in line (3) takes anything that is in Duck as an argument. In this case, this is not only a real duck, but also a person, because the Person class also implements Duck (line (4)). This is polymorphism. This property of a language permits us to write code that is generic in nature; using objects of interface types, our code can be valid for all the classes that implement the interface used.

Another property shows that Dart also resembles dynamic languages such as Ruby and Python; when a method is called on an object, its class, parent class, the parent class of the parent class, and so on (until the class Object), are searched for the method called. If it is found nowhere, Dart searches the class tree from the class to the Object class again for a method called noSuchMethod().

The Object has this method and its effect is to throw noSuchMethodError. We can use it to our advantage by implementing the method in our class itself; see line (6) in the Person class (the argument mirror is of the Invocation type; its memberName property is the name of the method called and its namedArguments property supplies a Map with the method's arguments). If we now remove line (5) so that Person no longer implements the swimAway()method, the Editor will give us a warning:

Concrete class Person has unimplemented members fromDuck: String swimAway().

However, if we now execute the code, the I'm not really a duck! message would be printed when print('${duck.swimAway()}') is called for the Person object. Because swimAway() didn't exist for the Person class or any of its parent classes, noSuchMethod is searched, found in the class itself, and executed. noSuchMethod can be used to do what is generally called metaprogramming in the dynamic languages arena, giving our applications greater flexibility to efficiently handle new situations.

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, like 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, String, BankAccount or even List, themselves. In this case, you can indicate the E type 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)

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

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

Here, value means 42. However, when we run in the production mode, this code runs just fine. Again, indicating the type helps us to prevent possible errors and, at the same time, document the 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 E type. This is why the List<E> type is called generic (or parameterized). The E formal type parameter stands for any possible type.

The same goes for Maps; a Map is, in fact, a generic Map<K,V> type, 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 will demonstrate:

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 the checked mode, not in the 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 can see that, in line (5), the type of the List is checked; this check works even in the production mode! (Uncheck the Run in Checked Mode checkbox in Run | Manage Launches and click on Apply to see it in action.) This is because generic types in Dart (unlike in Java) are reified; their type information is preserved during runtime, so you can test the type of collection even in the production mode. Note, however, that this is the type of the collection only. While adding the langs2.add(42); statement (which executes fine in the production mode), the check in line (4) still gives us the true value. If you want to check the types of all the elements in a collection in the production mode, you will have to do it 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 expected results mostly:

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. Line (2) is false, because not every Object is a String. Line (3) is false, because Strings are not integers. Line (4) is true, because Strings are also of the dynamic general type. Line (5) can be a surprise: dynamic is String. This is because those generic types without type parameters are considered to be substitutable (subtypes of) for any other version of the generic type.

Apart from List and Map, there are other important collection classes, such as Queue and Set, among the 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 the 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 the 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 the lists.dart file), 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 characteristics of a functional language: we see lots of functions taking functions as parameters or returning functions. Let's look at some of the 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 a function as a parameter that is applied to every i item of the collection in turn. In the following example, a function that simply prints the item is shown:

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

It is called an anonymous function, because it has no name.

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 you 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 take and takeWhile functions 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 the 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 i parameter to test its evenness, and we assign the anonymous function to a function variable called even. We then pass this function as a parameter to where and 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, which makes it appropriate and elegant for short predicate functions. Why do we need the toList() function to be called in this and the previous functions? Because where (and the other Iterable methods) returns a so-called lazy Iterable method. 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(), you will get 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 will 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 the 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 the other types? For this, we need to be able to compare the two List items: i1 and i2. If i2 is greater than i1, we will know the min and max values of the two and be able to sort them. Dart has this intrinsically defined for the basic int, num, String, Duration, and Date types. So, in our example with the int types, 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 an optional argument, a function of the int type, compare(E a, E b), belonging to the Comparable interface. Generally, this will be implemented as follows:

In the following code, we will 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. 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 will make a List of the 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 will then get the following exception:

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

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

class 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 min and max values 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 will print the following output (on successive lines):

Lincoln Abraham   Obama Barak   Peeters Kris   Poetin Vladimir

To use Queue, your code must import the collection library by using import 'dart:collection';, because this is the library the class is defined in. It is another collection type differing from a List in a way that the first (head) or the last item (tail) are important. 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 the index with elementAt(index) and forEach is also available. For this reason, Queues are ideal when you need a first-in first-out (FIFO) data structure or a last-in first-out (LIFO, which is called a stack in most languages) data structure.

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 following diagram). 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 app_breeding application. 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 folders level up with two periods (..) and then into the bin subfolder of breeding). As long as your libraries retain the same relative position to your client app (while deploying it in production), it will work. You can also import a library from a (remote) website using a URL in the following manner:

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

Absolute file paths in import are not recommended, because they break too easily while deploying. In the next section, we will 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, and classes) from a library, you will 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. However, what if you need both? In such a case, you can give one of the libraries an alias and differentiate between the two using this alias as a prefix. Suppose library1 and library2 have an object A; you can differentiate between the two 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 readability. Finally, the export command (possibly combined with show or hide) gives you the ability to combine (parts of) libraries, refer to the export app.

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 will know the abc method but not the xyz method:

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 file name with _ makes it private for the library (only known in the library itself). 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 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;
}

However, if we try to use them in the breeding.dart app, which imports breeding, we will get a warning in line (3) of the following code in the Editor; it will say 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 the checked and production modes). Note that, in lines (1) and (2), we typed the s1 public variable as String, while the _s2 private variable 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 that 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 of this library.