[KLA 멀티캠퍼스] C#7.0 제대로 배우기 Part.2(입문2)

22.08.04(목)

[1~2차시 - 생성자(Constructor)와 종료자]

 

* 생성자(Constructor)

: 설계된 클래스 객체를 생성하는 메소드와 같은 것.

 

* 생성자 형식

한정자 클래스명 (매개변수명)  { }

 

* 생성자 특징

- 클래스를 선언할 때 생성자를 구현하지 않았을 경우, 컴파일러에서 기본 생성자를 만들어 준다.

- 생성자의 이름은 클래스의 이름과 같다.

 

* 종료자

: 객체에 할당된 메모리를 해제하는 것.

 

* 종료자 형식

~클래스명 ()  { }

 

* 종료자 특징

- 클래스명에 ~를 붙여 사용한다.

- 생성자와 달리 한정자를 사용하지 않는다.

- 매개변수도 없다. 오버로딩도 안됨.

- 직접 호출이 불가하고 CLR(Common Language Runtime)의 가비지 컬렉터가 객체 소멸 시점을 판단해서 종료자를 호출해준다.

- CLR 덕분에 종료자 구지 안적어도 됨.

 

* CLR(Common Language Runtime) ? ⭐️⭐️⭐️

: 어플리케이션을 실행하기 위해 실행환경을 제공해주는 것.

: CLR이 C# 코드를 읽어서 컴퓨터(OS)가 이해할 수 있는 Native Code 로 변역해주는 역할. ( JIT 컴파일 )

cf) C# 6.0에서는 포맷팅을 할 때 $ 기호를 이용해서 표현할 수 있도록 하고 있다.

22.08.05(금)

[3차시 - static 필드와 static 메소드]

* static: 정적의 의미. ex) 정적 메소드, 정적 필드(변수) 등

 

한 프로그램 안에 클래스는 하나만 존재하지만 인스턴스는 여러개가 존재할 수 있다.

한 프로그램 안에 똑같은 클래스는 두 개가 존재할 수 없다.

이처럼 static 필드나 메소드는 클래스에 소속된 것이므로 프로그램 안에 유일하게 존재한다. => Class 명으로 직접 접근이 가능

namespace StaticEx{

    class Program{
    	static void Main(string[] args){
            DemoClass demoClass = new DemoClass();
            demoCalss.a = 100;
            demoClass.b = 200;
            
            DemoClass demoClass2 = new DemoClass();
            demoClass2.a = 1;
            demoClass2.b = 2;
            
            SdemoClass.a = 11; // static 필드이기 때문에(유일한) 클래스 명으로 바로 접근할 수 있다.
            SdemoClass.b = 22;
        }
    }

    class DemoClass{
    	public int a;
        public int b;
    }
    
    class SdemoClass{
    	public static int a;
        public static int b;
    }
}

 

* 인스턴스 메소드, 필드와 static 메소드, 필드의 차이점

namespace StaticEx2{
    class MyClass{
    	public static int Global_Count = 0;
    }
    
    class DemoCalss1{
    	public DemoClass2(){
        	MyClass.Galobal_Count++;
        }
    }
    class DemoCalss2{
    	public DemoClass2(){
        	MyClass.Galobal_Count++;
        }
    }
    class Program{
    	static void Main(string[] args){
            Console.WriteLine($"Global_Count: {MyClass.Global_Count}");
            new DemoClass1();
            new DemoClass1();
            new DemoClass2();
            Console.WriteLine($"Global_Count: {MyClass.Global_Count}");
        }
    }
}

 

[4차시 - 깊은복사의 이해]

 

ex) 얕은 복사, 깊은 복사 예시 코드

namespace ObjCopyEx{
    class Program{
    	class Demo1{
            public int aa;
            public int bb;
            
            //깊은 복사를 위한 메소드
            public Demo1 DeepCopy(){
            	Demo1 newDemo1 = new Demo1();
                newDemo1.aa = this.aa;
                newDemo1.bb = this.bb;
                
                return newDemo1;
            }
        }
        static void Main(string[] args){
            //얕은 복사
            Demo1 demo1 = new Demo1();
            demo1.aa = 100;
            demo1.bb = 100;
            
            Demo1 demo11 = demo1;
            demo11.bb = 1111;
            
            Console.WriteLine("----------얕은 복사----------")
            Console.WriteLine($"{demo1.aa} {demo1.bb}");//100 1111
            Console.WriteLine($"{demo11.aa} {demo11.bb}");//100 1111
            
            //깊은 복사
            Demo1 demo1 = new Demo1();
            demo1.aa = 100;
            demo.bb = 1000;
            
            Demo1 demo11 = demo1.DeepCopy();
            demo11.bb = 1111;
            
            Console.WriteLine("----------깊은 복사----------")
            Console.WriteLine($"{demo1.aa} {demo1.bb}");//100 1000
            Console.WriteLine($"{demo1.aa} {demo1.bb}");//100 1111
        }
    }
}

 

얕은 복사, 깊은 복사의 원리를 그림으로 알아보자.

얕은 복사와 깊은 복사의 차이는 앞에서 배웠던 개념인 참조형식과 값형식으로 이해하면 쉽다. 

 

* 얕은 복사: 참조 형태

 

* 깊은 복사: 값 형태

: 얕은 복사를 하면 Heap 메모리에 있는 같은 값을 가리키지만, 깊은 복사를 하면 Heap 메모리의 새로운 주소에 변수 공간을 만드므로 값을 분리해서 관리할 수 있다.

 

 

22.08.08(월), 22.08.11(목)

[5차시 - this, this() 생성자]

* this: 객체가 클래스 내부에서 자신을 지칭할 때 사용하는 키워드. 나 자신~!

namespace ThisEx{
    class Student{
    	private string name;
        public void SetName(string name){
        	this.name = name;
        }
    }
    class Program{
    	static void Main(string[] args){
        
        }
    }
}

: SetName() 함수에서 name = name; 이렇게 적으면 앞의 name 변수가 SetName 함수 인자에 있는 name 인지, Student 클래스의 name 인지 알 수가 없다. 이럴 때 this 키워드를 이용해서 = 왼쪽은 Student 클래스의 name, = 오른쪽은 매개변수의 name 이라고 명시해주는 것이다.

 

* this(): 생성자. 메소드와 비슷한 것으로 오버로딩이 가능함.

namespace ThisEx2{
    class Demo{
    	public int a, b, c;
        
        //a, b, c 등 변수를 중복적으로 변경하는 생성자 오버로딩 코드. 보기 아주 불편...
        public Demo(){
            this.a = 100;
        }
        public Demo(int b){
            this.a = 100;
            this.b = b;
        }
        public Demo(int b, int c){
            this.a = 100;
            this.b = b;
            this.c = c;
        }
    }
    
    class Program{
    	static void Main(string[] args){
            Demo demo = new Demo(200, 300);
            
            Console.WriteLine(demo.b); //200
            Console.WriteLine(demo.c); //300
        }
    }
}

위에서 변수를 중복적으로 변경하여 불편했던 코드를 this() 생성자를 이용해서 상속받고 중복을 제거한 코드

namespace ThisEx2{
    class Demo{
    	public int a, b, c;
        
        //a, b, c 등 변수를 중복적으로 변경하는 생성자 오버로딩 코드. 보기 아주 불편...
        public Demo(){
            this.a = 100;
            Console.WriteLine("Demo()"); //Demo()
        }
        public Demo(int b): this(){
            //this.a = 100; 주의!! 매개변수에 적은 변수만 처리해야 함.
            this.b = b;
            Console.WriteLine($"{Demo({b})"); //Demo(200)
        }
        public Demo(int b, int c): this(b){
            //this.a = 100;
            //tihs.b = b;
            this.c = c;
            Console.WriteLine($"{Demo({b} {c})"); //Demo(200 300)
        }
    }
    
    class Program{
    	static void Main(string[] args){
            Demo demo = new Demo(200, 300);
            
            Console.WriteLine(demo.a); //100
            Console.WriteLine(demo.b); //200
            Console.WriteLine(demo.c); //300
        }
    }
}

 

22.08.23(화)

[6~7차시 - 접근 제한자(Access Modifier)]

* 접근 제한자/한정자 종류

public, private, protected, internal, protected internal, private protected

1) public: 클래스의 내부 또는 외부 모든 곳에서 접근할 수 있도록 하는 지정자

2) private: 클래스 외부에서는 접근할 수 없도록 하는 지정자. 내부에서만 접근 가능하도록 하는 지정자.

                상속 받은 자식(파생) 클래스에서도 접근 허용 안됨.

3) protected: 클래스 외부에서는 접근할 수 없도록 하는 지정자. 하지만 파생 클래스에서는 접근 가능하도록 하는 지정자.

4) internal: 동일 어셈블리에 있는 코드에서만 public으로 접근할 수 있는 지정자.

                  다른 어셈블리에 있는 코드에서는 private과 같은 수준의 접근 수준을 갖는다. 즉 접근 불가.

                  * 어셈블리: 클래스 라이브러리(.dll), 실행파일(.exe) 등의 파일들

5) protected internal: 동일 어셈블리에 있는 코드에서만 protected로 접근할 수 있는 지정자.

                                  다른 어셈블리에 있는 코드에서는 private과 같은 접근 수준을 갖는다. 즉 접근 안됨.

6) private protected: 동일 어셈블리에 있는 클래스에서 상속받은 클래스 내부에서만 접근이 가능

 

* 한정자가 설정되어 있지 않을 때 기본 셋팅 값은 private이다.

 

예시)

namespace AccessModifierEx{
    class Demo{
    	public Demo(){
            Demo.public_method();
            Demo.private_method();
            Demo.protected_method();
            Demo.internal_method();
            Demo.protected_internal();
        }
        
        //public 접근 제한자
        public static void public_method(){ }
        
        //private 접근 제한자
        private static void private_method(){ }
        
        //protected 접근 제한자
        protected static void protected_method(){ }
        
        //internal 접근 제한자
        internal static void internal_method(){ }
        
        //protected internal 접근 제한자
        protected internal static void protected_internal(){}
        
        //private protected 접근 제한자
        private protected static void private_protected(){
        	//7.2버전으로 업그레이드해야 private protected 사용 가능. 
        }
    }
    
    class Demo2 : Demo{
    	public Demo2(){
            Demo.public_method();
            Demo.protected_method();
            Demo.protected_internal();
            Demo.private_protected();
            Demo.internal_method();
        }
    }
    
    class Program{
    	static void Main(string[] args){
            Demo.public_method();
            Demo.internal_method();
            Demo.protected_internal();
        }
    }
}

 

22.08.23(화)

[8차시 - 상속, 9차시 - base 키워드와 sealed 한정자]

* 상속: 부모 클래스가 갖고 있는 변수, 함수 등을 재사용하는 것.

* 용어: 상속 or 기반(부모) 클래스, 파생(자식) 클래스

namespace InheritEx{

    class Parent{
    	public Parent(){
        	Console.WriteLine("Parent() 생성자 호출");
        }
        ~Parent(){
        	Console.WriteLine("~Parent() 종료자 호출");
        }
    }    
    
    class Child : Parent{
    	public Child(){
        	Console.WriteLine("Child() 생성자 호출");
        }
        ~Child(){
        	Console.WriteLine("~Child() 종료자 호출");
        }
    }
    
    class Program{
    	static void Main(string[] args){
            Child child = new Child();
        }
    }
}

 

위 코드 결과 

Parent() 생성자 호출

Child() 생성자 호출

~Child() 종료자 호출

~Parent() 종료자 호출

=> 부모먼저 생성하고 자식을 생성한다. 또한, 자식을 먼저 종료하고 부모를 종료한다.

 

* 기반(부모) 클래스의 인자 생성자에게 파생(자식) 클래스가 인자를 전달하는 방법

-> base 키워드로 상속받을 수 있고 기반(부모) 클래스에 접근할 수 있다.

-> sealed 키워드를 이용하면 상속을 봉인하게 되어 상속이 불가능하도록 클래스를 선언할 수 있다.

namespace InheritEx2{

   class Parent{
    	protected string name;
    
    	public Parent(string name){
            this.name = name;
            Console.WriteLine($"{this.name}.Parnet() 생성자 호출");
        }
        ~Parent(){
            Console.WriteLine($"{this.name}.~Parnet() 종료자 호출");
        }
        public void ParentMethod(){
            Console.WriteLine($"{name}.ParentMethod()");
        }
    }
    
    class Child : Parent{
        public Child(string name) : base(name){
            Console.WriteLine($"{this.name}.Child() 생성자 호출");
        }
        ~Child(){
            Console.WriteLine($"{this.name}.~Child() 종료자 호출");
        }
        public void ChildMethod(){
            Console.WriteLine($"{name}.ChildMethod()");
        }
    }

	class Program{
    	static void Main(string[] args){
            Parent parentA = new Parent("parentA");
            parentA.ParentMethod();
            
            Child childA = new Child("childA");
            childA.ChildMethod();
        }
    }
}

 

위 코드 결과

parentA.Parent() 생성자 호출

parentA.ParentMethod()

childA.Parent() 생성자 호출

childA.Child() 생성자 호출

childA.ChildMethod()

childA.~Child() 종료자 호출

childA.~Parent() 종료자 호출

parentA.~Parent() 종료자 호출

 

 

22.09.15(목)

[10차시 - 상속관계의 클래스 형변환]

: Casting 연산자 -> () 괄호 이용.

 

//상속관계의 클래스 사이에서의 형변환

namespace ClassCoversionEx{

    class Human{
    	public void showInfo(){
            Console.WriteLine("Human");
        }
    }
    
    class Programmer : Human{
    	public void programming(){
            Console.WriteLine("프로그래밍 하는 개발자");
        }
    }
    
    class Designer : Human{
    	public void design(){
            Console.WriteLine("디자인하는 디자이너");
        }
    }
    
    class Program{
    	static void Main(string[] args){
            Human human = new Human();
            human.showInfo();
            
            Programmer programmer = new Programmer();
            programmer.programming();
            programmer.showInfo(); //Human 클래스를 상속받았기 때문에 호출 가능
            
            Designer designer = new Designer();
            designer.design();
            designer.showInfo(); //Human 클래스를 상속받았기 때문에 호출 가능
        }
    }
}

namespace ClassCoversionEx{

    class Human{
    	public void showInfo(){
            Console.WriteLine("Human");
        }
    }
    
    class Programmer : Human{
    	public void programming(){
            Console.WriteLine("프로그래밍 하는 개발자");
        }
    }
    
    class Designer : Human{
    	public void design(){
            Console.WriteLine("디자인하는 디자이너");
        }
    }
    
    class Program{
    	static void Main(string[] args){
            Human human = new Human();
            human.showInfo();
            
            human = new Programmer();// Programmer를 상속받앗기 때문에 Human객체가 Programmer가 될 수 있다.
            human.showInfo();
            
            Programmer programmer = (Programmer)human;
            programmer.showInfo();
            programmer.programming();
            
            human = new Designer();
            human.showInfo();
            
            Designer designer = (Designer)human;
            designer.showInfo();
            designer.design();
        }
    }
}

 

22.12.02(금)

[11차시 - is 연산자와 as 연산자]

형변환과 관련된 연산자: is, as

 

* as: 형변환(캐스티)과 같은 역할을 하는 연산자. 형변환에 실패했을 경우 null 값을 리턴한다.

* is: 해당 객체의 Type(형)이 일치하는지 여부를 bool 값으로 변환하는 연산자.

namespace AsIsEx{
    class Human{
    	public void ShowInfo(){
            Console.WriteLine("Human");
        }
    }
    
    classs Programmer : Human {
    	public void Programming(){
            Console.WriteLine("코딩하는 프로그래머");
        }
    }
    
    class Designer(){
    	public void Design(){
            Console.WriteLine("디자인하는 디자이너");
        }
    }
    
    class Program{
    	static void Main(string[] args){
            Human human = new Programmer();
            Programmer programmer;
            
            if(human is Programmer){
            	programmer = (Programmer)human;
                programmer.Programming();
            }
            
            Human human2 = new Designer();
            
            Designer designer = human2 as Designer;
            if(designer != nulll) designer.design();
            
            Designer designer2 = human as Designer;
            if(designer2 != null) desiginer2.design();
            else Console.WriteLine("designer2는 Designer 형이 아니다!");
        }
    }
}

출력값:

코딩하는 프로그래머

디자인하는 디자이너

designer2는 Designer형이 아니다!

 

[12차시 - 오버라이딩(virtual, override, new)]

* 오버라이드: 메소드 재정의

1) virtual: 부모(베이스) 클래스 메소드 앞에 붙이는 연산자. 자식(파생. derived) 클래스에서 재정의 될 수 있다.(안해도 상관 없음)

2) override: 자식(파생) 클래스 메소드 앞에 붙는 연산자. 부모로부터 받은 메소드를 재정의 한다라는 의미.

                     재정의 할 때는 부모의 메소드 이름과 같아야 한다. 프로토타입도 일치해야 함!

namespace OverrideEx{
    class BaseClass {
    	public virtual void echo(){
            Console.WriteLine("기반 클래스");
        }
    }
    
    class DerivedClass : BaseClass {
    	public override void echo(){
            Console.WriteLine("파생 클래스");
        }
    }    
    
    class Program {
    	static void Main(string[] args){
            DerivedClass derivedClass = new DerivedClass();
            derivedClass.echo(); // "파생 클래스" 출력!
        }
    }
}

* 참고) virtual, override 키워드 없이 재정의해서 사용될 수 있지만. 경고창이 뜨기도 하고. 원칙을 지켜주는게 좋다.

 

namespace OverrideEx{
    class BaseClass {
    	public virtual void echo(){
            Console.WriteLine("기반 클래스");
        }
    }
    
    class DerivedClass : BaseClass {
    	public new void echo(){
            Console.WriteLine("파생 클래스");
        }
    }    
    
    class Program {
    	static void Main(string[] args){
            DerivedClass derivedClass = new DerivedClass();
            derivedClass.echo(); // "기반 클래스" 출력!
        }
    }
}

* 참고) 파생 클래스에서 new 키워드를 붙여주면 자신의 메소드를 감추고 부모 클래스에 있는 메소드가 호출된다. 오버라이딩과 다른 개념.

 

[13차시 - 구조체(struct), 튜플]

C#에서는 struct라는 키워드를 사용하면 Value Type을 만들고 class를 사용하면 Reference Type을 만든다.

int, double, float, bool 타입을 기본(Primitive Type)이라고 하는데, struct로 정의된 Value Type이다.

 

Value Type은 상속될 수 없으며, 주로 간단한 데이터 값을 저장하는데 사용된다.

Reference Type은 class를 정의해서 만들고, 상속이 가능하고 좀 더 복잡한 데이터와 기능들을 정의하는 곳에 많이 사용된다.

 

* 구조체: struct라는 키워드를 이용해서 정의한다. 클래스와 같이 메소드, 속성(프로퍼티) 등 거의 비슷한 구조를 가지고 있지만, 상속을 할 수 없다. 클래스와 마찬가지로 인터페이스(interface) 구현을 할 수 있다.

namespace StructEx{

    //구조체 정의
    struct MyPoint{
        public int X;
        public int Y;
            
        //구조체는 생성자를 선언할 수 있다. but 기본 생성자(매개변수가 없는 생성자)는 생성 안됨!
        public MyPoint(int x, int y){
            this.X = x;
            this.Y = y;
        }
        
        //모든 구조체는 System.Object 형식을 상속하는 System.ValueType으로부터 직접 상속받음
        public string ToString(){
            return string.Format($"{X}, {Y}");
        }        
    }
        
    class Program{
    	static void Main(string[] args){
            MyPoint myPoint;
            myPoint.X = 100;
            myPoint.Y = 100;
            
            Console.WriteLine(myPoint.ToString());//100, 100
            
            MyPoint myPoint2 = new MyPoint(100,1000);
            MyPoint myPoint3 = myPoint2;//myPoint2 복사
            myPoint3.Y = 1001;
            
            Console.WriteLine(myPoint2.ToString());//1000, 1000
            Console.WriteLine(myPoint3.ToString());//1000, 1001
        }
    }
}

구조체는 클래스와 달리 객체를 복사할 때 깊은 복사가 이뤄진다!

 

* 튜플: 여러 개의 값(Field)을 담을 수 있는 구조체와 같은 것. () 안에 여러 개의 필드를 지정하여 만들 수 있다.

C# 7.0 이전 버전에서는 메소드에서 하나의 값만 리턴할 수 있었다. C# 7.0 이후 버전부터는 튜프을 사용해서 복수개의 값을 리턴할 수 있게 되었다. 

namespace TupleEx {
    //unnamed tuple 선언
    var t = (100, 200);
    
    //named tuple 선언
    var t = (Name: "홍길동", Id: "120")
    
    class Program{
    	static void Main(string[] args){
            var aa = ("홍길동", 40);
            Console.WriteLine($"{aa.Item1}, {aa.Item2}");//홍길동, 40
            
            var bb = (Name:"홍길복", Age:55);
            Console.WriteLine($"{bb.Name}, {bb.Age}");//홍길복, 55
            
            var (name, age) = bb;
            Console.WriteLine($"{name}, {age}");//홍길복, 55
            
            bb = aa; //깊은복사
            Console.WriteLine($"{bb.Name}, {bb.Age}");//홍길동, 40
        }
    }
}

 

패키지 관리자 콘솔에서 튜플 해당 패키지를 설치해줘야 한다.

PM> Install -Package "System.ValueTuple"

 

 

[14차시 - 튜플 리턴 타입을 이용한 메소드 사용하기]

 

 

22.12.29(목)

[15차시 - 인터페이스 이해]

* 인터페이스

- 물리적인 인터페이스의 개념: 다른 두 시스템 장치를 연결해주는 중간 접속 장치. ex) 키보드, 마우스, 모니터 등이 컴퓨터에 연결되어 사용자와 컴퓨터간의 인터페이스 역할을 한다.

- 코드 상에서의 인터페이스 개념: interface 키워드 사용해서 만든 일종의 명세서. 두 소프트웨어 간의 연결장치.

 

* 인터페이스의 특징

- 인터페이스는 필드를 포함하지 않는다. 메소드, 이벤트, 프로퍼티만을 멤버로 갖는다.
- 인터페이스는 모든 멤버 접근지정자는 public 이다. 따라서, 접근제한자를 사용할 수 없다.

    wyh? 인터페이스를 상속받아서 구현해야 하는데 접근 지정자가 설정되어 있다면 접근이 불가능하기 때문이다.

- 인터페이스는 구현부(몸통)가 없는 추상멤버를 갖는다.

- 인터페이스는 다중 상속이 가능하다.

    => 인터페이스가 다른 인터페이스를 상속 받을 수 있다. 클래스, 구조체에서도 인터페이스를 상속받을 수 있다.

    => 자식 인터페이스를 상속받은 클래스는 자식, 부모 함수를 모두 구현해주어야 한다.

 

인터페이스 선언 방법)

interface 인터페이스명
{
    반환형식 메소드명(매개변수, ..);
    ...
}

 

코드 예시)

namespace InterfaceEx{

    interface IMyInterfaceA
    {
    	void output();
    }
    
    interface IMyInterfaceB
    {
    	void output();
    }    
    
    class Program : IMyInterfaceA, IMyInterfaceB
    {
    	static void Main(string[] args)
        {
            MyClass myClass = new MyClass();
            
            IMyInterfaceA iA = myClass;
            iA.output();
            
            iMyInterfaceB iB = myClass;
            iB.output();
        }
        
        //인터페이스 상속 후 선언부 필요
        void iMyInterfaceA.output(){
            Console.WriteLine("A 인터페이스 output() 호출");
        }
        //인터페이스 상속 후 선언부 필요
        void iMyInterfaceB.output(){
            Console.WriteLine("B 인터페이스 output() 호출");
        }
    }
}

결과:

A 인터페이스 output() 호출

B 인터페이스 output() 호출

 

[16차시 - 추상클래스 이해]

* 추상 클래스: 인터페이스와 비슷하다 하지만, 추상클래스는 구현(몸통)부를 가질 수 있고 인스턴스를 가질 수는 없다.

                       사용하는 한정자는 abstract와 class 를 사용한다.

                       추상 클래스는 클래스와 달리 추상 메소드를 갖고 있다.

                       추상 클래스는 모든 멤버에 접근 제한자를 사용하지 않을 경우 private 설정된다.

* 추상 클래스 선언형식

abstract class 클래스 명
{
      //클래스와 동일
}

 

* 추상 메소드: 추상 메소드를 지정할 때 abstract 키워드를 사용한다.

                       추상 메소드는 private 이 될 수 없기 때문에 public, protected, internal, protected internal 중에 하나로

                       수식되도록 하고 있다.    

* 추상 메소드 선언형식

public abstract void A();

 

*예시

using System;

namespace Abstract
{
    abstract class MyAbstractClass
    {
        protected void ProtectedMethod()
        {
            Console.WriteLine("추상 클래스의 PotectedMethod 호출");
        }
        public void PublicMethod()
        {
            Console.WriteLine("추상 클래스의 PubicMethod 호출");
        }
        public abstract void AbstractMethod();
    }

    class Child : MyAbstractClass
    {
        public override void AbstractMethod()
        {
            Console.WriteLine("추상 클래스의 AbstractMethod 호출");
            ProtectedMetod();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            MyAbstractClass myAbstractClass = new MyAbstractClass();
            myAbstractClass.AbstractMethod();
            myAbstractClass.PublicMethod();
        }
    }
}

구현해야할 부분(abstract method)과 구현하지 않아도될 부분(abstract가 아닌 method)을 알려줄 때 사용하는 구조

 

[17차시 - 프로퍼티의 이해]

* 프로퍼티: get, set 접근자로 값을 설정하고 읽어오는 속성.

class EmployeeInfo
{
    public string Name
    {
        get
        {
            return Name;
        }
        set
        {
            Name = value;
        }
    }
}

 

- C# 7.0 부터 자동 프로퍼티 지원

class EmployeeInfo
{
    public string Name { get; set; }
}

class EmployeeInfo
{
    public string Name { get; set; } = "unknown"
}

초기값 지정도 가능하다.

class EmployeeInfo
{
    public string Name { get; private set; }
}

private set 은 내부에서만 값을 지정할 수 있고 외부에선 읽기만 가능한 값이라는 뜻.

 

- 객체를 생성할 때 객체의 필드를 초기화하는 다른 방법(생성자와 프로퍼티를 이용하는 방법)

namespace CshapTest
{
    class EmployeeInfo
    {
        public string Name { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            EmployeeInfo employee = new EmployeeInfo() {
                Name = "홍길동"
            };
        }
    }
}

 

[21차시 - ArrayList 사용하기]

* Collection(컬렉션): 데이터 모음을 담는 자료구조.

                                   ex) ArrayList, Queue, Stack, Hashtable

class Program
{
    static void Main(string[] args)
    {
        int[] array = new int[] { 1, 2, 3, 4 };
        Console.WriteLine(array.GetType());

        ArrayList arrayList = new ArrayList();
        arrayList.Add(1);
        arrayList.Add(2);
        arrayList.RemoveAt(1); // 해당 인덱스를 찾아서 제거
        arrayList.Insert(1, 1.2f); // Insert(index, data) // index 위치에 data 를 삽입
        
        foreach(object obj in arrayList)
        {
            Console.Write($"{obj} ");
        }
    }
}

Add 는 맨 뒤로 추가하는 것, Insert 는 앞으로 추가하는 것.

Collection 의 모든 요소들은 object 타입이기 때문에 foreach 문에서 object obj  가 가능하다.

 

[22차시 - Queue, Stack, Hashtable 사용]

* Queue: 선입선출(FIFO) 자료 구조.

                Enqueue(데이터 입력), Dequeue(데이터 출력)

class Program
{
    static void Main(string[] args)
    {
        Queue q = new Queue();
        q.Enqueue(1);
        q.Enqueue(100);
        q.Enqueue(200);
        q.Dequeue();
        q.Enqueue("가나다");
        
        foreach(object obj in q)
        {
            Console.WriteLine(obj); 
        }
    }
}

100

200

가나다

 

* Stack: 후입선출(LIFO) 자료구조

               Push(데이터 입력), Pop(데이터 출력)

class Program
{
    static void Main(string[] args)
    {
        Stack stack = new Stack();
        stack.Push(1);
        stack.Push(100);
        stack.Push(200);
        stack.Pop();
        stack.Push("가나다");

        foreach(object obj in stack)
        {
            Console.WriteLine(obj); 
        }
    }
}

가나다
100
1

 

* Hashtable: Hashing 알고리즘을 이용한 데이터 검색이 이뤄지는 방식의 알고리즘.

                     키를 이용해서 한번에 데이터가 저장되어 있는 컬렉션 내의 주소를 계산해 낸다.

class Program
{
    static void Main(string[] args)
    {
        Hashtable hashtable = new Hashtable();
        hashtable["Apple"] = "사과";
        hashtable["Banana"] = "바나나";

        foreach(DictionaryEntry obj in hashtable)
        {
            Console.WriteLine($"{obj.Key} {obj.Value}"); 
        }
    }
}

Banana 바나나
Apple 사과

 

[23차시 - 컬렉션 초기화, 인덱서]

class Program
{
    static void Main(string[] args)
    {
        //컬렉션 초기자를 이용한 초기화 방법 - stack, queue는 이용할 수 없음
        ArrayList arrayList1 = new ArrayList() { 10, 20, 30 };

        //배열을 이용한 초기화 방법
        int[] array = { 11, 22, 33, 44 };
        ArrayList arrayList2 = new ArrayList(array);
        Stack stack = new Stack(array);
        Queue queue = new Queue(array);

        //Hashtable 은 Dictionary Initialiser를 이용한다.
        Hashtable hashtable = new Hashtable() {
            ["Seoule"] = "서울", //{"Seoule", "서울"} 이런 형태도 가능
            ["Busan"] = "부산", //{"Busan", "부산"} 이런 형태도 가능
        };
    }
}

 

//인덱서

 

[24차시 - yield 키워드]

* Enumerator(Iterator): 집합적인 데이터셋으로 부터 데이터를 하나씩 호출자에게 보내주는 기능. 반복자.

                                        IEnumerator 라는 인터페이스를 구현해야 한다.

* yield 키워드: 호출자에게 컬렉션 데이터를 하나씩 리턴할 때 사용하는 키워드

        - yield return: 컬렉션 데이터를 하나씩 리턴하는데 사용

        - yield break: 리턴을 중지하고 Iteration 루프를 빠져 나올 때 사용

 

컬렉션 클래스는 Enumeration 이 가능한 클래스 인데, 이러한 클래스들을 Enumerable 클래스라고 한다.

이 Enumerable 클래스는 IEnumerable 인터페이스를 구현해야 한다.

 

IEnumerable 인터페이스는 GetEnumerator() 메소드 하나를 가지고 있다.

컬렉션 타입이나 Enumerable 클래스에서 GetEnumerator() 메소드를 구현하는 방법으로 yield 키워드를 사용할 수 있다.

 

GetEnumerator() 메소드에서 yield return 사용하면 컬렉션 데이터를 순차적으로 하나씩 넘겨주는 코드를 구현할 수 있고 리턴타입은 IEnumerator 인터페이스를 리턴할 수 있다.

class MyList
{
    private int[] data = { 1, 2, 3, 4, 5 };
    public IEnumerator GetEnumerator()
    {
        int i = 0;
        while (i < data.Length)
        {
            yield return data[i];
            i++;
        }
    }
}