유니티 시작, 요약 정리 3

1. 인터페이스

: 두 개의 클래스를 모두 상속 가능하게 하고 싶을 때 = 다중 상속을 가능하게 해준다.

함수, 프로퍼티, 인덱서, 이벤트만 가능

//안에 함수이외에 변수도 선언하여 다른 클래스에서 사용가능
abstract public class A : MonoBehavior
{
   abstract public void Abc();
}
 
//뼈대만 제공, 함수, 프로퍼티, 인덱서, 이벤트만 선언 가능
interface Itest
{
   void Bbc();
}
 
 
public class Test : A, Itest  //클래스 A, Itest 다중 상속
{
   public override void Abc()
   {
      print("A");
   }
 
   public void Bbc();
   {
      print("B");
   }
}

interface로 상속받을 경우 함수에 override를 붙이지 않아도 된다.

 

인터페이스 끼리 서로 상속이 가능하다.

interface Itest2 : Itest {}

 

 

2. 형식 매개변수 T

: 똑같은 내용이지만 다른 자료형의 변수인 함수를 만들때 사용

Or 어떤 타입의 변수가 올지 모를때 사용

1) 함수

void Print<T> (T value)
{
   print(value);
}
 
//string형
Print<string> ("abc");
//int형
Print<int> (1);

2) 클래스

public class Abc<T>
{
   public T var;
   public T[] array;
}
 
//string형
Abc<string> a;
 
a.var = "abc";
a.array = new string[2];
a.array[0] = "aaa";
 
//int형
Abc<int> b;
 
b.var = 5;
b.array = new int[3];
b.array[1] = 3;

 

 

3. 람다식

: 무명 매소드 : 함수를 안만들고 바로 델리게이트에 넣어 사용

int a = 5;
int b = 5;
 
int sum;
 
void Add()
{
   sum = a + b;
}
 
void Back()
{
   sum = 0;
}
 
delegate void MyDelegate();
MyDelegate myDelegate;
 
myDelegate = Add;
myDelegate += Back;
myDelegate += delegate() { print(sum); };    //무명 매소드(람다식)
//매개변수 a를 받고, 그 a를 반환하는 람다식
myDelegate += (int a, int b)=>print(a + b);  //무명 매소드(람다식)

무명 매소드(람다식)은 델리게이트를 통해만 꺼내 쓸 수 있다.

delegate void MyDelegate<T> (T a, T b);
MyDelegate<int> myDelegate;
 
myDelegate += (int a, int b) => print(a + b);
 
myDelegate(3,5);
//=> 8이 print됨

 

 

4. Func & Action

: Delegate를 줄여놓은 것과 같음

1) Action

delegate void MyDelegate<T1, T2> (T1 a, T2 b);
MyDelegate<int, int> myDelegate;
 
 
 
//Actiion은 반환값이 필요없다.
Action<int, int> myDelegate;
//=>시스템에 미리 만들어져있어 위의 내용과 달리 Action 한줄만 쓰면 된다.

2) Func

delegate string MyDelegate<T1, T2> (T1 a, T2 b);
MyDelegate<int, int> myDelegate;
 
 
 
//오른쪽 마지막에 있는 변수가 반환값(result), 앞에 나머지는 매개변수
Func<int, int, string> myDelegate;
myDelegate = (int a, int b) => { int sum = a + b; return sum + "이 반환되었습니다."}

Action과 Func 시스템에 미리 만들어져 있어 둘다 가져다 쓰면 되기 때문에 굳이 힘들게 delegate를 선언해서 사용하지 않아도 된다.

 

 

5. 예외처리

int a = 5;
int b = 0;
int c;
 
c = a / b;
//0으로 나눌수 없기에 오류를 뱉음.
//이 오류를 처리하기 위한 예외처리 함수
 
try
{
   //이 안에 예외처리를 하고 싶은 부분을 넣어준다.
   c = a / b;
}
//catch() 괄호안에 원하는 오류를 넣어준다.
//Exception : 모든 오류를 캐치
//DevideByZeroException : 0으로 나누어 버려 나오는 오류
//NullReferenceException : 아무것도 없을때 발생하는 오류
catch(DevideByZeroExetion ie)  //ie는 변수
{
   //오류에 걸렸을 때 호출할 것
   print(ie);
   b = 1;
   c = a / b;
   print(c);
}
//catch 함수는 여러개 사용 가능
catch(NullReferenceException ie)  //ie는 변수
{
   ...
}
//finally : 오류가 발생하든 발생하지 않든 최종적으로 실행될 마지막 명령코드
finally
{
   ...
}
 
 
//일부러 오류를 발생시키는 함수
//그냥 이런 기능이 있다는 예시
throw new Exception ("일부러 오류를 발생시킴");

 

 

6. 코루틴 (Coroutine)

: 병렬처리 기능

void LoopA(), void LoopB()가 있을 때

LoopA();

LoopB();

가 있다면 LoopA()가 실행되고 실행이 끝난 후 LoopB()가 실행된다.

하지만 코루틴(Coroutine)을 사용하면 LoopA(), LoopB() 를 동시에 호출할 수 있게 만들어준다.

IEnumerator LoopA()
{
   for (int i = 0; i < 10; i++)
   {
      print("i의 값 = " + i);
   }
 
   //반드시 시간에 관한 문법이 있어야 한다.(yield return)
   //null : 한 프레임씩 대기
   //new WaitForSecond(원하는 대기시간 적기) -> 1f : 1초
   yield return new WaitForSecond(1f);
}
 
IEnumerator LoopB()
{
   for (int x = 0; x < 10; x++)
   {
      print("x의 값 = " + x);
   }
 
   yield return new WaitForSecond(1f);
}
 
 
//일반적인 호출이 아닌 StartCoroutine으로 호출해야한다.
//코루틴은 WaitForSecond()에 있는 시간대로 각 함수들이 호출된다.
StartCoroutine(LoopA());
StartCoroutine(LoopB());

 

-파라미터(매개변수)가 많을 경우

private IEnumerator Coru1;
Coru1 = LoopA(1,2,3,4,5,6,7,8,9);
 
StartCoroutine(Coru1);
//실행할 때마다 LoopA(1,2,3,4,5,6,7,8,9)를 쓰기 힘들기에

 

-코루틴을 멈출 때

//코루틴 변수 만들기
Coroutine Coru1;
Coroutine Coru2;
 
//담아서 사용해야 실행을 중지시킬 수 있다.
Coru1 = StartCoroutine(LoopA());
Coru2 = StartCoroutine(LoopB());
//Coru2 = StartCoroutine("LoopB")
//문자열로 호출할 수 있지만, 문자열로 호출하면 과부화가 된다.
 
StartCoroutine(Stooop());
//또는 StartCoroutine(Stooop2()); 로 코루틴을 
 
 
 
IEnumerator Stooop()
{
   //2초 대기하고 Coru1을 실행 중지 시킨다.
   yield return new WaitForSecond(2f);
   StopCoroutine(Coru1);
 
   //2초 대기하고 Coru2를 실행 중지 시킨다.
   yield return new WaitForSecond(2f);
   StopCoroutine(Coru2);
}
 
 
 
IEnumerator Stooop2()
{
   //3초 대기하고 진행중이던 모든 코루틴을 종료시킨다.
   StopAllCoroutines();
}