코딩도상국

Class

void main()
{
  // constructor
  Idol blackPink = const Idol(
    name:'블랙핑크',
    members:['지수', '제니', '리사', '로제']);
  
  blackPink.sayHello();
  blackPink.introduce();
  
  // named constructor
  Idol blackPink2 = Idol.fromList([
    ['지수', '제니', '리사', '로제'],
    '블랙핑크'
    ]);
  
  blackPink2.sayHello();
  blackPink2.introduce();
  
}
 
class Idol
{
  final String name;
  final List<String> members;
  
  // constructor
  const Idol({
    required this.name, 
    required this.members});
  
  // named constructor
  Idol.fromList(List values)
    : this.members = values[0], 
      this.name= values[1];
  
  // function
  void sayHello() {print('안녕하세요. ${this.name}입니다.');}
  
  void introduce() {print('저희 멤버는 ${this.members}가 있습니다.');}
  
  // getter, setter 굳이 사용 X, 기능적 차이 없음
}

클래스는 java와 똑같다.

• 다만 클래스의 접근자가 private, public만 있다. 굉장히 마음에 든다.
• private은 변수 앞에 (_)를 붙이면 된다. public은 안붙여도 됨.
• getter, setter 굳이 사용해도 되지 않을 것 같다.

​

void main()
{
  Idol apink = Idol(name:'에이핑크', membersCount:5);
  
  apink.sayName();
  apink.sayMembersCount();
  
  print("--------------");
  
  BoyGroup bts = BoyGroup('BTS', 7);
  
  bts.sayMembersCount();
  bts.sayName();
}

class Idol{
  String name;
  int membersCount;
  
  Idol(
    {
      required this.name,
      required this.membersCount
    });
  
  void sayName() { print('저는 ${this.name}입니다.'); }
  
  void sayMembersCount()
  { print('${this.name}은 ${this.membersCount}명의 멤버가 있습니다.');}
}

class BoyGroup extends Idol
{
  BoyGroup(
    String name,
    int membersCount
  ) 
  : super(name:name, 
          membersCount:membersCount);
  
}

void main()
{
  Idol apink = Idol(name:'에이핑크', membersCount:5);
  
  apink.sayName();
  apink.sayMembersCount();
  
  print("--------------");
  
  BoyGroup bts = BoyGroup('BTS', 7);
  
  bts.sayMembersCount();
  bts.sayName();
}

class Idol{
  String name;
  int membersCount;
  
  Idol(
    {
      required this.name,
      required this.membersCount
    });
  
  void sayName() { print('저는 ${this.name}입니다.'); }
  
  void sayMembersCount()
  { print('${this.name}은 ${this.membersCount}명의 멤버가 있습니다.');}
}

class BoyGroup extends Idol
{
  BoyGroup(
    String name,
    int membersCount
  ) 
  : super(name:name, 
          membersCount:membersCount);
  
}

Static

void main()
{
  Employee seulgi = Employee('슬기');
  Employee chorong = Employee('초롱');
  
  // instance 귀속
  seulgi.printNameAndBuilding();
  chorong.printNameAndBuilding();
  print("--------------------------");
  // class 귀속 : static
  Employee.building = '모르는';
  seulgi.printNameAndBuilding();
  chorong.printNameAndBuilding();
  Employee.printBuilding();
}

class Employee
{
  static String? building;
  final String name; 
  
  Employee(this.name);
  
  void printNameAndBuilding()
  {
    print('제 이름은 $name입니다. $building 건물에서 근무하고 있습니다.');
  }
  
  static void printBuilding()
  {
    print('저는 $building 건물에서 근무 중입니다.'); 
  }
}

Generic

void main()
{
  Lecture<String> lecture1 = Lecture('123', 'lecture1');
  lecture1.printIdType();
  
  Lecture<int> lecture2 = Lecture(123, 'lecture1');
  lecture2.printIdType();
  
}


class Lecture<T>
{
  final T id;
  final String name;
  
  Lecture(this.id, this.name);
  
  void printIdType() {print(id.runtimeType);}
}

Basic

void main() 
{
  // study0 : variable 
  var name = 'Yoon Engineer';
  print("Hello ${name}");  
  
  // study1 : Operator
  int number1 = 10;
  int number2 = 20;
  print('${number1} + ${number2} = ${number1+number2}');
  
  // study2 : Boolean and type check
  bool isTrue = true;
  bool isFalse = false;
  
  print(isTrue.runtimeType);
  print(isFalse);
  
  // study3 : String operator
  String name1 = 'Hello';
  String name2 = 'Yoon';
  
  print(name1 + ' ' +name2);
  print('$name1 $name2');
  
  // study4 : Dynamic vs Var
  dynamic dynamic_test = 'Yoon Engineer';
  print(dynamic_test.runtimeType);
  
  dynamic_test = 1;
  print(dynamic_test.runtimeType);
  
  // study5 : Null
  // nullable - null이 될 수 있음.
  // non-nullable - null이 될 수 없음.
  String null_test = 'Yoon';
  print(null_test);
  
  //null_test = null; // 오류
  String? null_test2 = 'Yoon';
  print(null_test.runtimeType);
  null_test2 = null;
  print(null_test.runtimeType);
}

Final vs Const

void main()
{
  // final : 값 변경 불가
  final String name = 'Yoon';
  
  print(name);
  
  // const : 값 변경 불가
  const String name2 = 'Yoon';
  print(name2);
  
  // final, const var을 따로 작성하지 않아도 됨.
  final name3 = 'Yoon';
  const name4 = 'Yoon';
  print(name3);
  print(name4);
  
  // final vs const
  // final은 빌드 타임 값을 몰라도 됨.
  // const는 빌드 타임 값을 알아야 함.
  final DateTime now = DateTime.now();
  
  //const DateTime now = DateTime.now(); // error
  
}

Null, Operator

void main()
{
  dynamic? number = null;
  
  print(null);
  // ?? 연산자 : 변수가 null이면 Rvalue로 변환함
  number ??= 4;
  print(number);
  
}

void main()
{
  int number = 1;
  
  print(number is int);
  print(number is String);
  print(number is double);
  
  print(number is! int);
  print(number is! String);
  print(number is! double);
  
  // Conditional operator
  bool result1 = 12 > 10 && 1 > 0;
  bool result2 = 12 > 10 || 0 > 1;
  print(result1);
  print(result2);
}

List, Map, Set

void main()
{
  // python list와 동일한 역할을 함
  List<String> blackPink = ['제니', '지수', '로제', '리사'];
  List<int> numbers = [1, 2, 3, 4, 5];
  
  // List length
  print(blackPink.length);
  // Python 처럼 -1과 같은 인덱싱은 안됨
  print(blackPink[0]);
  // List value remove
  blackPink.remove('리사');
  print(blackPink);
  // List value add
  blackPink.add('리사');
  print(blackPink);
  // List indexOf
  print(blackPink.indexOf('리사'));
}

void main()
{
  // Map : {key : value}
  // Python dictionary와 똑같은 역할을 함.
  Map<String, String> dictionary = 
  {
    'Harry Potter' : '해리포터',
    'Ron weasley' : '론 위즐리'
  };
  print(dictionary);
  
  // addall
  dictionary.addAll(
    {
      'Hermione Granger' : '헤르미온느 그레인저'
    });
  print(dictionary);
  dictionary['Hello'] = "안녕";
  
  // indexing
  print(dictionary);
  print(dictionary['Harry Potter']);
  
  // remove
  dictionary.remove('Hello');
  print(dictionary);
  
  // keys, values
  print(dictionary.keys);
  print(dictionary.values);
}

If, switch

void main()
{
  int number = 3;
  if (number % 3 == 0)
  {
    print("ha");
  }
  else if(number % 3 == 1)
  {
    print("haha");
  }
  else
  {
    print("hahaha");
  }
  switch(number % 3)
  {
    case 0:
      print('ha');
      break;
    case 1:
      print('haha');
      break;
    default:
      print('hahaha');
      break;
  }
}

For loop

void main()
{
  int total = 0;
  List<int> numbers = [0, 1, 2, 3, 4, 5, 6];
  
  for(int n in numbers)
  {
    print(n);
  }
  
  print("----------------------");
  
  for(int n in numbers)
  {
    if(n == 3) continue;
    if(n == 5) break;
    print(n);
  }
}

Function, Signature

void main()
{
  var result1 = addNumbers(a:1, b:2);
  print(result1);
  
  var result2 = addNumbers(a:1, b:2, c:3);
  print(result2);
}

// named parameter
String addNumbers({
  required int a, 
  required int b, 
  int c =20})
{
  print('${a+b+c}');
  
  return 'success';
}

void main()
{
  int result = calculate(1, 2, 3, add);
  print(result);
}
 
// signature
typedef Operation = int Function(int x, int y, int z);

// 덧셈
int add(int x, int y, int z) => x + y + z;

// 뺄셈
int subract(int x, int y, int z) => x - y - z;

// function
int calculate(int x, int y, int z, Operation operation)
{
  return operation(x, y, z);
}

하루 정도 시간 내어 flutter를 하기 전에 Dart 언어를 쫙 읊어 보는 시간을 가져 본다.

​

Dart 언어는 공부해 보니 Java와 유사함을 느낌.

​

1. Var과 Dynamic : var는 한 번 타입이 정해지면, 변경 불가능. Dynamic은 한 번 타입이 정해지더라도 변경 가능.

2. Flutter2.0부터는 Null에 관련된 이슈가 업데이트됐다고 한다. 공부할 필요가 있을 것 같음.

3. final, const의 차이는 빌드 타임이다. final은 빌드 타임을 몰라도 되고, const는 알아야 함.

4. ??연산자는 null이면 Rvalue로 변환함.

5. 조건 연산자, 비트 연산자는 C와 동일함. 하지만 Dart 언어로 펌웨어 코딩할 일이 없으므로 비트 연산자는 사용되지 않을 것 같음.

6. List, Map, Set 모두 java와 일치함.

7. for 문도 java와 일치함. 결국 항상 느끼지만 새로운 언어를 공부할 때, 한 가지라도 제대로 터놓으면 다른 언어는 공부하기 편하다는 것을 뼈저리게 느낌.

​

아직까지 이상무.

네트워크를 통한 데이터를 가져오기, DB 쓰기 및 읽기, 파일 데이터 읽기 및 쓰기 등과 같은 경우 비동기 작업이 필요하다.

Future 란?
Future 클래스의 인스턴스이고, 비동기 작업의 결과를 나타내며 Uncompleted 또는 Completed의 두 가지 상태를 가질 수 있다.

Completed 상태는 작업이 완료된 상태이다. Uncompleted 상태는 작업이 완료되지 못한 상태이며, 완료할 작업은 event queue에 적재한다. 

Future는 보통 async, await와 함께 사용되며, 아래와 같이 사용한다.

• async 함수를 정의하려면 함수 본문 앞에 async를 추가한다.
• await 키워드는 비동기 함수에서만 작동한다.
  
  

1. Future, async, await

Future<void> printOrderMessage() async {
  print('Awaiting user order...');
  var order = await fetchUserOrder();
  print('Your order is: $order');
}

Future<String> fetchUserOrder() {
  // Imagine that this function is more complex and slow.
  return Future.delayed(const Duration(seconds: 4), () => 'Large Latte');
}

void main() async {
  countSeconds(4);
  await printOrderMessage();
}

void countSeconds(int s) {
  for (var i = 1; i <= s; i++) {
    Future.delayed(Duration(seconds: i), () => print(i));
  }
}
// Awaiting user order...
// 1
// 2
// 3
// 4
// Your order is: Large Latte

2. Error 다루기

비동기 함수에서 오류를 처리하려면 try-catch를 사용한다.

Future<void> printOrderMessage() async {
  try {
    print('Awaiting user order...');
    var order = await fetchUserOrder();
    print(order);
  } catch (err) {
    print('Caught error: $err');
  }
}

Future<String> fetchUserOrder() {
  // Imagine that this function is more complex.
  var str = Future.delayed(
      const Duration(seconds: 4),
      () => throw 'Cannot locate user order');
  return str;
}

void main() async {
  await printOrderMessage();
}