main() {
  Employee employee = Employee()
    ..name = 'Kim'
    ..setAge(25)
    ..showInfo();

  employee.name = 'Park';
  employee.setAge(30);
  employee.showInfo();
}

class Employee {
  var name = 'employee';
  int age = 10;

  setAge(int age) {
    this.age = age;
  }

  showInfo() {
    print('$name is $age.');
  }
}

Kim is 25.
Park is 30.

class Person {
  late String name;
  late int age;

  getName() {
    return name;
  }
}

main() {
  var student = new Person();
  var teacher = Person();
  Person person = Person();

  student.name = 'Kim';
  teacher.name = 'Park';
  person.name = 'Unknown';

  print('학생 이름이 뭐야 ? ${student.getName()}');
  print('학생 이름이 뭐야 ? ${teacher.getName()}');
  print('학생 이름이 뭐야 ? ${person.getName()}');
}

학생 이름이 뭐야 ? Kim
학생 이름이 뭐야 ? Park
학생 이름이 뭐야 ? Unknown

void main(){
  Cars bmw = Cars(320, 100000, 'BMW');

  print(bmw.price);
  bmw.saleCar();
  print(bmw.price);
}

class Cars {
  late int maxSpeed;
  late num price;
  late String name;
  
  Cars(int maxSpeed, num price, String name) {
    this.maxSpeed = maxSpeed;
    this.price = price;
    this.name = name;
  }
  
  num saleCar(){
    price = price * 0.9;
    return price;
  }    
}

100000
90000

import 'dart:collection'; // HashSet
import 'dart:math' as math;

void main(){
  var rand = math.Random();
  HashSet<int> lotteryNumber = HashSet(); // Set은 중복을 허용하지 않는 리스트
  
  while(lotteryNumber.length < 6){
    lotteryNumber.add(rand.nextInt(45));
  }
  
  print(lotteryNumber);
}

{6, 9, 11, 28, 38, 42}

class Person {
  Person() {
    print('This is Person Constructor!');
  }
}

class Student extends Person {

}

main() {
  var student = Student();
}

This is Person Constructor!
------------------------------

Student 클래스에는 생성자가 없다. 
따라서 자동으로 기본 생성자가 제공된다.

class Person {
  Person() {
    print('This is Person Constructor!');
  }
}

class Student extends Person {
  Student() {
    print('This is Student Constructor!');
  }
}

main() {
  var student = Student();
}

This is Person Constructor!
This is Student Constructor!

------------------------------

부모 클래스(Person)의 기본 생성자가 호출된 후
자식 클래스(Student)의 기본 생성자가 호출 

class Person {
  Person() {
    print('This is Person Constructor!');
  }

  Person.init() {
    print('This is Person.init Constructor!');
  }
}

class Student extends Person {
  Student() {
    print('This is Student Constructor!');
  }
}

main() {
  var student = Student();
  print('---------------------');
  var person = Person();
  print('---------------------');
  var init = Person.init();
}

This is Person Constructor!
This is Student Constructor!
---------------------
This is Person Constructor!
---------------------
This is Person.init Constructor!

class Person {
  String name;

  Person() : name = 'Kim' {
    print('This is Person($name) Constructor!');
  }
}

main() {
  var person = Person();
}

This is Person(Kim) Constructor!

class Person {
  String name;
  int age;

  Person(this.name, this.age) {
    print('This is Person($name, $age) Constructor!');
  }

  Person.initName(String name) : this(name, 20);
}

main() {
  var person = Person.initName('Kim');
}

This is Person(Kim, 20) Constructor!

class Person {
  final String name;
  final num age;

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

main() {
  Person person1 = const Person('Kim', 10);
  Person person2 = const Person('Kim', 20);
  Person person3 = const Person('Lee', 30);
  Person person4 = const Person('Kim', 10);

  print(identical(person1, person2)); // 동일 인스턴스인지 비교
  print(identical(person1, person3));
  print(identical(person1, person4));
  print(identical(person2, person3));
  print(identical(person3, person4));

  print('----------------');

  print('person1 : ${person1.name}, ${person1.age}');
  print('person2 : ${person2.name}, ${person2.age}');
  print('person3 : ${person3.name}, ${person3.age}');
  print('person4 : ${person4.name}, ${person4.age}');
}

false
false
true
false
false
----------------
person1 : Kim, 10
person2 : Kim, 20
person3 : Lee, 30
person4 : Kim, 10

class Person {
  Person.init();

  factory Person(type) {
    switch (type) {
      case 'Student':
        return Student();
      case 'Employee':
        return Employee();
      default:
        return Empty();
    }
  }

  String getType() {
    return 'Person';
  }
}

class Student extends Person {
  Student() : super.init();

  @override
  String getType() {
    return 'Student';
  }
}

class Employee extends Person {
  Employee() : super.init();

  @override
  String getType() {
    return 'Employee';
  }
}

class Empty extends Person {
  Empty() : super.init();

  @override
  String getType() {
    return 'Empty Value';
  }
}

main() {
  Person student = Person('Student');
  Person employee = Person('Employee');
  Person anycall = Person('Anycall');

  print('type = ${student.getType()}');
  print('type = ${employee.getType()}');
  print('type = ${anycall.getType()}');
}

type = Student
type = Employee
type = Empty Value

// Person 클래스는 부모 클래스
// 1개의 멤버 변수와 3개의 메서드로 구성
class Person {
  late String name;

  setName(String name) {
    // this는 해당 인스턴스를 가리킨다
    // 변수명이 동일하기 때문에 구분하기 위해서 this로 인스턴스 변수를 명확히 가리킨 것
    // this.name => Person 클래스의 인스턴스 변수인 late String name
    // name => setName(String name) 메서드의 인자 name
    this.name = name;
  }

  getName() {
    return name;
  }

  showInfo() {
    print('name is $name');
  }
}

// Student 클래스는 Person의 자식 클래스
// 부모 클래스인 Person의 멤버 변수와 메서드를 모두 상속
// Person의 멤버 변수와 메서드를 별도로 Student 클래스 내에 선언하지 않아도 사용 가능
class Student extends Person {
  late int studentID;

  // 부모 클래스 함수의 기능을 변경하고 싶다면 재정의
  @override
  showInfo() {
    // super는 부모 클래스를 가리킨다
    print('1. name is ${super.getName()} and id is $studentID.');

    // 자식 클래스는 이미 부모 클래스의 getName() 메서드도 상속받았기 때문에 생략 가능
    print('2. name is ${getName()} and id is $studentID.');

    // name 역시 상속받았기 때문에 name변수를 사용 가능
    print('3. name is $name and id is $studentID.');
  }
}

main() {
  Person person = Person();
  person.setName('Kim');
  person.showInfo();

  print('-----------');

  Student student = Student();
  student.studentID = 2020;
  student.setName('Kim');
  student.showInfo();
}

name is Kim
-----------
1. name is Kim and id is 2020.
2. name is Kim and id is 2020.
3. name is Kim and id is 2020.

class Person {
  late String _name;
  String get name => _name; // Getter

  // set name의 name은 임의로 지정해준 이름
  set name(String name) => _name = name; // Setter

  set setName(String name) => _name = name; // Setter
}

main() {
  Person person = Person();

  person.name = 'Kim';
  print(person.name);

  person.setName = 'Kevin';
  print(person.name);
}

Kim
Kevin

// 추상 클래스
abstract class Person {
  eat();

  sleep() {
    print('Person must sleep');
  }
}

abstract class Junior {
  work() {
    print('work hard');
  }
}

// 추상 클래스인 Person를 임플리먼트
class Developer implements Person, Junior {
  // 꼭 다른 기능으로 사용하기 위한 재정의가 아니더라도
  // 추상 클래스 Person의 추상 메서드인 eat()를 오버라이딩
  @override
  eat() {
    print('Developer like iced Americano.');
  }

  // @override를 생략가능
  sleep() {
    print('Developer must sleep');
  }

  @override
  work() {
    print('Junior developer works hard');
  }
}

main() {
  // person 객체의 타입으로 추상 클래스인 Person을 사용
  // 실제 생성되는 객체는 Developer
  Developer person = Developer();
  person.eat();
  person.sleep();
  person.work();

  //Person person = Person(); // 추상 클래스로 객체를 생성하려고 하면 에러가 발생
}

Developer like iced Americano.
Developer must sleep
Junior developer works hard

class Person {
  eat() {
    print('Person eats a food');
  }
}

// Person의 자식 클래스
class Student extends Person {
  eat() {
    print('Student eats a hambuger');
  }
}

// <T extends Person> 타입 매개변수
// Person 클래스와 그 자식 클래스가 실제 타입 매개변수
class Manager<T extends Person> {
  eat() {
    print('Manager eats a sandwich');
  }
}

class Dog {
  eat() {
    print('Dog eats a dog food');
  }
}

void main() {
  var manager1 = Manager();
  manager1.eat();
  var manager2 = Manager<Person>();
  manager2.eat();
  var manager3 = Manager<Student>();
  manager3.eat();
  print('--------------');
  var dog = Dog();
  dog.eat();
  /*
  Dog 클래스는 Manager 클래스의 실제 타입 매개변수가 아니다
  var manager4 = Manager<Dog>(); // 에러
  manager4.eat();
 */
}

Manager eats a sandwich
Manager eats a sandwich
Manager eats a sandwich
--------------
Dog eats a dog food

class Person {
  T getName<T>(T param) {
    return param;
  }
}

void main() {
  var person = Person();
  print(person.getName('Kim'));
  print(person.getName<String>('Kevin'));
  print(person.getName(123));
  //print(person.getName<String>(4567)); // 에러
  print(person.getName<int>(4567));
  //print(person.getName<int>('Bunny')); // 에러
}

Kim
Kevin
123
// 에러
4567
// 에러

printValue <T> (T aNumber){
  print('is $aNumber');
}

main(){
  var number1= 'two';
  printValue<String>(number1);

  var number2= 2;
  printValue<int>(number2);  
}

is two
is 2