start commit

Assets/Scripts/Chapter3.cs

@@ -0,0 +1,181 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+public class Chapter3 : MonoBehaviour, IEnumerator
+{
+    int count = 11; //기본적으로 접근지정자는 private
+    // 인터페이스 구현
+    public bool MoveNext()=> --count >=0;// count를 1감소 시키고 0이상이면 true 반환
+    public object Current => count;// 현재 count 값 반환
+    public void Reset() => count = 11;// count 값을 11로 초기화
+
+    // enum은 명시적으로 작성할수 있고 암시적으로 작성할수 있다.
+    public enum BorderSide : byte// enum의 기본 자료형은 int 이다.
+    {
+        Left = 1,
+        Right, // 2
+        Top = 4,
+        Bottom  // 5 바로 앞의 값을 기준으로 1씩 증가
+    }
+    // [Flags] // 비트 플래그로 사용하기 위한 어트리뷰트
+    // 2의 제곱수로 저장하는 건 Flags를 사용하는게 관례이다
+    [Flags] // 있어도 되고 없어도 되지만 비트 플래그를 사용시 명시적으로 표시하기 위해 사용
+    public enum FlagsEnum : byte
+    {
+        None = 0,
+        A = 1 << 0, // 1
+        B = 1 << 1, // 2
+        C = 1 << 2, // 4
+        D = 1 << 3  // 8
+    }
+
+
+    void Start()
+    {
+        // FlagsEnum 모두 출력 하기
+        foreach (FlagsEnum flag in Enum.GetValues(typeof(FlagsEnum)))
+        {
+            Debug.Log($"Flag: {flag}, Value: {(byte)flag}");
+        }
+
+        // Stack 제네릭 클래스 사용 예제
+        Stack<int> intStack = new Stack<int>();
+        intStack.Push(10);
+        intStack.Push(20);
+        Debug.Log(intStack.Pop()); // 20 출력
+        Debug.Log(intStack.Pop()); // 10 출력
+
+        // Swap 제네릭 메서드 사용 예제
+        int x = 5, y = 10;
+        Debug.Log($"Before Swap: x = {x}, y = {y}");
+        Swap<int>(ref x, ref y);
+        Debug.Log($"After Swap: x = {x}, y = {y}");
+
+        // Initialize 제네릭 제약조건 메서드 사용 예제
+        MyClass[] myClassArray = new MyClass[3];
+        Initialize<MyClass>(myClassArray);
+        foreach (var item in myClassArray)
+        {
+            Debug.Log(item != null ? $"{item}" : "Null");
+        }
+        // Initialize2 제네릭 제약조건 메서드 사용 예제
+        Initialize2<string>(new string[] { "Hello", "World", "!" });
+
+
+    }
+
+    /// <summary>
+    /// 제네릭을 사용한 Swap 메서드
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    /// <param name="a"></param>
+    /// <param name="b"></param>
+    void Swap<T>(ref T a, ref T b)
+    {
+        T temp = a;
+        a = b;
+        b = temp;
+    }
+    /// <summary>
+    /// 제네릭 제약조건을 사용하여 new() 생성자를 호출할수 있는 메서드
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    /// <param name="Array"></param>
+    void Initialize<T>(T[] Array) where T : new() // class, struct 등 참조형식, 값형식 제약조건도 사용 가능
+    {
+        for (int i = 0; i < Array.Length; i++)
+        {
+            Array[i] = new T();
+        }
+    }
+    void Initialize2<T>(T[] Array) where T : notnull // null 값을 허용하지 않는 제약조건
+    {
+        for (int i = 0; i < Array.Length; i++)
+        {
+            Debug.Log(Array[i]);
+        }
+    }
+
+    /// <summary>
+    /// 확작된 제네릭 메서드 사용
+    /// </summary>  
+    SpecialStack<int> specialStack = new SpecialStack<int>();
+    void Update()
+    {
+        if (Keyboard.current.wKey.isPressed)
+        {
+            specialStack.PushWithLog(UnityEngine.Random.Range(1, 100));
+        }
+        if (Keyboard.current.sKey.isPressed)
+        {
+            specialStack.PopWithLog();
+        }
+    }
+    /// <summary>
+    /// 재귀적 제네릭 메서드
+    /// </summary>
+    Balloon redBalloon = new Balloon { Color = "Red" };
+    Balloon blueBalloon = new Balloon { Color = "Blue" };
+
+    [ContextMenu("CompareBalloons")] /// 유니티 에디터에서 우클릭 실행용
+    public void CompareBalloons()
+    {
+        bool areEqual = redBalloon.Equals(blueBalloon);
+        Debug.Log($"Are balloons equal? {areEqual}");// False 출력
+    }
+    
+}
+
+/// <summary>
+/// 인터페이스는 기본적으로 public 이다 변수,함수...
+/// </summary>  
+interface IEnumerator // 인터페이스는 기본적으로 public 이다
+{
+    bool MoveNext();
+    object Current { get; }
+    void Reset();
+
+}
+/// <summary>
+/// 제네릭은 탬플릿화된 클래스 또는 함수이다.
+/// </summary>
+/// <typeparam name="T"></typeparam>
+class Stack<T>// 클래스는 기본적으로 internal 이다
+{
+    int position;
+    T[] items = new T[100];
+    public void Push(T i) => items[position++] = i;
+    public T Pop() => items[--position];
+}
+
+/// <summary>
+/// 파생된 제네릭 클래스를 상속하는 제네릭 클래스
+/// </summary>
+/// <typeparam name="T"></typeparam>
+class SpecialStack<T> : Stack<T>
+{
+    public void PushWithLog(T value)
+    {
+        Debug.Log($"Push: {value}");
+        Push(value);
+    }
+
+    public T PopWithLog()
+    {
+        T value = Pop();
+        Debug.Log($"Pop: {value}");
+        return value;
+    }
+}
+
+interface IEquatable<T> { bool Equals (T obj ); }/// 제네릭 인터페이스
+class Balloon : IEquatable<Balloon> // 제네릭 인터페이스 구현
+{
+    public string Color { get; set; }
+    public bool Equals(Balloon other)
+    {
+        return this.Color == other.Color;
+    }
+}