Single Inheritance: This inheritance occurs when a class inherits from a single parent class.

Multiple Inheritance: This inheritance occurs when a class inherits from more than one parent class. This is not supported by Dart.

Multi-Level Inheritance: This inheritance occurs when a class inherits another child class.

Hierarchical Inheritance: More than one class has the same parent class under hierarchical inheritance.

Dart's null-aware operators allow you to perform calculations based on whether or not a value is null. It's a shortened version of a longer expression. Instead of throwing an error, a null-aware operator can be used to make nullable types useful in Dart. These operators are used in fullback in such a way that you get a value rather than null at the end. Null-aware operators are used in practically every programming language to determine whether a variable's value is Null. Null is represented by the keyword null in the computer language Dart.

Streams are a type of data that is delivered asynchronously. User-generated events and data read from files are both included in data sequences. The Stream API provides two methods for processing streams: await for and listen(). Streams allow you to react to mistakes. Single subscription and broadcast streaming are the two types of streams available.

Optional parameters are those that are not required to be specified when invoking a function. After the essential parameters, optional parameters must be stated. Optional parameters can also have a default value that is utilized if the function call does not provide one.

Encapsulation is a technique for hiding property or method while still allowing access to it within the scope of the function. Unlike other object-oriented programming languages, Dart encapsulates data at the library level rather than the class level.

If you want to call many methods on the same object, you can avoid repeating the same target.

Dart supports polymorphism. Polymorphism allows a group of objects to share the same interface yet have various implementations. Let's add a new concrete class called Plane to the mix. You can use polymorphism to create Blimp and Plane and apply them to the Aircraft variable. You can use their shared attributes because they are both descendants of Aircraft. Each object instance has its own set of class properties and instance values and output that is exclusive to each object's class instance.

When an object is created in a program, constructors are used to initialize it. However, the default function Object() { [native code] } will not be built and will be disregarded if you do so. Dart constructors have the same name as the class and no return type.

The fat arrow syntax is simply a short hand for returning an expression and is similar to (){ return expression; }.

The fat arrow is for returning a single line, braces are for returning a code block.

Only an expression—not a statement—can appear between the arrow (=>) and the semicolon (;). For example, you can’t put an if statement there, but you can use a conditional expression

// Normal function

void function1(int a) {

  if (a == 3) {

    print('arg was 3');

  } else {

    print('arg was not 3');

  }

}

// Arrow Function

void function2(int a) => print('arg was ${a == 3 ? '' : 'not '}3');

Required Parameters

Dart required parameters are the arguments that are passed to a function and the function or method required all those parameters to complete its code block.

findVolume(int length, int breath, int height) {

 print('length = $length, breath = $breath, height = $height');

}

findVolume(10,20,30);

Optional Parameters

Optional parameters are defined at the end of the parameter list, after any required parameters.

In Flutter/Dart, there are 3 types of optional parameters: - Named - Parameters wrapped by { } - eg. getUrl(int color, [int favNum]) - Positional - Parameters wrapped by [ ]) - eg. getUrl(int color, {int favNum}) - Default - Assigning a default value to a parameter. - eg. getUrl(int color, [int favNum = 6])

Previous Next