C# 기초 문법 정리

C#

[C# 출력문]

C#으로 명령 프롬포트에 문자열을 출력하기위해선 System.Console.WriteLine(); 코드를 이용한다.

class WriteLineDemo1
{
	static void Main()
    {
    	System.Console.writeLine("명령 프롬포트에 출력할 내용");
    }
}

using System; 코드 구문을 사용했다면 아래와 같이 줄여서 표현이 가능하다.

using System;

class WriteLineDemo2
{
	static void Main()
    {
    	Console.WriteLine("명령 프롬포트에 출력할 내용");
        Console.Write("줄바꿈 없음");
        Console.WriteLine("줄바꿈 포함");
    }
}

 

[자리 표시자]

>Console.WriteLine("{0}","hello , c#");
hello , c#
> ConSole.WriteLine("{0}, {0}" , "hello , c#");
hello, c# , hello , c#

자리 표시자의 인덱스를 증가시켜 사용하기

>ConSole.WriteLine("{0}, {1}" , "hello", "c#");
hello, c#
>ConSole.WriteLine("{1} , {0}" , "hello", "c#");
c#, hello

 

[데이터 입력 관련 메서드]

ConSole.ReadLine()
콘솔로부터 한 줄을 입력 받는다. 콘솔 응용 프로그램에서 현재 시점에서 잠시 멈추는 역할도 한다.
엔터 누를때까지 대기한다.
ConSole.Read()
콘솔로부터 한 문자를 정수로 입력받는다.
ConSole.ReadKey()
콘솔로부터 하나의 문자나 사용자가 누른 기능키를 가져옵니다.

 

[ConSole.ReadLine() 메서드 사용]

Staic void Main()
{
	Console.WriteLine(Console.ReadLine());
}
> 문자열 입력 후 엔터 키를 누르세요. (입력)
> 문자열 입력 후 엔터 키를 누르세요. (출력)


static void Main()
{
	Console.Write("이름을 입력하시오 => ");
    
    string name = Console.ReadLine();
    Console.WriteLine("안녕하세요. {0}님." , name);
}
> 이름을 입력하시오 => 박용준(입력)
> 안녕하세요. 박용준님.(출력)

 

[단항 연산자]

//산술 연산자
>3+5
8
>3-5
-2
>3*5
15
>10/5
2
>3%5 //나머지
3

//문자열 연산자

>"hello" + "world" 
helloworld
>"hi" + " " + "everyone"
hi everyone
>"123" + "456"
123456
>"123"+ 456
123456
> 123 + 456
579

 

[할당, 증감 연산자]

//할당 연산자
>int num = 10;
>num = num + 1
>num
11
> num = num - 1
10

//축약형
>int num = 10;
>num += 1
11
>num -= 1
10

//증감 연산자
++(증가 연산자) 변숫값에서 1을 더함.
--(감소 연산자) 변숫값에서 1을 뺌.

//감소
>int num = -100;
>--num;
>num
-101
//증가
>++num
>num
-100

전위 증감 연산자(++x) 와 후위 증감 연산자(x++) 차이
값을 도출할 때 우선순위가 다름 ++x > x++

 

[관계형, 논리 연산자]

//관계형 연산자
> int x = 3;
> int y = 5;
> x == y
false
> x != y
true
> x > y
false
> x >= y
false
> x < y
true
> x <= y
true

// == 연산자 문자열 값 비교
> Console.WriteLine("AAA" == "aaa"); 
False

//논리 연산자
&&(AND)
true  && true  -> True
true  && false -> False
false && true  -> False
false && false -> False

||( OR)
true  || true  -> True
true  || false -> True
false || true  -> True
false || false -> False

!(NOT)
!true  -> False
!false -> True

 

[비트, 시프트 연산자 종류]

연산자	별칭	설명
&	비트단위 AND	비트 값이 둘 다 1일 때에만 1, 그렇지 않으면 0
|	비트단위 OR	비트 값이 하나라도 1이면 1, 그렇지 않으면 0
^	비트단위 XOR	비트값이 서로 다를 때에만 1, 그렇지 않으면 0
~	비트단위 NOT	비트 값이 1이면 0, 0이면1
<<	왼쪽 시프트	비트 값을 지정된 수만큼 왼쪽으로 이동
>>	오른쪽 시프트	비트 값을 지정된 수만큼 오른쪽으로 이동
>>>	부호없는 오른쪽 시프트	비트 값을 지정된 수만큼 오른쪽으로 이동하되 왼쪽을 0으로 채움

 

[제어문]

//조건문


if(조건식)
{
	// 조건문의 조건을 만족할 때 실행할 실행문들...
}


if(!(NOT)조건식)


if(조건식)
{
	if(조건식)
    {
    }
} // 중첩 조건식


if( 조건식 %% 조건식) // 하나에 여러개 조건식


if(조건식)
{
	//조건식이 참일 때 실행할 실행문1;
}
else
{
	//조건식이 거짓일 때 실행할 실행문2;
} // if ~ else문


if(조건식)
{
}
else
{
	if(조건식)
    {
    }
    else
    {
    }
} // 중첩 else문


if (조건식)
{
    실행문1;
}
else if (조건식)
{
    실행문2;
}
… 
else
{
    실행문n;
} // else if문(다중 if문)

//switch문

switch (표현식)
{
    case 값1 : 실행문1; break;
    case 값2 : 실행문2; break;
    ...
    default: 실행문n; break;
}

//for문

for (초기식; 조건식; 증감식)
{
    실행문;
}

//while문

while (조건식)
{
	조건식이 참일 때까지 실행할 문장들...
}


//do while 반복문

do
{
    실행문;
} while (조건식);


//foreach문(배열 반복)

foreach (항목 in 항목들) { … }

foreach ([데이터 형식] 변수 in 컬렉션형식)
{
    문장; // 변수에 들어 있는 값을 사용하는 문장이 온다.
}

//break, continue, goto로 반복문 제어

//break

static void Main()
    {
        for (int i = 0; i < 5; i++)
        {
            if (i >= 0)
            {
                break; // 현재 코드를 만나면 현재 for 문을 종료함
            }
        } // end of for
    }
    
//continue

static void Main()
    {
        for (int i = 1; i <= 5; i++)
        {
            if (i % 2 == 0)
            {
                // 현재 반복 중지 후 다음 반복으로 이동
                continue; // 짝수 건너뛰기
            }
            Console.WriteLine(i); // 1, 3, 5
        }
    }
    
//goto

static void Main()
    {
        Console.WriteLine("시작");
        Start:
        Console.WriteLine("0, 1, 2 중 하나 입력: _\b");
        int chapter = Convert.ToInt32(Console.ReadLine());

        if (chapter == 1)
        {
            goto Chapter1; // [1]번 코드 영역으로 이동
        }
        else if (chapter == 2)
        {
            goto Chapter2; // [2]번 코드 영역으로 이동
        }
        else
        {
            goto End; // [3]번 코드 영역으로 이동
        }

        Chapter1: // [1] 
        Console.WriteLine("1장입니다.");

        Chapter2: // [2]
        Console.WriteLine("2장입니다.");

        goto Start;

        End: // [3]
        Console.WriteLine("종료");
    }

 

[배열]

하나의 이름으로 여러개의 데이터를 저장하는 데이터 구조를 배열(Array)라고 한다. 

 

-하나의 변수에 하나의 값만을 저장할 수 있는 변수와는 달리 배열에는 하나의 배열명에 여러개의 데이터를 보관 가능

이처럼 변수 여러개를 하나의 이름으로 관리하는 것을 배열이라한다.

 

-배열은 요소들의 순서있는 집합, 각 요소는 인데스로 접근가능 (인덱스는 0부터 시작함.)

 

-하나의 배열에는 하나의 데이터 형식(정수형,문자열 배열 등)만을 보관가능

 

-배열은 메모리의 연속된 공간을 미리 할당하고 이를 대괄호[]와 0부터 시작하는 정수형 인덱스를 사용해 접근하는 구조

 

-배열 선언할 때는 new키워드 사용해 배열 생성 후 사용 가능

 

-배열도 변수

 

* n-1(n 마이너스 1 규칙) -> 배열의 인덱스는 0부터 요소의 개수에서 1을 뺀 수만큼 범위를 가진다.

- 5개 요소: 0~4

- 10개 요소: 0~9

 

//배열 선언
int[] numbers;

//new키워드를 사용하여 배열의 크기만큼 메모리 영역 생성.
int[] numbers;
numbers = new int[3];
// 한줄로 표현
int[] intArray = new int[3];

//1차원 배열 예시
int[] arr = new int[5];

//빈 배열
string[] authors = { }; // 빈 배열의 크기는 항상0.

//다차원 배열
int[] oneArray;         // 1차원 배열 선언
int[,] twoArray;        // 2차원 배열 선언
int[,,] threeArray;     // 3차원 배열 선언

//2차원 배열 선언
int[,] arr = new int[3,4];
//2차원 배열 초기화
int[,] arr = new int[,] { {1, 2, 3}, {4, 5, 6} };
//2차원 배열 접근
Console.WriteLine(arr[1,2]);


//3차원 배열 선언
string[,,] names = new string[2, 2, 2];
//3차원 배열 초기화
names[0, 0, 0] = "C#";
names[0, 0, 1] = "ASP.NET";

names[0, 1, 0] = "Windows Forms";
names[0, 1, 1] = "WPF";

names[1, 0, 0] = "Xamarin";
names[1, 0, 1] = "Unity";

names[1, 1, 0] = "UWP";
names[1, 1, 1] = "Azure";
//3차원 배열 사용
Console.WriteLine("\n0층");
Console.WriteLine($"{names[0, 0, 0],20}, {names[0, 0, 1],20}");
Console.WriteLine($"{names[0, 1, 0],20}, {names[0, 1, 1],20}");

Console.WriteLine("\n1층");
Console.WriteLine($"{names[1, 0, 0],20}, {names[1, 0, 1],20}");
Console.WriteLine($"{names[1, 1, 0],20}, {names[1, 1, 1],20}");

 

[함수(Function)]

코드 재사용을 목적으로 함.

//함수(기본적인 모양)

static void 함수이름()
{
    // 함수내용
}

//함수 호출 사용
static void Show()
    {
        Console.WriteLine("Hello World");
    }

    // Main 메서드(함수)
    static void Main()
    {
        Show(); //[2] 호출
    }
    

//재귀 함수(자기 자신을 호출하는 것)
static void Main()
    {
    Console.WriteLine(Factorial(4));
    }
// 재귀 함수를 사용한 Factorial 함수 만들기: 단, 재귀함수는 Tree 구조 탐색에 유리
    static int Factorial(int n)
    {
        // 종료
        if (n == 0 || n == 1)
        {
            return 1;
        }
        // 재귀 호출
        return n * Factorial(n - 1);
    }
    
//화살표 함수
static void Hi() => Console.WriteLine("안녕하세요.");
static void Multiply(int a, int b) => Console.WriteLine(a * b);


//로컬 함수
static void Main()
    {
        // 로컬 함수: 메서드(함수)내에서만 사용되는 또 다른 함수
        void Display(string text)
        {
            Console.WriteLine(text);
        }

        Display("로컬 함수");
    }

 

[구조체]

C# 구조체에는 다음과 같은 특징들이 존재한다.

- C# 구조체에 메소드, 필드, 속성등을 가질 수 있다.

- C# 구조체에 생성자를 정의할 수 있다.

- C# 프로그램에서 new 연산자를 이용하여 struct 객체를 생성할 수 있다.

 

- C# 구조체에 기본(Default) 생성자를 정의할 수 없다.

- C# 구조체에 소멸자를 정의할 수 없다.

- C# 구조체는 다른 구조체나 클래스의 기본 구조체(상속하기 위한)가 될 수 없다.

 

C#에서 구조체와 클래스는 다음과 같은 차이점이 존재한다.

- 클래스는 참조유형이며 구조체는 값 유형이다.

- 구조체는 상속을 지원하지 않는다.

- 구조체는 기본(디폴트) 생성자를 가질 수 없다.

 

//구조체 선언
struct Businesscard
{
	public string Name;
   	public int Age;
    public string Address;
}

//구조체 형식 변수 선언
Businesscard my;

//사용
my.Name = "홍길동";
my.Age = 21;
my.Address = "서울시";

//구조체 배열 선언
Businesscard[] names = new Businesscard[2];
//배열 사용
names[0].Name = "백두산"; names[0].Age = 102;
names[1].Name = "임꺽정"; names[1].Age = 31;

 

[열거형]

정수 형태의 값들을 별도의 이름으로 정의해 둔 상수들의 집합

 

-기본적으로 열거형 멤버들의 타입은 int형이며, 값을 따로 지정해주지 않는다면 첫번째 멤버는 0에서 시작하고 이후로는 순서대로 1씩 증가한다.

 

-열거형 멤버들의 타입을 따로 지정 가능하고, 각 멤버의 값도 지정할 수 있다.

 

-중간에 값을 따로 지정해주지 않은 멤버는 그 이전의 멤버 값에서 1 증가한 값으로 자동 지정된다. 

( ex) 이전에 멤버 값이 10이면 11로 자동 증가)

 

-열거형을 사용하면 상수를 사용하는 코드의 가독성을 크게 향상시킬 수 있다.

 

// 열거형 (자동 int형)
enum Direction
{
    Up,     // 0
    Down,   // 1
    Left,   // 2
    Right   // 3
}

//멤버 타입 지정 (long)
enum Item : long // 멤버 타입 지정
{
    None = -1,
    Usable = 1,
    Weapon = 10,
    Armor,          // = 11 (자동 1증가한 값)
    ForQuest = 100
}

 

[클래스]

//클래스 선언
public class 클래스이름
{
	//클래스 내용 구현
}


//클래스 레벨 메소드
class ClassNote
{
	static void Run()
    {
    	Console.WriteLine("ClassNote 클래스의 Run 메소드");
    }
    
    
    static void Main()
    {
    	Run(); // 메소드 레벨: 같은 클래스의 메소드 호출
        
        ClassNote.Run(); //클래스 레벨: 클래스, 메소드 형태로 호출
    }
}

 

[예외 처리]

C# 프로그래밍에서 프로그램이 실행되는 동안 발생하는 오류, 잘못 작성된 코드 등으로 발생된 예외는 프로그램을 강제적으로 종료하거나 잘못된 결과는 나타내는 식으로 발생한다. 이러한 경우에 대비로 예외 처리가 있다.

try
{
	//예외가 발생할 만한 코드를 작성
}
catch
{
	//예외가 발생할 때 처리해야 할 코드 블록
}
finally
{
	//예외가 발생하거나 정상일 때 모두 처리해야 할 코드 블록
}

//예제
class TryCatch
{
    static void Main()
    {
        try
        {
            int[] arr = new int[2];
            arr[100] = 1234; // 예외(에러) 발생: System.IndexOutOfRangeException
        }
        catch
        {
            Console.WriteLine("에러가 발생했습니다.");
        }
    }
}

 

[객체지향 프로그래밍]

코드 내의 모든 것을 객체로 표현하고자 함.

객체 = 속성(필드) + 기능(메소드)

ex) 사람 = 피부색 , 키 ,몸무게(속성) + 걷기, 뛰기(기능)

//클래스 구성

class Cat  
{
	// 속성 = 클래스의 변수 = 필드(Field)
	public string Name;
   	public string Color;
   
   // 기능 = 메소드
   public void Meow()
   {
   	Console.WriteLine("{0} : 야옹", Name);
   }
}

//객체 생성
class MainApp
    {
        static void Main(string[] args)
        {
            Cat kitty = new Cat(); // Cat클래스를 객체 kitty에 new연산자를 통해 대입
            kitty.Color = "하얀색"; // 대입된 kitty로 Color필드에 접근하여 값을 수정
            kitty.Name = "키티"; // 위와 동일
            kitty.Meow(); // Cat클래스에 있는 Meow()메소드에 접근
            Console.WriteLine("{0} : {1}", kitty.Name, kitty.Color); 
            //자리 표시자에 맞는 수정된 필드 값 대입
		}
    }

 

[생성자, 종료자]

생성자 : 객체가 생성될 때 호출

종료자 : 객체가 소멸될 때 호출

//생성자 선언
class Car
{
	public Car()
    {
    	Name = "";
        Color = "";
    }
    
    public Cat (string _Name, string _Color)
    {
    	Name = _Name;
    	Color = _Color;
    }
    
    public string Name;
    public string Color;
}

//생성자 호출 및 사용

Car suv = new Car(); // 생성자 버전1

Car audi = new Car( "아우디" , "청색");


//종료자

class 클래스 이름
{
	~클래스 이름()  // 종료자 
   {
   	//
   }
   
   // 필드
   // 메소드
}

 

[정적 필드, 메소드]

static으로 지정된 필드나 메소드는 클래스소속 

static으로 지정되지 않은 필드나 메소드는 인스턴스 소속

//정적 필드

class Global
{
   public static int Count = 0; // 정적 필드 선언
}

class ClassA
{
   public ClassA()
   {
       Global.Count++; // 정적 필드 접근
   }
}

class ClassB
{
   public ClassB()
   {
       Global.Count++; // 정적 필드 접근
   }
}

class MainApp
{
   static void Main()
   {
       Console.WriteLine($"Global.Count : {Global.Count}");
       
       new ClassA();
       new ClassA();
       new ClassB();
       new ClassB();

       Console.WriteLine($"Global.Count : {Global.Count}");
   }
}
> Global.Count : 0
> Global.COunt : 4


//정적 메소드
class MyClass
{
	public static void StaticMethod() // static 사용
   {
   	    // ...
   }
}

//...

MyClass.StaticMethod();  // 인스턴스 만들지 않고도 바로 호출 가능


// 인스턴스 메소드 //
class MyClass
{
	public void StaticMethod() // static 사용X
   {
   	    // ...
   }
}

//...

MyClass obj = new MyClass(); // 인스턴스 생성
obj.InstanceMethod(); // 인스턴스를 만들어야 호출 가능

 

[this]

객체 내부에서는 자신의 필드나 메소드에 접근 할 때 this 키워드 사용

 class Employee
   {
       private string Name;
       private string Position;

       public void SetName(string Name)
       {
           this.Name = Name;
       }

       public string GetName()
       {
           return Name;
       }

       public void SetPosition(string Position)
       {
           this.Position = Position;
       }

       public string GetPosition()
       {
           return this.Position;
       }
   }
    class MainApp
   {
       static void Main(string[] args)
       {
           Employee pooh = new Employee();
           pooh.SetName("Pooh");
           pooh.SetPosition("Waiter");
           Console.WriteLine($"Employee pooh - name :{pooh.GetName()}, position : {pooh.GetPosition()}");

           Employee tigger = new Employee();
           tigger.SetName("Tigger");
           tigger.SetPosition("Cleaner");
           Console.WriteLine($"Employee tigger - name:{tigger.GetName()}, position : {tigger.GetPosition()}");
       }
   }
}
> Employee pooh - name :Pooh, position : Waiter
> Employee tigger - name:Tigger, position : Cleaner

 

[this생성자]

자기 자신의 생성자를 가리키며 생성자의 코드 블록 내부가 아닌 앞쪽에서만 사용 가능

namespace ThisConstructor
{
    class MyClass
    {
        int a, b, c;

        public MyClass()
        {
            this.a = 5425;
            Console.WriteLine("MyClass()");
        }

        public MyClass(int b) : this()
        {
            this.b = b;
            Console.WriteLine($"MyClass({b})");
        }

        public MyClass(int b, int c) : this(b)
        {
            this.c = c;
            Console.WriteLine($"MyClass({b}. {c})");
        }

        public void PrintFields()
        {
            Console.WriteLine($"a:{a}, b:{b}, c:{c}");
        }
    }

    class MainApp
    {
        static void Main(string[] args)
        {
            MyClass a = new MyClass();
            a.PrintFields(); 
            Console.WriteLine(); 

            MyClass b = new MyClass(1);
            b.PrintFields();
            Console.WriteLine();

            MyClass c = new MyClass(10, 20);
            c.PrintFields();
        }
    }
}
> MyClass()
> a:5425, b:0 , c:0

> MyClass()
> MyClass(1)
> a:5425, b:1, c:0

> MyClass()
> MyClass(10)
> MyClass(10.20)
> a:5425, b:10 ,c:20

 

[상속]

-다른 클래스로부터 코드를 물려받아 쓰는 것

 

-새로 선언하는 클래스 이름 뒤에  : + 기반 클래스 이름 표기하여 상속

 

-물려주는 클래스: 기반/부모 클래스 , 물려받는 클래스 : 파생/자식 클래스

 

-상속을 받는 자식 클래스들은 기반 클래스의 모든 코드를 물려받아 더 많은 기능을 할 수 있다.

 

// 베이스 클래스
public class Animal
{
   public string Name { get; set; }
   public int Age { get; set; }
}

// 파생클래스
public class Dog : Animal
{       
   public void HowOld() 
   {
      // 베이스 클래스의 Age 속성 사용
      Console.WriteLine("나이: {0}", this.Age);
   }
}

public class Bird : Animal
{       
   public void Fly()
   {
      Console.WriteLine("{0}가 날다", this.Name);
   }
}

 

[오버로딩, 오버라이딩]

오버로딩 - 하나의 메소드로 여러가지를 구현하는 것(매개 변수의 개수 또는 타입만 다르게 정의하면 된다.)

 

오버라이딩 - 기반 클래스에서 파생된 메소드를 자식 클래스에서 재정의하는 것(다형성의 기반)

//오버로딩

namespace Overloading
{
    class MainApp
    {
        static int GetRectangleArea(int width, int height) //2개의 매개 변수 정수형int
        {
            return width * height;
        }

        static float GetRectangleArea(float width, float height) //2개의 매개 변수 실수형float
        {
            return width * height;
        }

        static int Sum(int a, int b) //2개의 매개 변수 정수형 int
        {
            return a + b;
        }

        static int Sum(int a, int b, int c)//3개의 매개 변수 정수형int
        {
            return a + b + c;
        }

        static void Main(string[] args)
        {
            Console.WriteLine(GetRectangleArea(20, 50));
            Console.WriteLine(GetRectangleArea(1.2f, 3.5f));
            Console.WriteLine(Sum(1, 2));
            Console.WriteLine(Sum(10, 11, 12));
        }
    }
}

//오버라이딩

namespace Overriding
{
    class ChessPiece
    {
        public virtual void Move() //부모 클래스에서는 virtual
        {
            Console.WriteLine("체스피스 : 이동할 수 없음");
        }
    }

    class Pawn : ChessPiece
    {
        public override void Move() //자식 클래스는 override
        {
            Console.WriteLine("폰 : 앞으로 한칸씩 이동, 초기에는 2칸 이동 가능");
        }
    }

    class Rook : ChessPiece
    {
        public override void Move() // 위와 동일
        {
            Console.WriteLine("룩 : 가로막고 있는 피스가 없는 한 종횡으로(상하좌우로) 원하는만큼 이동");
        }
    }

    class Bishop : ChessPiece
    {
        public override void Move() // 위와 동일
        {
            Console.WriteLine("비숍 : 가로막고 있는 피스가 없는 한 대각선방향으로 원하는만큼 이동");
        }
    }

    class MainApp
    {
        static void Main(string[] args)
        {
            ChessPiece piece = new ChessPiece();
            piece.Move(); 

            ChessPiece pawn = new Pawn();
            pawn.Move();

            ChessPiece rook = new Rook();
            rook.Move();

            ChessPiece bishop = new Bishop();
            bishop.Move();
        }
    }
}

 

[추상클래스]

추상클래스의 목적은  자식 클래스에서 공유할 수 있도록 추상 클래스의 공통적인 정의를 제공하는 것이다.

(추상클래스 안에서 접근 제한를 적지 않으면 모두 private)

 

추상 클래스 특징

1. new연산자를 이용하여 인스턴스 생성 불가

2. 오직 자식 클래스에서 상속을 통해서만 구현 가능

3. 추상 메소드와 추상 프로퍼티를 가질 수 있음.

 

추상 메소드 특징

1. 추상 메소드는 암시적으로 가상 메소드

2. 추상 메소드 선언은 오직 추상 클래스에서만 허용

3. 추상 메소드 선언할 때 static 또는 virtual 키워드 사용 불가

4. 추상 메소드는  실제 구현을 제공하지 않기에 메소드 본문이 없음.

//추상 클래스 및 메소드 선언

abstract class Animal
{
	public string name;
    public abstract void Move();
    
    public void Move2()
    {
    	Console.WriteLine("일반 메소드");
    }
}

// 상속 받아 추상 메소드 구현

class Dog : Animal
{
	public override void Move() //  자식 클래스는 override로 작성
    {
    	Console.WriteLine("네 발로 이동한다")'
    }
}

 

[인터페이스]

인터페이스에 속한 메소드는 모두 가상 메소드에 속한다.(virtual 키워드 지정 x  , 상속 받은 클래스에서 override 키워드 x)

 

인터페이스 특징

1. 메소드 , 프로퍼티, 인덱서, 이벤트만을 가질 수 있음.

2. 구현부가 없음.

3. 접근 제한자를 사용할 수 없고 모든 것이 public으로 선언

4. new 연산자를 이용해 인스턴스를 생성할 수 없지만 참조변수로는 만들기 가능

 

인터페이스 장점

1. 개발시간 단축

2. 표준화 가능

3. 서로 관계없는 클래스들에게 관계를 맺어 줌

4. 독립적인 프로그래밍 가능

 

*추상 클래스와 인터페이스 차이점 - 다중 상속의 유무(인터페이스 가능, 추상 클래스 불가능)

이유는 인터페이스는 클래스가 아니기 때문이다.

 

//인터페이스 선언 및 구현

interface ILogger // I를 붙여 인터페이스임을 나타내기 쉬움
{
	void WriteLog(string log);
}

class ConsoleLogger : ILogger //인터페이스 상속
{
	public void WriteLog(string log)
    {
    	Console.WriteLine("{0} {1}", DateTime.Now.ToLocalTime(), log);
    }
}

//인터페이스를 이용한 다형성

class Program
{
	static void Main(string[] args)
    {
    	ILogger logger = new ConsoleLogger(); //인터페이스로 객체생성
    }
}