Default Parameter Value

You can use = to define default values for the function’s named and positional arguments. The default value must be a compile-time constant, or null if no default is specified.

The following is an example of setting optional parameter defaults:

/// Set the [bold] and [hidden] flags... /// Sets the [bold] and [hidden] flags ... void enableFlags({bool bold = false, bool hidden = false}) {... } // bold will be true; And hidden is going to be false. enableFlags(bold: true);Copy the code

Older versions of Dart code used the colon (:) instead of = to set the default values for named parameters. The reason is that at first the named argument only supported:. However, this support is now obsolete, so we recommend that you specify the default value only with = for now.

The next example will show you how to set defaults for positional parameters:

String say(String from, String msg, [String device = 'carrier pigeon']) { var result = '$from says $msg with a $device';  return result; } assert(say('Bob', 'Howdy') == 'Bob says Howdy with a carrier pigeon');Copy the code

List or Map can also be used as defaults. The following example defines a function called doStuff() and specifies a list and Map value for its arguments named List and Gifts.

void doStuff(
    {List<int> list = const [1, 2, 3],
    Map<String, String> gifts = const {
      'first': 'paper',
      'second': 'cotton',
      'third': 'leather'
    }}) {
  print('list:  $list');
  print('gifts: $gifts');
}
Copy the code

The main () function

Each Dart program must have a main() top-level function as its entry point, which returns void and takes an optional argument of type List

.

Here is an example of the main() function for a Web application:

void main() { querySelector('#sample_text_id') .. text = 'Click me! '.. onClick.listen(reverseText); }Copy the code

Memo:

In the above code.. The syntax is called cascading invocation. Multiple operations can be performed on a single object using cascading access.

Here is an example of using the command line to access the main() function with arguments:

Dart args. Dart 1 test Run the app like this: dart args.dart 1 test void main(List<String> arguments) { print(arguments); assert(arguments.length == 2); assert(int.parse(arguments[0]) == 1); assert(arguments[1] == 'test'); }Copy the code

You can define and parse command-line arguments by using argument libraries.

Functions are first-class objects

You can pass a function as an argument to another function. Such as:

void printElement(int element) { print(element); } var list = [1, 2, 3]; // Pass printElement as an argument. list.forEach(printElement);Copy the code

You can also assign a function to a variable, as in:

var loudify = (msg) => '!!! ${msg.toUpperCase()} !!! '; assert(loudify('hello') == '!!! HELLO !!! ');Copy the code

Anonymous functions are used in this example. More on this in the next section.

Anonymous functions

Most methods have names, such as main() or printElement(). You can create a nameless method called an anonymous function, a Lambda expression, or a Closure Closure. You can assign an anonymous method to a variable and then use it, such as adding the variable to or removing it from a collection.

Anonymous methods look similar to named methods in that arguments can be defined between parentheses, separated by commas.

The following contents in braces are the body of the function:

([[type] parameter [,...]]) {function body; };

The following code defines an anonymous method that takes only one parameter item and has no parameter type. This function is called for each element in the List, printing a string of element positions and values:

var list = ['apples', 'bananas', 'oranges'];
list.forEach((item) {
  print('${list.indexOf(item)}: $item');
});
Copy the code

Click the Run button to execute the code.

If the function has only one return line, you can use the fat arrow abbreviation. Paste the following code into DartPad and click the Run button to verify that the two functions are the same.

list.forEach(
    (item) => print('${list.indexOf(item)}: $item'));
Copy the code

Lexical scope

Dart is a lexical scoped language. Variables are scoped at code writing time, and variables defined in braces can only be accessed within braces, similar to Java.

Here is an example of a nested function with variables in multiple scopes:

bool topLevel = true; void main() { var insideMain = true; void myFunction() { var insideFunction = true; void nestedFunction() { var insideNestedFunction = true; assert(topLevel); assert(insideMain); assert(insideFunction); assert(insideNestedFunction); }}}Copy the code

Note that the nestedFunction() function can access all variables, including the top-level variable.

Lexical closures

A closure is a function object that can access variables in its lexical scope even if the function object is called outside its original scope.

A function can enclose variables defined in its scope. In the following example, the function makeAdder() captures the variable addBy. Whenever the function returns, it can use the captured addBy variable.

/// returns a function that adds [addBy] to the function argument. /// Returns a function that adds [addBy] to the /// function's argument. Function makeAdder(int addBy) { return (int i) => addBy + i; } void main() {// Generate a function plus 2. var add2 = makeAdder(2); // Generate a function that adds 4. var add4 = makeAdder(4); assert(add2(3) == 5); assert(add4(3) == 7); }Copy the code

Tests whether the functions are equal

Here is an example test of equality between top-level functions, static methods and sample methods:

Void foo() {// define the top level function (A top-level function) class A {static void bar() {} // define the static void baz() {} // define the instance method} void main() { var x; // Compare whether the top-level functions are equal. x = foo; assert(foo == x); // Compare static methods for equality. x = A.bar; assert(A.bar == x); // Compare instance methods for equality. var v = A(); Var w = A(); Var y = w; x = w.baz; // These two closures refer to the same instance object, so they are equal. assert(y.baz == x); // These two closures refer to different instance objects, so they are not equal. assert(v.baz ! = w.baz); }Copy the code

The return value

All functions return values. The last line of a function that does not display a return statement defaults to return NULL; .

foo() {}

assert(foo() == null);
Copy the code

The operator

Dart supports the following table operators. You can implement these operators as members of a class.

Please note:

The operator precedence above is modeled after the Dart parser’s behavior. For a more accurate description, see the syntax in the Dart language specification.

Once you use the operator, you create the expression. Here are some examples of operator expressions:

a++
a + b
a = b
a == b
c ? a : b
a is T
Copy the code

In the operator table, operators are ranked in order of precedence, that is, the first row has the highest priority, the last row has the lowest priority, and the left-most row has the highest priority and the right-most row has the lowest priority. For example, the % operator has precedence over ==, while == has precedence over &&. According to the priority rule, this means that the following two lines of code execute identically:

// Parentheses improve readability. // Parentheses improve readability. if ((n % i == 0) && (d % i == 0)) ... // Difficult to understand, but the same effect as the code above. if (n % i == 0 && d % i == 0) ...Copy the code

Please note:

For operators with two operands, the left-hand operand determines the function of the operator. For example, for aVector and aPoint, the expression aVector + aPoint uses the addition operator (+) defined in the Vector.

Arithmetic operator

Dart supports common arithmetic operators:

Example:

assert(2 + 3 == 5); assert(2 - 3 == -1); assert(2 * 3 == 6); Assert (5/2 == 2.5); // The result is a float assert(5 ~/ 2 == 2); // The result is an integer assert(5%2 == 1); / / to take more than assert (5/2 = '${5 ~ / 2} r ${2} 5%' = = '5/2 = 2 r 1');Copy the code

Dart also supports increment and decrement operations.

Example:

var a, b; a = 0; b = ++a; // Increment a by 1 before b is assigned. assert(a == b); // 1 == 1 a = 0; b = a++; // Increment a by 1 after b is assigned. assert(a ! = b); / / 1! = 0 a = 0; b = --a; // Decrement a by 1 before b is assigned. assert(a == b); // -1 == -1 a = 0; b = a--; // Subtract a by 1 after b is assigned. assert(a ! = b); / / - 1! = 0Copy the code

Relational operator

The following table lists relational operators and their meanings:

To determine whether two objects x and y represent the same thing, use ==. (In rare cases, you may need to use the identical() function to determine whether two objects are identical.) . Here are some rules for the == operator:

1. Let’s say I have variablesx 和 y, and at least one of x and y is null, x == y returns true if and only if both x and y are null, otherwise false if only one is null.
2. x.==(y)Will return the value with or without y, that is, y is optional. That is to say,= =It’s actually a method in x, and it can be overridden. Please refer toRewriting operator.

The following code gives an example of each of these relational operators:

assert(2 == 2); assert(2 ! = 3); assert(3 > 2); assert(2 < 3); assert(3 >= 3); assert(2 <= 3);Copy the code

Type judgment operator

As, is, is! Operators are operators that determine the type of an object at run time.

Obj is T is true if and only if obj implements T’s interface. For example, obj is Object is always true, because all classes are subclasses of Object.

You can use the AS operator to convert an object to a specific type only if you are sure it is of that type. Such as:

(emp as Person).firstName = 'Bob';
Copy the code

If you are not sure if the object type is T, use is T to check the type before converting.

FirstName = 'Bob'; if (emp is Person) { }Copy the code

You can use the AS operator to abbreviate:

(emp as Person).firstName = 'Bob';
Copy the code

Memo:

There is a difference between the two methods: if the EMP is null or not of type Person, the first method will throw an exception and the second method will not.

The assignment operator

We can assign values using =, but we can also assign values using?? = to assign a value to a variable whose value is null.

// Assign value to a (Assign value to A) a = value; // assign b if and only if b is null. = value;Copy the code

Assignment operators like += combine arithmetic and assignment operators.

The following table explains how the coincidence operators work:

The following example shows how to use assignment and the compound assignment operator:

var a = 2; // Assign a *= 3; Multiply: a = a * 3 assert(a == 6); multiply: a = a * 3 assert(a == 6);Copy the code

Logical operator

With logical operators you can reverse or combine Boolean expressions.

Here is an example of using a logical expression:

if (! done && (col == 0 || col == 3)) { // ... Do something... }Copy the code

Bitwise and shift operators

In Dart, the binary bit operator can operate on a bit of binary, but only on integers.

Here is an example using bitwise and shift operators:

final value = 0x22;
final bitmask = 0x0f;

assert((value & bitmask) == 0x02); // 按位与 (AND)
assert((value & ~bitmask) == 0x20); // 取反后按位与 (AND NOT)
assert((value | bitmask) == 0x2f); // 按位或 (OR)
assert((value ^ bitmask) == 0x2d); // 按位异或 (XOR)
assert((value << 4) == 0x220); // 位左移 (Shift left)
assert((value >> 4) == 0x02); // 位右移 (Shift right)
Copy the code

Conditional expression

Dart has two special operators that can be used instead of if-else statements:

condition ? expr1 : expr2

If condition is true, evaluates expr1 (and returns its value); otherwise, evaluates and returns the value of expr2.

Conditions? Expression 1: Expression 2: Executes expression 1 and returns the result if the condition is true, otherwise executes expression 2 and returns the result.

expr1 ?? expr2

If expr1 is non-null, returns its value; otherwise, evaluates and returns the value of expr2.

Expression 1?? Expression 2: Returns the value of expression 1 if it is non-null, otherwise executes expression 2 and returns its value.

When determining assignments based on Boolean expressions, consider using? :.

var visibility = isPublic ? 'public' : 'private';
Copy the code

If the assignment is based on null, consider using?? .

String playerName(String name) => name ?? 'Guest';
Copy the code

The above example can also be written in at least two different forms, albeit less succinctly:

// Relative use? It's a bit long for the: operator. (Slightly longer version uses ? : operator). String playerName(String name) => name ! = null ? name : 'Guest'; // Longer if if-else is used. String playerName(String name) { if (name ! = null) { return name; } else { return 'Guest'; }}Copy the code

In production code, assertions are ignored, and arguments passed in to assert are not judged.

abnormal

Dart code can throw and catch exceptions. Exceptions represent unknown error conditions that can be thrown if the exception is not caught causing the code that threw the exception to terminate execution.

Unlike Java, all Dart exceptions are non-mandatory, methods don’t have to declare which exceptions will be thrown, and you don’t have to catch any.

Dart provides two types of exceptions, Exception and Error, and a series of subclasses, and you can define your own. But Dart can throw any non-NULL object as an Exception, not just an Exception or Error type.

An exception is thrown

Here is an example of throwing or throwing an exception:

throw FormatException('Expected at least 1 section');
Copy the code

You can also throw arbitrary objects:

throw 'Out of llamas! ';Copy the code

Memo:

Good code often throws an Exception of type Error or Exception.

Because a thrown exception is an expression, it can be used in => statements, and it can be thrown anywhere else where expressions are used:

void distanceTo(Point other) => throw UnimplementedError();
Copy the code

Catch exceptions

Catching an exception prevents the exception from being passed on (except when it is rethrown). Catching an exception gives you the opportunity to handle it:

try {
  breedMoreLlamas();
} on OutOfLlamasException {
  buyMoreLlamas();
}
Copy the code

For code that can throw more than one exception type, you can also specify multiple catch statements, one for each exception type. If the catch statement does not specify an exception type, it means that any exception type can be caught:

try { breedMoreLlamas(); } on OutOfLlamasException {// specify exception buyMoreLlamas(); } on Exception catch (e) {print('Unknown Exception: $e'); } catch (e) {// // print('Something really unknown: $e'); }Copy the code

As shown above, you can use on or catch to catch exceptions, on to specify the exception type, catch to catch exception objects, and both.

You can specify two parameters for the catch method. The first parameter is the exception object thrown and the second parameter is the StackTrace object:

Try {// ··· ·} on Exception catch (e) {print('Exception details:\n $e'); } catch (e, s) { print('Exception details:\n $e'); print('Stack trace:\n $s'); }Copy the code

The keyword rethrow can throw the caught exception again:

void misbehave() { try { dynamic foo = true; print(foo++); } catch (e) {print('misbehave() unhandled ${e.runtimeType}.'); rethrow; // Allows the caller to view the exception. } } void main() { try { misbehave(); } catch (e) { print('main() finished handling ${e.runtimeType}.'); }}Copy the code

Finally

The finally statement is always executed whether or not an exception is thrown. If no catch statement is specified to catch the exception, the exception is thrown after the finally statement is executed:

try { breedMoreLlamas(); } finally {// Always clean up, even if an exception is thrown. cleanLlamaStalls(); }Copy the code

A finally statement is executed after any matching catch statement:

try { breedMoreLlamas(); } catch (e) { print('Error: $e'); // Handle exceptions first. } finally { cleanLlamaStalls(); // Then clean up. }Copy the code

You can read the Exceptions section of the Dart Core Library Overview for more information.

class

Dart is an object-oriented language that supports mixin-based inheritance. All objects are instances of a class, and all classes inherit from the Object class. Mixin-based inheritance means that although there is only one superclass for each class (except Object), the code of one class can be reused in multiple other class inheritance. The Extension method is a way to add functionality to a class without changing it or creating a subclass.

Use the members of the class

The members of an object consist of functions and data (that is, methods and instance variables). Method calls are made through the object, which has access to its functions and data.

Use (.) To access an instance variable or method of an object:

var p = Point(2, 2); // Get y assert(p.y == 2); // Call the distanceTo() method on p. double distance = p.distanceTo(Point(4, 4));Copy the code

Use? . Instead of. Avoids the problem caused by null on the left side of the expression:

// If p is non-null, set a variable equal to its y value. var a = p? .y;Copy the code

Using constructors

Constructors can be used to create an object. Constructors can be named by the class name or the class name. identifier. For example, the following code creates a Point object using the Point() and point.fromjson () constructors respectively:

var p1 = Point(2, 2);
var p2 = Point.fromJson({'x': 1, 'y': 2});
Copy the code

The following code has the same effect, but the new keyword before the constructor name is optional:

var p1 = new Point(2, 2);
var p2 = new Point.fromJson({'x': 1, 'y': 2});
Copy the code

Version Tips:

Starting with Dart 2, the new keyword is optional.

Some classes provide constant constructors. Use the constant constructor to create compile-time constants preceded by the const keyword:

var p = const ImmutablePoint(2, 2);
Copy the code

Two compile-time constants constructed with the same constructor and the same parameter values are the same object:

var a = const ImmutablePoint(1, 1); var b = const ImmutablePoint(1, 1); assert(identical(a, b)); // They are the same instance!Copy the code

In constant context scenarios, you can omit the const keyword before a constructor or literal. For example, in the following example we create a constant Map:

// Lots of const keywords here. Const pointAndLine = const {'point': const [const ImmutablePoint(0, 0)], 'line': const [const ImmutablePoint(1, 10), const ImmutablePoint(-2, 11)], };Copy the code

Depending on the context, you can keep only the first const keyword and omit all the rest:

// Only one const, which establishes the constant context. // Only one const keyword is required, the others are implicitly related to the context. const pointAndLine = { 'point': [ImmutablePoint(0, 0)], 'line': [ImmutablePoint(1, 10), ImmutablePoint(-2, 11)], };Copy the code

However, if it is not possible to omit const from the context, the const keyword should not be omitted. Otherwise, a nonconstant object will be created. For example:

var a = const ImmutablePoint(1, 1); // Creates a constant (Creates a constant) var b = ImmutablePoint(1, 1); // Does NOT create a constant assert(! identical(a, b)); // These two variables are NOT the same instance!Copy the code

Version Tips:

Only starting with Dart 2 can the const keyword be omitted based on context judgment.

Gets the type of the object

The Type of an Object, which is an instance of Type, can be obtained at runtime using the runtimeType property of an Object.

print('The type of a is ${a.runtimeType}');
Copy the code

So far, we’ve solved how to use classes. The rest of this section shows you how to implement a class.

The instance variables

Here is an example of declaring an instance variable:

class Point { double x; // Declare the double variable x and initialize it to null. double y; // declare double y and initialize to null double z = 0; // declare the double variable z and initialize to 0. }Copy the code

All uninitialized instance variables have a value of NULL.

All instance variables implicitly declare a Getter method, and non-final instance variables implicitly declare a Setter method. You can look at getters and setters for more information.

class Point { double x; double y; } void main() { var point = Point(); point.x = 4; // Use Setter methods for x. assert(point.x == 4); // Use the Getter method for x. assert(point.y == null); // Default value is null. }Copy the code

If you initialize an instance variable when you declare it (rather than in a constructor or other method), the value of the instance variable is set when the object instance is created, before the constructor and its list of initializers are executed.

The constructor

A constructor can be declared by declaring a function that has the same name as the class (you can also add additional identifiers to the named constructor). Most constructors take the form of generative constructors, which create an instance of a class:

class Point { double x, y; Point(double x, double y) {// There will be a better way to implement this logic. this.x = x; this.y = y; }}Copy the code

Use the this keyword to reference the current instance.

Memo:

Using this keyword makes sense if and only if there is a naming conflict, otherwise Dart ignores this keyword.

Assigning a value to an instance variable in a constructor is similar for most programming languages, but Dart provides a special syntactic sugar to simplify this step:

class Point { double x, y; // The syntax sugar used to set x and y before the constructor body is executed. Point(this.x, this.y); }Copy the code

Default constructor

If you don’t declare a constructor, Dart automatically generates a no-argument constructor that calls its parent’s no-argument constructor.

Constructors are not inherited

A subclass does not inherit the constructor of its parent class, and if the subclass does not declare a constructor, there is only one constructor with no arguments by default.

The named constructor

You can declare multiple named constructors for a class to express more explicit intent:

class Point { double x, y; Point(this.x, this.y); // name constructor point.origin () : x = 0, y = 0; }Copy the code

Remember that constructors cannot be inherited, which means that subclasses cannot inherit the parent’s named constructor. If you want to provide a named constructor in a subclass with the same name as the parent’s named constructor, you need to declare it explicitly in the subclass.

Call the parent class non-default constructor

By default, the subclass constructor invokes the anonymous no-arg constructor of the parent, and the call will be in front of the subclass constructor function body code execution, if there is a list of initialization subclass constructor, then the initialization list before invoking the constructor of the parent is carried out, in general, the three call sequence is as follows:

1. Initialization list
2. A parameterless constructor for the parent class
3. Constructor of the current class

If the parent class does not have an anonymous, parameterless constructor, then the subclass must call one of the constructors of the parent class. Specifying a parent constructor for the subclass’s constructor needs only to be specified with (:) in front of the constructor body.

In the following example, the constructor of the Employee class calls the named constructor of the parent class Person. Click the Run button to execute the sample code.

Since the argument is passed to the parent constructor before the subclass constructor is executed, the argument can also be an expression, such as a function:

class Employee extends Person { Employee() : super.fromJson(defaultData); / /...}Copy the code

Please note:

Arguments passed to the parent constructor cannot use the this keyword, because at this point in the argument passing, the subclass constructor has not been executed and the instance object of the subclass has not been initialized, so all instance members cannot be accessed, but class members can.

Initialization list

In addition to calling the superclass constructor, instance variables can be initialized before the constructor body is executed. Each instance variable is separated by a comma.

// Initializer list sets instance variables before // The constructor body runs. // Use the initialization list to set instance variables before executing the constructor body. Point.fromJson(Map<String, double> json) : x = json['x'], y = json['y'] { print('In Point.fromJson(): ($x, $y)'); }Copy the code

Please note:

The statement to the right of initialize list expression = cannot use this keyword.

In development mode, you can use assert in the initialization list to validate input data:

Point.withAssert(this.x, this.y) : assert(x >= 0) {
  print('In Point.withAssert(): ($x, $y)');
}
Copy the code

It is very convenient to set final fields using the initializer list, which is used in the following example to set the values of three final variables. Click the Run button to execute the sample code.

Redirect constructor

Sometimes a constructor in a class can only be used to call other constructors in the class. This constructor does not have a function body, so you can use (:) after the function signature to specify the other constructors to be redirected to:

class Point { double x, y; // The primary constructor of the class. Point(this.x, this.y); // Delegate implementation to the main constructor. Point.alongXAxis(double x) : this(x, 0); }Copy the code

Constant constructor

If the objects generated by a class are immutable, you can make them compile-time constants when they are generated. You can do this by prefixing the class constructor with the const keyword and making sure that all instance variables are final.

class ImmutablePoint {
  static const ImmutablePoint origin = ImmutablePoint(0, 0);

  final double x, y;

  const ImmutablePoint(this.x, this.y);
}
Copy the code

Instances created by constant constructors are not always constants, as described in the section Using constructors.

Factory constructor

Identifying the constructor of a class with the factory keyword makes the constructor a factory constructor, which means that using the constructor to construct instances of the class does not always return a new instance object. For example, a factory constructor might return an instance from the cache, or an instance of a subtype.

In the following example, the Logger factory constructor returns an object from the cache, and the Logger.fromjson factory constructor initializes a final variable from the JSON object.

class Logger { final String name; bool mute = false; // the _cache variable is library private because it is preceded by an underscore. static final Map<String, Logger> _cache = <String, Logger>{}; factory Logger(String name) { return _cache.putIfAbsent( name, () => Logger._internal(name)); } factory Logger.fromJson(Map<String, Object> json) { return Logger(json['name'].toString()); } Logger._internal(this.name); void log(String msg) { if (! mute) print(msg); }}Copy the code

Memo:

This is not accessible in the factory constructor.

The factory constructor is called like any other constructor:

var logger = Logger('UI');
logger.log('Button clicked');

var logMap = {'name': 'UI'};
var loggerJson = Logger.fromJson(logMap);
Copy the code

methods

Methods are functions that provide behavior for an object.

Instance methods

Object instance methods have access to instance variables and this. The distanceTo() method below is an example of an instance method:

import 'dart:math'; class Point { double x, y; Point(this.x, this.y); double distanceTo(Point other) { var dx = x - other.x; var dy = y - other.y; return sqrt(dx * dx + dy * dy); }}Copy the code

The operator

Operators are instance methods with special names. Dart allows you to define operators with the following names:

Memo:

You may notice that some operators are not in the list, for example! =. Because they’re just grammatical sugar. The expression E1! = e2 is just! (e1 == e2) a syntactic sugar.

To represent the rewrite operator, we mark it with an operator identifier. Here is an example of overriding the + and – operators:

class Vector { final int x, y; Vector(this.x, this.y); Vector operator +(Vector v) => Vector(x + v.x, y + v.y); Vector operator -(Vector v) => Vector(x - v.x, y - v.y); Void main() {final v = Vector(2, 3); // Operator == and hashCode not shown. final w = Vector(2, 2); assert(v + w == Vector(4, 5)); assert(v - w == Vector(0, 1)); }Copy the code

Getter and Setter

Getters and setters are a pair of special methods for reading and writing properties of objects. As mentioned above, there is an implicit Getter for each property of an instance object, and a Setter for non-final properties. You can add getters and setters for additional attributes using the get and set keywords:

class Rectangle { double left, top, width, height; Rectangle(this.left, this.top, this.width, this.height); // Define two attributes generated by the calculation: right and bottom. double get right => left + width; set right(double value) => left = value - width; double get bottom => top + height; set bottom(double value) => top = value - height; } void main() { var rect = Rectangle(3, 4, 20, 15); assert(rect.left == 3); rect.right = 12; assert(rect.left == -8); }Copy the code

The advantage of using getters and setters is that you can use your instance variables and wrap them in methods over time without changing any code, meaning that you define them and then change them without affecting the original logic.

Memo:

Operators such as increment (++) execute correctly regardless of whether a Getter is defined. To avoid unnecessary exceptions, the operator calls the Getter once and stores its value in a temporary variable.

Abstract methods

Instance methods, getters, and setters can all be abstract. Defining an interface method without implementing it lets the class that implements it implement it. Abstract methods can only exist in abstract classes.

Use the semicolon (;) directly An alternative method body can declare an abstract method:

Abstract class Doer {// Define instance variables and methods... void doSomething(); // Define an abstract method. } class EffectiveDoer extends Doer {void doSomething() {// This method is not abstract anymore... }}Copy the code

An abstract class

Using the abstract keyword to identify a class makes it an abstract class that cannot be instantiated. Abstract classes are often used to declare interface methods and sometimes have concrete method implementations. If you want an abstract class to be instantiated at the same time, you can define a factory constructor for it.

Abstract classes often contain abstract methods. Here is an example of an abstract class that declares an abstract method:

// This class is declared abstract and thus // can't be instantiated. Abstract class AbstractContainer {// Define constructors, fields, methods, etc... void updateChildren(); // Abstract methods. }Copy the code

Implicit interface

Each class implicitly defines and implements an interface that contains all instance members of the class and other interfaces that the class implements. If you want to create A class A API that supports calling class B without inheriting from class B, you can implement A class B interface.

A class implements one or more interfaces and implements the API defined by each interface using the keyword implements:

// A person. The implicit interface contains The greet() method. The class Person {// _name variable is also included in the interface, but it is only visible in the library. final _name; // The constructor is not in the interface. Person(this._name); // Greet () on the interface. String greet(String who) => 'hello, $who. I am a $_name. '; } // An implementation of the Person interface. class Impostor implements Person { get _name => ''; String greet(String who) => 'hello $who. Do you know who I am? '; } String greetBob(Person Person) => person.greet(' Person '); Void main() {print(greetBob(Person(' small '))); print(greetBob(Impostor())); }Copy the code

If you need to implement multiple interface classes, you can separate each interface class with a comma:

class Point implements Comparable, Location {... }Copy the code

Extending a class

Create a subclass using the extends keyword and reference a parent class using the super keyword:

class Television { void turnOn() { _illuminateDisplay(); _activateIrSensor(); } class SmartTelevision extends Television {void turnOn() {super.turnon (); _bootNetworkInterface(); _initializeMemory(); _upgradeApps(); } / /...}Copy the code

Enumerated type

Enumeration types are special types, also called Enumerations or enums, that define a fixed number of constant values.

Using enums

Use enumerated

Use the keyword enum to define enumeration types:

enum Color { red, green, blue }
Copy the code

You can use trailing commas when declaring enumerated types.

Each enumerated value has a Getter method called the index member variable, which returns the positional value of the base index at 0. For example, the index of the first enumeration value is 0 and the index of the second enumeration value is 1. And so on.

assert(Color.red.index == 0);
assert(Color.green.index == 1);
assert(Color.blue.index == 2);
Copy the code

To get all enumeration values, use the values method of the enumeration class to get the list containing them:

List<Color> colors = Color.values;
assert(colors[2] == Color.blue);
Copy the code

You can use enumerations in Switch statements, but note that each case of an enumerated value must be handled. That is, each enumerated value must be a case clause, otherwise a warning will appear:

var aColor = Color.blue; Switch (aColor) {case color. red: print(' red! '); break; Case color. green: print(' Green as grass! '); break; Default: // Warning will appear without this statement. print(aColor); // 'Color.blue' }Copy the code

Enumerated types have two limitations:

• Enumerations cannot be subclasses, they cannot be mixed in, and you cannot implement an enumeration.
• An enumerated class cannot be explicitly instantiated.

You can consult the Dart programming language specification for more information.

Use mixins to add functionality to classes

Mixin is a method pattern for reusing code from a class in multiple inheritance.

Use the Mixin pattern using the with keyword followed by the name of the Mixin class:

Class Musician extends Person with Musical {// ···} Class Maestro extends Person with Musical, Aggressive, Demented { Maestro(String maestroName) { name = maestroName; canConduct = true; }}Copy the code

To implement a Mixin, create a class that inherits from Object and does not declare a constructor. Use the keyword mixin instead of class unless you want this class to be used as a normal class. Such as:

mixin Musical { bool canPlayPiano = false; bool canCompose = false; bool canConduct = false; void entertainMe() { if (canPlayPiano) { print('Playing piano'); } else if (canConduct) { print('Waving hands'); } else { print('Humming to self'); }}}Copy the code

You can use the keyword on to specify which classes can use the Mixin class. For example, if there is A Mixin class A, but A can only be used by class B, you can define A like this:

class Musician {
  // ...
}
mixin MusicalPerformer on Musician {
  // ...
}
class SingerDancer extends Musician with MusicalPerformer {
  // ...
}
Copy the code

In the preceding code, only classes that extend or implement the Musician class can use the mixin MusicalPerformer. Because SingerDancer extends Musician, SingerDancer can mix in MusicalPerformer.

Version Tips:

The mixin keyword is only referenced in Dart 2.1. Code in earlier versions usually uses abstract class instead. You can consult the Dart SDK change log and the 2.1 Mixin specification for more information about mixins changing in 2.1.

Class variables and methods

The static keyword is used to declare class variables or class methods.

A static variable

Static variables (class variables) are often used to declare state variables and constants that belong within the scope of a class:

class Queue { static const initialCapacity = 16; // ···} void main() {assert(queue.initialCapacity == 16); }Copy the code

Static variables are initialized the first time they are used.

Memo:

The code follows the naming rules in the style recommendation guide and uses camel case to name constants.

A static method

Static methods (that is, class methods) cannot operate on instances, so you cannot use this. But they can access static variables. You can call static methods directly on a class, as shown in the following example:

import 'dart:math'; class Point { double x, y; Point(this.x, this.y); static double distanceBetween(Point a, Point b) { var dx = a.x - b.x; var dy = a.y - b.y; return sqrt(dx * dx + dy * dy); } } void main() { var a = Point(2, 2); var b = Point(4, 4); var distance = Point.distanceBetween(a, b); Assert (2.8 < distance && distance < 2.9); print(distance); }Copy the code

Memo:

For some generic or common static methods, you should define them as top-level functions rather than static methods.

Static methods can be used as compile-time constants. For example, you can pass a static method as an argument to a constant constructor.

The generic

If you look at the API documentation for arrays, you’ll see that the array List is actually of type List

. <… The > symbol indicates that an array is a generic (or parameterized) type, usually using a single letter to represent type parameters such as E, T, S, K, and V.

Why generics?

Generics are often used when type safety is required, but they can also be beneficial to code execution:

• Specifying generics properly can help code generation better.
• Using generics reduces code duplication.

For example, if you want to declare an array that can only contain strings, you can declare the array as List

(pronounced “List of strings”). Then you can easily avoid the problems of putting non-string variables in the array. Meanwhile, the compiler and anyone else reading the code can easily find and locate problems:

var names = List<String>();
names.addAll(['Seth', 'Kathy', 'Lars']);
names.add(42); // Error
Copy the code

Another reason to use generics is to reduce code duplication. Generics allow you to share the same interface declaration between multiple implementations of different types. For example, in the following example, a class declares an interface for caching objects:

abstract class ObjectCache {
  Object getByKey(String key);
  void setByKey(String key, Object value);
}
Copy the code

Before long, you might want to do a special cache for String objects, so there’s a new class for String caching:

abstract class StringCache {
  String getByKey(String key);
  void setByKey(String key, String value);
}
Copy the code

If, at some point, you want to create a class for numeric types, there’s a lot of code like this…

Consider using generics to declare a class that can be implemented differently by different types of cache implementations:

abstract class Cache<T> {
  T getByKey(String key);
  void setByKey(String key, T value);
}
Copy the code

In the code above, T is an alternative type. It acts as a type placeholder that specifies the type when the developer calls the interface.

Use collection literals

List, Set, and Map literals can also be parameterized. To define a parameterized List, simply add

before the brackets; To define a parameterized Map, add

before the braces:
,>

Var names = <String>[' xiao Yun ', 'Xiao Fang ',' Xiao Min ']; Var uniqueNames = <String>{' uniqueNames ', 'uniqueNames ',' uniqueNames '}; Var pages = <String, String>{'index.html': 'homepage ', 'robots.txt': 'humans. TXT ':' we are human, not machine '};Copy the code

Use type-parameterized constructors

You can also use generics when calling constructors by enclosing Angle brackets after the class name (<… >) wrap one or more types:

var nameSet = Set<String>.from(names);
Copy the code

Create a Map object with a key of type Int and a value of type View:

var views = Map<int, View>();
Copy the code

A collection of generic types and the types they contain

Dart’s generic types are solidified, which means that the type information is retained even at runtime:

var names = List<String>(); Names.addall ([' xiao Yun ', 'Xiao Fang ',' Xiao Min ']); print(names is List<String>); // trueCopy the code

Memo:

Unlike Java, generics in Java are type erased, which means that generic types are removed at run time. In Java you can tell if an object is a List but you can’t tell if an object is a List

.

Restrict parameterized types

When using generics, you might want to limit the type range of a generic. Use the extends keyword:

Class Foo<T extends SomeBaseClass> { String toString() => "instance of 'Foo<$T>' "; } class Extender extends SomeBaseClass {... }Copy the code

Use SomeBaseClass or a subclass of SomeBaseClass as a generic parameter:

var someBaseClassFoo = Foo<SomeBaseClass>();
var extenderFoo = Foo<Extender>();
Copy the code

Foo

= SomeBaseClass

var foo = Foo(); print(foo); // Instance of 'Foo<SomeBaseClass>'Copy the code

Using a non-someBaseclass type as a generic parameter causes a compilation error:

var foo = Foo<Object>();
Copy the code

Use generic methods

Dart originally only supported specifying generics for class declarations, but now it is also possible to use generics for methods, called generic methods:

T first<T>(List<T> ts) {// Handle some initialization work or error detection...... T tmp = ts[0]; // Handle some extra checks... return tmp; }Copy the code

The generic T of the method first

can be used as follows:

• Function return value type (T).
• Parameter type (List<T>).
• Type of local variable (T tmp).

You can learn more about generics by looking at using generic functions.

Libraries and visibility

Import and library keywords can help you create a modular and shareable code base. The code base not only provides the API but also acts as a wrapper: members beginning with an underscore (_) are visible only in the code base. Each Dart program is a library, even if it is not specified using the keyword library.

Dart’s libraries can be published and deployed using package tools.

Use the library

Use import to specify the namespace so that other libraries can access it.

For example, you can import the dart: HTML library to use the DART Web API:

import 'dart:html';
Copy the code

The only argument to import is the URI used to specify the code base, in the form Dart: XXXXXX for libraries built into Dart. For other libraries, you can use a file system path or package: XXXXXX. The library specified by package: XXXXXX is provided through a package manager (such as the pub utility) :

import 'package:test/test.dart';
Copy the code

Memo:

A URI stands for uniform Resource Identifier (URI).

A URL (Uniform resource Locator) is a common URI.

Specifying the library prefix

If two code bases you imported have conflicting identifiers, you can specify a prefix for one of them. For example, if library1 and library2 both have Element classes, we could do this:

import 'package:lib1/lib1.dart'; import 'package:lib2/lib2.dart' as lib2; // Use the Element class lib1. Element element1 = Element(); // Use the Element class lib2. lib2.Element element2 = lib2.Element();Copy the code

Import part of the library

If you only want to use part of the code base, you can selectively import the code base. Such as:

// Import only foo in lib1. (Import only foo). import 'package:lib1/lib1.dart' show foo; // Import all of lib2 except foo. import 'package:lib2/lib2.dart' hide foo;Copy the code

To realize library

Refer to Creating dependent library packages for suggestions on how to implement library packages, including:

• How to organize the source files of the library.
• How to useexportCommand.
• When to usepartCommand.
• When to uselibraryCommand.
• How to implement multi-platform library support using dump and export commands.

To deal with the Future

You can obtain the result of a Future execution in two ways:

• useasync 和 await;
• Using the Future API, detail the reference library overview.

Code that uses async and await is asynchronous, but looks a bit like synchronous code. For example, the following code uses await to wait for the execution result of an asynchronous function.

await lookUpVersion();
Copy the code

We must use await in asynchronous functions with the async keyword:

Future checkVersion() async { var version = await lookUpVersion(); // continue processing logic with version}Copy the code

Memo:

Although an asynchronous function can handle time-consuming operations, it does not wait for these time-consuming operations to complete. An asynchronous function executes and returns a Future object when it encounters the first await expression (line of code), and then waits for the await expression to complete.

Use try, catch, and finally to handle exceptions caused by using await:

try { version = await lookUpVersion(); } catch (e) {// The version cannot be found.Copy the code

You can use the await keyword multiple times in asynchronous functions. For example, the following code waits for the result of a function three times:

var entrypoint = await findEntrypoint();
var exitCode = await runExecutable(entrypoint, args);
await flushThenExit(exitCode);
Copy the code

The return value of an await expression is usually a Future object; If not, it will automatically wrap it in a Future object. The Future object represents a "promise" and await expression blocks until the desired object returns.

If using await results in a compile error, make sure await is used in an asynchronous function. For example, if you want to use await in the main() function, the main() function must be identified with the async keyword.

Future main() async { checkVersion(); Print (' execute in Main: version is ${await lookUpVersion()}'); }Copy the code

To deal with the Stream

If you want to get a value from a Stream, you have two options:

• useasyncKeywords and oneAsynchronous loop(using theawait forKeyword identification).
• Use the Stream API. Refer to the library overview for details.

Memo:

Before using the await for keyword, make sure it makes the code logic clearer and that you really need to wait for all results to complete. For example, you should not normally use the await for keyword on UI event listeners because the stream of events emitted by the UI framework is infinite.

Defining an asynchronous loop with await for looks like this:

Await for (varOrType identifier in expression) {// Execute whenever Stream emits a value}Copy the code

The expression must be of type Stream. The execution process is as follows:

1. Wait until the Stream returns a data.
2. Execute the body of the loop with the data returned from Stream 1.
3. Repeat procedures 1 and 2 until the Stream data is returned.

Use the break and return statements to stop receiving Stream data, thus breaking out of the loop and unregistering to listen on the Stream.

If you encounter a compile-time error while implementing an asynchronous for loop, check to ensure that await for is in an asynchronous function. For example, to use an asynchronous for loop in an application’s main() function, the body of the main() function must be marked async:

Future main() async {
  // ...
  await for (var request in requestServer) {
    handleRequest(request);
  }
  // ...
}
Copy the code

You can consult the Dart: Async section of the library overview for more information on asynchronous programming.

The type definition

In the Dart language, functions are objects like strings and numbers, and you can use a type definition (or method type alias) to name the type of the function. When a function of the function type is assigned to a variable using function naming, the type definition preserves the associated type information.

For example, the following code does not use a type definition:

class SortedCollection { Function compare; SortedCollection(int f(Object a, Object b)) { compare = f; }} // Simple incomplete implementation. int sort(Object a, Object b) => 0; void main() { SortedCollection coll = SortedCollection(sort); // We know that compare is a function, but we don't know what function it is. assert(coll.compare is Function); }Copy the code

In this code, the type of the Function is lost when f is assigned to compare. The type of the Function is (Object, Object) → int (→ return), which is a subclass of Function. But when f is assigned to compare, the type of f (Object, Object) → int is lost. We can use typedefs to explicitly retain type information:

typedef Compare = int Function(Object a, Object b); class SortedCollection { Compare compare; SortedCollection(this.compare); } // Simple incomplete implementation. int sort(Object a, Object b) => 0; void main() { SortedCollection coll = SortedCollection(sort); assert(coll.compare is Function); assert(coll.compare is Compare); }Copy the code

Memo:

Currently, type definitions can only be used for function types, but that may change in the future.

Because a type definition is just an alias, we can use it to determine the method of any function type:

typedef Compare<T> = int Function(T a, T b);

int sort(int a, int b) => a - b;

void main() {
  assert(sort is Compare<int>); // True!
}
Copy the code

metadata

Using metadata adds some additional information to your code. Metadata annotations start with @, followed by a compile-time constant (such as deprecated) or call a constant constructor.

Dart has two annotations that all code can use: @deprecated and @Override. You can see extending a class to get an example of the use of @Override. Here is an example using @deprecated:

Class Television {/// _ deprecated: use [turnOn] instead of _ @ Deprecated void activate() {turnOn(); } // turn on the power of the TV. void turnOn() {... }}Copy the code

You can customize metadata annotations. The following example defines an @todo annotation with two parameters:

library todo;

class Todo {
  final String who;
  final String what;

  const Todo(this.who, this.what);
}
Copy the code

Examples of @todo annotations:

import 'todo.dart';

@Todo('seth', 'make this do something')
void doSomething() {
  print('do something');
}
Copy the code

Metadata can be used before library, class, typedef, type Parameter, constructor, factory, function, field, parameter, or variable declarations. It can also be used before import or export. You can use reflection to retrieve metadata information at run time.

annotation

Dart supports single-line, multi-line, and document comments.

Single-line comments

Single-line comments start with //. Anything between // and the end of the line is ignored by the compiler.

void main() { // TODO: refactor into an AbstractLlamaGreetingFactory? print('Welcome to my Llama farm! '); }Copy the code

Multiline comment

Multi-line comments start with /* and end with */. Anything between /* and */ is ignored by the compiler (document comments are not ignored), and multi-line comments can be nested.

void main() {
  /*
   * This is a lot of work. Consider raising chickens.

  Llama larry = Llama();
  larry.feed();
  larry.exercise();
  larry.clean();
   */
}
Copy the code

Documentation comments

A document comment can be a multi-line or single-line comment, starting with /// or /**. Using // on consecutive lines has the same effect as multi-line document comments.

In a document comment, the Dart compiler ignores all text unless you enclose it in brackets. Use brackets to refer to classes, methods, fields, top-level variables, functions, and parameters. The symbols in parentheses are resolved in the lexical field of the documented program element.

Here is a document comment that references other classes and members:

/// A domesticated South American camelid (Lama glama). /// /// Andean cultures have used llamas as meat and pack /// animals since pre-Hispanic times. class Llama { String name; /// Feeds your llama [Food]. /// /// The typical llama eats one bale of hay per week. void feed(Food food) { // ... } /// Exercises your llama with an [activity] for /// [timeLimit] minutes. void exercise(Activity activity, int timeLimit) { // ... }}Copy the code

In the generated document, [Food] becomes a link to the API documentation for the Food class.

Parse the Dart code and generate HTML documents. For examples of generating documents, refer to Dart API Documentation for recommendations on document structure, refer to the documentation: Guidelines for Dart Doc Comments.

conclusion

This page provides an overview of the features commonly used in the Dart language. There are more features to be implemented, but we hope they won’t break existing code. For more information, refer to the Dart language specification and the Efficient Dart Language Guide.

To learn more about the Dart core library, refer to the Dart Core Library Overview