Abstract Class , adalah class yang tidak bisa dibuat object Karena masih bersifat abstract, Abstract class memiliki method yang juga bersifat abstract atau belum memiliki implentasinya. Untuk membuat abstract class yaitu dengan menggunakan keyword abstract contoh pembuatan abstract class :

abstract class car{
  void onRun()
}

untuk membuat implementasi dari sebuah abstract class maka kita bisa embuât class implementatornya seperti berikut:

abstract class Car{
  void onRun();
  void onBreak();
}

class Truck implements Car{
  @override
  void onRun() {
    // TODO: implement onRun
    print("Truck run");
  }

  @override
  void onBreak() {
    // TODO: implement onBreak
    print("Truck on break");
  }

}

class Bus implements Car{
  @override
  void onBreak() {
    // TODO: implement onBreak
    print("Bus on break");
  }

  @override
  void onRun() {
    // TODO: implement onRun
    print("Bus on run");
  }

}

void main(){
  var truck = new Truck();
  truck.onRun();
  truck.onBreak();

  var bus = new Bus();
  bus.onRun();
  bus.onBreak();

}

//output

Truck run
Truck on break
Bus on run
Bus on break

Sample source code bisa di download di github pada link berikut dart-tutorial

Methods adalah function yang memberikan perilaku dari sebuah object.

Instance Methods

Metode instance pada objek dapat mengakses variabel instance dan this. Metode distanceTo () dalam contoh berikut adalah contoh metode instance

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);
  }
}

void main(){
  var point = Point(10, 10);
  print("Value is "+point.distanceTo(point).toString());
}

Value is 0.0

Operators

Operator adalah metode instance dengan nama khusus. Dart memungkinkan kita menentukan operator dengan nama berikut:

contoh penggunaan operator

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);

  // Operator == and hashCode not shown.
  // ···
}

void main() {
  final v = Vector(2, 3);
  final w = Vector(2, 2);

  assert(v + w == Vector(4, 5));
  assert(v - w == Vector(0, 1));
}

Getter and Setters

Getter dan setter adalah metode khusus yang menyediakan akses read dan write ke properti objek. Ingatlah bahwa setiap variabel contoh memiliki inplicit getter dan setter jika sesuai. Kita dapat membuat properti tambahan dengan menerapkan getter dan setter, menggunakan get dan set kata kunci:

class Rectangle {
  double left, top, width, height;

  Rectangle(this.left, this.top, this.width, this.height);

  // Define two calculated properties: 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);
}

Dengan getter dan setter, kita dapat memulai dengan variabel instance, kemudian menggabungkannya dengan metode, semuanya tanpa mengubah kode klien.

Sample source code bisa di download di github pada link berikut dart-tutorial

Constructor adalah method kudus yang akan di eksekusi saat pembuatan object dari sebuah class. Biasanya constructor digunakan untuk insialisasi atau memperispakn data yang object butuhkan. Cara membuat constructor yaitu dengan membuat function dengan nama yang sama pengan nama class .

class Person{
  String name;
  int age;

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

Pola penugasan argumen constructor ke variabel instan sangat umum, Dart memiliki sugar sintaksis untuk membuatnya mudah:

class Person{
  String name;
  int age;

  Person(this.name,this.age);
}

Default Constructors

Jiak kita tidak membuat contsructor pada sebua class, maka secara default cobstructors akan disediakan. Default constructors tidak memiliki arguments dan memanggil constructors tanpa argumen di superclass.

Constructors aren’t inherited

Subclass tidak mewarisi konstruktor dari superclass mereka. Subclass yang mendeklarasikan tidak ada konstruktor hanya memiliki konstruktor default (tanpa argumen, tanpa nama).

Names Constructors

Untuk membuat sebuah class yang memiliki contructors lebin dari satu ( Multiple Constructors), Maka kita bisa memberi nama pada contractos yang kita buat:

class Person{
  String name;
  int age;

  Person(this.name,this.age);
  // named contractor
  Person.getName(String name){
    this.name =name;
 }
}

Ingat bahwa konstruktor tidak diwariskan, yang berarti konstruktor bernama superclass tidak diwarisi oleh subclass. Jika kita ingin subclass dibuat dengan konstruktor bernama yang ditentukan di superclass, Anda harus mengimplementasikan konstruktor itu di subclass.

Invoking a non-default superclass constructor

Secara default, konstruktor dalam subclass memanggil konstruktor tanpa argumen kelas super tersebut. Konstruktor superclass dipanggil di awal badan konstruktor. Jika daftar penginisialisasi juga digunakan, itu dijalankan sebelum superclass dipanggil. Singkatnya, urutan eksekusi adalah sebagai berikut:

• initializer list
• superclass’s no-arg constructor
• main class’s no-arg constructor

class Employee extends Person {
  Employee() : super.fromJson(defaultData);
  // ···
}

Initializer list

Selain memanggil konstruktor superclass, kita juga bisa menginisialisasi variabel instan sebelum badan konstruktor dijalankan. Pisahkan penginisialisasi dengan koma.

Point.fromJson(Map<String, double> json)
    : x = json['x'],
      y = json['y'] {
  print('In Point.fromJson(): ($x, $y)');
}

Redirecting constructors

Terkadang satu-satunya tujuan konstruktor adalah mengarahkan ke konstruktor lain di class yang sama. Badan konstruktor is empty, dengan panggilan konstruktor muncul setelah titik dua (:).

class Point {
  double x, y;

  // The main constructor for this class.
  Point(this.x, this.y);

  // Delegates to the main constructor.
  Point.alongXAxis(double x) : this(x, 0);
}

Constant constructors

Jika kelas yang kita buat menghasilkan objek yang tidak pernah berubah, kita dapat membuat objek ini menjadi konstanta (const) waktu kompilasi. Untuk melakukan ini, tentukan konstruktor const dan pastikan bahwa semua variabel instan sudah final.

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

  final double x, y;

  const ImmutablePoint(this.x, this.y);
}

Factory Constructors

Gunakan factory keyword ketika melakukan implementasi constructor tanpa harus membuat instance baru dari sebuah class. factory mungkin mengembalikan instance dari cache atau mengembalikan instance dari subtype, Kasus penggunaan lain untuk konstruktor factory adalah menginisialisasi variabel final menggunakan logika yang tidak dapat ditangani dalam daftar penginisialisasi.

class Logger {
  final String name;
  bool mute = false;

  // _cache is library-private, thanks to
  // the _ in front of its name.
  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);
  }
}

Sample source code can be downloaded on github at the following link     dart-tutorial

Semua instance dari variable di generate implicit getter method. Non-final instance variable digenerate implicit setter method:

//code
class Person{
  String name;
  int age;

  Person(this.name,this.age);
}

void main(){
  var person = Person("Alfaz",30);
  
  print('Name : '+person.name);
  print('Age :'+person.age.toString());
}

//output
Name : Alfaz
Age :30

Jika kita menginisialisasi variable instance di mana dideklarasikan (bukan di constructor atau method), nilai harus ditetapkan saat instance dibuat, yaitu sebelum constructor dan daftar penginisialisasinya dijalankan.

Sample source code can be downloaded on github at the following link   dart-tutorial

Dart dapat melempar (throw) dan menangkap pengecualian (exceptions). Exception adalah kesalahan yang menunjukkan bahwa sesuatu yang tidak terduga telah terjadi. Jika Exception tidak tertangkap, isolat yang memunculkan pengecualian akan ditangguhkan, dan biasanya isolat dan programnya dihentikan.

Throw

Berikut contoh throw

throw 'Error number';

Karena throw exceptions adalah ekspresi, kita bisa me buat throw exceptions dalam pernyataan =>, serta di mana pun yang mengizinkan ekspresi.

void distanceTo(Point other) => throw UnimplementedError();

Catch

Catch, atau capturing, adalah exceptions menghentikan proses jika terjadi kesalahan

void misbehave() {
  try {
    dynamic foo = true;
    print(foo++); // Runtime error
  } catch (e) {
    print('misbehave() partially handled ${e.runtimeType}.');
    rethrow; // Allow callers to see the exception.
  }
}

void main() {
  try {
    misbehave();
  } catch (e) {
    print('main() finished handling ${e.runtimeType}.');
  }
}

Finally

Untuk memastikan bahwa beberapa kode berjalan baik exceptions dilempar atau tidak, gunakan klausa finally. Jika tidak ada klausa catch yang cocok dengan exceptions, exceptions tersebut tangkap setelah klausa finally berjalan:

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

if and else

Dart mendukung pernyataan if dengan else contoh pernyataan if dan else

//CODE
void main(){
  int numberA=10;

  if(numberA>=10){
    print("A more then 10");
  }else{
    print("A less then 10");
  }
}

//OUTPUT
A more then 10

Break and Continue

Break digunakan untuk menghentikan proses lopping contoh:

//CODE
void main(){
  exBreak();
}

void exBreak(){
  var list =[1,2,3,4,5];

  for(int i in list){
    if(i==4) break;
    print(i);
  }
}

//OUTPUT
1
2
3

Sedangkan continue digunakan untuk melanjutkan pada proses selanjutnya contoh:

//CODE

void main(){
  exContinue();
}

void exContinue(){
  var list =[1,2,3,4,5];
  for(int i in list){
    if(i==4) continue;
    print(i);
  }
}

//OUTPUT
1
2
3
5

Switch and case

Switch adalah pernyataan yang membandingkan integer, string, atau konstanta denna menggunakan ==. Jika Object yang dibandingkan harus semua instance dari class yang sama (dan bukan dari subtipe apapun), dan class tidak boleh override ==. Enumerated types bekerja dengan baik dalam pernyataan Switch.

//CODE
void main() {
  var command = 'OPEN';
  switch (command) {
    case 'CLOSED':
      execute('CLOSED');
      break;
    case 'OPEN':
      execute('OPEN');
      break;
    default:
      execute('FAILED');
  }
}

void execute(String command) {
  print(command);
}

//OUTPUT
OPEN

Assert

Assert biasanya digunakan selama pengembangan, gunakan pernyataan assert – assert (condition, optionalMessage); – untuk melakukan test eksekusi normal jika kondisi boolean false.

// Make sure the variable has a non-null value.
assert(text != null);

// Make sure the value is less than 100.
assert(number < 100);

// Make sure this is an https URL.
assert(urlString.startsWith('https'));

Sample source code can be downloaded on github at the following link    dart-tutorial

Biasanya ketika kita membuat sebuah function maka function yang kita buat memiliki nama seperti getName() atau main() , tetapi kita juka bisa membuat function yang tidak memiliki nama (nameless) disebut anonymous function atau lamda. Contoh kita bisa membuat anonymous function pada variable:

//CODE
void main() {
  var list = ['apples', 'bananas', 'oranges'];
  list.forEach((item) {
    print('${list.indexOf(item)}: $item');
  });
}

//OUTPUT
0: apples
1: bananas
2: oranges

Kita bisa menulis function diatas dengan menggunakan lamda / Arrow funtion

//CODE
void main() {
  var list = ['apples', 'bananas', 'oranges'];
  list.forEach(
    (item) => print('${list.indexOf(item)}: $item'));
}

//OUTPUT
0: apples
1: bananas
2: oranges

Sample source code can be downloaded on github at the following link     dart-tutorial

Kita bisa melakukan parsing paramater dari function ke function lainya contoh :

void main(){
  var list=[1,2,3];
  list.forEach(printElement);
}

void printElement(int element){
  print(element);
}

1
2
3

Sample source code can be downloaded on github at the following link    dart-tutorial

Semua aplikasi/ program harus memilki top level function main(), Dimana berfungsi sebagai entry point sebuah aplikasi / program. main() function mengembalikan void dan bisa memiliki arguments, tetapi sifatnya optional List<String>.

contoh pemnulisan main() tanya paramater

void main(){
   print("Hello Dart");
}

contoh penulisan main() dengan paramater

void main(List<String> args){
  for(String ar in args){
    print(ar);
  }
}

untuk menjalankan program main() yang memiliki arguments kita bisa menjalankannya dengan perintah dart run <nama_file.dart> <paramater>

$dart run main.dart "Jhon" "Cris"

Jhon
Cris

Sample source code can be downloaded on github at the following link    dart-tutorial

Jika subrutin adalah kotak hitam, maka parameter merupakan alat atau untuk memberikan informasi dari dunia luar ke dalam kotak. Parameter merupakan bagian dari antar muka dengan suatu subrutin. Dengan menggunakan parameter, kita dapat mengatur perilaku suatu subrutin sesuai dengan masukan yang diberikan.

Function dapat memiliki sejumlah parameter. Ini dapat diikuti baik dengan Named Paramater atau dengan optional position paramater.

Named Parameter

Membuat sebuah function dengan Named Paramater paramNam:value. Contoh kita akan membuat sebuah function dengan Named Parameter, paramater pertama Bertie String dan parameter kedua int

nama_fucntion (param_1,param_2)

//CODE
void main(){
  printPerson("Jhon", 34);
}

void printPerson(String name, int age){
  print("Name is : $name  age : "+age.toString());
}

//OUTPUT

Name is : Jhon  age : 34

Optional positional paramaters

Membungkus satu set parameter fungsi dalam [] menandainya sebagai parameter posisi opsional:

String say(String from,String msg,[String? device]){
  var result = '$from says $msg';
  if (device != null) {
    result = '$result with a $device';
  }
  return result;
}

mari kita lita dalam function yang kita buat terdapat 3 parameter diamant paramater ke 3 bersifat opsional yaitu setelah tipe data ada tanda tanya ( ? ) ini untuk menhindari error compiler jika paratamer ke3 vernirai null.

//CODE
void main(){
  print("Name is : $name  age : "+age.toString());
}

String say(String from,String msg,[String? device]){
  var result = '$from says $msg';
  if (device != null) {
    result = '$result with a $device';
  }
  return result;
}

Jhon says Hello Dart

Jika kita tidak mengunakan tanda (?) pada paramater ke 3 dan nilainya null maka ketika program kita jalankan maka akan terjadi kesalahan.

//CODE
void main(){
  print("Name is : $name  age : "+age.toString());
}

String say(String from,String msg,[String device]){
  var result = '$from says $msg';
  if (device != null) {
    result = '$result with a $device';
  }
  return result;
}

Error: Optional parameter 'device' should have a default value because its type 'String' doesn't allow null.
String say(String from,String msg,[String device]){

Default Paramater Value

Untuk memebuat sebuah parameter dengan nilai default kita bisa menggunakan = setelah nama paramater param_1 = param_value

//CODE
void main(){
  message(name :"Cris");
}

void message({String name ="Jhon" ,String msg = 'Hello Dart'}){
  print("Name is : $name message :$msg");
}

//OUTPUT
Name is : Cris message :Hello Dart

Sample source code can be downloaded on github at the following link    dart-tutorial