├── .gitignore ├── LICENSE ├── README.md ├── absract_class ├── .gitignore ├── CHANGELOG.md ├── README.md ├── analysis_options.yaml ├── bin │ ├── absract_class.dart │ └── abstract_class2.dart ├── docs │ ├── gomora.png │ ├── kucign3.jpg │ ├── kucing.jpg │ ├── kucing2.jpg │ └── ultra.jpg ├── lib │ ├── character.dart │ ├── flying_monster.dart │ ├── hero.dart │ ├── monster.dart │ ├── monster_burung.dart │ ├── monster_dragon.dart │ └── monster_ubur.dart └── pubspec.yaml ├── aplikasi_pertama ├── .gitignore ├── CHANGELOG.md ├── README.md ├── analysis_options.yaml ├── bin │ └── aplikasi_pertama.dart ├── lib │ └── aplikasi_pertama.dart ├── pubspec.yaml └── test │ └── aplikasi_pertama_test.dart ├── async_await ├── .gitignore ├── CHANGELOG.md ├── README.md ├── analysis_options.yaml ├── bin │ └── async_await.dart ├── lib │ └── async_await.dart └── pubspec.yaml ├── class_objects ├── .gitignore ├── CHANGELOG.md ├── README.md ├── analysis_options.yaml ├── bin │ └── class_objects.dart ├── lib │ └── class_objects.dart ├── pubspec.yaml └── test │ └── class_objects_test.dart ├── constructors ├── .gitignore ├── CHANGELOG.md ├── README.md ├── analysis_options.yaml ├── bin │ ├── constructors.dart │ ├── person.dart │ └── student.dart ├── lib │ └── constructors.dart ├── pubspec.yaml └── test │ └── constructors_test.dart ├── custom_sort ├── .gitignore ├── CHANGELOG.md ├── README.md ├── analysis_options.yaml ├── bin │ ├── custom_sort.dart │ ├── custom_sort2.dart │ └── custom_sort3.dart ├── lib │ └── custom_sort.dart └── pubspec.yaml ├── dynamic_vars ├── .gitignore ├── CHANGELOG.md ├── README.md ├── analysis_options.yaml ├── bin │ └── dynamic_vars.dart ├── lib │ └── dynamic_vars.dart ├── pubspec.yaml └── test │ └── dynamic_vars_test.dart ├── enkapsulasi ├── .gitignore ├── CHANGELOG.md ├── README.md ├── analysis_options.yaml ├── bin │ └── enkapsulasi.dart ├── lib │ └── enkapsulasi.dart └── pubspec.yaml ├── enums ├── .gitignore ├── CHANGELOG.md ├── README.md ├── analysis_options.yaml ├── bin │ └── enums.dart ├── lib │ └── enums.dart └── pubspec.yaml ├── final_const ├── .gitignore ├── CHANGELOG.md ├── README.md ├── analysis_options.yaml ├── bin │ └── final_const.dart ├── lib │ └── final_const.dart ├── pubspec.yaml └── test │ └── final_const_test.dart ├── fungsi ├── .gitignore ├── CHANGELOG.md ├── README.md ├── analysis_options.yaml ├── bin │ ├── _contohdefault_params.dart │ ├── anon_func.dart │ ├── anon_func2.dart │ ├── bentuk_pemanggilan.dart │ ├── contoh_lamda.dart │ ├── contoh_void.dart │ ├── func_params.dart │ ├── fungsi.dart │ ├── name_params_case.dart │ ├── opti_name_params.dart │ ├── opti_posisi_params.dart │ └── optiname_ver2.dart ├── docs │ └── resep_es_rumput_laut_2.jpg ├── lib │ └── fungsi.dart ├── pubspec.yaml └── test │ └── fungsi_test.dart ├── furure_or ├── .gitignore ├── CHANGELOG.md ├── README.md ├── analysis_options.yaml ├── bin │ └── furure_or.dart ├── lib │ └── furure_or.dart ├── pubspec.yaml └── test │ └── furure_or_test.dart ├── generic ├── .gitignore ├── CHANGELOG.md ├── README.md ├── analysis_options.yaml ├── bin │ └── generic.dart ├── lib │ ├── generic.dart │ └── secure_box.dart └── pubspec.yaml ├── inherit ├── .gitignore ├── CHANGELOG.md ├── README.md ├── analysis_options.yaml ├── bin │ ├── inherit.dart │ └── new_inherit.dart ├── lib │ ├── character.dart │ ├── hero.dart │ ├── monster.dart │ ├── monster_burung.dart │ └── monster_ubur.dart └── pubspec.yaml ├── mapping ├── .gitignore ├── CHANGELOG.md ├── README.md ├── analysis_options.yaml ├── bin │ ├── conttains.dart │ ├── every.dart │ ├── filtering.dart │ ├── kosong.dart │ ├── loops_mapping.dart │ ├── manual_sort.dart │ ├── mapping.dart │ ├── new_mapping.dart │ ├── new_mapping2.dart │ ├── sets.dart │ ├── sorting_list.dart │ └── subslist.dart ├── lib │ └── mapping.dart ├── pubspec.yaml └── test │ └── mapping_test.dart ├── mixins ├── .gitignore ├── CHANGELOG.md ├── README.md ├── analysis_options.yaml ├── bin │ └── mixins.dart ├── lib │ ├── character.dart │ ├── drink_ability_mixins.dart │ ├── flying_monster.dart │ ├── hero.dart │ ├── kinshi.dart │ ├── monster.dart │ ├── monster_burung.dart │ ├── monster_dragon.dart │ ├── monster_ubur.dart │ └── shogun.dart └── pubspec.yaml ├── operator_overriding ├── .gitignore ├── CHANGELOG.md ├── README.md ├── analysis_options.yaml ├── bin │ └── operator_overriding.dart ├── lib │ └── operator_overriding.dart └── pubspec.yaml ├── percabangan ├── .gitignore ├── CHANGELOG.md ├── README.md ├── analysis_options.yaml ├── bin │ ├── assign_var.dart │ ├── penyingkatan.dart │ ├── percabangan.dart │ └── switchdarts.dart ├── docs │ └── img │ │ └── switch.png ├── lib │ └── percabangan.dart ├── pubspec.yaml └── test │ └── percabangan_test.dart ├── perulangan ├── .gitignore ├── CHANGELOG.md ├── README.md ├── analysis_options.yaml ├── bin │ ├── perulangan.dart │ ├── perulangan_do_while.dart │ ├── perulangan_while.dart │ ├── unary_operator.dart │ └── unary_trick.dart ├── lib │ └── perulangan.dart ├── pubspec.yaml └── test │ └── perulangan_test.dart ├── reuireds ├── .gitignore ├── CHANGELOG.md ├── README.md ├── analysis_options.yaml ├── bin │ └── reuireds.dart ├── lib │ └── reuireds.dart ├── pubspec.yaml └── test │ └── reuireds_test.dart ├── singleton ├── .gitignore ├── CHANGELOG.md ├── README.md ├── analysis_options.yaml ├── bin │ ├── services.dart │ ├── singleton.dart │ └── user.dart ├── lib │ └── singleton.dart ├── pubspec.yaml └── test │ └── singleton_test.dart ├── solid_principle ├── .gitignore ├── CHANGELOG.md ├── README.md ├── analysis_options.yaml ├── bin │ ├── ConnectDB.dart │ ├── interfacing.dart │ ├── listkov.dart │ ├── openclosed.dart │ ├── solid.dart │ └── solid_principle.dart ├── lib │ └── solid_principle.dart └── pubspec.yaml ├── static_keywords ├── .gitignore ├── CHANGELOG.md ├── README.md ├── analysis_options.yaml ├── bin │ └── static_keywords.dart ├── lib │ └── static_keywords.dart └── pubspec.yaml └── underscore_parameter ├── .gitignore ├── CHANGELOG.md ├── README.md ├── analysis_options.yaml ├── bin └── underscore_parameter.dart ├── lib └── underscore_parameter.dart └── pubspec.yaml /.gitignore: -------------------------------------------------------------------------------- 1 | # See https://www.dartlang.org/guides/libraries/private-files 2 | 3 | # Files and directories created by pub 4 | .dart_tool/ 5 | .packages 6 | build/ 7 | # If you're building an application, you may want to check-in your pubspec.lock 8 | pubspec.lock 9 | 10 | # Directory created by dartdoc 11 | # If you don't generate documentation locally you can remove this line. 12 | doc/api/ 13 | 14 | # Avoid committing generated Javascript files: 15 | *.dart.js 16 | *.info.json # Produced by the --dump-info flag. 17 | *.js # When generated by dart2js. Don't specify *.js if your 18 | # project includes source files written in JavaScript. 19 | *.js_ 20 | *.js.deps 21 | *.js.map 22 | .idea/ 23 | .vscode/ 24 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2021 Feri Lukmansyah 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # mastering-dart 2 | Repo for Teach Yourself mastering dart programming language 3 | 4 | ## Chapter 5 | 6 | 1. [Membuat Aplikasi Pertama Menggunakan Dart](aplikasi_pertama/README.md) 7 | 2. [Percabangan](percabangan/README.md) 8 | 3. [Perulangan](perulangan/README.md) 9 | 4. [Fungsi, Parameter dan lambda Expression](fungsi/README.md) 10 | 5. [List, Set dan Mapping](mapping/README.md) 11 | 6. [Class dan Object](class_objects/README.md) 12 | 7. [Enkapsulasi](enkapsulasi/README.md) 13 | 8. [Pewarisan/Inheritence, keyword `is` dan`as` ](inherit/README.md) 14 | 9. [Abstract Class dan Interface](absract_class/README.md) 15 | 10. [Mixins](mixins/README.md) 16 | 11. [Constructor](constructors/README.md) 17 | 12. [Parameter Underscore](underscore_parameter/README.md) 18 | 13. [Static Keywords](static_keywords/README.md) 19 | 14. [Async Await dan Future](async_await/README.md) 20 | 15. [Final dan Const](final_const/README.md) 21 | 16. [Generic dan Generic Type](generic/README.md) 22 | 17. [Enum dan Cascade Notation](enums/README.md) 23 | 18. [Required, Assert dan Try Catch](reuireds/README.md) 24 | 19. [Custom Sort dan ForEach](custom_sort/README.md) 25 | 20. [Solid Principle](solid_principle/README.md) 26 | 21. [Operator Override](operator_overriding/README.md) 27 | 22. [Singleton](singleton/README.md) 28 | 23. [Future Or](furure_or/README.md) 29 | 24. [tipe data `dynamic` dan `var`](dynamic_vars/README.md) <- update tgl: 14 juli 2021 30 | 31 | 32 | ### Referensi dan Sumber Belajar 33 | 34 | #### Flutter 35 | 36 | * Channel youtube (rekomendasi) : https://www.youtube.com/user/kh3w4nx1ng 37 | * Dokumentasi Flutter: https://flutter.dev/docs 38 | * Komunitas flutter (telegram): https://t.me/flutter_id 39 | * Artikel update: https://t.me/flutterDev 40 | * Forum Diskusi: https://github.com/flutter/flutter 41 | * Medium Publisher: https://medium.com/flutter-community 42 | 43 | #### Dart 44 | * [Dokumentasi Dart](https://dart.dev/guides/) 45 | * [playlist untuk belajar dart](https://www.youtube.com/playlist?list=PLZQbl9Jhl-VDeCuNNp7C2SR1lFsIjQRQo) 46 | -------------------------------------------------------------------------------- /absract_class/.gitignore: -------------------------------------------------------------------------------- 1 | # Files and directories created by pub. 2 | .dart_tool/ 3 | .packages 4 | 5 | # Conventional directory for build output. 6 | build/ 7 | -------------------------------------------------------------------------------- /absract_class/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.0 2 | 3 | - Initial version. 4 | -------------------------------------------------------------------------------- /absract_class/README.md: -------------------------------------------------------------------------------- 1 | ### Abstract Class dan Interface 2 | 3 | --- 4 | 5 | ### Abstract Class 6 | 7 | adalah `class` yang tidak bisa dibuat object, nah class ini biasa digunakan sebagai class dasar (*template*) 8 | cara penggunaan nya cukup inherit/wariskan kepada `class` lain 9 | 10 | #### Analogi 11 | 12 | klo diibaratkan analogi abstract class itu seperti bentuk umum suatu object katakanlah `kucing` 13 | 14 | ![jenis kucing](docs/kucing.jpg) 15 | 16 | nah kucing kan ada berbagai jenis misalnya 17 | 18 | * anggora 19 | * persia 20 | 21 | ![kucin2](docs/kucing2.jpg) 22 | 23 | kalo kita ingin katakan jenis kucing secara spesifik misalnya `kucing anggora` nah kata kucing ini harusnya 24 | terdapat berbagai jenis dan kita tidak bisa langsung menyimpulkan itu kucing (*kalo pengen spesifik*) 25 | 26 | sama juga berlaku untuk `class` kita ga bisa langsung membuat object yang menyatakan itu adalah `Monster` 27 | tanpa mengetahui jenisnya 28 | 29 | ![abstract kucing](docs/kucign3.jpg) 30 | 31 | nah untuk itu kita perlu membuat `abstract class` agar si class induk tidak bisa dibuat object 32 | tapi harus diwariskan dulu agar bisa dipake di class lain 33 | 34 | contohnya 35 | 36 | ```dart 37 | // tampung object 38 | List monsters = []; 39 | 40 | // add object 41 | monsters.add(MonsterUbur()); 42 | monsters.add(MonsterBurung()); 43 | monsters.add(Monster()); 44 | ``` 45 | 46 | lengkapnya 47 | 48 | ```dart 49 | import 'package:absract_class/hero.dart'; 50 | import 'package:absract_class/monster.dart'; 51 | import 'package:absract_class/monster_burung.dart'; 52 | import 'package:absract_class/monster_ubur.dart'; 53 | 54 | void main(List arguments) { 55 | Hero hero = new Hero(); 56 | Monster m = new MonsterBurung(); 57 | 58 | // objects baru 59 | MonsterUbur ubur = new MonsterUbur(); 60 | MonsterBurung burung = new MonsterBurung(); 61 | 62 | // tampung object 63 | List monsters = []; 64 | 65 | // add object 66 | monsters.add(MonsterUbur()); 67 | monsters.add(MonsterBurung()); 68 | monsters.add(Monster()); 69 | 70 | // keyword as 71 | print('monster burung'); 72 | print((m as MonsterBurung).fly()); 73 | 74 | for (Monster monster in monsters) { 75 | if (monster is MonsterBurung) { 76 | print(monster.eatHuman()); 77 | } 78 | } 79 | } 80 | ``` 81 | 82 | kita buat object dari class `Monster` bisa karena blom di abstract 83 | 84 | hasilnya 85 | 86 | ``` 87 | monster burung 88 | woosh 89 | yummy 90 | ``` 91 | beda lagi klo kita ubah class monsternya kaya gini 92 | 93 | ```dart 94 | import 'package:absract_class/character.dart'; 95 | 96 | abstract class Monster extends Character { 97 | String eatHuman() => 'yummy'; 98 | } 99 | ``` 100 | 101 | dan kita jalankan lagi hasilnya pasti error 102 | 103 | ``` 104 | bin/absract_class.dart:20:16: Error: The class 'Monster' is abstract and can't be instantiated. 105 | monsters.add(Monster()); 106 | ^^^^^^^ 107 | ``` 108 | 109 | > Note: karena class `Monster` difungsikan sebagai template maka ga wajib punya `method` yang ada 110 | > implementasinya 111 | 112 | studi kasusnya ketika kita lihat class `monster`, setiap monster pasti bisa berjalan kan dan caranya pasti beda beda 113 | nah dalam `abstract class` kita bisa tambah method misalnya `move()` tapi kita ga beri implentasi si method ini harus ngapain 114 | 115 | ![gomora](docs/gomora.png) 116 | 117 | ![ultraman](docs/ultra.jpg) 118 | 119 | ```dart 120 | import 'package:absract_class/character.dart'; 121 | 122 | abstract class Monster extends Character { 123 | String eatHuman() => 'yummy'; 124 | String move(); 125 | } 126 | ``` 127 | nah implementasi methodnya di class yang mewarisi `class monster` nanti 128 | 129 | nah sekarang kita ubah semua turunan dari class `Monster` mengoverride method dari si `Monster` menggunakan 130 | `@override` 131 | 132 | ```dart 133 | // lib/monster_burung.dart 134 | 135 | import 'package:absract_class/monster.dart'; 136 | 137 | class MonsterBurung extends Monster { 138 | String fly() { 139 | return 'woosh'; 140 | } 141 | 142 | @override 143 | String move() { 144 | return 'pake sayap'; 145 | } 146 | } 147 | ``` 148 | 149 | ```dart 150 | // lib/monster_ubur.dart 151 | 152 | import 'package:absract_class/monster.dart'; 153 | 154 | class MonsterUbur extends Monster { 155 | String berenang () => 'slup slup'; 156 | 157 | @override 158 | String move() { 159 | return 'berenang renang'; 160 | } 161 | } 162 | ``` 163 | 164 | nah klo kita panggil 165 | 166 | ```dart 167 | for (Monster monster in monsters) { 168 | if (monster is MonsterBurung) { 169 | print(monster.eatHuman()); 170 | print('cara jalan'); 171 | print(monster.move()); 172 | } 173 | } 174 | ``` 175 | 176 | lengkapnya 177 | 178 | ```dart 179 | import 'package:absract_class/hero.dart'; 180 | import 'package:absract_class/monster.dart'; 181 | import 'package:absract_class/monster_burung.dart'; 182 | import 'package:absract_class/monster_ubur.dart'; 183 | 184 | void main(List arguments) { 185 | Hero hero = new Hero(); 186 | Monster m = new MonsterBurung(); 187 | 188 | // objects baru 189 | MonsterUbur ubur = new MonsterUbur(); 190 | MonsterBurung burung = new MonsterBurung(); 191 | 192 | // tampung object 193 | List monsters = []; 194 | 195 | // add object 196 | monsters.add(MonsterUbur()); 197 | monsters.add(MonsterBurung()); 198 | // keyword as 199 | print('monster burung'); 200 | print((m as MonsterBurung).fly()); 201 | 202 | for (Monster monster in monsters) { 203 | if (monster is MonsterBurung) { 204 | print(monster.eatHuman()); 205 | print('cara jalan'); 206 | print(monster.move()); 207 | } 208 | } 209 | } 210 | ``` 211 | 212 | hasilnya 213 | 214 | ``` 215 | monster burung 216 | woosh 217 | yummy 218 | cara jalan 219 | pake sayap 220 | ``` 221 | 222 | disini kita bisa juga override method sudah ada implementasinya contoh 223 | 224 | ```dart 225 | // new object 226 | @override 227 | String eatHuman() { 228 | return 'sruput'; 229 | } 230 | ``` 231 | 232 | lengkap implementasinya bisa disini 233 | 234 | ```dart 235 | import 'package:absract_class/monster.dart'; 236 | 237 | class MonsterBurung extends Monster { 238 | String fly() { 239 | return 'woosh'; 240 | } 241 | 242 | @override 243 | String move() { 244 | return 'pake sayap'; 245 | } 246 | 247 | // new object 248 | @override 249 | String eatHuman() { 250 | return 'sruput'; 251 | } 252 | } 253 | ``` 254 | 255 | ketika dijalankan hasilnya 256 | 257 | ``` 258 | monster burung 259 | woosh 260 | sruput 261 | cara jalan 262 | pake sayap 263 | ``` 264 | ### Interface 265 | 266 | sama seperti `abstract class` `interface` adalah template untuk mengumpulkan method/property yang 267 | harus dimiliki oleh `class` yang mengimplement interface tadi 268 | 269 | dalam bahasa dart ga punya interface nah untuk membuatnya kita bisa buat `abstract class` seperti ini 270 | 271 | ```dart 272 | abstract class FlyingMonster { 273 | String fly(); 274 | } 275 | ``` 276 | 277 | kemudian kita buat class monster baru 278 | 279 | ```dart 280 | import 'package:absract_class/flying_monster.dart'; 281 | import 'package:absract_class/monster_ubur.dart'; 282 | 283 | class MonsterDragon extends MonsterUbur implements FlyingMonster { 284 | @override 285 | String fly() { 286 | return 'terbang tinggi grr!!!'; 287 | } 288 | } 289 | 290 | ``` 291 | 292 | kemudian kita add ke list seperti ini 293 | 294 | ```dart 295 | 296 | ``` 297 | 298 | ### Apa Bedanya? 299 | 300 | sebuah `class` hanya bisa `extends` dari satu parrent class aja, klo `implements` bisa banyak `interface` 301 | 302 | contoh 303 | 304 | ```dart 305 | // lib/flying_monster.dart 306 | 307 | abstract class FlyingMonster { 308 | String fly(); 309 | } 310 | 311 | abstract class DemonSlayer { 312 | String killerDemons(); 313 | } 314 | ``` 315 | 316 | kemudian kita implements 317 | 318 | ```dart 319 | // lib/monster_dragon.dart 320 | 321 | import 'package:absract_class/flying_monster.dart'; 322 | import 'package:absract_class/monster_ubur.dart'; 323 | 324 | class MonsterDragon extends MonsterUbur implements FlyingMonster, DemonSlayer { 325 | @override 326 | String fly() { 327 | return 'terbang tinggi grr!!!'; 328 | } 329 | 330 | @override 331 | String killerDemons() { 332 | return 'Demon is a weak grr'; 333 | } 334 | } 335 | 336 | ``` 337 | 338 | --- 339 | 340 | [inheritance](../inherit/README.md) <> [Mixins](../mixins/README.md) 341 | -------------------------------------------------------------------------------- /absract_class/analysis_options.yaml: -------------------------------------------------------------------------------- 1 | # Defines a default set of lint rules enforced for projects at Google. For 2 | # details and rationale, see 3 | # https://github.com/dart-lang/pedantic#enabled-lints. 4 | 5 | include: package:pedantic/analysis_options.yaml 6 | 7 | # For lint rules and documentation, see http://dart-lang.github.io/linter/lints. 8 | 9 | # Uncomment to specify additional rules. 10 | # linter: 11 | # rules: 12 | # - camel_case_types 13 | 14 | # analyzer: 15 | # exclude: 16 | # - path/to/excluded/files/** 17 | -------------------------------------------------------------------------------- /absract_class/bin/absract_class.dart: -------------------------------------------------------------------------------- 1 | import 'package:absract_class/hero.dart'; 2 | import 'package:absract_class/monster.dart'; 3 | import 'package:absract_class/monster_burung.dart'; 4 | import 'package:absract_class/monster_ubur.dart'; 5 | 6 | void main(List arguments) { 7 | Hero hero = new Hero(); 8 | Monster m = new MonsterBurung(); 9 | 10 | // objects baru 11 | MonsterUbur ubur = new MonsterUbur(); 12 | MonsterBurung burung = new MonsterBurung(); 13 | 14 | // tampung object 15 | List monsters = []; 16 | 17 | // add object 18 | monsters.add(MonsterUbur()); 19 | monsters.add(MonsterBurung()); 20 | // keyword as 21 | print('monster burung'); 22 | print((m as MonsterBurung).fly()); 23 | 24 | for (Monster monster in monsters) { 25 | if (monster is MonsterBurung) { 26 | print(monster.eatHuman()); 27 | print('cara jalan'); 28 | print(monster.move()); 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /absract_class/bin/abstract_class2.dart: -------------------------------------------------------------------------------- 1 | import 'package:absract_class/flying_monster.dart'; 2 | import 'package:absract_class/hero.dart'; 3 | import 'package:absract_class/monster.dart'; 4 | import 'package:absract_class/monster_burung.dart'; 5 | import 'package:absract_class/monster_dragon.dart'; 6 | import 'package:absract_class/monster_ubur.dart'; 7 | 8 | void main(List arguments) { 9 | Hero hero = new Hero(); 10 | Monster m = new MonsterBurung(); 11 | 12 | // objects baru 13 | MonsterUbur ubur = new MonsterUbur(); 14 | MonsterBurung burung = new MonsterBurung(); 15 | 16 | // tampung object 17 | List monsters = []; 18 | 19 | // add object 20 | monsters.add(MonsterUbur()); 21 | monsters.add(MonsterBurung()); 22 | monsters.add(MonsterDragon()); 23 | // keyword as 24 | print('monster burung'); 25 | print((m as MonsterBurung).fly()); 26 | 27 | for (Monster monster in monsters) { 28 | if (monster is FlyingMonster) { 29 | print((monster as FlyingMonster).fly()); 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /absract_class/docs/gomora.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/perymerdeka/mastering-dart/5eee63cbc6c9df07e9454f89cd3e2cbccc07eb40/absract_class/docs/gomora.png -------------------------------------------------------------------------------- /absract_class/docs/kucign3.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/perymerdeka/mastering-dart/5eee63cbc6c9df07e9454f89cd3e2cbccc07eb40/absract_class/docs/kucign3.jpg -------------------------------------------------------------------------------- /absract_class/docs/kucing.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/perymerdeka/mastering-dart/5eee63cbc6c9df07e9454f89cd3e2cbccc07eb40/absract_class/docs/kucing.jpg -------------------------------------------------------------------------------- /absract_class/docs/kucing2.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/perymerdeka/mastering-dart/5eee63cbc6c9df07e9454f89cd3e2cbccc07eb40/absract_class/docs/kucing2.jpg -------------------------------------------------------------------------------- /absract_class/docs/ultra.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/perymerdeka/mastering-dart/5eee63cbc6c9df07e9454f89cd3e2cbccc07eb40/absract_class/docs/ultra.jpg -------------------------------------------------------------------------------- /absract_class/lib/character.dart: -------------------------------------------------------------------------------- 1 | class Character { 2 | late int _healthPoint; 3 | 4 | int get healthPoint => _healthPoint; 5 | set healthPoint(int value) { 6 | if (value < 0) { 7 | value *= -1; 8 | } 9 | 10 | _healthPoint = value; 11 | } 12 | } -------------------------------------------------------------------------------- /absract_class/lib/flying_monster.dart: -------------------------------------------------------------------------------- 1 | abstract class FlyingMonster { 2 | String fly(); 3 | } 4 | 5 | abstract class DemonSlayer { 6 | String killerDemons(); 7 | } -------------------------------------------------------------------------------- /absract_class/lib/hero.dart: -------------------------------------------------------------------------------- 1 | import 'package:absract_class/character.dart'; 2 | 3 | class Hero extends Character { 4 | 5 | String killAllMonster() => 'take this'; 6 | } -------------------------------------------------------------------------------- /absract_class/lib/monster.dart: -------------------------------------------------------------------------------- 1 | import 'package:absract_class/character.dart'; 2 | 3 | abstract class Monster extends Character { 4 | String eatHuman() => 'yummy'; 5 | String move(); 6 | } 7 | -------------------------------------------------------------------------------- /absract_class/lib/monster_burung.dart: -------------------------------------------------------------------------------- 1 | import 'package:absract_class/monster.dart'; 2 | 3 | class MonsterBurung extends Monster { 4 | String fly() { 5 | return 'woosh'; 6 | } 7 | 8 | @override 9 | String move() { 10 | return 'pake sayap'; 11 | } 12 | 13 | // new object 14 | @override 15 | String eatHuman() { 16 | return 'sruput'; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /absract_class/lib/monster_dragon.dart: -------------------------------------------------------------------------------- 1 | import 'package:absract_class/flying_monster.dart'; 2 | import 'package:absract_class/monster_ubur.dart'; 3 | 4 | class MonsterDragon extends MonsterUbur implements FlyingMonster, DemonSlayer { 5 | @override 6 | String fly() { 7 | return 'terbang tinggi grr!!!'; 8 | } 9 | 10 | @override 11 | String killerDemons() { 12 | return 'Demon is a weak grr'; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /absract_class/lib/monster_ubur.dart: -------------------------------------------------------------------------------- 1 | import 'package:absract_class/monster.dart'; 2 | 3 | class MonsterUbur extends Monster { 4 | String berenang () => 'slup slup'; 5 | 6 | @override 7 | String move() { 8 | return 'berenang renang'; 9 | } 10 | } -------------------------------------------------------------------------------- /absract_class/pubspec.yaml: -------------------------------------------------------------------------------- 1 | name: absract_class 2 | description: A sample command-line application. 3 | version: 1.0.0 4 | # homepage: https://www.example.com 5 | 6 | environment: 7 | sdk: '>=2.12.0 <3.0.0' 8 | 9 | # dependencies: 10 | # path: ^1.8.0 11 | 12 | dev_dependencies: 13 | pedantic: ^1.10.0 14 | test: ^1.16.0 15 | -------------------------------------------------------------------------------- /aplikasi_pertama/.gitignore: -------------------------------------------------------------------------------- 1 | # Files and directories created by pub. 2 | .dart_tool/ 3 | .packages 4 | 5 | # Conventional directory for build output. 6 | build/ 7 | -------------------------------------------------------------------------------- /aplikasi_pertama/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.0 2 | 3 | - Initial version. 4 | -------------------------------------------------------------------------------- /aplikasi_pertama/README.md: -------------------------------------------------------------------------------- 1 | ### Membuat Aplikasi Pertama Menggunakan Dart 2 | 3 | --- 4 | 5 | chapter pertama kali ini akan membuat aplikasi pertama menggunakan dart 6 | 7 | pastikan menginstall IDE versi comunity dan mencari plugin di market place pilih `dart` dan `flutter`. 8 | 9 | ### Resource Instalasi Dart SDK 10 | 11 | * [Setting SDK dart di android studio](https://www.devopsschool.com/blog/error-dart-sdk-is-not-configured-in-android-studio/) 12 | * [Dart SDK](https://dart.dev/get-dart) 13 | * [InteliJ IDEA](https://www.jetbrains.com/idea/) 14 | * [Dokumentasi Dart](https://dart.dev/guides/) 15 | 16 | --- 17 | 18 | [project root](../README.md) <> [Chapter 2: Percabangan]() 19 | -------------------------------------------------------------------------------- /aplikasi_pertama/analysis_options.yaml: -------------------------------------------------------------------------------- 1 | # Defines a default set of lint rules enforced for projects at Google. For 2 | # details and rationale, see 3 | # https://github.com/dart-lang/pedantic#enabled-lints. 4 | 5 | include: package:pedantic/analysis_options.yaml 6 | 7 | # For lint rules and documentation, see http://dart-lang.github.io/linter/lints. 8 | 9 | # Uncomment to specify additional rules. 10 | # linter: 11 | # rules: 12 | # - camel_case_types 13 | 14 | # analyzer: 15 | # exclude: 16 | # - path/to/excluded/files/** 17 | -------------------------------------------------------------------------------- /aplikasi_pertama/bin/aplikasi_pertama.dart: -------------------------------------------------------------------------------- 1 | import 'dart:io'; 2 | 3 | void main(List arguments) { 4 | String? input = stdin.readLineSync(); 5 | 6 | // konversi type data 7 | int? number = int.tryParse(input!); 8 | 9 | 10 | // menampikna ke layar 11 | print(number! + 12); 12 | } 13 | -------------------------------------------------------------------------------- /aplikasi_pertama/lib/aplikasi_pertama.dart: -------------------------------------------------------------------------------- 1 | int calculate() { 2 | return 6 * 7; 3 | } 4 | -------------------------------------------------------------------------------- /aplikasi_pertama/pubspec.yaml: -------------------------------------------------------------------------------- 1 | name: aplikasi_pertama 2 | description: A sample command-line application. 3 | version: 1.0.0 4 | # homepage: https://www.example.com 5 | 6 | environment: 7 | sdk: '>=2.12.0 <3.0.0' 8 | 9 | # dependencies: 10 | # path: ^1.8.0 11 | 12 | dev_dependencies: 13 | pedantic: ^1.10.0 14 | test: ^1.16.0 15 | -------------------------------------------------------------------------------- /aplikasi_pertama/test/aplikasi_pertama_test.dart: -------------------------------------------------------------------------------- 1 | import 'package:test/test.dart'; 2 | 3 | void main() { 4 | test('calculate', () { 5 | // expect(calculate(), 42); 6 | }); 7 | } 8 | -------------------------------------------------------------------------------- /async_await/.gitignore: -------------------------------------------------------------------------------- 1 | # Files and directories created by pub. 2 | .dart_tool/ 3 | .packages 4 | 5 | # Conventional directory for build output. 6 | build/ 7 | -------------------------------------------------------------------------------- /async_await/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.0 2 | 3 | - Initial version. 4 | -------------------------------------------------------------------------------- /async_await/README.md: -------------------------------------------------------------------------------- 1 | ### Async Await dan Future 2 | 3 | 4 | ### `Future` 5 | 6 | `Future` ini biasa digunakan untuk menunjukan sebuah hasil method ga akan langsung ke return 7 | 8 | contoh 9 | 10 | ```dart 11 | // method async 12 | Future getDataAsync() async { 13 | // buat delay 14 | await Future.delayed(Duration(seconds: 3)); 15 | ``` 16 | jadi kita nunggu `Future.delayed` selesai baru dieksekusi method berikutnya karena kita pasang `await` 17 | 18 | lalu kita buat `main` nya seperti ini 19 | 20 | ```dart 21 | import 'package:async_await/async_await.dart'; 22 | 23 | void main(List arguments) async { 24 | var p = Person(); 25 | print('job 1'); 26 | print('job 2'); 27 | p.getDataAsync().then((_) => {print('job3: ' + p.name)}); 28 | print('job4'); 29 | } 30 | ``` 31 | 32 | kalo kita jalankan hasilnya `job3` akan ditunggu sekama 3 detik karena pake `then` 33 | 34 | hasilnya 35 | 36 | ``` 37 | job 1 38 | job 2 39 | job4 40 | get data done 41 | job3: joko // ini akan ditungu 3 detik 42 | ``` 43 | 44 | ### Referensi dan Sumber Belajar 45 | 46 | * [asynchronous support](https://dart.dev/guides/language/language-tour#asynchrony-support) 47 | 48 | --- 49 | 50 | [static keywords](../static_keywords/README.md) <> [Final dan Const](../final_const/README.md) -------------------------------------------------------------------------------- /async_await/analysis_options.yaml: -------------------------------------------------------------------------------- 1 | # Defines a default set of lint rules enforced for projects at Google. For 2 | # details and rationale, see 3 | # https://github.com/dart-lang/pedantic#enabled-lints. 4 | 5 | include: package:pedantic/analysis_options.yaml 6 | 7 | # For lint rules and documentation, see http://dart-lang.github.io/linter/lints. 8 | 9 | # Uncomment to specify additional rules. 10 | # linter: 11 | # rules: 12 | # - camel_case_types 13 | 14 | # analyzer: 15 | # exclude: 16 | # - path/to/excluded/files/** 17 | -------------------------------------------------------------------------------- /async_await/bin/async_await.dart: -------------------------------------------------------------------------------- 1 | import 'package:async_await/async_await.dart'; 2 | 3 | void main(List arguments) async { 4 | var p = Person(); 5 | print('job 1'); 6 | print('job 2'); 7 | p.getDataAsync().then((_) => {print('job3: ' + p.name)}); 8 | print('job4'); 9 | } 10 | -------------------------------------------------------------------------------- /async_await/lib/async_await.dart: -------------------------------------------------------------------------------- 1 | class Person { 2 | String name = 'default name'; 3 | 4 | void getData() { 5 | name = 'joko'; 6 | print('get data done'); 7 | } 8 | 9 | // method async 10 | Future getDataAsync() async { 11 | // buat delay 12 | await Future.delayed(Duration(seconds: 3)); 13 | 14 | name = 'joko'; 15 | print('get data done'); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /async_await/pubspec.yaml: -------------------------------------------------------------------------------- 1 | name: async_await 2 | description: A sample command-line application. 3 | version: 1.0.0 4 | # homepage: https://www.example.com 5 | 6 | environment: 7 | sdk: '>=2.12.0 <3.0.0' 8 | 9 | # dependencies: 10 | # path: ^1.8.0 11 | 12 | dev_dependencies: 13 | pedantic: ^1.10.0 14 | test: ^1.16.0 15 | -------------------------------------------------------------------------------- /class_objects/.gitignore: -------------------------------------------------------------------------------- 1 | # Files and directories created by pub. 2 | .dart_tool/ 3 | .packages 4 | 5 | # Conventional directory for build output. 6 | build/ 7 | -------------------------------------------------------------------------------- /class_objects/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.0 2 | 3 | - Initial version. 4 | -------------------------------------------------------------------------------- /class_objects/README.md: -------------------------------------------------------------------------------- 1 | ### Paradigma OOP 2 | 3 | *Objects Orented Programming* adalah paradigma pemrograman dimana kita membuat sebuah sistem tang terdiri dari beberapa object yang saling berinteraksi 4 | 5 | beberapa yang harus dikehaui tentang OOP yaitu adalah 6 | 7 | * class 8 | * Constructor 9 | * Method 10 | 11 | #### Class 12 | 13 | `Class` sendiri adalah `blueprint` dari suatu object 14 | kalo dianalogikan seperti sketsa pada sebuah lukisan 15 | 16 | #### Field 17 | 18 | segala sesuatu yang dimiliki `class` 19 | 20 | #### method 21 | 22 | adalah apa yang dapat dilakukan oleh si `class` itu sendiri 23 | 24 | #### Object 25 | 26 | adalah bentuk realisasi atau bentuk nyata dari `class` 27 | 28 | #### identifier 29 | 30 | adalah itentitas dari sebuah `class` agar si `class` dapat dipanggil 31 | 32 | > ketika `identifier` tidak merujuk object apapun maka nilainya `null` 33 | 34 | contoh pembuatan `class` seperti ini 35 | 36 | ```dart 37 | main(List args) { 38 | PersegiPanjang kotak1, kotak2; 39 | 40 | // membuat object 41 | kotak1 = new PersegiPanjang(); 42 | kotak2 = new PersegiPanjang(); 43 | 44 | kotak1.lebar = 10; 45 | kotak1.panjang = 2; 46 | 47 | // kotak 2 48 | kotak2.lebar = 10; 49 | kotak2.panjang = 2; 50 | 51 | // hitung luas kotak 52 | double luasKotak = kotak1.hitungLuas(); 53 | 54 | // luas kotak 2 55 | double luasKotak2 = kotak2.hitungLuas(); 56 | 57 | // cetak hasil; 58 | print(luasKotak); 59 | print(luasKotak2); 60 | } 61 | 62 | class PersegiPanjang { 63 | late double panjang; 64 | late double lebar; 65 | 66 | double hitungLuas() { 67 | return this.panjang * this.lebar; 68 | } 69 | } 70 | ``` 71 | output 72 | 73 | ``` 74 | 20.0 75 | 20.0 76 | ``` 77 | 78 | disini kita membuat method `hitungLuas()` untuk menghitung luas persegi panjang. 79 | 80 | > Note: keyword `new` dan `this` itu sunnah jadi boleh ditambahkan dan bolehh tidak 81 | 82 | 83 | ### Referensi dan Resource 84 | 85 | * [dokumentasi](https://dart.dev/guides/language/language-tou) 86 | 87 | --- 88 | 89 | [List dan Mapping](../mapping/README.md) <> [Enkapsulasi](../enkapsulasi/README.md) 90 | -------------------------------------------------------------------------------- /class_objects/analysis_options.yaml: -------------------------------------------------------------------------------- 1 | # Defines a default set of lint rules enforced for projects at Google. For 2 | # details and rationale, see 3 | # https://github.com/dart-lang/pedantic#enabled-lints. 4 | 5 | include: package:pedantic/analysis_options.yaml 6 | 7 | # For lint rules and documentation, see http://dart-lang.github.io/linter/lints. 8 | 9 | # Uncomment to specify additional rules. 10 | # linter: 11 | # rules: 12 | # - camel_case_types 13 | 14 | # analyzer: 15 | # exclude: 16 | # - path/to/excluded/files/** 17 | -------------------------------------------------------------------------------- /class_objects/bin/class_objects.dart: -------------------------------------------------------------------------------- 1 | main(List args) { 2 | PersegiPanjang kotak1, kotak2; 3 | 4 | // membuat object 5 | kotak1 = new PersegiPanjang(); 6 | kotak2 = new PersegiPanjang(); 7 | 8 | kotak1.lebar = 10; 9 | kotak1.panjang = 2; 10 | 11 | // kotak 2 12 | kotak2.lebar = 10; 13 | kotak2.panjang = 2; 14 | 15 | // hitung luas kotak 16 | double luasKotak = kotak1.hitungLuas(); 17 | 18 | // luas kotak 2 19 | double luasKotak2 = kotak2.hitungLuas(); 20 | 21 | // cetak hasil; 22 | print(luasKotak); 23 | print(luasKotak2); 24 | } 25 | 26 | class PersegiPanjang { 27 | late double panjang; 28 | late double lebar; 29 | 30 | double hitungLuas() { 31 | return this.panjang * this.lebar; 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /class_objects/lib/class_objects.dart: -------------------------------------------------------------------------------- 1 | int calculate() { 2 | return 6 * 7; 3 | } 4 | -------------------------------------------------------------------------------- /class_objects/pubspec.yaml: -------------------------------------------------------------------------------- 1 | name: class_objects 2 | description: A sample command-line application. 3 | version: 1.0.0 4 | # homepage: https://www.example.com 5 | 6 | environment: 7 | sdk: '>=2.12.0 <3.0.0' 8 | 9 | # dependencies: 10 | # path: ^1.8.0 11 | 12 | dev_dependencies: 13 | pedantic: ^1.10.0 14 | test: ^1.16.0 15 | -------------------------------------------------------------------------------- /class_objects/test/class_objects_test.dart: -------------------------------------------------------------------------------- 1 | import 'package:class_objects/class_objects.dart'; 2 | import 'package:test/test.dart'; 3 | 4 | void main() { 5 | test('calculate', () { 6 | expect(calculate(), 42); 7 | }); 8 | } 9 | -------------------------------------------------------------------------------- /constructors/.gitignore: -------------------------------------------------------------------------------- 1 | # Files and directories created by pub. 2 | .dart_tool/ 3 | .packages 4 | 5 | # Conventional directory for build output. 6 | build/ 7 | -------------------------------------------------------------------------------- /constructors/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.0 2 | 3 | - Initial version. 4 | -------------------------------------------------------------------------------- /constructors/README.md: -------------------------------------------------------------------------------- 1 | ### Constructor 2 | 3 | `constructor` adalah method khusus yang dipanggil pertama kali ketika kita membuat sebuah class dan 4 | nama `constructor` tersebut sama dengan nama `classnya` 5 | `constructor` sendiri tidak punya tipe kembalian 6 | 7 | #### Constructor ini Apa 8 | 9 | * `constructor` fungsinya adalah membuat object dari classnya 10 | * selain itu di `constructor` kita dapat menaruh segala sesuatu yang ingin dilakukan ketika `object` tersebut dibuat 11 | 12 | #### Contoh constructor 13 | 14 | ```dart 15 | class Person { 16 | String? name; 17 | Person() { 18 | name = 'no name'; 19 | } 20 | } 21 | ``` 22 | 23 | nah ketika kita inisiasi di main 24 | 25 | ```dart 26 | import 'person.dart'; 27 | 28 | void main(List arguments) { 29 | Person p = Person(); 30 | print(p.name); 31 | } 32 | ``` 33 | 34 | kemudian kita cetak maka akan mencetak `no name` 35 | 36 | ``` 37 | no name 38 | ``` 39 | 40 | ### Constructor dengan Parameter 41 | 42 | untuk menambahkan parameter kita pake keyword `this` contoh 43 | 44 | ```dart 45 | class Person { 46 | String? name; 47 | Person(String name) { 48 | this.name = name; 49 | } 50 | } 51 | ``` 52 | 53 | kita panggilnya 54 | 55 | ```dart 56 | import 'person.dart'; 57 | 58 | void main(List arguments) { 59 | Person p = Person('Feri'); 60 | print(p.name); 61 | } 62 | ``` 63 | 64 | hasilnya 65 | 66 | ``` 67 | Feri 68 | ``` 69 | 70 | ### Comstructor dengan nilai default 71 | 72 | kita bisa pake [optional named parameter](../fungsi/README.md) contoh seperti ini 73 | 74 | ```dart 75 | class Person { 76 | String? name; 77 | Person({String name = 'no name'}) { 78 | this.name = name; 79 | } 80 | } 81 | ``` 82 | 83 | kalo ga diisi keluarnya `no name` tapi kalo diisi 84 | 85 | ```dart 86 | import 'person.dart'; 87 | 88 | void main(List arguments) { 89 | Person p = Person(name: 'feri'); 90 | print(p.name); 91 | } 92 | ``` 93 | 94 | hasilnya akan keluar `feri` 95 | 96 | ### Constructor dalam inheritance 97 | 98 | dalam inheritance yang pertama kali di eksekusi adalah `parent constructor` baru turunanya urut sampai kebawah 99 | 100 | ```dart 101 | class Person { 102 | String? name; 103 | Person({String name = 'no name'}) { 104 | print('Constructor Person'); 105 | this.name = name; 106 | } 107 | } 108 | ``` 109 | kemudian 110 | 111 | ```dart 112 | import 'person.dart'; 113 | 114 | class Student extends Person { 115 | Student() { 116 | print('Student Constructor'); 117 | } 118 | } 119 | ``` 120 | 121 | lalu kita panggil 122 | 123 | ```dart 124 | import 'person.dart'; 125 | import 'student.dart'; 126 | 127 | void main(List arguments) { 128 | Person p = Student(); 129 | print(p.name); 130 | } 131 | ``` 132 | 133 | jika dijalankan hasilnya 134 | 135 | 136 | ``` 137 | Constructor Person 138 | Student Constructor 139 | no name 140 | ``` 141 | 142 | nah yang dipanggil oleh `child class` yaitu si `Student` secara default adalah constructor yang kosomg 143 | jika kita mau mendefinisikan constructor mana yang harus dipakai si `child class` atau si `student` 144 | kita bisa pakai seperti imi 145 | 146 | ```dart 147 | import 'person.dart'; 148 | 149 | class Student extends Person { 150 | Student() : super('student baru'){ 151 | print('Student Constructor'); 152 | } 153 | } 154 | ``` 155 | 156 | dalam kasus ini ketika parrent gak punya constructor kosong seperti ini 157 | 158 | ```dart 159 | class Person { 160 | String? name; 161 | Person(String name) { 162 | print('Constructor Person'); 163 | this.name = name; 164 | } 165 | } 166 | ``` 167 | 168 | pemanggilanya sama kaya tadi 169 | 170 | ```dart 171 | import 'person.dart'; 172 | import 'student.dart'; 173 | 174 | void main(List arguments) { 175 | Person p = Student(); 176 | print(p.name); 177 | } 178 | ``` 179 | 180 | hasilnya dia akan membuat constructor baru 181 | 182 | ``` 183 | Constructor Person 184 | Student Constructor 185 | student baru 186 | ``` 187 | 188 | sama seperti 189 | 190 | ```dart 191 | import 'person.dart'; 192 | 193 | class Student extends Person { 194 | Student() : super(name: 'student baru'){ 195 | print('Student Constructor'); 196 | } 197 | } 198 | ``` 199 | 200 | ### Menambah Parameter 201 | 202 | untuk menambah parameter, bisa, contoh seperti ini 203 | 204 | ```dart 205 | import 'person.dart'; 206 | 207 | class Student extends Person { 208 | Student({String studentName = 'student baru'}) : super(name: studentName){ 209 | print('Student Constructor'); 210 | } 211 | } 212 | ``` 213 | 214 | ### Resource dan Referensi 215 | * [Dokumentasi Constructor](https://dart.dev/guides/language/language-tour#using-constructors) 216 | 217 | --- 218 | 219 | [Mixins](../mixins/README.md) <> [Parameter Underscore](../underscore_parameter/README.md) -------------------------------------------------------------------------------- /constructors/analysis_options.yaml: -------------------------------------------------------------------------------- 1 | # Defines a default set of lint rules enforced for projects at Google. For 2 | # details and rationale, see 3 | # https://github.com/dart-lang/pedantic#enabled-lints. 4 | 5 | include: package:pedantic/analysis_options.yaml 6 | 7 | # For lint rules and documentation, see http://dart-lang.github.io/linter/lints. 8 | 9 | # Uncomment to specify additional rules. 10 | # linter: 11 | # rules: 12 | # - camel_case_types 13 | 14 | # analyzer: 15 | # exclude: 16 | # - path/to/excluded/files/** 17 | -------------------------------------------------------------------------------- /constructors/bin/constructors.dart: -------------------------------------------------------------------------------- 1 | import 'person.dart'; 2 | import 'student.dart'; 3 | 4 | void main(List arguments) { 5 | Person p = Student(); 6 | print(p.name); 7 | } 8 | -------------------------------------------------------------------------------- /constructors/bin/person.dart: -------------------------------------------------------------------------------- 1 | class Person { 2 | String? name; 3 | Person({String? name}) { 4 | print('Constructor Person'); 5 | this.name = name; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /constructors/bin/student.dart: -------------------------------------------------------------------------------- 1 | import 'person.dart'; 2 | 3 | class Student extends Person { 4 | Student({String studentName = 'student baru'}) : super(name: studentName){ 5 | print('Student Constructor'); 6 | } 7 | } -------------------------------------------------------------------------------- /constructors/lib/constructors.dart: -------------------------------------------------------------------------------- 1 | int calculate() { 2 | return 6 * 7; 3 | } 4 | -------------------------------------------------------------------------------- /constructors/pubspec.yaml: -------------------------------------------------------------------------------- 1 | name: constructors 2 | description: A sample command-line application. 3 | version: 1.0.0 4 | # homepage: https://www.example.com 5 | 6 | environment: 7 | sdk: '>=2.12.0 <3.0.0' 8 | 9 | # dependencies: 10 | # path: ^1.8.0 11 | 12 | dev_dependencies: 13 | pedantic: ^1.10.0 14 | test: ^1.16.0 15 | -------------------------------------------------------------------------------- /constructors/test/constructors_test.dart: -------------------------------------------------------------------------------- 1 | import 'package:constructors/constructors.dart'; 2 | import 'package:test/test.dart'; 3 | 4 | void main() { 5 | test('calculate', () { 6 | expect(calculate(), 42); 7 | }); 8 | } 9 | -------------------------------------------------------------------------------- /custom_sort/.gitignore: -------------------------------------------------------------------------------- 1 | # Files and directories created by pub. 2 | .dart_tool/ 3 | .packages 4 | 5 | # Conventional directory for build output. 6 | build/ 7 | -------------------------------------------------------------------------------- /custom_sort/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.0 2 | 3 | - Initial version. 4 | -------------------------------------------------------------------------------- /custom_sort/README.md: -------------------------------------------------------------------------------- 1 | ### Custom Sort dan For `Each` 2 | 3 | ### `ForEach` 4 | 5 | untuk mengakses method dari object yang ditampung pada sebuah list kita bisa pake `forEach` 6 | 7 | ```dart 8 | // looping 9 | persons.forEach((element) { 10 | print(element.role! + ' - ' + element.age.toString()); 11 | }); 12 | ``` 13 | 14 | lengkapnya 15 | 16 | ```dart 17 | void main(List arguments) { 18 | List persons = [ 19 | Person('Admin', 23), 20 | Person('User', 19), 21 | Person('Merchart', 33), 22 | Person('admin', 22), 23 | ]; 24 | 25 | // looping 26 | persons.forEach((element) { 27 | print(element.role! + ' - ' + element.age.toString()); 28 | }); 29 | } 30 | 31 | class Person { 32 | String? role; 33 | late final int age; 34 | 35 | // constructor 36 | Person(this.role, this.age); 37 | } 38 | ``` 39 | 40 | hasilnya 41 | 42 | ``` 43 | Admin - 23 44 | User - 19 45 | Merchart - 33 46 | admin - 22 47 | ``` 48 | 49 | ### Custom Sort 50 | 51 | kita dapat menggunakan keyword `sort` 52 | 53 | ```dart 54 | // sorting 55 | persons.sort((p1, p2) => p1.age - p2.age); 56 | ``` 57 | lengkapnya 58 | 59 | ```dart 60 | void main(List arguments) { 61 | List persons = [ 62 | Person('Admin', 23), 63 | Person('User', 19), 64 | Person('Merchart', 33), 65 | Person('admin', 22), 66 | ]; 67 | 68 | // sorting 69 | persons.sort((p1, p2) => p1.age - p2.age); 70 | 71 | // looping 72 | persons.forEach((element) { 73 | print(element.role! + ' - ' + element.age.toString()); 74 | }); 75 | } 76 | 77 | class Person { 78 | String? role; 79 | late final int age; 80 | 81 | // constructor 82 | Person(this.role, this.age); 83 | } 84 | ``` 85 | 86 | keteranganya bisa baca di [halaman List dan Mapping](../mapping/README.md) 87 | 88 | hasilnya 89 | 90 | ``` 91 | Admin - 23 92 | User - 19 93 | Merchart - 33 94 | admin - 22 95 | ``` 96 | #### Compare 97 | 98 | kita bisa mengurutkan berdasarkan string mengunakan `compareTo` 99 | 100 | ```dart 101 | persons.sort((p1, p2) => p1.role.compareTo(p2.role)); 102 | ``` 103 | 104 | lengkapnya 105 | 106 | ```dart 107 | void main(List arguments) { 108 | List persons = [ 109 | Person('Admin', 23), 110 | Person('User', 19), 111 | Person('Merchart', 33), 112 | Person('Admin', 22), 113 | ]; 114 | 115 | // sorting 116 | persons.sort((p1, p2) => p1.role.compareTo(p2.role)); 117 | 118 | // looping 119 | persons.forEach((element) { 120 | print(element.role+ ' - ' + element.age.toString()); 121 | }); 122 | } 123 | 124 | class Person { 125 | String role; 126 | late final int age; 127 | 128 | // constructor 129 | Person(this.role, this.age); 130 | } 131 | ``` 132 | 133 | hasilnya 134 | 135 | ```dart 136 | Admin - 23 137 | Admin - 22 138 | Merchart - 33 139 | User - 19 140 | ``` 141 | 142 | jika ingin lebih kompleks gini penggunaanya, misal mau mengurutkan umur dan role 143 | 144 | ```dart 145 | persons.sort((p1, p2) { 146 | if (p1.role.compareTo(p2.role) != 0) { 147 | return p1.role.compareTo(p2.role); 148 | } else { 149 | return p1.age.compareTo(p2.age); 150 | } 151 | }); 152 | ``` 153 | lengkapnya 154 | 155 | ```dart 156 | void main(List arguments) { 157 | List persons = [ 158 | Person('Admin', 23), 159 | Person('User', 19), 160 | Person('Merchart', 33), 161 | Person('Admin', 22), 162 | Person('Admin', 23), 163 | Person('User', 20), 164 | Person('Merchart', 55), 165 | Person('Admin', 22), 166 | ]; 167 | 168 | // sorting 169 | persons.sort((p1, p2) { 170 | if (p1.role.compareTo(p2.role) != 0) { 171 | return p1.role.compareTo(p2.role); 172 | } else { 173 | return p1.age.compareTo(p2.age); 174 | } 175 | }); 176 | 177 | // looping 178 | persons.forEach((element) { 179 | print(element.role + ' - ' + element.age.toString()); 180 | }); 181 | } 182 | 183 | class Person { 184 | String role; 185 | late final int age; 186 | 187 | // constructor 188 | Person(this.role, this.age); 189 | } 190 | ``` 191 | 192 | hasilnya 193 | 194 | ``` 195 | Admin - 22 196 | Admin - 22 197 | Admin - 23 198 | Admin - 23 199 | Merchart - 33 200 | Merchart - 55 201 | User - 19 202 | User - 20 203 | ``` 204 | 205 | kalo mau custom lagi pengurutanya kita bisa pake switch case untuk memberi tanda mana yang mau kita urutkan terlebih dahulu 206 | 207 | ```dart 208 | persons.sort((p1, p2) { 209 | if (p1.roleWeight - p2.roleWeight != 0) { 210 | return p1.roleWeight - p2.roleWeight; 211 | } else { 212 | return p1.age.compareTo(p2.age); 213 | } 214 | }); 215 | ``` 216 | 217 | lengkapnya 218 | 219 | ```dart 220 | void main(List arguments) { 221 | List persons = [ 222 | Person('Admin', 23), 223 | Person('User', 19), 224 | Person('Merchart', 33), 225 | Person('Admin', 22), 226 | Person('Admin', 23), 227 | Person('User', 20), 228 | Person('Merchart', 55), 229 | Person('Admin', 22), 230 | ]; 231 | 232 | // sorting 233 | persons.sort((p1, p2) { 234 | if (p1.roleWeight - p2.roleWeight != 0) { 235 | return p1.roleWeight - p2.roleWeight; 236 | } else { 237 | return p1.age.compareTo(p2.age); 238 | } 239 | }); 240 | 241 | // looping 242 | persons.forEach((element) { 243 | print(element.role + ' - ' + element.age.toString()); 244 | }); 245 | } 246 | 247 | class Person { 248 | String role; 249 | late final int age; 250 | 251 | // constructor 252 | Person(this.role, this.age); 253 | 254 | int get roleWeight { 255 | switch (role) { 256 | case 'Merchart': 257 | return 1; 258 | break; 259 | case 'Admin': 260 | return 2; 261 | break; 262 | default: 263 | return 3; 264 | } 265 | } 266 | } 267 | ``` 268 | 269 | hasilnya 270 | 271 | ```dart 272 | Merchart - 33 273 | Merchart - 55 274 | Admin - 22 275 | Admin - 22 276 | Admin - 23 277 | Admin - 23 278 | User - 19 279 | User - 20 280 | ``` 281 | 282 | --- 283 | 284 | [Required, Assert dan Try Catch](../reuireds/README.md) <> [Solid Principle](../solid_principle/README.md) -------------------------------------------------------------------------------- /custom_sort/analysis_options.yaml: -------------------------------------------------------------------------------- 1 | # Defines a default set of lint rules enforced for projects at Google. For 2 | # details and rationale, see 3 | # https://github.com/dart-lang/pedantic#enabled-lints. 4 | 5 | include: package:pedantic/analysis_options.yaml 6 | 7 | # For lint rules and documentation, see http://dart-lang.github.io/linter/lints. 8 | 9 | # Uncomment to specify additional rules. 10 | # linter: 11 | # rules: 12 | # - camel_case_types 13 | 14 | # analyzer: 15 | # exclude: 16 | # - path/to/excluded/files/** 17 | -------------------------------------------------------------------------------- /custom_sort/bin/custom_sort.dart: -------------------------------------------------------------------------------- 1 | void main(List arguments) { 2 | List persons = [ 3 | Person('Admin', 23), 4 | Person('User', 19), 5 | Person('Merchart', 33), 6 | Person('Admin', 22), 7 | Person('Admin', 23), 8 | Person('User', 20), 9 | Person('Merchart', 55), 10 | Person('Admin', 22), 11 | ]; 12 | 13 | // sorting 14 | persons.sort((p1, p2) => p1.role.compareTo(p2.role)); 15 | 16 | // looping 17 | persons.forEach((element) { 18 | print(element.role + ' - ' + element.age.toString()); 19 | }); 20 | } 21 | 22 | class Person { 23 | String role; 24 | late final int age; 25 | 26 | // constructor 27 | Person(this.role, this.age); 28 | } 29 | -------------------------------------------------------------------------------- /custom_sort/bin/custom_sort2.dart: -------------------------------------------------------------------------------- 1 | void main(List arguments) { 2 | List persons = [ 3 | Person('Admin', 23), 4 | Person('User', 19), 5 | Person('Merchart', 33), 6 | Person('Admin', 22), 7 | Person('Admin', 23), 8 | Person('User', 20), 9 | Person('Merchart', 55), 10 | Person('Admin', 22), 11 | ]; 12 | 13 | // sorting 14 | persons.sort((p1, p2) { 15 | if (p1.role.compareTo(p2.role) != 0) { 16 | return p1.role.compareTo(p2.role); 17 | } else { 18 | return p1.age.compareTo(p2.age); 19 | } 20 | }); 21 | 22 | // looping 23 | persons.forEach((element) { 24 | print(element.role + ' - ' + element.age.toString()); 25 | }); 26 | } 27 | 28 | class Person { 29 | String role; 30 | late final int age; 31 | 32 | // constructor 33 | Person(this.role, this.age); 34 | } 35 | -------------------------------------------------------------------------------- /custom_sort/bin/custom_sort3.dart: -------------------------------------------------------------------------------- 1 | void main(List arguments) { 2 | List persons = [ 3 | Person('Admin', 23), 4 | Person('User', 19), 5 | Person('Merchart', 33), 6 | Person('Admin', 22), 7 | Person('Admin', 23), 8 | Person('User', 20), 9 | Person('Merchart', 55), 10 | Person('Admin', 22), 11 | ]; 12 | 13 | // sorting 14 | persons.sort((p1, p2) { 15 | if (p1.roleWeight - p2.roleWeight != 0) { 16 | return p1.roleWeight - p2.roleWeight; 17 | } else { 18 | return p1.age.compareTo(p2.age); 19 | } 20 | }); 21 | 22 | // looping 23 | persons.forEach((element) { 24 | print(element.role + ' - ' + element.age.toString()); 25 | }); 26 | } 27 | 28 | class Person { 29 | String role; 30 | late final int age; 31 | 32 | // constructor 33 | Person(this.role, this.age); 34 | 35 | int get roleWeight { 36 | switch (role) { 37 | case 'Merchart': 38 | return 1; 39 | break; 40 | case 'Admin': 41 | return 2; 42 | break; 43 | default: 44 | return 3; 45 | } 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /custom_sort/lib/custom_sort.dart: -------------------------------------------------------------------------------- 1 | int calculate() { 2 | return 6 * 7; 3 | } 4 | -------------------------------------------------------------------------------- /custom_sort/pubspec.yaml: -------------------------------------------------------------------------------- 1 | name: custom_sort 2 | description: A sample command-line application. 3 | version: 1.0.0 4 | # homepage: https://www.example.com 5 | 6 | environment: 7 | sdk: '>=2.12.0 <3.0.0' 8 | 9 | # dependencies: 10 | # path: ^1.8.0 11 | 12 | dev_dependencies: 13 | pedantic: ^1.10.0 14 | test: ^1.16.0 15 | -------------------------------------------------------------------------------- /dynamic_vars/.gitignore: -------------------------------------------------------------------------------- 1 | # Files and directories created by pub. 2 | .dart_tool/ 3 | .packages 4 | 5 | # Conventional directory for build output. 6 | build/ 7 | -------------------------------------------------------------------------------- /dynamic_vars/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.0 2 | 3 | - Initial version. 4 | -------------------------------------------------------------------------------- /dynamic_vars/README.md: -------------------------------------------------------------------------------- 1 | ## Type Data `Var` dan `dynamic` 2 | 3 | membahas lebih detil tentang tipe data `var` dan `dynamic` 4 | 5 | ### Type Data `dynamic` 6 | 7 | adalah tipe data yang dapat dipasan dengan tipe apapun 8 | 9 | contoh kita membpunyai sebuah variable bertipe `dynamic` dalam variabel ini kita dapat menunjuk tipe data apapun 10 | 11 | ```dart 12 | void main() { 13 | dynamic myDynamic = 10; 14 | print(myDynamic); 15 | } 16 | ``` 17 | 18 | maka hasilnya akan 19 | 20 | ``` 21 | 10 22 | ``` 23 | 24 | jika kita ubah seperti ini 25 | 26 | ```dart 27 | void main() { 28 | dynamic myDynamic = 10; 29 | myDynamic = 'ini string'; 30 | print(myDynamic); 31 | } 32 | 33 | ``` 34 | 35 | maka hasilnya akan berubah atau merujuk pada object baru 36 | 37 | ``` 38 | ini string 39 | ``` 40 | 41 | > Note: `dynamic` ini tipe data yang dapat berubah sesui nilai/tipe yang di tunjuk oleh `dynamic` itu sendiri 42 | 43 | contoh lagi 44 | 45 | ```dart 46 | void main() { 47 | dynamic myDynamic; 48 | myDynamic = 10; 49 | 50 | // kita bisa ganti nilai assign dulu menggunakan `as` 51 | print((myDynamic as Manusia).name); 52 | } 53 | 54 | class Manusia { 55 | String name = 'feri lukman'; 56 | 57 | } 58 | ``` 59 | 60 | maka hasilnya 61 | 62 | ``` 63 | feri lukman 64 | ``` 65 | 66 | contoh lain 67 | 68 | ```dart 69 | void main() { 70 | dynamic myDynamic; 71 | myDynamic = 10; 72 | 73 | myDynamic = Manusia(); 74 | 75 | // cetak nilai 76 | print(myDynamic.name); 77 | } 78 | 79 | class Manusia { 80 | String name = 'feri lukman'; 81 | 82 | } 83 | ``` 84 | 85 | hasilnya 86 | 87 | ``` 88 | feri lukman 89 | ``` 90 | 91 | ### Tipe Data `var` 92 | 93 | tipe data `var` adalah tipe data yang memungkinkan variable untuk menunjuk object apapun tapi hanya sekali sejak dideklarasikan 94 | 95 | contoh 96 | 97 | ```dart 98 | void main () { 99 | var datas = 'feri lukmansyah'; 100 | 101 | print(datas.runtimeType); 102 | 103 | } 104 | ``` 105 | 106 | maka hasilnya akan jadi 107 | 108 | 109 | ``` 110 | String 111 | ``` 112 | 113 | dimana dengan tipe `var` ini jika kita deklarasikan diawal adalah string maka object yang selanjutnya adalah string 114 | 115 | 116 | ```dart 117 | void main () { 118 | var datas = 'feri lukmansyah'; 119 | 120 | datas = 'budi'; 121 | print(datas); 122 | } 123 | ``` 124 | 125 | hasilnya 126 | 127 | ``` 128 | budi 129 | ``` 130 | 131 | jika kita deklarasi nilainya di belakanng maka tipe `var` ini otomatis berubah jadi `dynamic` 132 | 133 | contoh 134 | 135 | ```dart 136 | void main () { 137 | var identitas; 138 | identitas = 'feri'; 139 | identitas = 20; 140 | print(identitas); 141 | } 142 | ``` 143 | 144 | maka hasilnya 145 | 146 | ``` 147 | 20 148 | ``` 149 | 150 | ### Kapan kita Harus pake `var` atau `dynamic` 151 | 152 | kalo kita variable bisa diisi tipe data apapun misal untuk keperluan parsing `json` 153 | maka kita pake `dynamic` 154 | kalo pake `var` kalo awalnya kita tidak tau jenis tipe data 155 | 156 | --- 157 | 158 | [Future Or](../furure_or/README.md) <> [materi Selesai]() -------------------------------------------------------------------------------- /dynamic_vars/analysis_options.yaml: -------------------------------------------------------------------------------- 1 | # Defines a default set of lint rules enforced for projects at Google. For 2 | # details and rationale, see 3 | # https://github.com/dart-lang/pedantic#enabled-lints. 4 | 5 | include: package:pedantic/analysis_options.yaml 6 | 7 | # For lint rules and documentation, see http://dart-lang.github.io/linter/lints. 8 | 9 | # Uncomment to specify additional rules. 10 | # linter: 11 | # rules: 12 | # - camel_case_types 13 | 14 | # analyzer: 15 | # exclude: 16 | # - path/to/excluded/files/** 17 | -------------------------------------------------------------------------------- /dynamic_vars/bin/dynamic_vars.dart: -------------------------------------------------------------------------------- 1 | void main(List arguments) { 2 | var identitas; 3 | identitas = 'feri'; 4 | identitas = 20; 5 | print(identitas); 6 | } 7 | -------------------------------------------------------------------------------- /dynamic_vars/lib/dynamic_vars.dart: -------------------------------------------------------------------------------- 1 | int calculate() { 2 | return 6 * 7; 3 | } 4 | -------------------------------------------------------------------------------- /dynamic_vars/pubspec.yaml: -------------------------------------------------------------------------------- 1 | name: dynamic_vars 2 | description: A sample command-line application. 3 | version: 1.0.0 4 | # homepage: https://www.example.com 5 | 6 | environment: 7 | sdk: '>=2.12.0 <3.0.0' 8 | 9 | # dependencies: 10 | # path: ^1.8.0 11 | 12 | dev_dependencies: 13 | pedantic: ^1.10.0 14 | test: ^1.16.0 15 | -------------------------------------------------------------------------------- /dynamic_vars/test/dynamic_vars_test.dart: -------------------------------------------------------------------------------- 1 | import 'package:dynamic_vars/dynamic_vars.dart'; 2 | import 'package:test/test.dart'; 3 | 4 | void main() { 5 | test('calculate', () { 6 | expect(calculate(), 42); 7 | }); 8 | } 9 | -------------------------------------------------------------------------------- /enkapsulasi/.gitignore: -------------------------------------------------------------------------------- 1 | # Files and directories created by pub. 2 | .dart_tool/ 3 | .packages 4 | 5 | # Conventional directory for build output. 6 | build/ 7 | -------------------------------------------------------------------------------- /enkapsulasi/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.0 2 | 3 | - Initial version. 4 | -------------------------------------------------------------------------------- /enkapsulasi/README.md: -------------------------------------------------------------------------------- 1 | ### Enkapsulasi 2 | 3 | --- 4 | 5 | enkapsulasi itu adalah teknik pembungkusan jadi data-data yang dibuat dalam suatu `class` itu dibuat private 6 | 7 | dalam bahasa `dart` kita bisa pake `property` 8 | 9 | contoh kita punya `class` untuk menghitung luas persegi dimana salah satu variable nya private 10 | 11 | #### Contoh menggunakan Getter & setter 12 | 13 | ```dart 14 | // lib/encapsulasi.dart 15 | 16 | void main(List arguments) {} 17 | 18 | class PersegiPanjang { 19 | late double _panjang; 20 | late double lebar; 21 | 22 | // setter 23 | void setPanjang(double value) { 24 | if (value < 0) { 25 | value *= 1; 26 | } 27 | _panjang = value; 28 | } 29 | double getPanjang() => _panjang; 30 | double hitungLuas() { 31 | return this._panjang * this.lebar; 32 | } 33 | } 34 | ``` 35 | 36 | lalu kita coba 37 | akses dari file yang berbeda 38 | 39 | ```dart 40 | import 'dart:io'; 41 | 42 | import 'package:enkapsulasi/enkapsulasi.dart'; 43 | 44 | void main(List arguments) { 45 | PersegiPanjang kotak1, kotak2; 46 | 47 | kotak1 = PersegiPanjang(); 48 | 49 | // set lebar 50 | kotak1.setPanjang(double.tryParse(stdin.readLineSync()!)!); 51 | kotak1.lebar = double.tryParse(stdin.readLineSync()!)!; 52 | 53 | // kotak 2 54 | kotak2 = PersegiPanjang(); 55 | kotak2.setPanjang(1); 56 | kotak2.lebar = 1; 57 | 58 | print(kotak1.hitungLuas() + kotak2.hitungLuas()); 59 | 60 | 61 | } 62 | ``` 63 | 64 | disini kita perlu membuat method untuk mengeset variabel yang bersifat private agar bisa diakses dari luar class 65 | 66 | ```dart 67 | // setter 68 | void setPanjang(double value) { 69 | if (value < 0) { 70 | value *= 1; 71 | } 72 | _panjang = value; 73 | } 74 | ``` 75 | 76 | contoh untuk ambil nilai `_panjang` kita bisa buat fungsi seperti ini 77 | 78 | ```dart 79 | double getPanjang() => _panjang; 80 | ``` 81 | kalo kita panggil seperti ini 82 | 83 | ```dart 84 | print(kotak1.getPanjang()); 85 | ``` 86 | 87 | kalo dijalankan outputnya seperti ini 88 | 89 | ``` 90 | 3 91 | 5 92 | 16.0 93 | 1.0 // ini getter nya 94 | ``` 95 | 96 | #### Menggunakan `Property` 97 | 98 | sama seperti getter dan setter kita bisa buat `property` untuk akses private variable 99 | 100 | ##### Setter Property 101 | 102 | ```dart 103 | // setter lebar 104 | void set lebar (double value) => _lebar = value; 105 | ``` 106 | 107 | ##### Getter Propery 108 | 109 | ```dart 110 | // getter lebar 111 | double get lebar { 112 | return _lebar; 113 | } 114 | ``` 115 | 116 | kalo kita lihat penggunaan `property` ini sama kaya penggunaan field 117 | 118 | ```dart 119 | void main(List arguments) {} 120 | 121 | class PersegiPanjang { 122 | late double _panjang; 123 | late double _lebar; 124 | 125 | // setter lebar 126 | void set lebar(double value) { 127 | _lebar = value; 128 | } 129 | 130 | // getter lebar 131 | double get lebar { 132 | return _lebar; 133 | } 134 | 135 | // setter panjang 136 | void setPanjang(double value) { 137 | if (value < 0) { 138 | value *= 1; 139 | } 140 | _panjang = value; 141 | } 142 | 143 | // getter panjang 144 | double getPanjang() => _panjang; 145 | 146 | double hitungLuas() { 147 | return this._panjang * this._lebar; 148 | } 149 | } 150 | ``` 151 | 152 | > didalam sebuah `class` yang baik di jadikan method itu adalah *apa yang bisa dilakukan class tersebut* 153 | > kemudian *apa yang dimiliki cass tersebut itu dijadikan field* 154 | 155 | kita dapat membuat properti tanpa field seperti ini 156 | 157 | kalo kita lihat hitung luas 158 | 159 | ```dart 160 | double hitungLuas() { 161 | return this._panjang * this._lebar; 162 | } 163 | ``` 164 | kita bisa bikin propertynya seperti ini 165 | 166 | ```dart 167 | double hitungLuas() { 168 | return this._panjang * this._lebar; 169 | } 170 | 171 | // bikin property 172 | double get luas => this._panjang * this._lebar; 173 | } 174 | ``` 175 | jadi kita panggilnya 176 | 177 | ```dart 178 | print(kotak1.luas + kotak2.luas); 179 | ``` 180 | 181 | kode lengkapnya 182 | 183 | ```dart 184 | void main(List arguments) {} 185 | 186 | class PersegiPanjang { 187 | late double _panjang; 188 | late double _lebar; 189 | 190 | // setter lebar 191 | void set lebar(double value) { 192 | _lebar = value; 193 | } 194 | 195 | // getter lebar 196 | 197 | double get lebar { 198 | return _lebar; 199 | } 200 | 201 | // setter panjang 202 | void setPanjang(double value) { 203 | if (value < 0) { 204 | value *= 1; 205 | } 206 | _panjang = value; 207 | } 208 | 209 | // getter panjang 210 | double getPanjang() => _panjang; 211 | 212 | double hitungLuas() { 213 | return this._panjang * this._lebar; 214 | } 215 | 216 | // bikin property 217 | double get luas => this._panjang * this._lebar; 218 | } 219 | 220 | ``` 221 | 222 | outputnya sama aja 223 | 224 | ``` 225 | 2.0 226 | 1.0 227 | ``` 228 | 229 | --- 230 | 231 | [class dan object](../class_objects/README.md) <> [inheritance](../inherit/README.md) -------------------------------------------------------------------------------- /enkapsulasi/analysis_options.yaml: -------------------------------------------------------------------------------- 1 | # Defines a default set of lint rules enforced for projects at Google. For 2 | # details and rationale, see 3 | # https://github.com/dart-lang/pedantic#enabled-lints. 4 | 5 | include: package:pedantic/analysis_options.yaml 6 | 7 | # For lint rules and documentation, see http://dart-lang.github.io/linter/lints. 8 | 9 | # Uncomment to specify additional rules. 10 | # linter: 11 | # rules: 12 | # - camel_case_types 13 | 14 | # analyzer: 15 | # exclude: 16 | # - path/to/excluded/files/** 17 | -------------------------------------------------------------------------------- /enkapsulasi/bin/enkapsulasi.dart: -------------------------------------------------------------------------------- 1 | import 'dart:io'; 2 | 3 | import 'package:enkapsulasi/enkapsulasi.dart'; 4 | 5 | void main(List arguments) { 6 | PersegiPanjang kotak1, kotak2; 7 | 8 | kotak1 = PersegiPanjang(); 9 | 10 | // set lebar 11 | kotak1.setPanjang(double.tryParse(stdin.readLineSync()!)!); 12 | kotak1.lebar = double.tryParse(stdin.readLineSync()!)!; 13 | 14 | // kotak 2 15 | kotak2 = PersegiPanjang(); 16 | kotak2.setPanjang(1); 17 | kotak2.lebar = 1; 18 | 19 | print(kotak1.luas + kotak2.luas); 20 | 21 | // ambil nilai 22 | print(kotak1.getPanjang()); 23 | } 24 | -------------------------------------------------------------------------------- /enkapsulasi/lib/enkapsulasi.dart: -------------------------------------------------------------------------------- 1 | void main(List arguments) {} 2 | 3 | class PersegiPanjang { 4 | late double _panjang; 5 | late double _lebar; 6 | 7 | // setter lebar 8 | void set lebar(double value) { 9 | _lebar = value; 10 | } 11 | 12 | // getter lebar 13 | 14 | double get lebar { 15 | return _lebar; 16 | } 17 | 18 | // setter panjang 19 | void setPanjang(double value) { 20 | if (value < 0) { 21 | value *= 1; 22 | } 23 | _panjang = value; 24 | } 25 | 26 | // getter panjang 27 | double getPanjang() => _panjang; 28 | 29 | double hitungLuas() { 30 | return this._panjang * this._lebar; 31 | } 32 | 33 | // bikin property 34 | double get luas => this._panjang * this._lebar; 35 | } 36 | -------------------------------------------------------------------------------- /enkapsulasi/pubspec.yaml: -------------------------------------------------------------------------------- 1 | name: enkapsulasi 2 | description: A sample command-line application. 3 | version: 1.0.0 4 | # homepage: https://www.example.com 5 | 6 | environment: 7 | sdk: '>=2.12.0 <3.0.0' 8 | 9 | # dependencies: 10 | # path: ^1.8.0 11 | 12 | dev_dependencies: 13 | pedantic: ^1.10.0 14 | test: ^1.16.0 15 | -------------------------------------------------------------------------------- /enums/.gitignore: -------------------------------------------------------------------------------- 1 | # Files and directories created by pub. 2 | .dart_tool/ 3 | .packages 4 | 5 | # Conventional directory for build output. 6 | build/ 7 | -------------------------------------------------------------------------------- /enums/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.0 2 | 3 | - Initial version. 4 | -------------------------------------------------------------------------------- /enums/README.md: -------------------------------------------------------------------------------- 1 | ### Enums 2 | 3 | ketika kita melakukan switch case pada paramaternya katakanlah parameter status jadi untuk memberikan object 4 | dengan status tertentu kita bisa pake enum 5 | 6 | ```dart 7 | // enum 8 | enum UcoaStatus {normal, poisoned, confused} 9 | ``` 10 | 11 | penerapan lengkapnya 12 | 13 | ```dart 14 | void main(List arguments) { 15 | MonsterUcoa m = MonsterUcoa(status: UcoaStatus.poisoned); 16 | 17 | // move 18 | m.move(); 19 | } 20 | 21 | // enum 22 | enum UcoaStatus {normal, poisoned, confused} 23 | 24 | class MonsterUcoa { 25 | final UcoaStatus status; // 1. normal, 2. poisoned, 3. confusing 26 | 27 | // constructor 28 | MonsterUcoa({this.status = UcoaStatus.normal}); 29 | 30 | void move() { 31 | switch(status) { 32 | case UcoaStatus.normal: 33 | print('Ucoa is Moving'); 34 | break; 35 | case UcoaStatus.poisoned: 36 | print('Ucoa Cammot Move need Help'); 37 | break; 38 | case UcoaStatus.confused: 39 | print('Ucoa is Confusing'); 40 | break; 41 | default: 42 | } 43 | } 44 | void eat() { 45 | print('Ucoa is Eating'); 46 | } 47 | } 48 | ``` 49 | 50 | kalo dijalankan outputnya 51 | 52 | ``` 53 | Ucoa Cammot Move need Help 54 | ``` 55 | 56 | ### Cascade Notation 57 | 58 | `Cascade Notation` digunakan ketika memanggil beberapa method terhadap satu buah object yang sama 59 | secara berurutan kita bisa pakai `..` 60 | 61 | ```dart 62 | void main(List arguments) { 63 | MonsterUcoa m = MonsterUcoa(status: UcoaStatus.poisoned) 64 | ..move() 65 | ..eat(); 66 | } 67 | ``` 68 | 69 | atau seperti ini jika terputus oleh perintah lain 70 | 71 | ```dart 72 | void main(List arguments) { 73 | MonsterUcoa m = MonsterUcoa(status: UcoaStatus.poisoned); 74 | print('ini method'); 75 | m 76 | ..move() 77 | ..eat(); 78 | } 79 | ``` 80 | 81 | hasilnya 82 | ``` 83 | Ucoa Cammot Move need Help 84 | Ucoa is Eating 85 | ``` 86 | 87 | --- 88 | 89 | [Generic dan Generic Type](../generic/README.md) <> [Required, Assert dan Try Catch](../reuireds/README.md) -------------------------------------------------------------------------------- /enums/analysis_options.yaml: -------------------------------------------------------------------------------- 1 | # Defines a default set of lint rules enforced for projects at Google. For 2 | # details and rationale, see 3 | # https://github.com/dart-lang/pedantic#enabled-lints. 4 | 5 | include: package:pedantic/analysis_options.yaml 6 | 7 | # For lint rules and documentation, see http://dart-lang.github.io/linter/lints. 8 | 9 | # Uncomment to specify additional rules. 10 | # linter: 11 | # rules: 12 | # - camel_case_types 13 | 14 | # analyzer: 15 | # exclude: 16 | # - path/to/excluded/files/** 17 | -------------------------------------------------------------------------------- /enums/bin/enums.dart: -------------------------------------------------------------------------------- 1 | void main(List arguments) { 2 | MonsterUcoa m = MonsterUcoa(status: UcoaStatus.poisoned); 3 | print('ini method'); 4 | m 5 | ..move() 6 | ..eat(); 7 | } 8 | 9 | // enum 10 | enum UcoaStatus { normal, poisoned, confused } 11 | 12 | class MonsterUcoa { 13 | final UcoaStatus status; // 1. normal, 2. poisoned, 3. confusing 14 | 15 | // constructor 16 | MonsterUcoa({this.status = UcoaStatus.normal}); 17 | 18 | void move() { 19 | switch (status) { 20 | case UcoaStatus.normal: 21 | print('Ucoa is Moving'); 22 | break; 23 | case UcoaStatus.poisoned: 24 | print('Ucoa Cammot Move need Help'); 25 | break; 26 | case UcoaStatus.confused: 27 | print('Ucoa is Confusing'); 28 | break; 29 | default: 30 | } 31 | } 32 | 33 | void eat() { 34 | print('Ucoa is Eating'); 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /enums/lib/enums.dart: -------------------------------------------------------------------------------- 1 | int calculate() { 2 | return 6 * 7; 3 | } 4 | -------------------------------------------------------------------------------- /enums/pubspec.yaml: -------------------------------------------------------------------------------- 1 | name: enums 2 | description: A sample command-line application. 3 | version: 1.0.0 4 | # homepage: https://www.example.com 5 | 6 | environment: 7 | sdk: '>=2.12.0 <3.0.0' 8 | 9 | # dependencies: 10 | # path: ^1.8.0 11 | 12 | dev_dependencies: 13 | pedantic: ^1.10.0 14 | test: ^1.16.0 15 | -------------------------------------------------------------------------------- /final_const/.gitignore: -------------------------------------------------------------------------------- 1 | # Files and directories created by pub. 2 | .dart_tool/ 3 | .packages 4 | 5 | # Conventional directory for build output. 6 | build/ 7 | -------------------------------------------------------------------------------- /final_const/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.0 2 | 3 | - Initial version. 4 | -------------------------------------------------------------------------------- /final_const/README.md: -------------------------------------------------------------------------------- 1 | ### Reference, Pointer dan identifier 2 | 3 | ketika kita mendeklarasikan sebuah variabel, sebenarnya variable bukan bersifat sebagai penampung nilai 4 | tapi merujuk pada alamat object yang dimaksud, contoh 5 | 6 | ```dart 7 | List dataList = []; 8 | ``` 9 | 10 | disini kita akan membuat object yang bertipw `List` lalu alamat di memori disimpan ke variabel `dataList` 11 | 12 | ### Konsep Penting 13 | 14 | misal kita punya beberapa object seperti ini 15 | 16 | ```dart 17 | Tree first = Tree(num: 1); 18 | ``` 19 | ```dart 20 | Tree seconds = Tree(num: 1); 21 | ``` 22 | 23 | jika kita bandingkan maka tidak akan sama karena `seconds` akan membentuk object baru, klo kita coba samakan maka hasilnya 24 | `not identical` beda cerita kalo yang ini 25 | 26 | ```dart 27 | Tree third = first(); 28 | ``` 29 | 30 | maka object `first` akan di copy ke kedalam `third` maka `first` dan `third` merujuk pada object yang sama (`identical`) 31 | 32 | ### `Final` Keywords 33 | 34 | `Final` keyword digunakann untuk point object seterusnya selama aplikasi jalan, dan untuk menggunakan keyword 35 | `Final` ini harus di inisialisasi langsung atau bisa lewat `constructor` dan dapat di deklarasikan dimanapun 36 | 37 | ```dart 38 | void main(List arguments) { 39 | final int x = 10; 40 | } 41 | ``` 42 | 43 | tau dalam class kaya gini 44 | 45 | ```dart 46 | class Regular { 47 | final int? number; 48 | Regular({this.number}); 49 | } 50 | ``` 51 | 52 | ### `const` atau Konstanta 53 | 54 | dibagi jadi 2 jenis 55 | 56 | * Literal const: yaitu nilai yang langsung kita tulis contoh `double x = 2.5` 57 | * Symbolic Const: itu konstanta yang diberikan simbol contoh `const x = 2.5` 58 | 59 | > Note: perbedaanya dengan `final` adalah kalo `final` itu merujuk pada object kalo `const` 60 | > itu nilainya di asosiasi ke object yang sama 61 | 62 | `const` hanya dapat di deklarasikan sebagai variable lokal/static 63 | 64 | contoh lain 65 | 66 | ```dart 67 | Tree first = const Tree(num: 1); 68 | ``` 69 | ```dart 70 | Tree seconds = const Tree(num: 1); 71 | ``` 72 | karena indentifikasinya berdasarkan nilai dia jadi merujuk ke object yang sama 73 | 74 | contoh 75 | 76 | ```dart 77 | class ConstClass { 78 | final int? number; 79 | const ConstClass({this.number}); 80 | } 81 | ``` 82 | 83 | dimain kita panggil seperti ini 84 | 85 | ```dart 86 | void main(List arguments) { 87 | // final int x = 10; 88 | var a = const ConstClass(number: 5); 89 | var b = const ConstClass(number: 5); 90 | 91 | // cek indentitas 92 | print(identical(a, b)); 93 | } 94 | ``` 95 | 96 | ketika kita cetak hasilnya 97 | 98 | ``` 99 | true 100 | ``` 101 | 102 | ### Keuntungan Pake `Const` atau konstanta 103 | 104 | * kita ga bakal buat object berulang-ulang 105 | * dibuatnya waktu pas compile 106 | * konstata hanya bisa di dekarasikan di `top level` `local` atau `static field 107 | 108 | --- 109 | [Async Await](../async_await/README.md) <> [Generic dan Generic Type Dart](../generic/README.md)` 110 | -------------------------------------------------------------------------------- /final_const/analysis_options.yaml: -------------------------------------------------------------------------------- 1 | # Defines a default set of lint rules enforced for projects at Google. For 2 | # details and rationale, see 3 | # https://github.com/dart-lang/pedantic#enabled-lints. 4 | 5 | include: package:pedantic/analysis_options.yaml 6 | 7 | # For lint rules and documentation, see http://dart-lang.github.io/linter/lints. 8 | 9 | # Uncomment to specify additional rules. 10 | # linter: 11 | # rules: 12 | # - camel_case_types 13 | 14 | # analyzer: 15 | # exclude: 16 | # - path/to/excluded/files/** 17 | -------------------------------------------------------------------------------- /final_const/bin/final_const.dart: -------------------------------------------------------------------------------- 1 | void main(List arguments) { 2 | // final int x = 10; 3 | var a = const ConstClass(number: 5); 4 | var b = const ConstClass(number: 5); 5 | 6 | // cek indentitas 7 | print(identical(a, b)); 8 | } 9 | 10 | class Regular { 11 | final int? number; 12 | Regular({this.number}); 13 | } 14 | 15 | class ConstClass { 16 | final int? number; 17 | const ConstClass({this.number}); 18 | } 19 | -------------------------------------------------------------------------------- /final_const/lib/final_const.dart: -------------------------------------------------------------------------------- 1 | int calculate() { 2 | return 6 * 7; 3 | } 4 | -------------------------------------------------------------------------------- /final_const/pubspec.yaml: -------------------------------------------------------------------------------- 1 | name: final_const 2 | description: A sample command-line application. 3 | version: 1.0.0 4 | # homepage: https://www.example.com 5 | 6 | environment: 7 | sdk: '>=2.12.0 <3.0.0' 8 | 9 | # dependencies: 10 | # path: ^1.8.0 11 | 12 | dev_dependencies: 13 | pedantic: ^1.10.0 14 | test: ^1.16.0 15 | -------------------------------------------------------------------------------- /final_const/test/final_const_test.dart: -------------------------------------------------------------------------------- 1 | import 'package:final_const/final_const.dart'; 2 | import 'package:test/test.dart'; 3 | 4 | void main() { 5 | test('calculate', () { 6 | expect(calculate(), 42); 7 | }); 8 | } 9 | -------------------------------------------------------------------------------- /fungsi/.gitignore: -------------------------------------------------------------------------------- 1 | # Files and directories created by pub. 2 | .dart_tool/ 3 | .packages 4 | 5 | # Conventional directory for build output. 6 | build/ 7 | -------------------------------------------------------------------------------- /fungsi/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.0 2 | 3 | - Initial version. 4 | -------------------------------------------------------------------------------- /fungsi/README.md: -------------------------------------------------------------------------------- 1 | ### Fungsi, Optional Parameter dan Lambda Expression 2 | 3 | --- 4 | 5 | ### Fungsi 6 | 7 | fungsi adaahh sekumpulan statement yang independen 8 | dan hanya melakukan tugas secara spesifik atau tertentu saja 9 | 10 | 11 | fungsi dapat mengembalikan nilai (*optional*) pada pemanggil, jika tidak mengembalikan nilai apapun maka tipenya adalah `void` 12 | 13 | #### analogi fungsi 14 | 15 | kalo diibaratkan gambaranya seperti **membuat es rumput laut** 16 | 17 | ![analogi fungsi](docs/resep_es_rumput_laut_2.jpg) 18 | 19 | dapat dilihat pada gambar, pada gambar ini, nah untuk membuat es rumput laut kita memerlukan beberapa 20 | bahan seperti 21 | 22 | * cincau 23 | * rumput laut dan lainya 24 | kemudian hasil akhirnya akan menghasilkan `1 porsi` es rumput laut 25 | 26 | bisa kita lihat bahwa es ini mempunyai banyak bahan 27 | 28 | * cintau 29 | * rumput laut 30 | * roti 31 | * kolang kaling 32 | 33 | dan lainya kemudian semua bahan itu diproses lalu menghasilkan `1 porsi` es rumput laut 34 | 35 | bayangkan semua bahan itu adalah `parameter fungsi yang dibutuhkan` kemudian ada `mangkuk` dan `pengaduk` adalah logika/cara olah gimana kita proses 36 | semua bahan (*parameter*) tersebut sehingga menghasilkan `1 porsi` es rumput laut tersebut 37 | 38 | contoh pembuatan fungsi 39 | 40 | ```dart 41 | double segitiga(int a, int b) { 42 | return 0.5 * a * b; 43 | } 44 | 45 | void main(List arguments) { 46 | // panggil fungsi 47 | double luas = segitiga(5, 10); 48 | 49 | // cetak fungsi 50 | print('hasil perhitunganya adalah: ' + luas.toString()); 51 | } 52 | ``` 53 | 54 | hasilnya adalah melakukan perhitungan luas segitiga, hasilnya 55 | 56 | ```shell script 57 | hasil perhitunganya adalah: 25.0 58 | ``` 59 | 60 | penjelasan 61 | 62 | 63 | 64 | * `double` adalah tipe data kembalian dari fungsi 65 | * `segitiga` adalah nama fungsi 66 | * `int a` dan `int b` adalah parameternya (*wajib*) 67 | 68 | #### contoh fungsi `void` 69 | 70 | fungsi bertipe `void` adalah fungsi yang tidak mengembalikan sesuatu 71 | 72 | ```dart 73 | void cetak_nama() { 74 | print('halo nama saya adalah feri, salam kenal :)'); 75 | } 76 | main(List args) { 77 | cetak_nama(); 78 | } 79 | ``` 80 | 81 | hasilnya 82 | 83 | ```shell script 84 | halo nama saya adalah feri, salam kenal :) 85 | ``` 86 | ### Bentuk Pemanggilan Fungsi 87 | 88 | ada beberapa bentuk pemanggilan fungsi contoh 89 | 90 | ```dart 91 | 92 | double segitiga(int a, int b) { 93 | return 0.5 * a * b; 94 | } 95 | 96 | void main(List arguments) { 97 | 98 | // cetak fungsi 99 | print("hasil perhitungan " + segitiga(5, 10).toString()); 100 | } 101 | ``` 102 | 103 | hasilnya sama 104 | 105 | ```shell script 106 | hasil perhitungan 25.0 107 | ``` 108 | 109 | ### Optional - Named Parameter 110 | 111 | `optional parameter` adalah parameter yang tidak wajib di isi, 112 | kita bisa meggunakan tanda `{}` untuk membuat `optional named parameter` 113 | 114 | ```dart 115 | void bilang_halo({nama, ucapan, teman}) { 116 | print('$nama bilang ke $teman salam kenal si $teman bilang $ucapan'); 117 | } 118 | 119 | main(List args) { 120 | bilang_halo(nama: 'feri', ucapan: 'saya berasal dari jepara', teman: 'budi'); 121 | } 122 | ``` 123 | 124 | output 125 | 126 | ```shell script 127 | feri bilang ke budi salam kenal si budi bilang saya berasal dari jepara 128 | ``` 129 | 130 | > Note: keunggulan `optional named parameter` ini tidak harus urut karena sudah di definisikan dengan nama 131 | 132 | contoh lainya 133 | 134 | ```dart 135 | String pesan(String from, String message, {String? to, String? appName}) { 136 | return from + 137 | ' mengirim ' + message + 138 | ((to != null) ? ' to ' + to : '') + 139 | ((appName != null) ? ' via ' + appName : ''); 140 | } 141 | 142 | main(List args) { 143 | print(pesan('feri', 'halo')); 144 | } 145 | ``` 146 | 147 | hasilnya jika mengisi parameter wajib saja 148 | 149 | ```shell script 150 | feri mengirim halo 151 | 152 | Process finished with exit code 0 153 | ``` 154 | 155 | jika mengisi parameter `to` seperti ini 156 | 157 | ```shell script 158 | print(pesan('feri', 'halo', to: 'budi')); 159 | ``` 160 | 161 | hasilnya 162 | 163 | 164 | ```shell script 165 | feri mengirim halo to budi 166 | ``` 167 | 168 | jika mengisi semua parameter seperti ini 169 | 170 | ```shell script 171 | print(pesan('feri', 'halo', to: 'budi', appName: 'telegram')); 172 | ``` 173 | hasilnya 174 | 175 | ```shell script 176 | feri mengirim halo to budi via telegram 177 | ``` 178 | 179 | > Note: keungulanya kita tidak harus isi secara urut dan opsional aja bisa yang mana aja duluan 180 | 181 | contoh *isi parameter acak* 182 | 183 | ```dart 184 | String pesan(String from, String message, {String? to, String? appName}) { 185 | return from + 186 | ' mengirim ' + message + 187 | ((to != null) ? ' to ' + to : '') + 188 | ((appName != null) ? ' via ' + appName : ''); 189 | } 190 | 191 | main(List args) { 192 | print(pesan('feri', 'halo', appName: 'whatsapp')); 193 | } 194 | ``` 195 | 196 | output 197 | 198 | ```shell script 199 | feri mengirim halo via whatsapp 200 | ``` 201 | 202 | ### Optional - Positional Parameter 203 | 204 | adalah fungsi dengan `optional parameter` yang urut berdasarkan posisi 205 | kalo membuat `optional positional parameter` kita menggunakan `[]` (*kurung siku*) 206 | 207 | ```dart 208 | String pesan(String from, String message, [String? to, String? appName]) { 209 | return from + 210 | ' mengirim ' + message + 211 | ((to != null) ? ' to ' + to : '') + 212 | ((appName != null) ? ' via ' + appName : ''); 213 | } 214 | 215 | main(List args) { 216 | print(pesan('feri', 'halo', 'budi', 'telegram')); 217 | } 218 | ``` 219 | 220 | > Note: jika menggunakan `positional parameter` harus mengisi secara berurutan 221 | > contoh `print(pesan('feri', 'halo', 'budi', 'telegram'));` namun didak wajib diisi semuanya 222 | > boleh tidak diisi asalkan `urutanya tetap` 223 | 224 | contoh 225 | 226 | ```dart 227 | String pesan(String from, String message, [String? to, String? appName]) { 228 | return from + 229 | ' mengirim ' + message + 230 | ((to != null) ? ' to ' + to : '') + 231 | ((appName != null) ? ' via ' + appName : ''); 232 | } 233 | 234 | main(List args) { 235 | print(pesan('feri', 'halo', 'budi')); 236 | } 237 | ``` 238 | 239 | hasilnya 240 | 241 | ```shell script 242 | feri mengirim halo to budi 243 | ``` 244 | 245 | ### Default Parameter value 246 | 247 | adalah parameter fungsi yang memiliki nilai awal (`default`) jadi jika gak diisi maka nilai parameternya 248 | akan diisi oleh nilai awal tadi 249 | 250 | embuat nilai `default parameter` bisa menggunakan tanda `=` 251 | 252 | contoh 253 | 254 | ```dart 255 | String pesan(String from, String message, {String? to, String? appName = 'telegram'}) { 256 | return from + 257 | ' mengirim ' + message + 258 | ((to != null) ? ' to ' + to : '') + 259 | ((appName != null) ? ' via ' + appName : ''); 260 | } 261 | 262 | main(List args) { 263 | print(pesan('feri', 'halo')); 264 | } 265 | ``` 266 | 267 | bisa kita lihat di `appName = 'telegram'` jadi kita gak perlu ngisi 268 | cukup panggil dengan `print(pesan('feri', 'halo'));` 269 | 270 | outputnya 271 | 272 | ```shell script 273 | feri mengirim halo via telegram 274 | ``` 275 | 276 | ### Arrow Syntax (`=>`) atau Lambda Expression 277 | 278 | `Lambda` biasa digunakan untuk menyingkat fungsi yang mengembalikan nilai, jadi satu baris aja 279 | 280 | > Note: hanya boleh berupa `expression` yang memiliki nilai 281 | 282 | contohnya seperti ini 283 | 284 | ```dart 285 | double segitiga(int a, int b) => 0.5 * a * b; 286 | 287 | 288 | void main(List arguments) { 289 | 290 | // cetak fungsi 291 | print("hasil perhitungan " + segitiga(5, 10).toString()); 292 | } 293 | ``` 294 | 295 | hasilnya sama aja 296 | 297 | ```shell script 298 | hasil perhitungan 25.0 299 | ``` 300 | 301 | ### Fungsi adalah First Class Object 302 | 303 | lebih lanjut lagi tentang fungsi 304 | 305 | * fungsi dapat disimpan di variabel 306 | * fungsi dapat dimasukan sebagai paramater 307 | * fungsi dapat dijadikan nilai kembalian/`return` 308 | 309 | contoh 310 | 311 | ```dart 312 | double segitiga(int a, int b) => 0.5 * a * b; 313 | 314 | void main(List arguments) { 315 | // cetak fungsi 316 | Function tiga = segitiga; 317 | print("hasil perhitungan " + tiga(5, 10).toString()); 318 | } 319 | ``` 320 | 321 | ### Anonymous Function 322 | 323 | adalah fungsi yang ga memiliki nama, contoh penggunaan 324 | 325 | ```dart 326 | int matematika(int num1, int num2, Function counting) => counting(num1, num2); 327 | 328 | void main(List arguments) { 329 | // cetak fungsi 330 | print("hasil perhitungan " + 331 | matematika(10, 20, (int num1, int num2) => num1 + num2).toString()); 332 | } 333 | ``` 334 | 335 | atau lebih spesifik lagi 336 | 337 | ```dart 338 | int matematika(int num1, int num2, Function(int, int) counting) => counting(num1, num2); 339 | 340 | void main(List arguments) { 341 | // cetak fungsi 342 | print("hasil perhitungan " + 343 | matematika(10, 20, (int num1, int num2) => num1 + num2).toString()); 344 | } 345 | 346 | ``` 347 | 348 | hasilnya 349 | 350 | ```shell script 351 | hasil perhitungan 30 352 | ``` 353 | 354 | ### Referensi dan Resource 355 | 356 | * [Dokumentasi](https://dart.dev/guides/language/language-tour#functions) 357 | 358 | --- 359 | 360 | [Perulangan](../perulangan/README.md) <> [List dan Mapping](../mapping/README.md) -------------------------------------------------------------------------------- /fungsi/analysis_options.yaml: -------------------------------------------------------------------------------- 1 | # Defines a default set of lint rules enforced for projects at Google. For 2 | # details and rationale, see 3 | # https://github.com/dart-lang/pedantic#enabled-lints. 4 | 5 | include: package:pedantic/analysis_options.yaml 6 | 7 | # For lint rules and documentation, see http://dart-lang.github.io/linter/lints. 8 | 9 | # Uncomment to specify additional rules. 10 | # linter: 11 | # rules: 12 | # - camel_case_types 13 | 14 | # analyzer: 15 | # exclude: 16 | # - path/to/excluded/files/** 17 | -------------------------------------------------------------------------------- /fungsi/bin/_contohdefault_params.dart: -------------------------------------------------------------------------------- 1 | String pesan(String from, String message, {String? to, String? appName = 'telegram'}) { 2 | return from + 3 | ' mengirim ' + message + 4 | ((to != null) ? ' to ' + to : '') + 5 | ((appName != null) ? ' via ' + appName : ''); 6 | } 7 | 8 | main(List args) { 9 | print(pesan('feri', 'halo')); 10 | } 11 | -------------------------------------------------------------------------------- /fungsi/bin/anon_func.dart: -------------------------------------------------------------------------------- 1 | int matematika(int num1, int num2, Function counting) => counting(num1, num2); 2 | 3 | void main(List arguments) { 4 | // cetak fungsi 5 | print("hasil perhitungan " + 6 | matematika(10, 20, (int num1, int num2) => num1 + num2).toString()); 7 | } 8 | -------------------------------------------------------------------------------- /fungsi/bin/anon_func2.dart: -------------------------------------------------------------------------------- 1 | int matematika(int num1, int num2, Function(int, int) counting) => counting(num1, num2); 2 | 3 | void main(List arguments) { 4 | // cetak fungsi 5 | print("hasil perhitungan " + 6 | matematika(10, 20, (int num1, int num2) => num1 + num2).toString()); 7 | } 8 | -------------------------------------------------------------------------------- /fungsi/bin/bentuk_pemanggilan.dart: -------------------------------------------------------------------------------- 1 | 2 | double segitiga(int a, int b) { 3 | return 0.5 * a * b; 4 | } 5 | 6 | void main(List arguments) { 7 | 8 | // cetak fungsi 9 | print("hasil perhitungan " + segitiga(5, 10).toString()); 10 | } 11 | -------------------------------------------------------------------------------- /fungsi/bin/contoh_lamda.dart: -------------------------------------------------------------------------------- 1 | double segitiga(int a, int b) => 0.5 * a * b; 2 | 3 | 4 | void main(List arguments) { 5 | 6 | // cetak fungsi 7 | print("hasil perhitungan " + segitiga(5, 10).toString()); 8 | } 9 | -------------------------------------------------------------------------------- /fungsi/bin/contoh_void.dart: -------------------------------------------------------------------------------- 1 | void cetak_nama() { 2 | print('halo nama saya adalah feri, salam kenal :)'); 3 | } 4 | main(List args) { 5 | cetak_nama(); 6 | } -------------------------------------------------------------------------------- /fungsi/bin/func_params.dart: -------------------------------------------------------------------------------- 1 | double segitiga(int a, int b) => 0.5 * a * b; 2 | 3 | void main(List arguments) { 4 | // cetak fungsi 5 | Function tiga = segitiga; 6 | print("hasil perhitungan " + tiga(5, 10).toString()); 7 | } 8 | -------------------------------------------------------------------------------- /fungsi/bin/fungsi.dart: -------------------------------------------------------------------------------- 1 | 2 | double segitiga(int a, int b) { 3 | return 0.5 * a * b; 4 | } 5 | 6 | void main(List arguments) { 7 | // panggil fungsi 8 | double luas = segitiga(5, 10); 9 | 10 | // cetak fungsi 11 | print('hasil perhitunganya adalah: ' + luas.toString()); 12 | } 13 | -------------------------------------------------------------------------------- /fungsi/bin/name_params_case.dart: -------------------------------------------------------------------------------- 1 | String pesan(String from, String message, {String? to, String? appName}) { 2 | return from + 3 | ' mengirim ' + message + 4 | ((to != null) ? ' to ' + to : '') + 5 | ((appName != null) ? ' via ' + appName : ''); 6 | } 7 | 8 | main(List args) { 9 | print(pesan('feri', 'halo', to: 'budi', appName: 'telegram')); 10 | } 11 | -------------------------------------------------------------------------------- /fungsi/bin/opti_name_params.dart: -------------------------------------------------------------------------------- 1 | 2 | void bilang_halo({nama, ucapan, teman}) { 3 | print('$nama bilang ke $teman salam kenal si $teman bilang $ucapan'); 4 | } 5 | 6 | main(List args) { 7 | bilang_halo(nama: 'feri', ucapan: 'saya berasal dari jepara', teman: 'budi'); 8 | } -------------------------------------------------------------------------------- /fungsi/bin/opti_posisi_params.dart: -------------------------------------------------------------------------------- 1 | String pesan(String from, String message, [String? to, String? appName]) { 2 | return from + 3 | ' mengirim ' + message + 4 | ((to != null) ? ' to ' + to : '') + 5 | ((appName != null) ? ' via ' + appName : ''); 6 | } 7 | 8 | main(List args) { 9 | print(pesan('feri', 'halo', 'budi')); 10 | } 11 | -------------------------------------------------------------------------------- /fungsi/bin/optiname_ver2.dart: -------------------------------------------------------------------------------- 1 | String pesan(String from, String message, {String? to, String? appName}) { 2 | return from + 3 | ' mengirim ' + message + 4 | ((to != null) ? ' to ' + to : '') + 5 | ((appName != null) ? ' via ' + appName : ''); 6 | } 7 | 8 | main(List args) { 9 | print(pesan('feri', 'halo', appName: 'whatsapp')); 10 | } 11 | -------------------------------------------------------------------------------- /fungsi/docs/resep_es_rumput_laut_2.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/perymerdeka/mastering-dart/5eee63cbc6c9df07e9454f89cd3e2cbccc07eb40/fungsi/docs/resep_es_rumput_laut_2.jpg -------------------------------------------------------------------------------- /fungsi/lib/fungsi.dart: -------------------------------------------------------------------------------- 1 | int calculate() { 2 | return 6 * 7; 3 | } 4 | -------------------------------------------------------------------------------- /fungsi/pubspec.yaml: -------------------------------------------------------------------------------- 1 | name: fungsi 2 | description: A sample command-line application. 3 | version: 1.0.0 4 | # homepage: https://www.example.com 5 | 6 | environment: 7 | sdk: '>=2.12.0 <3.0.0' 8 | 9 | # dependencies: 10 | # path: ^1.8.0 11 | 12 | dev_dependencies: 13 | pedantic: ^1.10.0 14 | test: ^1.16.0 15 | -------------------------------------------------------------------------------- /fungsi/test/fungsi_test.dart: -------------------------------------------------------------------------------- 1 | import 'package:fungsi/fungsi.dart'; 2 | import 'package:test/test.dart'; 3 | 4 | void main() { 5 | test('calculate', () { 6 | expect(calculate(), 42); 7 | }); 8 | } 9 | -------------------------------------------------------------------------------- /furure_or/.gitignore: -------------------------------------------------------------------------------- 1 | # Files and directories created by pub. 2 | .dart_tool/ 3 | .packages 4 | 5 | # Conventional directory for build output. 6 | build/ 7 | -------------------------------------------------------------------------------- /furure_or/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.0 2 | 3 | - Initial version. 4 | -------------------------------------------------------------------------------- /furure_or/README.md: -------------------------------------------------------------------------------- 1 | ### FutureOr 2 | 3 | fungsi `FutureOr` ini adalah untuk mengakomodasi tipe kembalian yang bisa berupa `Future` atau langsung tipe datanya contoh 4 | 5 | ```dart 6 | import 'dart:async'; 7 | 8 | void main(List arguments) async{ 9 | User user = User(); 10 | UserManager userManager = UserManager(FireBaseStorage()); 11 | print(await userManager.getUserAge(user)); 12 | } 13 | 14 | class User { 15 | // User Related Data 16 | int age = 0; 17 | } 18 | 19 | class UserManager { 20 | final IDataStorage datastorage; 21 | 22 | UserManager(this.datastorage); 23 | 24 | void saveDataStorage(User user) { 25 | datastorage.saveData(user); 26 | } 27 | 28 | // future or 29 | FutureOr getUserAge(User user) async { 30 | return await datastorage.getUserAge(user); 31 | } 32 | } 33 | 34 | abstract class IDataStorage { 35 | void saveData(User user); 36 | FutureOr getUserAge(User user); 37 | } 38 | 39 | class FireBaseStorage implements IDataStorage { 40 | @override 41 | void saveData(User user) { 42 | // connect to Firebase 43 | // save data 44 | } 45 | @override 46 | FutureOr getUserAge(User user) async { 47 | // TODO: implement getUserAge 48 | // ambil user age 49 | await Future.delayed(Duration(seconds: 3)); 50 | return 20; 51 | } 52 | } 53 | 54 | class LocalStorage implements IDataStorage { 55 | @override 56 | void saveData(User user) { 57 | // TODO: implement saveData 58 | // connect data to local 59 | // save data 60 | } 61 | 62 | @override 63 | FutureOr getUserAge(user) { 64 | // ambil tanggal lahir 65 | // bandingkan 66 | // hitung umur 67 | return 10; 68 | } 69 | } 70 | ``` 71 | hasilnya ketika kita menunggu 3 detik hasilnya 72 | 73 | ``` 74 | 20 75 | ``` 76 | 77 | --- 78 | 79 | [Singleton](../singleton/README.md) <> [tipe data `var` dan `dynamic`](../dynamic_vars/README.md) -------------------------------------------------------------------------------- /furure_or/analysis_options.yaml: -------------------------------------------------------------------------------- 1 | # Defines a default set of lint rules enforced for projects at Google. For 2 | # details and rationale, see 3 | # https://github.com/dart-lang/pedantic#enabled-lints. 4 | 5 | include: package:pedantic/analysis_options.yaml 6 | 7 | # For lint rules and documentation, see http://dart-lang.github.io/linter/lints. 8 | 9 | # Uncomment to specify additional rules. 10 | # linter: 11 | # rules: 12 | # - camel_case_types 13 | 14 | # analyzer: 15 | # exclude: 16 | # - path/to/excluded/files/** 17 | -------------------------------------------------------------------------------- /furure_or/bin/furure_or.dart: -------------------------------------------------------------------------------- 1 | import 'dart:async'; 2 | 3 | void main(List arguments) async{ 4 | User user = User(); 5 | UserManager userManager = UserManager(FireBaseStorage()); 6 | print(await userManager.getUserAge(user)); 7 | } 8 | 9 | class User { 10 | // User Related Data 11 | int age = 0; 12 | } 13 | 14 | class UserManager { 15 | final IDataStorage datastorage; 16 | 17 | UserManager(this.datastorage); 18 | 19 | void saveDataStorage(User user) { 20 | datastorage.saveData(user); 21 | } 22 | 23 | // future or 24 | FutureOr getUserAge(User user) async { 25 | return await datastorage.getUserAge(user); 26 | } 27 | } 28 | 29 | abstract class IDataStorage { 30 | void saveData(User user); 31 | FutureOr getUserAge(User user); 32 | } 33 | 34 | class FireBaseStorage implements IDataStorage { 35 | @override 36 | void saveData(User user) { 37 | // connect to Firebase 38 | // save data 39 | } 40 | @override 41 | FutureOr getUserAge(User user) async { 42 | // TODO: implement getUserAge 43 | // ambil user age 44 | await Future.delayed(Duration(seconds: 3)); 45 | return 20; 46 | } 47 | } 48 | 49 | class LocalStorage implements IDataStorage { 50 | @override 51 | void saveData(User user) { 52 | // TODO: implement saveData 53 | // connect data to local 54 | // save data 55 | } 56 | 57 | @override 58 | FutureOr getUserAge(user) { 59 | // ambil tanggal lahir 60 | // bandingkan 61 | // hitung umur 62 | return 10; 63 | } 64 | } 65 | -------------------------------------------------------------------------------- /furure_or/lib/furure_or.dart: -------------------------------------------------------------------------------- 1 | int calculate() { 2 | return 6 * 7; 3 | } 4 | -------------------------------------------------------------------------------- /furure_or/pubspec.yaml: -------------------------------------------------------------------------------- 1 | name: furure_or 2 | description: A sample command-line application. 3 | version: 1.0.0 4 | # homepage: https://www.example.com 5 | 6 | environment: 7 | sdk: '>=2.12.0 <3.0.0' 8 | 9 | # dependencies: 10 | # path: ^1.8.0 11 | 12 | dev_dependencies: 13 | pedantic: ^1.10.0 14 | test: ^1.16.0 15 | -------------------------------------------------------------------------------- /furure_or/test/furure_or_test.dart: -------------------------------------------------------------------------------- 1 | import 'package:furure_or/furure_or.dart'; 2 | import 'package:test/test.dart'; 3 | 4 | void main() { 5 | test('calculate', () { 6 | expect(calculate(), 42); 7 | }); 8 | } 9 | -------------------------------------------------------------------------------- /generic/.gitignore: -------------------------------------------------------------------------------- 1 | # Files and directories created by pub. 2 | .dart_tool/ 3 | .packages 4 | 5 | # Conventional directory for build output. 6 | build/ 7 | -------------------------------------------------------------------------------- /generic/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.0 2 | 3 | - Initial version. 4 | -------------------------------------------------------------------------------- /generic/README.md: -------------------------------------------------------------------------------- 1 | ### Generic Type 2 | 3 | adalah keyword untuk mengantikan tipe data supaya tipe data menjadi global secara umum dilambangkan 4 | 5 | `T` diambil dari kata `Type` seperti ini 6 | 7 | ```dart 8 | class SecureBox { 9 | final T _data; 10 | final String _pin; 11 | 12 | SecureBox(this._data, this._pin); 13 | 14 | T? getDate(String pin) => (pin == _pin) ? _data : null; 15 | } 16 | ``` 17 | 18 | kemudian penerapan nya di `main` kaya gini 19 | 20 | ```dart 21 | import 'package:generic/secure_box.dart'; 22 | 23 | void main(List arguments) { 24 | var box = SecureBox('test data', '123'); 25 | 26 | // get data 27 | print(box.getDate('123').toString()); 28 | } 29 | ``` 30 | 31 | kemudian kalo kita jalankan seperti ini 32 | 33 | ``` 34 | test data 35 | ``` 36 | 37 | contoh lagi misal datanya jadi `int` kita tinggal otak atik main 38 | 39 | 40 | ```dart 41 | import 'package:generic/secure_box.dart'; 42 | 43 | void main(List arguments) { 44 | var box = SecureBox(124, '123'); 45 | 46 | // get data 47 | print(box.getDate('123').toString()); 48 | } 49 | ``` 50 | 51 | hasilnya 52 | 53 | ``` 54 | 124 55 | ``` 56 | 57 | --- 58 | 59 | [Final dan Const](../final_const/README.md) <> [Enum dan Cascade Notation](../enums/README.md) -------------------------------------------------------------------------------- /generic/analysis_options.yaml: -------------------------------------------------------------------------------- 1 | # Defines a default set of lint rules enforced for projects at Google. For 2 | # details and rationale, see 3 | # https://github.com/dart-lang/pedantic#enabled-lints. 4 | 5 | include: package:pedantic/analysis_options.yaml 6 | 7 | # For lint rules and documentation, see http://dart-lang.github.io/linter/lints. 8 | 9 | # Uncomment to specify additional rules. 10 | # linter: 11 | # rules: 12 | # - camel_case_types 13 | 14 | # analyzer: 15 | # exclude: 16 | # - path/to/excluded/files/** 17 | -------------------------------------------------------------------------------- /generic/bin/generic.dart: -------------------------------------------------------------------------------- 1 | import 'package:generic/secure_box.dart'; 2 | 3 | void main(List arguments) { 4 | var box = SecureBox('test data', '123'); 5 | 6 | // get data 7 | print(box.getDate('123').toString()); 8 | } 9 | -------------------------------------------------------------------------------- /generic/lib/generic.dart: -------------------------------------------------------------------------------- 1 | class DateTimeSecureBox { 2 | final DateTime _data; 3 | final String _pin; 4 | 5 | DateTimeSecureBox(this._data, this._pin); 6 | 7 | DateTime? getDate(String pin) => (pin == _pin) ? _data : null; 8 | } -------------------------------------------------------------------------------- /generic/lib/secure_box.dart: -------------------------------------------------------------------------------- 1 | class SecureBox { 2 | final T _data; 3 | final String _pin; 4 | 5 | SecureBox(this._data, this._pin); 6 | 7 | T? getDate(String pin) => (pin == _pin) ? _data : null; 8 | } -------------------------------------------------------------------------------- /generic/pubspec.yaml: -------------------------------------------------------------------------------- 1 | name: generic 2 | description: A sample command-line application. 3 | version: 1.0.0 4 | # homepage: https://www.example.com 5 | 6 | environment: 7 | sdk: '>=2.12.0 <3.0.0' 8 | 9 | # dependencies: 10 | # path: ^1.8.0 11 | 12 | dev_dependencies: 13 | pedantic: ^1.10.0 14 | test: ^1.16.0 15 | -------------------------------------------------------------------------------- /inherit/.gitignore: -------------------------------------------------------------------------------- 1 | # Files and directories created by pub. 2 | .dart_tool/ 3 | .packages 4 | 5 | # Conventional directory for build output. 6 | build/ 7 | -------------------------------------------------------------------------------- /inherit/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.0 2 | 3 | - Initial version. 4 | -------------------------------------------------------------------------------- /inherit/README.md: -------------------------------------------------------------------------------- 1 | ### Inheritance 2 | 3 | --- 4 | 5 | 6 | pewarisan suattu class diwarisi method dan attribute dari kelas lain kelas yang mewariskan disebut `parent class` kemudian yang menerima warisan disebut `child class` 7 | 8 | #### Studi kasus 9 | 10 | misalnya kita mempunyai dua buah class 11 | 12 | ```dart 13 | // monster.dart 14 | 15 | class Monster { 16 | late int _healthPoint; 17 | 18 | int get healthPoint => _healthPoint; 19 | set healthPoint(value) => _healthPoint = value; 20 | 21 | String eatHuman() => 'yummy'; 22 | } 23 | ``` 24 | 25 | ```dart 26 | // hero.dart 27 | 28 | class Hero { 29 | late int _healthPoint; 30 | 31 | int get healthPoint => _healthPoint; 32 | set healthPoint (int value) => _healthPoint = value; 33 | 34 | String killAllMonster() => 'take this'; 35 | } 36 | ``` 37 | jika kita lihat ada bebrapa duplikat kan 38 | 39 | kita bisa buat lebih praktis misalnya kita buat file baru namanya `character.dart` lalu isi dengan 40 | 41 | ```dart 42 | class Character { 43 | late int _healthPoint; 44 | 45 | int get healthPoint => _healthPoint; 46 | set healthPoint(value) { 47 | if (value < 0) { 48 | value *= -1; 49 | } 50 | 51 | _healthPoint = value; 52 | } 53 | } 54 | ``` 55 | 56 | kemudian kita ubah seperti ini 57 | 58 | 59 | untuk pemanggilan kita cukup panggil sekali aja, btw untuk ubahnya bisa diubah seperti ini di tiap `class` yang akan kita 60 | lakukan inheritance 61 | 62 | ```dart 63 | // lib/hero.dart 64 | import 'package:inherit/character.dart'; 65 | 66 | class Hero extends Character { 67 | 68 | String killAllMonster() => 'take this'; 69 | } 70 | ``` 71 | 72 | ```dart 73 | // lib/monster.dart 74 | import 'package:inherit/character.dart'; 75 | 76 | class Monster extends Character { 77 | 78 | String eatHuman() => 'yummy'; 79 | } 80 | ``` 81 | 82 | contoh pemanggilanya kaya gini 83 | 84 | ```dart 85 | // /bin/inherit.dart 86 | 87 | import 'package:inherit/hero.dart'; 88 | import 'package:inherit/monster.dart'; 89 | 90 | void main(List arguments) { 91 | Hero hero = new Hero(); 92 | Monster monster = new Monster(); 93 | 94 | // inisialisasi 95 | hero.healthPoint = -10; 96 | monster.healthPoint = 30; 97 | 98 | // pemanggilan 99 | print('Hero HP: ' + hero.healthPoint.toString()); 100 | print('monster HP: ' + monster.healthPoint.toString()); 101 | 102 | // object class 103 | print(hero.killAllMonster()); 104 | print(monster.eatHuman()); 105 | } 106 | 107 | ``` 108 | 109 | outputnya 110 | 111 | ``` 112 | Hero HP: 10 113 | monster HP: 30 114 | take this 115 | yummy 116 | ``` 117 | 118 | disini kesimpulanya jika menggunaan `inheritance` ketika pengen ubah keseluruhan method kita cukup ubah methodny di `parrent class` kemudian jika ingin menambah method atau mengubah method tertentu yang hanya ada di class turunan kita cukup ubah di `child class` masing-masing. 119 | 120 | #### Contoh Lain 121 | 122 | kita bisa mewariskan class lagi secara lebih spesifik lagi misalnya kita `extends` `class` turunan seperti ini 123 | 124 | ```dart 125 | import 'package:inherit/monster.dart'; 126 | 127 | class MonsterUbur extends Monster { 128 | String berenang () => 'slup slup'; 129 | } 130 | ``` 131 | 132 | dan 133 | 134 | ```dart 135 | import 'package:inherit/monster.dart'; 136 | 137 | class MonsterBurung extends Monster{ 138 | String fly () { 139 | return 'woosh'; 140 | } 141 | } 142 | ``` 143 | 144 | keudian dapat kita panggil seperti ini 145 | 146 | ```dart 147 | import 'package:inherit/hero.dart'; 148 | import 'package:inherit/monster.dart'; 149 | import 'package:inherit/monster_burung.dart'; 150 | import 'package:inherit/monster_ubur.dart'; 151 | 152 | void main(List arguments) { 153 | Hero hero = new Hero(); 154 | Monster monster = new Monster(); 155 | 156 | // objectt baru 157 | MonsterUbur ubur = new MonsterUbur(); 158 | MonsterBurung burung = new MonsterBurung(); 159 | 160 | // inisialisasi 161 | hero.healthPoint = -10; 162 | monster.healthPoint = 30; 163 | 164 | // pemanggilan 165 | print('Hero HP: ' + hero.healthPoint.toString()); 166 | print('monster HP: ' + monster.healthPoint.toString()); 167 | 168 | // object class 169 | print(hero.killAllMonster()); 170 | print(monster.eatHuman()); 171 | 172 | // object baru 173 | print('Monster Ubur-ubur: ' + ubur.berenang().toString()); 174 | print('Monster Burung: ' + burung.fly().toString()); 175 | } 176 | ``` 177 | 178 | outputnya 179 | 180 | ``` 181 | Hero HP: 10 182 | monster HP: 30 183 | take this 184 | yummy 185 | Monster Ubur-ubur: slup slup 186 | Monster Burung: woosh 187 | ``` 188 | 189 | penggunaan lainya kita bisa menampung object ke sebuah list, 190 | contoh 191 | 192 | ```dart 193 | // tampung object 194 | List monsters = []; 195 | 196 | // add object 197 | monsters.add(MonsterUbur()); 198 | monsters.add(MonsterBurung()); 199 | 200 | for (Monster monster in monsters) { 201 | print(monster.eatHuman()); 202 | } 203 | ``` 204 | 205 | lengkapnya seperti ini 206 | 207 | ```dart 208 | import 'package:inherit/hero.dart'; 209 | import 'package:inherit/monster.dart'; 210 | import 'package:inherit/monster_burung.dart'; 211 | import 'package:inherit/monster_ubur.dart'; 212 | 213 | void main(List arguments) { 214 | Hero hero = new Hero(); 215 | Monster monster = new Monster(); 216 | 217 | // objects baru 218 | MonsterUbur ubur = new MonsterUbur(); 219 | MonsterBurung burung = new MonsterBurung(); 220 | 221 | // tampung object 222 | List monsters = []; 223 | 224 | // add object 225 | monsters.add(MonsterUbur()); 226 | monsters.add(MonsterBurung()); 227 | 228 | for (Monster monster in monsters) { 229 | print(monster.eatHuman()); 230 | } 231 | } 232 | ``` 233 | 234 | disini kita menjalankan 2 method dari sebuah class outpunya 235 | 236 | ``` 237 | yummy 238 | yummy 239 | ``` 240 | 241 | 242 | ### Keywords `as`dan `is` 243 | 244 | #### Keyword is 245 | 246 | keyword ini biasa digunakan untuk mengecek sebuah `object` 247 | 248 | contoh 249 | 250 | ```dart 251 | for (Monster monster in monsters) { 252 | if (monster is MonsterBurung) { 253 | print(monster.eatHuman()); 254 | } 255 | } 256 | ``` 257 | 258 | maka keluarnya hanya satu aja 259 | 260 | ``` 261 | yummy 262 | ``` 263 | #### Keyword `as` 264 | 265 | keyword ini digunakan untuk mendefinisikan secara spesifik suatu object contoh seperti ini 266 | 267 | ```dart 268 | // keyword as 269 | print('monster burung'); 270 | print((m as MonsterBurung).fly()); 271 | ``` 272 | lengkap penerapanya begini 273 | 274 | ```dart 275 | import 'package:inherit/hero.dart'; 276 | import 'package:inherit/monster.dart'; 277 | import 'package:inherit/monster_burung.dart'; 278 | import 'package:inherit/monster_ubur.dart'; 279 | 280 | void main(List arguments) { 281 | Hero hero = new Hero(); 282 | Monster m = new MonsterBurung(); 283 | 284 | // objects baru 285 | MonsterUbur ubur = new MonsterUbur(); 286 | MonsterBurung burung = new MonsterBurung(); 287 | 288 | // tampung object 289 | List monsters = []; 290 | 291 | // add object 292 | monsters.add(MonsterUbur()); 293 | monsters.add(MonsterBurung()); 294 | 295 | // keyword as 296 | print('monster burung'); 297 | print((m as MonsterBurung).fly()); 298 | } 299 | ``` 300 | 301 | outputnya seperti ini 302 | 303 | ``` 304 | monster burung 305 | woosh 306 | yummy 307 | ``` 308 | 309 | > Note: Contoh kasusnya seperti ini 310 | > kalo misalnya kita membuat turunan dari suato object lebih dari 1 `class` maka 311 | > untuk untuk mengeksekusi method dari class tertentu yang mempunyai turunan sama 312 | > dengan class lainya kita bisa pake keyword `as` 313 | 314 | --- 315 | 316 | [enkapsulasi](../enkapsulasi/README.md) <> [Abstract Class](../absract_class/README.md) 317 | -------------------------------------------------------------------------------- /inherit/analysis_options.yaml: -------------------------------------------------------------------------------- 1 | # Defines a default set of lint rules enforced for projects at Google. For 2 | # details and rationale, see 3 | # https://github.com/dart-lang/pedantic#enabled-lints. 4 | 5 | include: package:pedantic/analysis_options.yaml 6 | 7 | # For lint rules and documentation, see http://dart-lang.github.io/linter/lints. 8 | 9 | # Uncomment to specify additional rules. 10 | # linter: 11 | # rules: 12 | # - camel_case_types 13 | 14 | # analyzer: 15 | # exclude: 16 | # - path/to/excluded/files/** 17 | -------------------------------------------------------------------------------- /inherit/bin/inherit.dart: -------------------------------------------------------------------------------- 1 | import 'package:inherit/hero.dart'; 2 | import 'package:inherit/monster.dart'; 3 | import 'package:inherit/monster_burung.dart'; 4 | import 'package:inherit/monster_ubur.dart'; 5 | 6 | void main(List arguments) { 7 | Hero hero = new Hero(); 8 | Monster monster = new Monster(); 9 | 10 | // objectt baru 11 | MonsterUbur ubur = new MonsterUbur(); 12 | MonsterBurung burung = new MonsterBurung(); 13 | 14 | // inisialisasi 15 | hero.healthPoint = -10; 16 | monster.healthPoint = 30; 17 | 18 | // pemanggilan 19 | print('Hero HP: ' + hero.healthPoint.toString()); 20 | print('monster HP: ' + monster.healthPoint.toString()); 21 | 22 | // object class 23 | print(hero.killAllMonster()); 24 | print(monster.eatHuman()); 25 | 26 | // object baru 27 | print('Monster Ubur-ubur: ' + ubur.berenang().toString()); 28 | print('Monster Burung: ' + burung.fly().toString()); 29 | } 30 | -------------------------------------------------------------------------------- /inherit/bin/new_inherit.dart: -------------------------------------------------------------------------------- 1 | import 'package:inherit/hero.dart'; 2 | import 'package:inherit/monster.dart'; 3 | import 'package:inherit/monster_burung.dart'; 4 | import 'package:inherit/monster_ubur.dart'; 5 | 6 | void main(List arguments) { 7 | Hero hero = new Hero(); 8 | Monster m = new MonsterBurung(); 9 | 10 | // objects baru 11 | MonsterUbur ubur = new MonsterUbur(); 12 | MonsterBurung burung = new MonsterBurung(); 13 | 14 | // tampung object 15 | List monsters = []; 16 | 17 | // add object 18 | monsters.add(MonsterUbur()); 19 | monsters.add(MonsterBurung()); 20 | 21 | // keyword as 22 | print('monster burung'); 23 | print((m as MonsterBurung).fly()); 24 | 25 | for (Monster monster in monsters) { 26 | if (monster is MonsterBurung) { 27 | print(monster.eatHuman()); 28 | } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /inherit/lib/character.dart: -------------------------------------------------------------------------------- 1 | class Character { 2 | late int _healthPoint; 3 | 4 | int get healthPoint => _healthPoint; 5 | set healthPoint(int value) { 6 | if (value < 0) { 7 | value *= -1; 8 | } 9 | 10 | _healthPoint = value; 11 | } 12 | } -------------------------------------------------------------------------------- /inherit/lib/hero.dart: -------------------------------------------------------------------------------- 1 | import 'package:inherit/character.dart'; 2 | 3 | class Hero extends Character { 4 | 5 | String killAllMonster() => 'take this'; 6 | } -------------------------------------------------------------------------------- /inherit/lib/monster.dart: -------------------------------------------------------------------------------- 1 | import 'package:inherit/character.dart'; 2 | 3 | class Monster extends Character { 4 | 5 | String eatHuman() => 'yummy'; 6 | } -------------------------------------------------------------------------------- /inherit/lib/monster_burung.dart: -------------------------------------------------------------------------------- 1 | import 'package:inherit/monster.dart'; 2 | 3 | class MonsterBurung extends Monster { 4 | String fly () { 5 | return 'woosh'; 6 | } 7 | } -------------------------------------------------------------------------------- /inherit/lib/monster_ubur.dart: -------------------------------------------------------------------------------- 1 | import 'package:inherit/monster.dart'; 2 | 3 | class MonsterUbur extends Monster { 4 | String berenang () => 'slup slup'; 5 | } -------------------------------------------------------------------------------- /inherit/pubspec.yaml: -------------------------------------------------------------------------------- 1 | name: inherit 2 | description: A sample command-line application. 3 | version: 1.0.0 4 | # homepage: https://www.example.com 5 | 6 | environment: 7 | sdk: '>=2.12.0 <3.0.0' 8 | 9 | # dependencies: 10 | # path: ^1.8.0 11 | 12 | dev_dependencies: 13 | pedantic: ^1.10.0 14 | test: ^1.16.0 15 | -------------------------------------------------------------------------------- /mapping/.gitignore: -------------------------------------------------------------------------------- 1 | # Files and directories created by pub. 2 | .dart_tool/ 3 | .packages 4 | 5 | # Conventional directory for build output. 6 | build/ 7 | -------------------------------------------------------------------------------- /mapping/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.0 2 | 3 | - Initial version. 4 | -------------------------------------------------------------------------------- /mapping/README.md: -------------------------------------------------------------------------------- 1 | ### List, Set dan Mapping 2 | 3 | --- 4 | 5 | ### List 6 | adalah kumpulan `array object` jika dalam bahasa pemrograman lain disebut `array` klo di dart disebut 7 | `List` 8 | 9 | #### contoh penggunaan 10 | 11 | contoh penggunaan list 12 | 13 | ```dart 14 | main(List args) { 15 | List dataList = []; 16 | 17 | List numbers = [1, 2, 3, 4]; 18 | 19 | // akses list 20 | print('list ke 0 adalah'); 21 | print(numbers[0]); // akses index ke 0 22 | 23 | dataList.add(20); // dambah 1 item ke datalist 24 | dataList.addAll([10, 20,30]); // tambah item ke list 25 | 26 | // insert ke index tertentu 27 | dataList.insert(0, 50); // nilai baru ke data list index ke 0 28 | 29 | dataList.insertAll(1, numbers); // insert iterable item ke index tertentu 30 | 31 | // hasil akhir 32 | print(dataList); 33 | } 34 | ``` 35 | 36 | contoh outputnya 37 | 38 | ```shell script 39 | list ke 0 adalah 40 | 1 41 | [50, 1, 2, 3, 4, 20, 10, 20, 30] 42 | ``` 43 | 44 | ### Penerapan menggunakan Looping 45 | 46 | ada beberapa penerapan perulangan pada list 47 | * `for` 48 | * `for in` 49 | * `for Each` 50 | 51 | #### `for` 52 | 53 | penerapanya seperti ini 54 | 55 | ```dart 56 | // looping for pada list 57 | for ( int index = 0; index < dataList.length; index++) { 58 | print(dataList[index]); 59 | } 60 | ``` 61 | 62 | lengkapnya 63 | 64 | ```dart 65 | main(List args) { 66 | List dataList = []; 67 | 68 | List numbers = [1, 2, 3, 4]; 69 | 70 | // akses list 71 | print('list ke 0 adalah'); 72 | print(numbers[0]); // akses index ke 0 73 | 74 | dataList.add(20); // dambah 1 item ke datalist 75 | dataList.addAll([10, 20,30]); // tambah item ke list 76 | 77 | // insert ke index tertentu 78 | dataList.insert(0, 50); // nilai baru ke data list index ke 0 79 | 80 | dataList.insertAll(1, numbers); // insert iterable item ke index tertentu 81 | 82 | // looping for pada list 83 | for (int index =0; index < dataList.length; index++) { 84 | print(dataList[index]); 85 | } 86 | 87 | } 88 | ``` 89 | 90 | output 91 | 92 | ```shell script 93 | 1 94 | 50 95 | 1 96 | 2 97 | 3 98 | 4 99 | 20 100 | 10 101 | 20 102 | 30 103 | ``` 104 | 105 | #### `for in` 106 | 107 | penerapanya seperti ini 108 | 109 | ```dart 110 | // looping for pada list 111 | for (int index in dataList) { 112 | print(index); 113 | } 114 | ``` 115 | 116 | lengkapnya 117 | 118 | 119 | ```dart 120 | main(List args) { 121 | List dataList = []; 122 | 123 | List numbers = [1, 2, 3, 4]; 124 | 125 | // akses list 126 | print('list ke 0 adalah'); 127 | print(numbers[0]); // akses index ke 0 128 | 129 | dataList.add(20); // dambah 1 item ke datalist 130 | dataList.addAll([10, 20,30]); // tambah item ke list 131 | 132 | // insert ke index tertentu 133 | dataList.insert(0, 50); // nilai baru ke data list index ke 0 134 | 135 | dataList.insertAll(1, numbers); // insert iterable item ke index tertentu 136 | 137 | // looping for pada list 138 | for (int index in dataList) { 139 | print(index); 140 | } 141 | 142 | } 143 | ``` 144 | ```shell script 145 | 1 146 | 50 147 | 1 148 | 2 149 | 3 150 | 4 151 | 20 152 | 10 153 | 20 154 | 30 155 | ``` 156 | 157 | #### `for each` 158 | 159 | contoh penerapan `forEach` seperti ini 160 | 161 | ```dart 162 | // looping for pada list 163 | dataList.forEach((element) { 164 | print(element); 165 | }); 166 | ``` 167 | 168 | lengkapnya 169 | 170 | ```dart 171 | main(List args) { 172 | List dataList = []; 173 | 174 | List numbers = [1, 2, 3, 4]; 175 | 176 | // akses list 177 | print('list ke 0 adalah'); 178 | print(numbers[0]); // akses index ke 0 179 | 180 | dataList.add(20); // dambah 1 item ke datalist 181 | dataList.addAll([10, 20,30]); // tambah item ke list 182 | 183 | // insert ke index tertentu 184 | dataList.insert(0, 50); // nilai baru ke data list index ke 0 185 | 186 | dataList.insertAll(1, numbers); // insert iterable item ke index tertentu 187 | 188 | // looping for pada list 189 | dataList.forEach((element) { 190 | print(element); 191 | }); 192 | 193 | } 194 | ``` 195 | 196 | outputnya sama 197 | baik itu 198 | * `for` 199 | * `for in` 200 | * `forEach` 201 | 202 | ```shell script 203 | list ke 0 adalah 204 | 1 205 | 50 206 | 1 207 | 2 208 | 3 209 | 4 210 | 20 211 | 10 212 | 20 213 | 30 214 | ``` 215 | 216 | ### Penggunaan Lanjutan Pada List 217 | 218 | seperti 219 | 220 | ```dart 221 | dataList.remove(10); // hapus nilai 222 | dataList.removeAt(0); // hapus berdasarkan index 223 | dataList.removeLast(); // hapus item terakhir 224 | dataList.removeRange(0, 4); // remove berdasarkan index 225 | ``` 226 | 227 | lengkapnya 228 | 229 | ```dart 230 | main(List args) { 231 | List dataList = []; 232 | 233 | List numbers = [1, 2, 3, 4]; 234 | 235 | // akses list 236 | print('list ke 0 adalah'); 237 | print(numbers[0]); // akses index ke 0 238 | 239 | dataList.add(20); // dambah 1 item ke datalist 240 | dataList.addAll([10, 20, 30]); // tambah item ke list 241 | 242 | // insert ke index tertentu 243 | dataList.insert(0, 50); // nilai baru ke data list index ke 0 244 | 245 | dataList.insertAll(1, numbers); // insert iterable item ke index tertentu 246 | 247 | dataList.remove(10); // hapus nilai 248 | dataList.removeAt(0); // hapus berdasarkan index 249 | dataList.removeLast(); // hapus item terakhir 250 | dataList.removeRange(0, 4); // remove berdasarkan index 251 | } 252 | ``` 253 | 254 | outputnya 255 | 256 | ```shell script 257 | list ke 0 adalah 258 | 1 259 | ``` 260 | 261 | > Note: perhitungan index dimulai dari angka `0` dan untuk end dimulai dari sebelum angka tersebut 262 | > misal `dataList.removeRange(0, 4)` 263 | > berati perhitungan dimulai dari `0` dan dakhiri dengan angka sebelum `4` 264 | 265 | #### Filtering Remove Pada Dart 266 | 267 | kita adpat melakukan `filtering` dahulu sebelum remove item pada dart menggunakan 268 | `removeWhere();` dimana kita menjalankan suatu fungsi dulu sebelum menghapus sebuah item 269 | 270 | contoh 271 | 272 | ```dart 273 | // contoh filtering 274 | dataList.removeWhere((element) => element % 2 !=0); 275 | print("Bilangan Ganjil"); 276 | print(dataList); 277 | ``` 278 | contoh lengkap 279 | 280 | ```dart 281 | main(List args) { 282 | List dataList = []; 283 | 284 | List numbers = [1, 2, 3, 4]; 285 | 286 | // akses list 287 | print('list ke 0 adalah'); 288 | print(numbers[0]); // akses index ke 0 289 | 290 | dataList.add(20); // dambah 1 item ke datalist 291 | dataList.addAll([10, 20, 30]); // tambah item ke list 292 | 293 | // insert ke index tertentu 294 | dataList.insert(0, 50); // nilai baru ke data list index ke 0 295 | 296 | dataList.insertAll(1, numbers); // insert iterable item ke index tertentu 297 | 298 | // contoh filtering 299 | dataList.removeWhere((element) => element % 2 !=0); 300 | print("Bilangan Ganjil"); 301 | print(dataList); 302 | 303 | } 304 | ``` 305 | 306 | outputntya seperti ini 307 | 308 | ```shell script 309 | Bilangan Ganjil 310 | [50, 2, 4, 20, 10, 20, 30] 311 | ``` 312 | 313 | #### Cek Item Tertentu dalam `List` dart 314 | 315 | untuk cek item kita bisa pake `contains` 316 | 317 | ```dart 318 | // cek jika item tertentu ada dalam list atau tidak 319 | if (dataList.contains(30)) { 320 | print('item ditemukan'); 321 | 322 | } else { 323 | print('ga nemu'); 324 | } 325 | ``` 326 | 327 | contoh lengkapnya kaya gini 328 | 329 | ```dart 330 | main(List args) { 331 | List dataList = []; 332 | 333 | List numbers = [1, 2, 3, 4]; 334 | 335 | // akses list 336 | print('list ke 0 adalah'); 337 | print(numbers[0]); // akses index ke 0 338 | 339 | dataList.add(20); // dambah 1 item ke datalist 340 | dataList.addAll([10, 20, 30]); // tambah item ke list 341 | 342 | // insert ke index tertentu 343 | dataList.insert(0, 50); // nilai baru ke data list index ke 0 344 | 345 | dataList.insertAll(1, numbers); // insert iterable item ke index tertentu 346 | 347 | // contoh filtering 348 | dataList.removeWhere((element) => element % 2 !=0); 349 | 350 | // cek jika item tertentu ada dalam list atau tidak 351 | if (dataList.contains(30)) { 352 | print('item ditemukan'); 353 | 354 | } else { 355 | print('ga nemu'); 356 | } 357 | 358 | } 359 | ``` 360 | 361 | output 362 | 363 | ```shell script 364 | item ditemukan 365 | ``` 366 | 367 | #### Ambil Sebagian dari List 368 | 369 | untuk operasi tersebut kita bisa pake `sublist` seperti ini 370 | 371 | ```dart 372 | // ambil data list tertentu 373 | List databaru = dataList.sublist(2, 5); // ambil data dari index ke 2 sampai sebelum 5 374 | print(databaru); 375 | ``` 376 | 377 | lengkapnya 378 | 379 | ```dart 380 | main(List args) { 381 | List dataList = []; 382 | 383 | List numbers = [1, 2, 3, 4]; 384 | 385 | // akses list 386 | print('list ke 0 adalah'); 387 | print(numbers[0]); // akses index ke 0 388 | 389 | dataList.add(20); // dambah 1 item ke datalist 390 | dataList.addAll([10, 20, 30]); // tambah item ke list 391 | 392 | // insert ke index tertentu 393 | dataList.insert(0, 50); // nilai baru ke data list index ke 0 394 | 395 | dataList.insertAll(1, numbers); // insert iterable item ke index tertentu 396 | 397 | // contoh filtering 398 | dataList.removeWhere((element) => element % 2 !=0); 399 | 400 | // ambil data list tertentu 401 | List databaru = dataList.sublist(2, 5); // ambil data dari index ke 2 sampai sebelum 5 402 | print(databaru); 403 | 404 | } 405 | ``` 406 | 407 | hasilnya 408 | 409 | ```shell script 410 | [4, 20, 10] 411 | ``` 412 | 413 | > Note: untuk `sublist` end parameternya optional jadi ga diisi gak apa 414 | 415 | #### Hapus Semua List 416 | 417 | kita bisa pake `dataList.clear();` 418 | 419 | > Note `dataList` adalah nama listnya 420 | 421 | #### Sorting item Pada List 422 | 423 | kita bisa melakukan sorting pada list menggunakan `sort()` 424 | 425 | #### Default Sort 426 | 427 | adalah sorting list dengan standar dart 428 | 429 | ```dart 430 | // default sorting 431 | dataList.sort(); 432 | 433 | // akses item 434 | dataList.forEach((element) { 435 | print(element); 436 | }); 437 | ``` 438 | 439 | lengkapnya 440 | 441 | ```dart 442 | main(List args) { 443 | List dataList = []; 444 | 445 | List numbers = [1, 2, 3, 4]; 446 | 447 | // akses list 448 | print('list ke 0 adalah'); 449 | print(numbers[0]); // akses index ke 0 450 | 451 | dataList.add(20); // dambah 1 item ke datalist 452 | dataList.addAll([10, 20, 30]); // tambah item ke list 453 | 454 | // insert ke index tertentu 455 | dataList.insert(0, 50); // nilai baru ke data list index ke 0 456 | 457 | dataList.insertAll(1, numbers); // insert iterable item ke index tertentu 458 | 459 | // contoh filtering 460 | dataList.removeWhere((element) => element % 2 != 0); 461 | 462 | // default sorting 463 | dataList.sort(); 464 | 465 | // akses item 466 | dataList.forEach((element) { 467 | print(element); 468 | }); 469 | } 470 | 471 | ``` 472 | 473 | output 474 | 475 | ```shell script 476 | 1 477 | 2 478 | 4 479 | 10 480 | 20 481 | 20 482 | 30 483 | 50 484 | ``` 485 | 486 | #### sorting Manual 487 | 488 | kita bisa menentukan sorting kita sendiri menggunakan `sort()` dengan mengisi parameter fungsi dalam `sort()` 489 | 490 | **Studi kasus** 491 | 492 | kita buat fungsi degan 2 parameter katakanlah `a` dan `b` jika return dari fungsi tersebut 493 | jika si `a` hasilnya negatif maka `a` berada diurutan paling depan jika si `a` hasilnya negatif maka 494 | si `b` yang berada di urutan paling depan 495 | 496 | contoh 497 | 498 | ```dart 499 | // manual sort 500 | dataList.sort((a, b) => b - a); 501 | 502 | // akses item 503 | dataList.forEach((element) { 504 | print(element); 505 | }); 506 | ``` 507 | 508 | 509 | lengkapnya 510 | 511 | ```dart 512 | main(List args) { 513 | List dataList = []; 514 | 515 | List numbers = [1, 2, 3, 4]; 516 | 517 | // akses list 518 | print('list ke 0 adalah'); 519 | print(numbers[0]); // akses index ke 0 520 | 521 | dataList.add(20); // dambah 1 item ke datalist 522 | dataList.addAll([10, 20, 30]); // tambah item ke list 523 | 524 | // insert ke index tertentu 525 | dataList.insert(0, 50); // nilai baru ke data list index ke 0 526 | 527 | dataList.insertAll(1, numbers); // insert iterable item ke index tertentu 528 | 529 | // contoh filtering 530 | dataList.removeWhere((element) => element % 2 != 0); 531 | 532 | // manual sort 533 | dataList.sort((a, b) => b - a); 534 | 535 | // akses item 536 | dataList.forEach((element) { 537 | print(element); 538 | }); 539 | } 540 | 541 | ``` 542 | 543 | hasilnya bakal menurun 544 | 545 | ```shell script 546 | 1 547 | 2 548 | 4 549 | 10 550 | 20 551 | 20 552 | 30 553 | 50 554 | ``` 555 | 556 | #### Cek Bilangan pada List 557 | 558 | kita bisa mengecek suatu list apakah iterator dalam kondisi tertentu, bernilai `true` atau `false` kita bisa pake 559 | `every()` 560 | 561 | contoh studi kasus menenukan bilangan ganjil 562 | 563 | ```dart 564 | // contoh filtering 565 | dataList.removeWhere((element) => element % 2 == 0); 566 | 567 | // cek dengan every 568 | if (dataList.every((element) => element % 2 != 0)) { 569 | print('semua ganjil'); 570 | } else { 571 | print('ada yang genap'); 572 | } 573 | 574 | // akses item 575 | dataList.forEach((element) { 576 | print(element); 577 | }); 578 | ``` 579 | 580 | kode lengkapnya 581 | 582 | ```dart 583 | main(List args) { 584 | List dataList = []; 585 | 586 | List numbers = [1, 2, 3, 4]; 587 | 588 | // akses list 589 | print('list ke 0 adalah'); 590 | print(numbers[0]); // akses index ke 0 591 | 592 | dataList.add(20); // dambah 1 item ke datalist 593 | dataList.addAll([10, 20, 30]); // tambah item ke list 594 | 595 | // insert ke index tertentu 596 | dataList.insert(0, 50); // nilai baru ke data list index ke 0 597 | 598 | dataList.insertAll(1, numbers); // insert iterable item ke index tertentu 599 | 600 | // contoh filtering 601 | dataList.removeWhere((element) => element % 2 == 0); 602 | 603 | // cek dengan every 604 | if (dataList.every((element) => element % 2 != 0)) { 605 | print('semua ganjil'); 606 | } else { 607 | print('ada yang genap'); 608 | } 609 | 610 | // akses item 611 | dataList.forEach((element) { 612 | print(element); 613 | }); 614 | } 615 | ``` 616 | 617 | contoh output 618 | 619 | ```shell script 620 | list ke 0 adalah 621 | 1 622 | semua ganjil 623 | 1 624 | 3 625 | ``` 626 | 627 | 628 | #### Cek List Kosong 629 | 630 | untuk cek list kosong atau tidak, bisa pake 631 | * `isEmpty()` untuk cek apakah list kosong `->` `boolean` 632 | * `isNotEmpty()` untuk cek apakah list tidak kosong `->` `boolean` 633 | 634 | [cek dokumentasi](https://dart.dev/guides/language/language-tour#lists) 635 | 636 | ### Set 637 | 638 | kumpulan tipe data `array` yang unix dan tidak ada duplikatnya, kita bisa menggunakan tanda`{}` 639 | untuk membuat `Set` 640 | 641 | 642 | ```dart 643 | main(List args) { 644 | Set halogens = {'fluorine', 'chlorine', 'bromine', 'iodine', 'astatine'}; 645 | } 646 | ``` 647 | 648 | ### konversi List ke Set 649 | 650 | kita bisa menggunakan `toSet();` 651 | 652 | ```dart 653 | // convert list ke set 654 | Set converts = dataList.toSet(); 655 | 656 | // akses item 657 | converts.forEach((element) { 658 | print(element); 659 | }); 660 | ``` 661 | 662 | contoh lengkap 663 | 664 | ```dart 665 | main(List args) { 666 | List dataList = []; 667 | 668 | List numbers = [1, 2, 3, 4]; 669 | 670 | // akses list 671 | print('list ke 0 adalah'); 672 | print(numbers[0]); // akses index ke 0 673 | 674 | dataList.add(20); // dambah 1 item ke datalist 675 | dataList.addAll([10, 20, 30]); // tambah item ke list 676 | 677 | // insert ke index tertentu 678 | dataList.insert(0, 50); // nilai baru ke data list index ke 0 679 | 680 | dataList.insertAll(1, numbers); // insert iterable item ke index tertentu 681 | 682 | // contoh filtering 683 | dataList.removeWhere((element) => element % 2 != 0); 684 | 685 | // convert list ke set 686 | Set converts = dataList.toSet(); 687 | 688 | // akses item 689 | converts.forEach((element) { 690 | print(element); 691 | }); 692 | } 693 | 694 | ``` 695 | 696 | hasilnya 697 | 698 | ```shell script 699 | 1 700 | 50 701 | 2 702 | 4 703 | 20 704 | 10 705 | 30 706 | ``` 707 | 708 | ### Mapping 709 | 710 | mapping adalah cara untuk mengubah data tertentu menjadi bentuk lain yang mempunyai `key` dan `value` 711 | jadi bentuk datanya akan menjadi seperti ini 712 | 713 | ```dart 714 | var gifts = { 715 | // Key: Value 716 | 'first': 'partridge', 717 | 'second': 'turtledoves', 718 | 'fifth': 'golden rings' 719 | }; 720 | 721 | var nobleGases = { 722 | 2: 'helium', 723 | 10: 'neon', 724 | 18: 'argon', 725 | }; 726 | ``` 727 | 728 | ada beberapa cara kita bisa Mapping Manual menggunakan Looping 729 | 730 | ```dart 731 | main(List args) { 732 | List dataList = []; 733 | List number = [10, 20, 30, 60]; 734 | 735 | // looping 736 | number.forEach((element) { 737 | dataList.add('angka ke ' + element.toString()); 738 | }); 739 | 740 | // cetak list 741 | dataList.forEach((newElement) { 742 | print(newElement); 743 | }); 744 | } 745 | ``` 746 | 747 | #### Cara Praktis 748 | 749 | ada cara praktisnya kita bisa pake `map()` 750 | 751 | contoh 752 | 753 | ```dart 754 | main(List args) { 755 | List dataList = []; 756 | List number = [10, 20, 30, 60]; 757 | 758 | // looping 759 | number.map((e) => ' angka ' + e.toString()); 760 | 761 | // cetak list 762 | dataList.forEach((newElement) { 763 | print(newElement); 764 | }); 765 | } 766 | ``` 767 | 768 | outputnya sama aja 769 | 770 | ```shell script 771 | angka ke 10 772 | angka ke 20 773 | angka ke 30 774 | angka ke 60 775 | ``` 776 | 777 | --- 778 | 779 | [fungsi dan Parameter](../fungsi/README.md) <> [Class dan Object](../class_objects/README.md) -------------------------------------------------------------------------------- /mapping/analysis_options.yaml: -------------------------------------------------------------------------------- 1 | # Defines a default set of lint rules enforced for projects at Google. For 2 | # details and rationale, see 3 | # https://github.com/dart-lang/pedantic#enabled-lints. 4 | 5 | include: package:pedantic/analysis_options.yaml 6 | 7 | # For lint rules and documentation, see http://dart-lang.github.io/linter/lints. 8 | 9 | # Uncomment to specify additional rules. 10 | # linter: 11 | # rules: 12 | # - camel_case_types 13 | 14 | # analyzer: 15 | # exclude: 16 | # - path/to/excluded/files/** 17 | -------------------------------------------------------------------------------- /mapping/bin/conttains.dart: -------------------------------------------------------------------------------- 1 | main(List args) { 2 | List dataList = []; 3 | 4 | List numbers = [1, 2, 3, 4]; 5 | 6 | // akses list 7 | print('list ke 0 adalah'); 8 | print(numbers[0]); // akses index ke 0 9 | 10 | dataList.add(20); // dambah 1 item ke datalist 11 | dataList.addAll([10, 20, 30]); // tambah item ke list 12 | 13 | // insert ke index tertentu 14 | dataList.insert(0, 50); // nilai baru ke data list index ke 0 15 | 16 | dataList.insertAll(1, numbers); // insert iterable item ke index tertentu 17 | 18 | // contoh filtering 19 | dataList.removeWhere((element) => element % 2 !=0); 20 | 21 | // cek jika item tertentu ada dalam list atau tidak 22 | if (dataList.contains(30)) { 23 | print('item ditemukan'); 24 | 25 | } else { 26 | print('ga nemu'); 27 | } 28 | 29 | } -------------------------------------------------------------------------------- /mapping/bin/every.dart: -------------------------------------------------------------------------------- 1 | main(List args) { 2 | List dataList = []; 3 | 4 | List numbers = [1, 2, 3, 4]; 5 | 6 | // akses list 7 | print('list ke 0 adalah'); 8 | print(numbers[0]); // akses index ke 0 9 | 10 | dataList.add(20); // dambah 1 item ke datalist 11 | dataList.addAll([10, 20, 30]); // tambah item ke list 12 | 13 | // insert ke index tertentu 14 | dataList.insert(0, 50); // nilai baru ke data list index ke 0 15 | 16 | dataList.insertAll(1, numbers); // insert iterable item ke index tertentu 17 | 18 | // contoh filtering 19 | dataList.removeWhere((element) => element % 2 == 0); 20 | 21 | // cek dengan every 22 | if (dataList.every((element) => element % 2 != 0)) { 23 | print('semua ganjil'); 24 | } else { 25 | print('ada yang genap'); 26 | } 27 | 28 | // akses item 29 | dataList.forEach((element) { 30 | print(element); 31 | }); 32 | } 33 | -------------------------------------------------------------------------------- /mapping/bin/filtering.dart: -------------------------------------------------------------------------------- 1 | main(List args) { 2 | List dataList = []; 3 | 4 | List numbers = [1, 2, 3, 4]; 5 | 6 | // akses list 7 | print('list ke 0 adalah'); 8 | print(numbers[0]); // akses index ke 0 9 | 10 | dataList.add(20); // dambah 1 item ke datalist 11 | dataList.addAll([10, 20, 30]); // tambah item ke list 12 | 13 | // insert ke index tertentu 14 | dataList.insert(0, 50); // nilai baru ke data list index ke 0 15 | 16 | dataList.insertAll(1, numbers); // insert iterable item ke index tertentu 17 | 18 | // contoh filtering 19 | dataList.removeWhere((element) => element % 2 !=0); 20 | print("Bilangan Ganjil"); 21 | print(dataList); 22 | 23 | } -------------------------------------------------------------------------------- /mapping/bin/kosong.dart: -------------------------------------------------------------------------------- 1 | main(List args) { 2 | List dataList = []; 3 | 4 | List numbers = [1, 2, 3, 4]; 5 | 6 | // akses list 7 | print('list ke 0 adalah'); 8 | print(numbers[0]); // akses index ke 0 9 | 10 | dataList.add(20); // dambah 1 item ke datalist 11 | dataList.addAll([10, 20, 30]); // tambah item ke list 12 | 13 | // insert ke index tertentu 14 | dataList.insert(0, 50); // nilai baru ke data list index ke 0 15 | 16 | dataList.insertAll(1, numbers); // insert iterable item ke index tertentu 17 | 18 | // contoh filtering 19 | dataList.removeWhere((element) => element % 2 != 0); 20 | 21 | // manual sort 22 | dataList.sort((a, b) => b - a); 23 | 24 | // akses item 25 | dataList.forEach((element) { 26 | print(element); 27 | }); 28 | } 29 | -------------------------------------------------------------------------------- /mapping/bin/loops_mapping.dart: -------------------------------------------------------------------------------- 1 | main(List args) { 2 | List dataList = []; 3 | 4 | List numbers = [1, 2, 3, 4]; 5 | 6 | // akses list 7 | print('list ke 0 adalah'); 8 | print(numbers[0]); // akses index ke 0 9 | 10 | dataList.add(20); // dambah 1 item ke datalist 11 | dataList.addAll([10, 20, 30]); // tambah item ke list 12 | 13 | // insert ke index tertentu 14 | dataList.insert(0, 50); // nilai baru ke data list index ke 0 15 | 16 | dataList.insertAll(1, numbers); // insert iterable item ke index tertentu 17 | 18 | dataList.remove(10); // hapus nilai 19 | dataList.removeAt(0); // hapus berdasarkan index 20 | dataList.removeLast(); // hapus item terakhir 21 | dataList.removeRange(0, 4); // remove berdasarkan index 22 | } 23 | -------------------------------------------------------------------------------- /mapping/bin/manual_sort.dart: -------------------------------------------------------------------------------- 1 | main(List args) { 2 | List dataList = []; 3 | 4 | List numbers = [1, 2, 3, 4]; 5 | 6 | // akses list 7 | print('list ke 0 adalah'); 8 | print(numbers[0]); // akses index ke 0 9 | 10 | dataList.add(20); // dambah 1 item ke datalist 11 | dataList.addAll([10, 20, 30]); // tambah item ke list 12 | 13 | // insert ke index tertentu 14 | dataList.insert(0, 50); // nilai baru ke data list index ke 0 15 | 16 | dataList.insertAll(1, numbers); // insert iterable item ke index tertentu 17 | 18 | // contoh filtering 19 | dataList.removeWhere((element) => element % 2 != 0); 20 | 21 | // manual sort 22 | dataList.sort((a, b) => b - a); 23 | 24 | // akses item 25 | dataList.forEach((element) { 26 | print(element); 27 | }); 28 | } 29 | -------------------------------------------------------------------------------- /mapping/bin/mapping.dart: -------------------------------------------------------------------------------- 1 | main(List args) { 2 | List dataList = []; 3 | 4 | List numbers = [1, 2, 3, 4]; 5 | 6 | // akses list 7 | print('list ke 0 adalah'); 8 | print(numbers[0]); // akses index ke 0 9 | 10 | dataList.add(20); // dambah 1 item ke datalist 11 | dataList.addAll([10, 20,30]); // tambah item ke list 12 | 13 | // insert ke index tertentu 14 | dataList.insert(0, 50); // nilai baru ke data list index ke 0 15 | 16 | dataList.insertAll(1, numbers); // insert iterable item ke index tertentu 17 | 18 | // hasil akhir 19 | print(dataList); 20 | } -------------------------------------------------------------------------------- /mapping/bin/new_mapping.dart: -------------------------------------------------------------------------------- 1 | main(List args) { 2 | List dataList = []; 3 | List number = [10, 20, 30, 60]; 4 | 5 | // looping 6 | number.forEach((element) { 7 | dataList.add('angka ke ' + element.toString()); 8 | }); 9 | 10 | // cetak list 11 | dataList.forEach((newElement) { 12 | print(newElement); 13 | }); 14 | } 15 | -------------------------------------------------------------------------------- /mapping/bin/new_mapping2.dart: -------------------------------------------------------------------------------- 1 | main(List args) { 2 | List dataList = []; 3 | List number = [10, 20, 30, 60]; 4 | 5 | // looping 6 | number.map((e) => ' angka ' + e.toString()); 7 | 8 | // cetak list 9 | dataList.forEach((newElement) { 10 | print(newElement); 11 | }); 12 | } 13 | -------------------------------------------------------------------------------- /mapping/bin/sets.dart: -------------------------------------------------------------------------------- 1 | main(List args) { 2 | List dataList = []; 3 | 4 | List numbers = [1, 2, 3, 4]; 5 | 6 | // akses list 7 | print('list ke 0 adalah'); 8 | print(numbers[0]); // akses index ke 0 9 | 10 | dataList.add(20); // dambah 1 item ke datalist 11 | dataList.addAll([10, 20, 30]); // tambah item ke list 12 | 13 | // insert ke index tertentu 14 | dataList.insert(0, 50); // nilai baru ke data list index ke 0 15 | 16 | dataList.insertAll(1, numbers); // insert iterable item ke index tertentu 17 | 18 | // contoh filtering 19 | dataList.removeWhere((element) => element % 2 != 0); 20 | 21 | // convert list ke set 22 | Set converts = dataList.toSet(); 23 | 24 | // akses item 25 | converts.forEach((element) { 26 | print(element); 27 | }); 28 | } 29 | -------------------------------------------------------------------------------- /mapping/bin/sorting_list.dart: -------------------------------------------------------------------------------- 1 | main(List args) { 2 | List dataList = []; 3 | 4 | List numbers = [1, 2, 3, 4]; 5 | 6 | // akses list 7 | print('list ke 0 adalah'); 8 | print(numbers[0]); // akses index ke 0 9 | 10 | dataList.add(20); // dambah 1 item ke datalist 11 | dataList.addAll([10, 20, 30]); // tambah item ke list 12 | 13 | // insert ke index tertentu 14 | dataList.insert(0, 50); // nilai baru ke data list index ke 0 15 | 16 | dataList.insertAll(1, numbers); // insert iterable item ke index tertentu 17 | 18 | // contoh filtering 19 | dataList.removeWhere((element) => element % 2 != 0); 20 | 21 | // default sorting 22 | dataList.sort(); 23 | 24 | // akses item 25 | dataList.forEach((element) { 26 | print(element); 27 | }); 28 | } 29 | -------------------------------------------------------------------------------- /mapping/bin/subslist.dart: -------------------------------------------------------------------------------- 1 | main(List args) { 2 | List dataList = []; 3 | 4 | List numbers = [1, 2, 3, 4]; 5 | 6 | // akses list 7 | print('list ke 0 adalah'); 8 | print(numbers[0]); // akses index ke 0 9 | 10 | dataList.add(20); // dambah 1 item ke datalist 11 | dataList.addAll([10, 20, 30]); // tambah item ke list 12 | 13 | // insert ke index tertentu 14 | dataList.insert(0, 50); // nilai baru ke data list index ke 0 15 | 16 | dataList.insertAll(1, numbers); // insert iterable item ke index tertentu 17 | 18 | // contoh filtering 19 | dataList.removeWhere((element) => element % 2 !=0); 20 | 21 | // ambil data list tertentu 22 | List databaru = dataList.sublist(2, 5); // ambil data dari index ke 2 sampai sebelum 5 23 | print(databaru); 24 | 25 | } -------------------------------------------------------------------------------- /mapping/lib/mapping.dart: -------------------------------------------------------------------------------- 1 | int calculate() { 2 | return 6 * 7; 3 | } 4 | -------------------------------------------------------------------------------- /mapping/pubspec.yaml: -------------------------------------------------------------------------------- 1 | name: mapping 2 | description: A sample command-line application. 3 | version: 1.0.0 4 | # homepage: https://www.example.com 5 | 6 | environment: 7 | sdk: '>=2.12.0 <3.0.0' 8 | 9 | # dependencies: 10 | # path: ^1.8.0 11 | 12 | dev_dependencies: 13 | pedantic: ^1.10.0 14 | test: ^1.16.0 15 | -------------------------------------------------------------------------------- /mapping/test/mapping_test.dart: -------------------------------------------------------------------------------- 1 | import 'package:mapping/mapping.dart'; 2 | import 'package:test/test.dart'; 3 | 4 | void main() { 5 | test('calculate', () { 6 | expect(calculate(), 42); 7 | }); 8 | } 9 | -------------------------------------------------------------------------------- /mixins/.gitignore: -------------------------------------------------------------------------------- 1 | # Files and directories created by pub. 2 | .dart_tool/ 3 | .packages 4 | 5 | # Conventional directory for build output. 6 | build/ 7 | -------------------------------------------------------------------------------- /mixins/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.0 2 | 3 | - Initial version. 4 | -------------------------------------------------------------------------------- /mixins/README.md: -------------------------------------------------------------------------------- 1 | ### Mixins 2 | 3 | `Mixins` mirip seperti interface, hanya aja bedanya kalo `interface` itu memaksakan method/periaku yang dimiliki oleh interface tadi 4 | kalo si `Mixins` itu menambahkan. contoh 5 | 6 | kita buat `mixin` 7 | 8 | ```dart 9 | // lib/drink_ability_mixin.dart 10 | 11 | mixin DrinkAbilityMixin { 12 | String drink() => 'mbeerr'; 13 | } 14 | ``` 15 | 16 | lalu kita taruh dengan keyword `with` 17 | 18 | ```dart 19 | import 'package:mixins/drink_ability_mixins.dart'; 20 | import 'package:mixins/flying_monster.dart'; 21 | import 'package:mixins/monster_ubur.dart'; 22 | 23 | class MonsterDragon extends MonsterUbur 24 | with DrinkAbilityMixin 25 | implements FlyingMonster, DemonSlayer { 26 | @override 27 | String fly() { 28 | return 'terbang tinggi grr!!!'; 29 | } 30 | 31 | @override 32 | String killerDemons() { 33 | return 'Demon is a weak grr'; 34 | } 35 | } 36 | ``` 37 | 38 | > Note: Pastikan selalu menaruh dengan `with` sebelum keyword `implements` arag tidak error 39 | 40 | ketika kita implementasi di main 41 | maka seperti ini 42 | 43 | ```dart 44 | for (Monster m in monsters) { 45 | if (m is DrinkAbilityMixin) { 46 | print((m as DrinkAbilityMixin).drink()); 47 | } 48 | } 49 | ``` 50 | 51 | lengkapnya 52 | 53 | ```dart 54 | import 'package:mixins/drink_ability_mixins.dart'; 55 | import 'package:mixins/hero.dart'; 56 | import 'package:mixins/monster.dart'; 57 | import 'package:mixins/monster_burung.dart'; 58 | import 'package:mixins/monster_dragon.dart'; 59 | import 'package:mixins/monster_ubur.dart'; 60 | 61 | void main(List arguments) { 62 | // tampung object 63 | List monsters = []; 64 | 65 | // add object 66 | monsters.add(MonsterUbur()); 67 | monsters.add(MonsterBurung()); 68 | monsters.add(MonsterDragon()); 69 | 70 | for (Monster m in monsters) { 71 | if (m is DrinkAbilityMixin) { 72 | print((m as DrinkAbilityMixin).drink()); 73 | } 74 | } 75 | } 76 | ``` 77 | 78 | hasilnya 79 | 80 | ``` 81 | mbeerr 82 | ``` 83 | 84 | #### `Mixins` hanya untuk class tertentu 85 | 86 | kita bisa set sebuah mixins hanya boleh dimiliki di class tertentu, kita pake keyword `on` misalnya 87 | 88 | ```dart 89 | import 'package:mixins/hero.dart'; 90 | 91 | mixin Knight on Hero{ 92 | String swords () => 'increase power to kill monster'; 93 | } 94 | ``` 95 | kemudian kita buat class baru turunan dari `Hero` maka bisa di tambahkan mixins nya 96 | 97 | ```dart 98 | import 'package:mixins/hero.dart'; 99 | import 'package:mixins/kinshi.dart'; 100 | 101 | class Ninja extends Hero with Knight { 102 | 103 | } 104 | ``` 105 | 106 | kemudian kita bisa panggil begini 107 | 108 | ```dart 109 | Ninja ninja = Ninja(); 110 | print(ninja.swords()); 111 | ``` 112 | lengkapnya seperti ini 113 | 114 | ```dart 115 | import 'package:mixins/drink_ability_mixins.dart'; 116 | import 'package:mixins/hero.dart'; 117 | import 'package:mixins/kinshi.dart'; 118 | import 'package:mixins/monster.dart'; 119 | import 'package:mixins/monster_burung.dart'; 120 | import 'package:mixins/monster_dragon.dart'; 121 | import 'package:mixins/monster_ubur.dart'; 122 | import 'package:mixins/shogun.dart'; 123 | 124 | void main(List arguments) { 125 | // tampung object 126 | 127 | List heroes = []; 128 | List monsters = []; 129 | 130 | // add object 131 | Ninja ninja = Ninja(); 132 | print(ninja.swords()); 133 | 134 | monsters.add(MonsterUbur()); 135 | monsters.add(MonsterBurung()); 136 | monsters.add(MonsterDragon()); 137 | 138 | for (Monster m in monsters) { 139 | if (m is DrinkAbilityMixin) { 140 | print((m as DrinkAbilityMixin).drink()); 141 | } 142 | } 143 | } 144 | ``` 145 | 146 | hasilnya 147 | 148 | ``` 149 | increase power to kill monster 150 | mbeerr 151 | ``` 152 | 153 | ### Little Notes 154 | 155 | * `inheritance` adalah mewariskan perilaku/method pada class turunannya (`extends`) dan hanya bisa 1 kali aja 156 | * `interface` adalah memaksakan *behavior*/perilaku yang dimiliki oleh `interface` tersebut kepada class yang meng (`implements`) nya (*jadi harus `override`*) 157 | * `mixins` menambah perilaku atau *behavior* yang dimiliki `mixins` ke sebuah class (`with`), dan sebuah class dapat pakai banyak `mixins` 158 | 159 | --- 160 | 161 | ### Resource dan Referensi 162 | 163 | * [dokumentasi dart: Mixin](https://dart.dev/guides/language/language-tour#adding-features-to-a-class-mixins) 164 | 165 | --- 166 | 167 | [Abstract Class dan Interface](../absract_class/README.md) <> [Constructor](../constructors/README.md) -------------------------------------------------------------------------------- /mixins/analysis_options.yaml: -------------------------------------------------------------------------------- 1 | # Defines a default set of lint rules enforced for projects at Google. For 2 | # details and rationale, see 3 | # https://github.com/dart-lang/pedantic#enabled-lints. 4 | 5 | include: package:pedantic/analysis_options.yaml 6 | 7 | # For lint rules and documentation, see http://dart-lang.github.io/linter/lints. 8 | 9 | # Uncomment to specify additional rules. 10 | # linter: 11 | # rules: 12 | # - camel_case_types 13 | 14 | # analyzer: 15 | # exclude: 16 | # - path/to/excluded/files/** 17 | -------------------------------------------------------------------------------- /mixins/bin/mixins.dart: -------------------------------------------------------------------------------- 1 | import 'package:mixins/drink_ability_mixins.dart'; 2 | import 'package:mixins/hero.dart'; 3 | import 'package:mixins/kinshi.dart'; 4 | import 'package:mixins/monster.dart'; 5 | import 'package:mixins/monster_burung.dart'; 6 | import 'package:mixins/monster_dragon.dart'; 7 | import 'package:mixins/monster_ubur.dart'; 8 | import 'package:mixins/shogun.dart'; 9 | 10 | void main(List arguments) { 11 | // tampung object 12 | 13 | List heroes = []; 14 | List monsters = []; 15 | 16 | // add object 17 | Ninja ninja = Ninja(); 18 | print(ninja.swords()); 19 | 20 | monsters.add(MonsterUbur()); 21 | monsters.add(MonsterBurung()); 22 | monsters.add(MonsterDragon()); 23 | 24 | for (Monster m in monsters) { 25 | if (m is DrinkAbilityMixin) { 26 | print((m as DrinkAbilityMixin).drink()); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /mixins/lib/character.dart: -------------------------------------------------------------------------------- 1 | class Character { 2 | late int _healthPoint; 3 | 4 | int get healthPoint => _healthPoint; 5 | set healthPoint(int value) { 6 | if (value < 0) { 7 | value *= -1; 8 | } 9 | 10 | _healthPoint = value; 11 | } 12 | } -------------------------------------------------------------------------------- /mixins/lib/drink_ability_mixins.dart: -------------------------------------------------------------------------------- 1 | 2 | mixin DrinkAbilityMixin { 3 | String drink() => 'mbeerr'; 4 | } -------------------------------------------------------------------------------- /mixins/lib/flying_monster.dart: -------------------------------------------------------------------------------- 1 | abstract class FlyingMonster { 2 | String fly(); 3 | } 4 | 5 | abstract class DemonSlayer { 6 | String killerDemons(); 7 | } -------------------------------------------------------------------------------- /mixins/lib/hero.dart: -------------------------------------------------------------------------------- 1 | 2 | import 'package:mixins/character.dart'; 3 | import 'package:mixins/kinshi.dart'; 4 | 5 | class Hero extends Character { 6 | 7 | String killAllMonster() => 'take this'; 8 | } -------------------------------------------------------------------------------- /mixins/lib/kinshi.dart: -------------------------------------------------------------------------------- 1 | import 'package:mixins/hero.dart'; 2 | 3 | mixin Knight on Hero{ 4 | String swords () => 'increase power to kill monster'; 5 | } -------------------------------------------------------------------------------- /mixins/lib/monster.dart: -------------------------------------------------------------------------------- 1 | import 'package:mixins/character.dart'; 2 | 3 | abstract class Monster extends Character { 4 | String eatHuman() => 'yummy'; 5 | String move(); 6 | } 7 | -------------------------------------------------------------------------------- /mixins/lib/monster_burung.dart: -------------------------------------------------------------------------------- 1 | 2 | 3 | import 'package:mixins/monster.dart'; 4 | 5 | class MonsterBurung extends Monster { 6 | String fly() { 7 | return 'woosh'; 8 | } 9 | 10 | @override 11 | String move() { 12 | return 'pake sayap'; 13 | } 14 | 15 | // new object 16 | @override 17 | String eatHuman() { 18 | return 'sruput'; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /mixins/lib/monster_dragon.dart: -------------------------------------------------------------------------------- 1 | import 'package:mixins/drink_ability_mixins.dart'; 2 | import 'package:mixins/flying_monster.dart'; 3 | import 'package:mixins/monster_ubur.dart'; 4 | 5 | class MonsterDragon extends MonsterUbur with DrinkAbilityMixin 6 | implements FlyingMonster, DemonSlayer { 7 | @override 8 | String fly() { 9 | return 'terbang tinggi grr!!!'; 10 | } 11 | 12 | @override 13 | String killerDemons() { 14 | return 'Demon is a weak grr'; 15 | } 16 | } 17 | 18 | -------------------------------------------------------------------------------- /mixins/lib/monster_ubur.dart: -------------------------------------------------------------------------------- 1 | import 'package:mixins/monster.dart'; 2 | 3 | class MonsterUbur extends Monster { 4 | String berenang () => 'slup slup'; 5 | 6 | @override 7 | String move() { 8 | return 'berenang renang'; 9 | } 10 | } -------------------------------------------------------------------------------- /mixins/lib/shogun.dart: -------------------------------------------------------------------------------- 1 | import 'package:mixins/hero.dart'; 2 | import 'package:mixins/kinshi.dart'; 3 | 4 | class Ninja extends Hero with Knight { 5 | 6 | } -------------------------------------------------------------------------------- /mixins/pubspec.yaml: -------------------------------------------------------------------------------- 1 | name: mixins 2 | description: A sample command-line application. 3 | version: 1.0.0 4 | # homepage: https://www.example.com 5 | 6 | environment: 7 | sdk: '>=2.12.0 <3.0.0' 8 | 9 | # dependencies: 10 | # path: ^1.8.0 11 | 12 | dev_dependencies: 13 | pedantic: ^1.10.0 14 | test: ^1.16.0 15 | -------------------------------------------------------------------------------- /operator_overriding/.gitignore: -------------------------------------------------------------------------------- 1 | # Files and directories created by pub. 2 | .dart_tool/ 3 | .packages 4 | 5 | # Conventional directory for build output. 6 | build/ 7 | -------------------------------------------------------------------------------- /operator_overriding/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.0 2 | 3 | - Initial version. 4 | -------------------------------------------------------------------------------- /operator_overriding/README.md: -------------------------------------------------------------------------------- 1 | ### Operator Override 2 | 3 | Cara melakukan `operator override` adalah metode penggantian operasi ketika berbeda tipe data atau sedang membandingkan tipe data 4 | 5 | ```dart 6 | void main(List arguments) { 7 | Hero a = Hero(20); 8 | Hero b = Hero(10); 9 | 10 | // test 11 | print(a > b); 12 | } 13 | 14 | class Hero { 15 | late final int power; 16 | 17 | Hero(this.power); 18 | 19 | Hero operator +(var other) { 20 | if (other is Hero) { 21 | return Hero(power + other.power); 22 | } else if (other is int) { 23 | return Hero(power + other); 24 | } else { 25 | return this; 26 | } 27 | } 28 | 29 | // override operator 30 | @override 31 | bool operator ==(var other) { 32 | // TODO: implement == 33 | if (other is Hero) { 34 | if (other.power == power) { 35 | return true; 36 | } 37 | } 38 | return false; 39 | } 40 | 41 | bool operator >(var other) { 42 | if (other is Hero) { 43 | if (power > other.power) { 44 | return true; 45 | } 46 | } 47 | return false; 48 | } 49 | } 50 | ``` 51 | 52 | hasilnya 53 | 54 | ``` 55 | true 56 | ``` 57 | 58 | --- 59 | 60 | [Solid Principle](../solid_principle/README.md) <> [Singleton](../singleton/README.md) 61 | -------------------------------------------------------------------------------- /operator_overriding/analysis_options.yaml: -------------------------------------------------------------------------------- 1 | # Defines a default set of lint rules enforced for projects at Google. For 2 | # details and rationale, see 3 | # https://github.com/dart-lang/pedantic#enabled-lints. 4 | 5 | include: package:pedantic/analysis_options.yaml 6 | 7 | # For lint rules and documentation, see http://dart-lang.github.io/linter/lints. 8 | 9 | # Uncomment to specify additional rules. 10 | # linter: 11 | # rules: 12 | # - camel_case_types 13 | 14 | # analyzer: 15 | # exclude: 16 | # - path/to/excluded/files/** 17 | -------------------------------------------------------------------------------- /operator_overriding/bin/operator_overriding.dart: -------------------------------------------------------------------------------- 1 | void main(List arguments) { 2 | Hero a = Hero(20); 3 | Hero b = Hero(10); 4 | 5 | // test 6 | print(a > b); 7 | } 8 | 9 | class Hero { 10 | late final int power; 11 | 12 | Hero(this.power); 13 | 14 | Hero operator +(var other) { 15 | if (other is Hero) { 16 | return Hero(power + other.power); 17 | } else if (other is int) { 18 | return Hero(power + other); 19 | } else { 20 | return this; 21 | } 22 | } 23 | 24 | // override operator 25 | @override 26 | bool operator ==(var other) { 27 | // TODO: implement == 28 | if (other is Hero) { 29 | if (other.power == power) { 30 | return true; 31 | } 32 | } 33 | return false; 34 | } 35 | 36 | bool operator >(var other) { 37 | if (other is Hero) { 38 | if (power > other.power) { 39 | return true; 40 | } 41 | } 42 | return false; 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /operator_overriding/lib/operator_overriding.dart: -------------------------------------------------------------------------------- 1 | int calculate() { 2 | return 6 * 7; 3 | } 4 | -------------------------------------------------------------------------------- /operator_overriding/pubspec.yaml: -------------------------------------------------------------------------------- 1 | name: operator_overriding 2 | description: A sample command-line application. 3 | version: 1.0.0 4 | # homepage: https://www.example.com 5 | 6 | environment: 7 | sdk: '>=2.12.0 <3.0.0' 8 | 9 | # dependencies: 10 | # path: ^1.8.0 11 | 12 | dev_dependencies: 13 | pedantic: ^1.10.0 14 | test: ^1.16.0 15 | -------------------------------------------------------------------------------- /percabangan/.gitignore: -------------------------------------------------------------------------------- 1 | # Files and directories created by pub. 2 | .dart_tool/ 3 | .packages 4 | 5 | # Conventional directory for build output. 6 | build/ 7 | -------------------------------------------------------------------------------- /percabangan/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.0 2 | 3 | - Initial version. 4 | -------------------------------------------------------------------------------- /percabangan/README.md: -------------------------------------------------------------------------------- 1 | ### Percabangan (Conditional Statement) 2 | 3 | --- 4 | 5 | percabangan adalah salah satu cara menentukan kondisi pada suatu program, pada bahasa program dart ini 6 | ada 2 syntax yaitu 7 | 8 | * if else 9 | * switch 10 | 11 | ### Penggunaan If Else 12 | 13 | karena bahasa pemrograman dart contoh ini `if Else` dart mirip dengan bahasa penrograman `C` 14 | 15 | ```dart 16 | import 'dart:io'; 17 | 18 | main(List args) { 19 | String? input = stdin.readLineSync(); 20 | var number = int.tryParse(input!); 21 | 22 | if (number! > 0) { 23 | print('bilangan positif'); 24 | } else if (number < 0) { 25 | print('bilangan negatif'); 26 | } else { 27 | print('bilangan 0'); 28 | } 29 | } 30 | ``` 31 | 32 | #### Penjelasan Program 33 | 34 | pada contoh program diatas kita menentukan nomor jika `>` `0` bilangan positif jika `< 0` maka bilangan negatif 35 | jika `0` maka bilangan tersebut dicetak `0` 36 | 37 | ### Assign Variabel 38 | 39 | contoh penggunaan assign variabel (*Mengganti nilai Variabel*) berikut penerapanya dalam `if else` 40 | 41 | ```dart 42 | import 'dart:io'; 43 | 44 | main(List args) { 45 | String? input = stdin.readLineSync(); 46 | int? number = int.tryParse(input!); 47 | 48 | String output; 49 | 50 | if (number! > 0) { 51 | output = 'positif'; 52 | } else if (number < 0) { 53 | output = 'bilangan negatif'; 54 | } else { 55 | output = 'bilangan 0'; 56 | } 57 | 58 | // cetak kondisi 59 | print(output); 60 | } 61 | 62 | ``` 63 | 64 | ### Penyingkatan 65 | 66 | kita dapat menyingkat kondisi seperti ini 67 | 68 | * `?` untuk if 69 | * `:` else 70 | 71 | penggunanya seperti ini 72 | 73 | ```dart 74 | import 'dart:io'; 75 | 76 | main(List args) { 77 | String? input = stdin.readLineSync(); 78 | int? number = int.tryParse(input!); 79 | 80 | String output; 81 | 82 | // penyingkatan 83 | output = (number! > 0) ? 'postitif' : 'negatif'; 84 | 85 | // cetak kondisi 86 | print(output); 87 | } 88 | ``` 89 | 90 | kita dapat lihat dan fokus disini 91 | 92 | ```dart 93 | output = (number! > 0) ? 'postitif' : 'negatif'; 94 | ``` 95 | 96 | cara bacanya sama seperti code assign variabel biasa 97 | 98 | ### Alternative lain 99 | 100 | kita bisa langsung print seperti ini 101 | 102 | ```dart 103 | print((number! > 0) ? 'postitif' : 'negatif'); 104 | ``` 105 | hasilnya sama aja 106 | 107 | ### Switch Case 108 | 109 | kondisional seperti ini syaratnya nilainya tetap contoh seperti ini 110 | 111 | 112 | ```dart 113 | import 'dart:io'; 114 | 115 | main(List args) { 116 | String? input = stdin.readLineSync(); 117 | int? number = int.tryParse(input!); 118 | 119 | switch (number) { 120 | case 0: 121 | print('bilangan 0'); 122 | break; 123 | case 1: 124 | print('bilangan 1'); 125 | break; 126 | default: 127 | print('Bilangan Lain'); 128 | } 129 | } 130 | ``` 131 | * `break` digunakan untuk ketika kodisi terpenuhi maka program akan terpenuhi 132 | * `default` digunakan ketika kodisi dari `switch` tidak sesuai case contoh output 133 | 134 | ![contoh switch](docs/img/switch.png) 135 | 136 | ### Resource dan Referensi 137 | 138 | * [Dokumentasi](https://dart.dev/guides/language/language-tour#control-flow-statements) 139 | --- 140 | 141 | [aplikasi pertama](../aplikasi_pertama/README.md) <> [perulangan](../perulangan/README.md) *Chapter ini* -------------------------------------------------------------------------------- /percabangan/analysis_options.yaml: -------------------------------------------------------------------------------- 1 | # Defines a default set of lint rules enforced for projects at Google. For 2 | # details and rationale, see 3 | # https://github.com/dart-lang/pedantic#enabled-lints. 4 | 5 | include: package:pedantic/analysis_options.yaml 6 | 7 | # For lint rules and documentation, see http://dart-lang.github.io/linter/lints. 8 | 9 | # Uncomment to specify additional rules. 10 | # linter: 11 | # rules: 12 | # - camel_case_types 13 | 14 | # analyzer: 15 | # exclude: 16 | # - path/to/excluded/files/** 17 | -------------------------------------------------------------------------------- /percabangan/bin/assign_var.dart: -------------------------------------------------------------------------------- 1 | import 'dart:io'; 2 | 3 | main(List args) { 4 | String? input = stdin.readLineSync(); 5 | int? number = int.tryParse(input!); 6 | 7 | String output; 8 | 9 | if (number! > 0) { 10 | output = 'positif'; 11 | } else if (number < 0) { 12 | output = 'bilangan negatif'; 13 | } else { 14 | output = 'bilangan 0'; 15 | } 16 | 17 | // cetak kondisi 18 | print(output); 19 | } 20 | -------------------------------------------------------------------------------- /percabangan/bin/penyingkatan.dart: -------------------------------------------------------------------------------- 1 | import 'dart:io'; 2 | 3 | main(List args) { 4 | String? input = stdin.readLineSync(); 5 | int? number = int.tryParse(input!); 6 | 7 | String output; 8 | 9 | // penyingkatan 10 | output = (number! > 0) ? 'postitif' : 'negatif'; 11 | 12 | // cetak kondisi 13 | print(output); 14 | } 15 | -------------------------------------------------------------------------------- /percabangan/bin/percabangan.dart: -------------------------------------------------------------------------------- 1 | import 'dart:io'; 2 | 3 | main(List args) { 4 | String? input = stdin.readLineSync(); 5 | var number = int.tryParse(input!); 6 | 7 | if (number! > 0) { 8 | print('bilangan positif'); 9 | } else if (number < 0) { 10 | print('bilangan negatif'); 11 | } else { 12 | print('bilangan 0'); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /percabangan/bin/switchdarts.dart: -------------------------------------------------------------------------------- 1 | import 'dart:io'; 2 | 3 | main(List args) { 4 | String? input = stdin.readLineSync(); 5 | int? number = int.tryParse(input!); 6 | 7 | switch (number) { 8 | case 0: 9 | print('bilangan 0'); 10 | break; 11 | case 1: 12 | print('bilangan 1'); 13 | break; 14 | default: 15 | print('Bilangan Lain'); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /percabangan/docs/img/switch.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/perymerdeka/mastering-dart/5eee63cbc6c9df07e9454f89cd3e2cbccc07eb40/percabangan/docs/img/switch.png -------------------------------------------------------------------------------- /percabangan/lib/percabangan.dart: -------------------------------------------------------------------------------- 1 | int calculate() { 2 | return 6 * 7; 3 | } 4 | -------------------------------------------------------------------------------- /percabangan/pubspec.yaml: -------------------------------------------------------------------------------- 1 | name: percabangan 2 | description: A sample command-line application. 3 | version: 1.0.0 4 | # homepage: https://www.example.com 5 | 6 | environment: 7 | sdk: '>=2.12.0 <3.0.0' 8 | 9 | # dependencies: 10 | # path: ^1.8.0 11 | 12 | dev_dependencies: 13 | pedantic: ^1.10.0 14 | test: ^1.16.0 15 | -------------------------------------------------------------------------------- /percabangan/test/percabangan_test.dart: -------------------------------------------------------------------------------- 1 | import 'package:percabangan/percabangan.dart'; 2 | import 'package:test/test.dart'; 3 | 4 | void main() { 5 | test('calculate', () { 6 | expect(calculate(), 42); 7 | }); 8 | } 9 | -------------------------------------------------------------------------------- /perulangan/.gitignore: -------------------------------------------------------------------------------- 1 | # Files and directories created by pub. 2 | .dart_tool/ 3 | .packages 4 | 5 | # Conventional directory for build output. 6 | build/ 7 | -------------------------------------------------------------------------------- /perulangan/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.0 2 | 3 | - Initial version. 4 | -------------------------------------------------------------------------------- /perulangan/README.md: -------------------------------------------------------------------------------- 1 | ### Perulangan dan Unary Operator 2 | 3 | chapter 3 4 | 5 | --- 6 | 7 | perulangan digunakan ketika kita membuat program, tentu kita mempunyai suatu perintah yang diulang beberapa kali 8 | 9 | ### Perulangan Dalam Dart 10 | 11 | dalam bahasa pemrograman dart terdapat beberapa cara melakukan perulangan, caranya mirip seperti melakukan perulanga menggunakan 12 | `C` `C#` dan bahasa pemrograman mirip `C` Lainya 13 | 14 | berikut adalah bebercara cara melakukan perulangan 15 | 16 | * **`For`** 17 | * **`while`** 18 | * **`do while`** 19 | 20 | #### Perulangan For 21 | 22 | pembuatannya sama seperti perulangan dalam `C` contoh 23 | 24 | ```dart 25 | void main(List arguments) { 26 | for (int counter = 0; counter < 5; counter = counter + 1) { 27 | print('berulangan ke ' + counter.toString()); 28 | } 29 | 30 | } 31 | ``` 32 | contoh output 33 | 34 | ```shell script 35 | berulangan ke 0 36 | berulangan ke 1 37 | berulangan ke 2 38 | berulangan ke 3 39 | berulangan ke 4 40 | 41 | Process finished with exit code 0 42 | 43 | ``` 44 | 45 | contoh lain 46 | 47 | ```dart 48 | void main(List arguments) { 49 | for (int data = 5; data >= 1; data = data -1) { 50 | print('perulangan mundur dari ' + data.toString()); 51 | } 52 | 53 | } 54 | ``` 55 | 56 | hasil 57 | 58 | ```shell script 59 | perulangan mundur dari 5 60 | perulangan mundur dari 4 61 | perulangan mundur dari 3 62 | perulangan mundur dari 2 63 | perulangan mundur dari 1 64 | ``` 65 | 66 | > note: Perhitungan Perulangan ini dimulai dari `0` sama seperti menghitung index 67 | 68 | #### Penyingkatan For 69 | 70 | setelah mengetahui benduk dasar kita dapat menyingkatnya seperti ini 71 | 72 | * `counter = counter + 1` maka jadi `counter +=1` 73 | * `data = data -1 ` maka jadi `data -= 1` 74 | 75 | ### Perulangan while 76 | 77 | perulangan `while` yaitu perulangan yang dieksekusi selama kodisinya `true` contoh 78 | 79 | ```dart 80 | main(List args) { 81 | int number = 0; 82 | while (number < 5) { 83 | print('ulang sebanyak ' + number.toString()); 84 | number += 1; 85 | } 86 | } 87 | ``` 88 | 89 | contoh output 90 | 91 | ```shell script 92 | ulang sebanyak 0 93 | ulang sebanyak 1 94 | ulang sebanyak 2 95 | ulang sebanyak 3 96 | ulang sebanyak 4 97 | 98 | Process finished with exit code 0 99 | ``` 100 | 101 | ### Perulangan do while 102 | 103 | perulangan `do while` mirip seperti `while` hanya saja perulangan ini mengevaluasi kondisi setelah perulangan 104 | 105 | contoh 106 | 107 | ```dart 108 | main(List args) { 109 | int number = 0; 110 | do { 111 | print('perulangkan ke ' + number.toString()); 112 | number += 1; 113 | } while (number < 5); 114 | } 115 | ``` 116 | 117 | outputnya seperti ini 118 | 119 | ```shell script 120 | perulangkan ke 0 121 | perulangkan ke 1 122 | perulangkan ke 2 123 | perulangkan ke 3 124 | perulangkan ke 4 125 | 126 | Process finished with exit code 0 127 | ``` 128 | 129 | #### perbedaan `while` dan `do while` 130 | 131 | jika `do while` maka akan di eksekusi dulu baru di cek kalo `while` dia melakukan cek dulu 132 | jika kondisinya `true` maka baru dieksekusi 133 | 134 | > Note: Kalo `do while` jika pegecekan `false` si `do` akan tetap dieksekusi minimal `1x` 135 | 136 | contoh 137 | 138 | ```dart 139 | main(List args) { 140 | int number = 6; 141 | do { 142 | print('perulangkan ke ' + number.toString()); 143 | number += 1; 144 | } while (number < 5); 145 | } 146 | ``` 147 | 148 | dia akan cetak `1x` 149 | 150 | ```shell script 151 | perulangkan ke 6 152 | 153 | Process finished with exit code 0 154 | ``` 155 | 156 | ### Unary Operator 157 | 158 | * `++` (*increment*) 159 | * `--` (*decrement*) 160 | 161 | operator ini biasa diterapkan di perulangan contoh penerapanya bisa menyingkat `+= 1` atau `-= 1` contohnya 162 | 163 | ```dart 164 | main(List args) { 165 | int number = 0; 166 | while (number < 5) { 167 | print('ulang sebanyak ' + number.toString()); 168 | number ++; 169 | } 170 | } 171 | ``` 172 | 173 | outputnya tetep sama 174 | 175 | ```shell script 176 | ulang sebanyak 0 177 | ulang sebanyak 1 178 | ulang sebanyak 2 179 | ulang sebanyak 3 180 | ulang sebanyak 4 181 | 182 | Process finished with exit code 0 183 | ``` 184 | 185 | **Contoh Lain** 186 | 187 | ```dart 188 | for (int data = 5; data >= 1; data --) { 189 | print('perulangan mundur dari ' + data.toString()); 190 | } 191 | ``` 192 | 193 | outputnya sama 194 | 195 | ```shell script 196 | perulangan mundur dari 5 197 | perulangan mundur dari 4 198 | perulangan mundur dari 3 199 | perulangan mundur dari 2 200 | perulangan mundur dari 1 201 | 202 | Process finished with exit code 0 203 | ``` 204 | 205 | ### Bentuk Lain Pemakaian 206 | 207 | terdapat beberapa cara untuk memakai unary ini contoh 208 | 209 | * `a++` 210 | * `++a` 211 | * `b--` 212 | * `--b` 213 | 214 | > **Caranya Lihat posisi operator** 215 | > kalo `++` nya didepan `++a` berati ditambah dulu baru dipakai 216 | > kalo `++` nya dibelakang `a++` berati dipakai dulu baru ditambah 217 | > untuk operator `--` sama 218 | 219 | 220 | contoh penerapan 221 | 222 | **a++** 223 | 224 | ```dart 225 | main(List args) { 226 | int a, b; 227 | 228 | a = 10; 229 | b = a++; // hasilnya b = 10 (dipake dulu baru ditambah) 230 | print('isi dari a adalah' + a.toString()); 231 | print('isi dari b adalah ' + b.toString()); 232 | } 233 | ``` 234 | outputnya 235 | 236 | ```shell script 237 | isi dari a 11 238 | isi dari b adalah 10 239 | 240 | Process finished with exit code 0 241 | ``` 242 | 243 | **++a** 244 | 245 | 246 | ```dart 247 | ain(List args) { 248 | int a, b; 249 | 250 | a = 10; // berunah jadi 11 karena ditambah 251 | b = ++a; // hasilnya b = 11 (ditambah dulu baru dipake) 252 | print('isi dari a adalah ' + a.toString()); 253 | print('isi dari b adalah ' + b.toString()); 254 | } 255 | ``` 256 | 257 | output 258 | 259 | ```shell script 260 | isi dari a adalah 11 261 | isi dari b adalah 11 262 | 263 | Process finished with exit code 0 264 | ``` 265 | 266 | ### Referensi dan Resource 267 | 268 | * [dokumentasi](https://dart.dev/guides/language/language-tour#control-flow-statements) 269 | 270 | --- 271 | 272 | 273 | [Percabangan](../percabangan/README.md) <> [Fungsi, parameter Lambda Expression](../fungsi/README.md) 274 | -------------------------------------------------------------------------------- /perulangan/analysis_options.yaml: -------------------------------------------------------------------------------- 1 | # Defines a default set of lint rules enforced for projects at Google. For 2 | # details and rationale, see 3 | # https://github.com/dart-lang/pedantic#enabled-lints. 4 | 5 | include: package:pedantic/analysis_options.yaml 6 | 7 | # For lint rules and documentation, see http://dart-lang.github.io/linter/lints. 8 | 9 | # Uncomment to specify additional rules. 10 | # linter: 11 | # rules: 12 | # - camel_case_types 13 | 14 | # analyzer: 15 | # exclude: 16 | # - path/to/excluded/files/** 17 | -------------------------------------------------------------------------------- /perulangan/bin/perulangan.dart: -------------------------------------------------------------------------------- 1 | 2 | void main(List arguments) { 3 | for (int counter = 1; counter <= 5; counter += 1) { 4 | print('berulangan ke ' + counter.toString()); 5 | } 6 | 7 | for (int data = 5; data >= 1; data --) { 8 | print('perulangan mundur dari ' + data.toString()); 9 | } 10 | 11 | } -------------------------------------------------------------------------------- /perulangan/bin/perulangan_do_while.dart: -------------------------------------------------------------------------------- 1 | main(List args) { 2 | int number = 6; 3 | do { 4 | print('perulangkan ke ' + number.toString()); 5 | number += 1; 6 | } while (number < 5); 7 | } -------------------------------------------------------------------------------- /perulangan/bin/perulangan_while.dart: -------------------------------------------------------------------------------- 1 | main(List args) { 2 | int number = 0; 3 | while (number < 5) { 4 | print('ulang sebanyak ' + number.toString()); 5 | number += 1; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /perulangan/bin/unary_operator.dart: -------------------------------------------------------------------------------- 1 | main(List args) { 2 | int number = 0; 3 | while (number < 5) { 4 | print('ulang sebanyak ' + number.toString()); 5 | number ++; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /perulangan/bin/unary_trick.dart: -------------------------------------------------------------------------------- 1 | main(List args) { 2 | int a, b; 3 | 4 | a = 10; // berunah jadi 11 karena ditambah 5 | b = ++a; // hasilnya b = 11 (ditambah dulu baru dipake) 6 | print('isi dari a adalah ' + a.toString()); 7 | print('isi dari b adalah ' + b.toString()); 8 | } -------------------------------------------------------------------------------- /perulangan/lib/perulangan.dart: -------------------------------------------------------------------------------- 1 | int calculate() { 2 | return 6 * 7; 3 | } 4 | -------------------------------------------------------------------------------- /perulangan/pubspec.yaml: -------------------------------------------------------------------------------- 1 | name: perulangan 2 | description: A sample command-line application. 3 | version: 1.0.0 4 | # homepage: https://www.example.com 5 | 6 | environment: 7 | sdk: '>=2.12.0 <3.0.0' 8 | 9 | # dependencies: 10 | # path: ^1.8.0 11 | 12 | dev_dependencies: 13 | pedantic: ^1.10.0 14 | test: ^1.16.0 15 | -------------------------------------------------------------------------------- /perulangan/test/perulangan_test.dart: -------------------------------------------------------------------------------- 1 | import 'package:perulangan/perulangan.dart'; 2 | import 'package:test/test.dart'; 3 | 4 | void main() { 5 | test('calculate', () { 6 | expect(calculate(), 42); 7 | }); 8 | } 9 | -------------------------------------------------------------------------------- /reuireds/.gitignore: -------------------------------------------------------------------------------- 1 | # Files and directories created by pub. 2 | .dart_tool/ 3 | .packages 4 | 5 | # Conventional directory for build output. 6 | build/ 7 | -------------------------------------------------------------------------------- /reuireds/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.0 2 | 3 | - Initial version. 4 | -------------------------------------------------------------------------------- /reuireds/README.md: -------------------------------------------------------------------------------- 1 | ### `Required` `Assert` dan `Try Catch` 2 | 3 | #### `Required` 4 | 5 | mengubah optional parameter jadi wajib 6 | 7 | ```dart 8 | Person({required this.name, this.age = 0}); 9 | ``` 10 | 11 | implementasi 12 | 13 | ```dart 14 | 15 | void main(List arguments) { 16 | Person p; 17 | p = Person(); 18 | print(p.age); 19 | 20 | } 21 | 22 | class Person { 23 | final String name; 24 | final int age; 25 | 26 | // constructor 27 | Person({required this.name, this.age = 0}); 28 | } 29 | 30 | ``` 31 | 32 | kalo person ga diisi maka akan error 33 | 34 | ``` 35 | The named parameter 'name' is required, but there's no corresponding argument. 36 | ``` 37 | 38 | beda lagi klo implementasinya seperti ini 39 | 40 | ```dart 41 | 42 | void main(List arguments) { 43 | Person p; 44 | p = Person(name: 'feri'); 45 | print(p.age); 46 | 47 | } 48 | 49 | class Person { 50 | final String name; 51 | final int age; 52 | 53 | // constructor 54 | Person({required this.name, this.age = 0}); 55 | } 56 | ``` 57 | 58 | jika kita lihat kita isi paramater yang dibutuhkan seperti ini 59 | 60 | ```dart 61 | p = Person(name: 'feri'); 62 | ``` 63 | 64 | #### `Assert` 65 | 66 | `assert` digunakan untuk mengecek apakah bilai yang dimasukan sesuai yang diharapkan atau tidak, kemablian nya adalah pesan error 67 | 68 | ```dart 69 | class Person { 70 | final String name; 71 | final int age; 72 | 73 | // constructor 74 | Person({required this.name, this.age = 0}){ 75 | assert(name == String, 'name not string'); 76 | } 77 | } 78 | ``` 79 | 80 | dalam `assert` expresi harus mengembalikan boolean 81 | 82 | ### `try` dan `catch` 83 | 84 | untuk menangani error kita bisa pake `try catch` 85 | 86 | ```dart 87 | try { 88 | p = Person(name: 'pery'); 89 | print(p.age); 90 | } catch (e) { 91 | print(e); 92 | } 93 | ``` 94 | 95 | lengkapnya 96 | 97 | ```dart 98 | void main(List arguments) { 99 | Person p; 100 | try { 101 | p = Person(name: 'pery'); 102 | print(p.age); 103 | } catch (e) { 104 | print(e); 105 | } 106 | } 107 | 108 | ``` 109 | 110 | --- 111 | [Enum dan Cascade Notation](../enums/README.md) <> [Custom Sort dan ForEach](../custom_sort/README.md) -------------------------------------------------------------------------------- /reuireds/analysis_options.yaml: -------------------------------------------------------------------------------- 1 | # Defines a default set of lint rules enforced for projects at Google. For 2 | # details and rationale, see 3 | # https://github.com/dart-lang/pedantic#enabled-lints. 4 | 5 | include: package:pedantic/analysis_options.yaml 6 | 7 | # For lint rules and documentation, see http://dart-lang.github.io/linter/lints. 8 | 9 | # Uncomment to specify additional rules. 10 | # linter: 11 | # rules: 12 | # - camel_case_types 13 | 14 | # analyzer: 15 | # exclude: 16 | # - path/to/excluded/files/** 17 | -------------------------------------------------------------------------------- /reuireds/bin/reuireds.dart: -------------------------------------------------------------------------------- 1 | void main(List arguments) { 2 | Person p; 3 | try { 4 | p = Person(name: 'pery'); 5 | print(p.age); 6 | } catch (e) { 7 | print(e); 8 | } 9 | } 10 | 11 | class Person { 12 | final String name; 13 | final int age; 14 | 15 | // constructor 16 | Person({required this.name, this.age = 0}) { 17 | String pery = 'pery'; 18 | assert(name == pery, 'name not string'); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /reuireds/lib/reuireds.dart: -------------------------------------------------------------------------------- 1 | int calculate() { 2 | return 6 * 7; 3 | } 4 | -------------------------------------------------------------------------------- /reuireds/pubspec.yaml: -------------------------------------------------------------------------------- 1 | name: reuireds 2 | description: A sample command-line application. 3 | version: 1.0.0 4 | # homepage: https://www.example.com 5 | 6 | environment: 7 | sdk: '>=2.12.0 <3.0.0' 8 | 9 | # dependencies: 10 | # path: ^1.8.0 11 | 12 | dev_dependencies: 13 | pedantic: ^1.10.0 14 | test: ^1.16.0 15 | -------------------------------------------------------------------------------- /reuireds/test/reuireds_test.dart: -------------------------------------------------------------------------------- 1 | import 'package:reuireds/reuireds.dart'; 2 | import 'package:test/test.dart'; 3 | 4 | void main() { 5 | test('calculate', () { 6 | expect(calculate(), 42); 7 | }); 8 | } 9 | -------------------------------------------------------------------------------- /singleton/.gitignore: -------------------------------------------------------------------------------- 1 | # Files and directories created by pub. 2 | .dart_tool/ 3 | .packages 4 | 5 | # Conventional directory for build output. 6 | build/ 7 | -------------------------------------------------------------------------------- /singleton/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.0 2 | 3 | - Initial version. 4 | -------------------------------------------------------------------------------- /singleton/README.md: -------------------------------------------------------------------------------- 1 | ### Singleton 2 | 3 | `Singleton` adalah `design pattern` dimana satu buah class hanya bisa dibuat menjadi satu buah object 4 | 5 | contoh seperti ini 6 | 7 | ```dart 8 | // singleton 9 | class ServiceSingleton { 10 | static final ServiceSingleton _instance = ServiceSingleton._internal(); 11 | 12 | ServiceSingleton._internal(); 13 | 14 | factory ServiceSingleton() { 15 | return _instance; 16 | } 17 | 18 | Future getUserData() async { 19 | // get User Data Process 20 | return User(); 21 | } 22 | } 23 | ``` 24 | 25 | untuk main seperti ini 26 | 27 | ```dart 28 | void main(List arguments) { 29 | ServiceSingleton service1 = ServiceSingleton(); 30 | ServiceSingleton service2 = ServiceSingleton(); 31 | 32 | // check object 33 | if (service1 == service2) { 34 | print('sama'); 35 | } else { 36 | print('tidak sama'); 37 | } 38 | } 39 | ``` 40 | 41 | hasilnya 42 | 43 | ``` 44 | sama 45 | ``` 46 | 47 | --- 48 | [Operator Override](../operator_overriding/README.md) <> [Future Or](../furure_or/README.md) 49 | -------------------------------------------------------------------------------- /singleton/analysis_options.yaml: -------------------------------------------------------------------------------- 1 | # Defines a default set of lint rules enforced for projects at Google. For 2 | # details and rationale, see 3 | # https://github.com/dart-lang/pedantic#enabled-lints. 4 | 5 | include: package:pedantic/analysis_options.yaml 6 | 7 | # For lint rules and documentation, see http://dart-lang.github.io/linter/lints. 8 | 9 | # Uncomment to specify additional rules. 10 | # linter: 11 | # rules: 12 | # - camel_case_types 13 | 14 | # analyzer: 15 | # exclude: 16 | # - path/to/excluded/files/** 17 | -------------------------------------------------------------------------------- /singleton/bin/services.dart: -------------------------------------------------------------------------------- 1 | import 'user.dart'; 2 | 3 | class Services { 4 | Future getUserData() async { 5 | // get User Data Process 6 | return User(); 7 | } 8 | } 9 | 10 | // singleton 11 | class ServiceSingleton { 12 | static final ServiceSingleton _instance = ServiceSingleton._internal(); 13 | 14 | ServiceSingleton._internal(); 15 | 16 | factory ServiceSingleton() { 17 | return _instance; 18 | } 19 | 20 | Future getUserData() async { 21 | // get User Data Process 22 | return User(); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /singleton/bin/singleton.dart: -------------------------------------------------------------------------------- 1 | import 'services.dart'; 2 | 3 | void main(List arguments) { 4 | ServiceSingleton service1 = ServiceSingleton(); 5 | ServiceSingleton service2 = ServiceSingleton(); 6 | 7 | // check object 8 | if (service1 == service2) { 9 | print('sama'); 10 | } else { 11 | print('sama'); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /singleton/bin/user.dart: -------------------------------------------------------------------------------- 1 | class User {} -------------------------------------------------------------------------------- /singleton/lib/singleton.dart: -------------------------------------------------------------------------------- 1 | int calculate() { 2 | return 6 * 7; 3 | } 4 | -------------------------------------------------------------------------------- /singleton/pubspec.yaml: -------------------------------------------------------------------------------- 1 | name: singleton 2 | description: A sample command-line application. 3 | version: 1.0.0 4 | # homepage: https://www.example.com 5 | 6 | environment: 7 | sdk: '>=2.12.0 <3.0.0' 8 | 9 | # dependencies: 10 | # path: ^1.8.0 11 | 12 | dev_dependencies: 13 | pedantic: ^1.10.0 14 | test: ^1.16.0 15 | -------------------------------------------------------------------------------- /singleton/test/singleton_test.dart: -------------------------------------------------------------------------------- 1 | import 'package:singleton/singleton.dart'; 2 | import 'package:test/test.dart'; 3 | 4 | void main() { 5 | test('calculate', () { 6 | expect(calculate(), 42); 7 | }); 8 | } 9 | -------------------------------------------------------------------------------- /solid_principle/.gitignore: -------------------------------------------------------------------------------- 1 | # Files and directories created by pub. 2 | .dart_tool/ 3 | .packages 4 | 5 | # Conventional directory for build output. 6 | build/ 7 | -------------------------------------------------------------------------------- /solid_principle/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.0 2 | 3 | - Initial version. 4 | -------------------------------------------------------------------------------- /solid_principle/README.md: -------------------------------------------------------------------------------- 1 | ### SOLID Principle 2 | 3 | chapter kali ini akan membahas hal yang penting yaitu `SOLID` 4 | 5 | * `S` - Single Responsibility Principle 6 | * `O` - Open/Closed Principle 7 | * `L` - Listkov Substitution Principle 8 | * `I` - Interface Segregation Principle 9 | * `D` - Dependencies Inversion Principle 10 | 11 | ### Single Responsibility Principle 12 | 13 | sebuah class harus fokus pada 1 task tertentu jangan sampai ada `SuperClass` (*Class yang tidak fokus pada 1 tugas*) 14 | 15 | contoh 16 | 17 | ```dart 18 | class Car { 19 | late AirConditioner airConditioner; 20 | late Radio radio; 21 | 22 | void turnOnCar() { 23 | //.. 24 | } 25 | void turnOffCar() { 26 | //.. 27 | } 28 | } 29 | 30 | class AirConditioner { 31 | void turnOnAirConditioner() { 32 | //.. 33 | } 34 | void turnOffAirConditioner() { 35 | //.. 36 | } 37 | } 38 | 39 | class Radio { 40 | void playMusic() { 41 | //.. 42 | } 43 | } 44 | ``` 45 | 46 | strukttur class seperti ini akan memudahkan kita untuk mencari sebuah bug 47 | 48 | ### Open/Closed Principle 49 | 50 | sebuah class baiknya adalah `Close` untuk Modifikasi dan `Open` untuk Extension contoh 51 | kalo kita punya class itu baiknya ga bisa diubah ubah kalo misal mau tambah fitur itu baiknya kita tambah bukan malah ubah si `class` nya :) 52 | 53 | misal kita punya class seperti ini 54 | 55 | ```dart 56 | class Heroes { 57 | void killMonster() { 58 | //.. 59 | } 60 | void walk() { 61 | //... 62 | } 63 | } 64 | 65 | ``` 66 | 67 | kita mau menambah fitur dia bisa Punya skill Khusus misalnya ada teknik pukul kita ga boleh ubah class 68 | karena nanti ada impact ketika atda yang menggunakan aplikasi kita/method yang dulu kita buat 69 | ini bakal ngaruh sama sisten kita yang lain? jadi kita buat aja class baru untuk fitur ini 70 | 71 | ```dart 72 | lass Heroes { 73 | void killMonster() { 74 | //.. 75 | } 76 | void walk() { 77 | //... 78 | } 79 | } 80 | 81 | 82 | // class untuk fitur baru 83 | class KiritoSwords extends Heroes { 84 | void doubleWeapon() { 85 | //.. 86 | } 87 | void onePunch() { 88 | //.. 89 | } 90 | } 91 | ``` 92 | 93 | jadi method lama tetep ada kita tambah aja fitur baru di extends class nya lengkapnya baca lagi ke halaman [inheritance](../inherit/README.md) :) 94 | 95 | ### Listkov Substitution Principle 96 | 97 | Setiap Class yang merupakan turunan dari `class parent` itu harus memiliki sifat/perilaku dari `parent class` nya jadi nanti lebih mudah buat cari bug, tambah fitur, ngoding juga lebih enak 98 | 99 | ```dart 100 | class Cat { 101 | void eat() { 102 | //.. 103 | } 104 | void walk() { 105 | //.. 106 | } 107 | void sleep() { 108 | //.. 109 | } 110 | } 111 | 112 | // dikelompokan dalam 1 jenis parent nya 113 | 114 | class Anggora extends Cat { 115 | @override 116 | void eat() { 117 | //... makan dengan gaya anggora 118 | } 119 | } 120 | ``` 121 | 122 | ### Interface Segregation Principle 123 | 124 | jadi ketika kita membuat `interface` itu harus spesifik ke tujuan tertentu, di suatu `class` kita jangan meng-implementasi 125 | sesuatu yang tidak dibutuhkan, contoh 126 | 127 | 128 | ```dart 129 | abstract class Hero { 130 | void regularAttack(); 131 | } 132 | 133 | // pisah class secara spesifik 134 | abstract class ImagicCaster { 135 | void castMagic(); 136 | } 137 | 138 | abstract class Healer { 139 | void heal(); 140 | } 141 | 142 | abstract class Stealer { 143 | void stealMoney(); 144 | } 145 | 146 | // implementasi 147 | class Thief extends Hero implements Stealer { 148 | @override 149 | void regularAttack() { 150 | // TODO: implement regularAttack 151 | } 152 | 153 | @override 154 | void stealMoney() { 155 | // TODO: implement stealMoney 156 | } 157 | } 158 | 159 | class ShiroMajutsu extends Hero implements Healer, ImagicCaster { 160 | @override 161 | void castMagic() { 162 | // TODO: implement castMagic 163 | } 164 | 165 | @override 166 | void heal() { 167 | // TODO: implement heal 168 | } 169 | 170 | @override 171 | void regularAttack() { 172 | // TODO: implement regularAttack 173 | } 174 | } 175 | 176 | class KuroMajutsu extends Hero implements ImagicCaster { 177 | @override 178 | void castMagic() { 179 | // TODO: implement castMagic 180 | } 181 | 182 | @override 183 | void regularAttack() { 184 | // TODO: implement regularAttack 185 | } 186 | } 187 | ``` 188 | 189 | dengan demikian ga bakal ada lagi method yang ga kepake :) jadi kita bener2 implementasi method yang bener2 dibutuhkan 190 | 191 | ### Dependencies Inversion Principle 192 | 193 | dalam prinsip ini `High-Level Module` tidak boleh bergantung dengan `Low-level Module` keduanya harus bergantung pada `abstraction` 194 | sedangkan `abstraction` tidak boleh bergantung pada `detail` harusnya si `detail` yang bergantung pada `abstract` 195 | 196 | * `low level module`: bagian yang sering buerubah 197 | * `High Level Model` : bagian yang jarang berubah 198 | 199 | agar lebih tau gambaranya seperti ini 200 | 201 | ```dart 202 | class User {} 203 | 204 | class UserManager { 205 | final IDataStorage datastorage; 206 | 207 | UserManager(this.datastorage); 208 | 209 | void saveDataStorage(User user) { 210 | datastorage.saveData(user); 211 | } 212 | } 213 | 214 | abstract class IDataStorage { 215 | void saveData(User user); 216 | } 217 | 218 | class FireBaseStorage implements IDataStorage { 219 | @override 220 | void saveData(User user) { 221 | // connect to Firebase 222 | // save data 223 | } 224 | } 225 | 226 | class LocalStorage implements IDataStorage { 227 | @override 228 | void saveData(User user) { 229 | // TODO: implement saveData 230 | // connect data to local 231 | // save data 232 | } 233 | } 234 | ``` 235 | 236 | sekarang kita lihat bahwa `High Level Module` bergantung patda `abstraction` tapi abstraction tidak bergabtung pada detail 237 | 238 | --- 239 | 240 | [Custom Sort dan For Each](../custom_sort/README.md) <> [Operator Overriding](../operator_overriding/README.md) -------------------------------------------------------------------------------- /solid_principle/analysis_options.yaml: -------------------------------------------------------------------------------- 1 | # Defines a default set of lint rules enforced for projects at Google. For 2 | # details and rationale, see 3 | # https://github.com/dart-lang/pedantic#enabled-lints. 4 | 5 | include: package:pedantic/analysis_options.yaml 6 | 7 | # For lint rules and documentation, see http://dart-lang.github.io/linter/lints. 8 | 9 | # Uncomment to specify additional rules. 10 | # linter: 11 | # rules: 12 | # - camel_case_types 13 | 14 | # analyzer: 15 | # exclude: 16 | # - path/to/excluded/files/** 17 | -------------------------------------------------------------------------------- /solid_principle/bin/ConnectDB.dart: -------------------------------------------------------------------------------- 1 | class User {} 2 | 3 | class UserManager { 4 | final IDataStorage datastorage; 5 | 6 | UserManager(this.datastorage); 7 | 8 | void saveDataStorage(User user) { 9 | datastorage.saveData(user); 10 | } 11 | } 12 | 13 | // bergantung disini high Levelnya 14 | abstract class IDataStorage { 15 | void saveData(User user); 16 | } 17 | 18 | // abstraction tidak bergantung pada detil 19 | 20 | class FireBaseStorage implements IDataStorage { 21 | @override 22 | void saveData(User user) { 23 | // connect to Firebase 24 | // save data 25 | } 26 | } 27 | 28 | class LocalStorage implements IDataStorage { 29 | @override 30 | void saveData(User user) { 31 | // TODO: implement saveData 32 | // connect data to local 33 | // save data 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /solid_principle/bin/interfacing.dart: -------------------------------------------------------------------------------- 1 | abstract class Hero { 2 | void regularAttack(); 3 | } 4 | 5 | // pisah class secara spesifik 6 | abstract class ImagicCaster { 7 | void castMagic(); 8 | } 9 | 10 | abstract class Healer { 11 | void heal(); 12 | } 13 | 14 | abstract class Stealer { 15 | void stealMoney(); 16 | } 17 | 18 | // implementasi 19 | class Thief extends Hero implements Stealer { 20 | @override 21 | void regularAttack() { 22 | // TODO: implement regularAttack 23 | } 24 | 25 | @override 26 | void stealMoney() { 27 | // TODO: implement stealMoney 28 | } 29 | } 30 | 31 | class ShiroMajutsu extends Hero implements Healer, ImagicCaster { 32 | @override 33 | void castMagic() { 34 | // TODO: implement castMagic 35 | } 36 | 37 | @override 38 | void heal() { 39 | // TODO: implement heal 40 | } 41 | 42 | @override 43 | void regularAttack() { 44 | // TODO: implement regularAttack 45 | } 46 | } 47 | 48 | class KuroMajutsu extends Hero implements ImagicCaster { 49 | @override 50 | void castMagic() { 51 | // TODO: implement castMagic 52 | } 53 | 54 | @override 55 | void regularAttack() { 56 | // TODO: implement regularAttack 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /solid_principle/bin/listkov.dart: -------------------------------------------------------------------------------- 1 | class Cat { 2 | void eat() { 3 | //.. 4 | } 5 | void walk() { 6 | //.. 7 | } 8 | void sleep() { 9 | //.. 10 | } 11 | } 12 | 13 | // dikelompokan dalam 1 jenis parent nya 14 | 15 | class Anggora extends Cat { 16 | @override 17 | void eat() { 18 | //... makan dengan gaya anggora 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /solid_principle/bin/openclosed.dart: -------------------------------------------------------------------------------- 1 | class Heroes { 2 | void killMonster() { 3 | //.. 4 | } 5 | void walk() { 6 | //... 7 | } 8 | } 9 | 10 | class KiritoSwords extends Heroes { 11 | void doubleWeapon() { 12 | //.. 13 | } 14 | void onePunch() { 15 | //.. 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /solid_principle/bin/solid.dart: -------------------------------------------------------------------------------- 1 | class Car { 2 | late AirConditioner airConditioner; 3 | late Radio radio; 4 | 5 | void turnOnCar() { 6 | //.. 7 | } 8 | void turnOffCar() { 9 | //.. 10 | } 11 | } 12 | 13 | class AirConditioner { 14 | void turnOnAirConditioner() { 15 | //.. 16 | } 17 | void turnOffAirConditioner() { 18 | //.. 19 | } 20 | } 21 | 22 | class Radio { 23 | void playMusic() { 24 | //.. 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /solid_principle/bin/solid_principle.dart: -------------------------------------------------------------------------------- 1 | void main(List arguments) { 2 | 3 | } 4 | -------------------------------------------------------------------------------- /solid_principle/lib/solid_principle.dart: -------------------------------------------------------------------------------- 1 | int calculate() { 2 | return 6 * 7; 3 | } 4 | -------------------------------------------------------------------------------- /solid_principle/pubspec.yaml: -------------------------------------------------------------------------------- 1 | name: solid_principle 2 | description: A sample command-line application. 3 | version: 1.0.0 4 | # homepage: https://www.example.com 5 | 6 | environment: 7 | sdk: '>=2.12.0 <3.0.0' 8 | 9 | # dependencies: 10 | # path: ^1.8.0 11 | 12 | dev_dependencies: 13 | pedantic: ^1.10.0 14 | test: ^1.16.0 15 | -------------------------------------------------------------------------------- /static_keywords/.gitignore: -------------------------------------------------------------------------------- 1 | # Files and directories created by pub. 2 | .dart_tool/ 3 | .packages 4 | 5 | # Conventional directory for build output. 6 | build/ 7 | -------------------------------------------------------------------------------- /static_keywords/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.0 2 | 3 | - Initial version. 4 | -------------------------------------------------------------------------------- /static_keywords/README.md: -------------------------------------------------------------------------------- 1 | ### Static Keywords 2 | 3 | `static` ini menyatakan bahwa member dari sebuah class bisa berupa (*field/method*) itu menjadi milik class tersebut 4 | 5 | ```dart 6 | class Person { 7 | String? name; 8 | int? age; 9 | static int maxAge = 150; 10 | 11 | // constructor 12 | Person (this.name, int age) { 13 | this.age = (age > 150) ? 150 : age; 14 | } 15 | } 16 | ``` 17 | 18 | kemudian kita panggi dari `main` seperti ini 19 | 20 | ```dart 21 | import 'package:static_keywords/static_keywords.dart'; 22 | 23 | void main(List arguments) { 24 | Person p = Person('david', 170); 25 | 26 | print(p.maxAge); 27 | } 28 | ``` 29 | 30 | jika kita jalankan maka akan menjadi error 31 | 32 | ``` 33 | Error: The getter 'maxAge' isn't defined for the class 'Person'. 34 | - 'Person' is from 'package:static_keywords/static_keywords.dart' ('lib/static_keywords.dart'). 35 | Try correcting the name to the name of an existing getter, or defining a getter or field named 'maxAge'. 36 | print(p.maxAge); 37 | ``` 38 | 39 | karena field `maxAge` bukan milik si object tersebut jd tidak akan dikenali, beda lagi ceritanya kalo kita ubah seperti ini 40 | 41 | ```dart 42 | import 'package:static_keywords/static_keywords.dart'; 43 | 44 | void main(List arguments) { 45 | Person p = Person('david', 170); 46 | 47 | print(Person.maxAge); 48 | } 49 | ``` 50 | 51 | disini kita definisikan kita akan mengakses `maxAge` milik si `Person` jika kita jalankan hasilnya 52 | 53 | ``` 54 | 150 55 | ``` 56 | 57 | kelebihan `static` ini kalo kita taruh suatu field ini di satu class maka akan memakan tempat cuman 1, 58 | beda lagi kalo nyimpen di object kita bakal punya 1 field/variabel yang punya nilai yang sama tiap kali kita buat object 59 | 60 | --- 61 | 62 | [Parameter Underscore](../underscore_parameter/README.md) <> [Async Await dan Future](../async_await/README.md) -------------------------------------------------------------------------------- /static_keywords/analysis_options.yaml: -------------------------------------------------------------------------------- 1 | # Defines a default set of lint rules enforced for projects at Google. For 2 | # details and rationale, see 3 | # https://github.com/dart-lang/pedantic#enabled-lints. 4 | 5 | include: package:pedantic/analysis_options.yaml 6 | 7 | # For lint rules and documentation, see http://dart-lang.github.io/linter/lints. 8 | 9 | # Uncomment to specify additional rules. 10 | # linter: 11 | # rules: 12 | # - camel_case_types 13 | 14 | # analyzer: 15 | # exclude: 16 | # - path/to/excluded/files/** 17 | -------------------------------------------------------------------------------- /static_keywords/bin/static_keywords.dart: -------------------------------------------------------------------------------- 1 | import 'package:static_keywords/static_keywords.dart'; 2 | 3 | void main(List arguments) { 4 | Person p = Person('david', 170); 5 | 6 | print(Person.maxAge); 7 | } 8 | -------------------------------------------------------------------------------- /static_keywords/lib/static_keywords.dart: -------------------------------------------------------------------------------- 1 | class Person { 2 | String? name; 3 | int? age; 4 | static int maxAge = 150; 5 | 6 | // constructor 7 | Person (this.name, int age) { 8 | this.age = (age > 150) ? 150 : age; 9 | } 10 | } -------------------------------------------------------------------------------- /static_keywords/pubspec.yaml: -------------------------------------------------------------------------------- 1 | name: static_keywords 2 | description: A sample command-line application. 3 | version: 1.0.0 4 | # homepage: https://www.example.com 5 | 6 | environment: 7 | sdk: '>=2.12.0 <3.0.0' 8 | 9 | # dependencies: 10 | # path: ^1.8.0 11 | 12 | dev_dependencies: 13 | pedantic: ^1.10.0 14 | test: ^1.16.0 15 | -------------------------------------------------------------------------------- /underscore_parameter/.gitignore: -------------------------------------------------------------------------------- 1 | # Files and directories created by pub. 2 | .dart_tool/ 3 | .packages 4 | 5 | # Conventional directory for build output. 6 | build/ 7 | -------------------------------------------------------------------------------- /underscore_parameter/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.0 2 | 3 | - Initial version. 4 | -------------------------------------------------------------------------------- /underscore_parameter/README.md: -------------------------------------------------------------------------------- 1 | ### Paramater Underscore 2 | 3 | biasanya dalam paeramater ada paramater yang di isi dengan underscore, itu artinya kita akan mengabaikan nilai yang akan dimasukan dalam parameter tersebut 4 | 5 | ```dart 6 | class Person { 7 | String? name; 8 | Function(String name)? doHobby; 9 | 10 | // constructor 11 | Person(this.name, {this.doHobby}); 12 | 13 | // method 14 | void takeARest() { 15 | if (doHobby != null) { 16 | doHobby!(name!); 17 | } 18 | } 19 | } 20 | ``` 21 | 22 | kemudian pemanggilanya seperti ini 23 | 24 | ```dart 25 | import 'package:underscore_parameter/underscore_parameter.dart'; 26 | 27 | void main(List arguments) { 28 | var person = Person('feri', doHobby: feriHobby); 29 | 30 | // panggil method 31 | person.takeARest(); 32 | } 33 | 34 | void feriHobby(String name) { 35 | print('$name learn code everyday'); 36 | } 37 | ``` 38 | 39 | hasilnya 40 | 41 | ``` 42 | feri learn code everyday 43 | ``` 44 | 45 | ### Penyingkatan 46 | 47 | kita dapat menyingkat menjadi seperti ini 48 | 49 | ```dart 50 | import 'package:underscore_parameter/underscore_parameter.dart'; 51 | 52 | void main(List arguments) { 53 | var person = Person('feri', doHobby: (String name) { 54 | print('$name learn code everyday'); 55 | }); 56 | 57 | // panggil method 58 | person.takeARest(); 59 | } 60 | ``` 61 | 62 | hasilnya sama aja 63 | 64 | ``` 65 | feri learn code everyday 66 | ``` 67 | 68 | bisa kita lihat bahwa paramater `name` gak kepake maka dari itu kita ganti underscore seperti ini 69 | 70 | ```dart 71 | import 'package:underscore_parameter/underscore_parameter.dart'; 72 | 73 | void main(List arguments) { 74 | var person = Person('feri', doHobby: (_) { 75 | print('learn code everyday'); 76 | }); 77 | 78 | // panggil method 79 | person.takeARest(); 80 | } 81 | ``` 82 | 83 | hasilnya 84 | 85 | ``` 86 | learn code everyday 87 | ``` 88 | 89 | --- 90 | [Constructor](../constructors/README.md) <> [Static Keywords](../static_keywords/README.md) -------------------------------------------------------------------------------- /underscore_parameter/analysis_options.yaml: -------------------------------------------------------------------------------- 1 | # Defines a default set of lint rules enforced for projects at Google. For 2 | # details and rationale, see 3 | # https://github.com/dart-lang/pedantic#enabled-lints. 4 | 5 | include: package:pedantic/analysis_options.yaml 6 | 7 | # For lint rules and documentation, see http://dart-lang.github.io/linter/lints. 8 | 9 | # Uncomment to specify additional rules. 10 | # linter: 11 | # rules: 12 | # - camel_case_types 13 | 14 | # analyzer: 15 | # exclude: 16 | # - path/to/excluded/files/** 17 | -------------------------------------------------------------------------------- /underscore_parameter/bin/underscore_parameter.dart: -------------------------------------------------------------------------------- 1 | import 'package:underscore_parameter/underscore_parameter.dart'; 2 | 3 | void main(List arguments) { 4 | var person = Person('feri', doHobby: (_) { 5 | print('learn code everyday'); 6 | }); 7 | 8 | // panggil method 9 | person.takeARest(); 10 | } 11 | -------------------------------------------------------------------------------- /underscore_parameter/lib/underscore_parameter.dart: -------------------------------------------------------------------------------- 1 | class Person { 2 | String? name; 3 | Function(String name)? doHobby; 4 | 5 | // constructor 6 | Person(this.name, {this.doHobby}); 7 | 8 | // method 9 | void takeARest() { 10 | if (doHobby != null) { 11 | doHobby!(name!); 12 | } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /underscore_parameter/pubspec.yaml: -------------------------------------------------------------------------------- 1 | name: underscore_parameter 2 | description: A sample command-line application. 3 | version: 1.0.0 4 | # homepage: https://www.example.com 5 | 6 | environment: 7 | sdk: '>=2.12.0 <3.0.0' 8 | 9 | # dependencies: 10 | # path: ^1.8.0 11 | 12 | dev_dependencies: 13 | pedantic: ^1.10.0 14 | test: ^1.16.0 15 | --------------------------------------------------------------------------------