c# study : 클래스 c# study


//this 키워드
//객체 내부에서(클래스 내부에서) 객체가 자신의 필드나 메소드에 접근할 때 this키워드를 사용
//
namespace This
{
    class Employee
    {
        private string Name;
        private string Position;
    
        public void SetName(string Name) // SetName 메소드는 Employee 클래스의 변수인 Name(this.Name)에  
                                         // 입력받은 매개변수 Name을 저장하는 기능. 
        {
            this.Name = Name;  
        }

        public string GetName()  // GetName 메소드는 Name을 반환.
        {
            return Name;
        }

        public void SetPosition(string Position) // SetPosition 메소드는 Employee 클래스의 변수인 Position(this.Position)에
        {                                        // 입력받은 매개변수 Position을 저장하는 기능.
            this.Position = Position;
        }

        public string GetPosition() // GetPosition 메소드는 Position을 반환.
        {
            return this.Position;
        }
    }
    class MainApp
    {
        static void Main(string[] args)
        {
            Employee pooh = new Employee();  // Employee클래스의 pooh라는 인스턴스 생성
            pooh.SetName("Pooh");            // SetName에 매개변수 Pooh 저장
            pooh.SetPosition("Waiter");      // SetPosition에 매개변수 Waiter 저장

            Console.WriteLine($"{pooh.GetName()} {pooh.GetPosition()}"); // 반환

            Employee tigger = new Employee(); // 위 내용과 같음.
            tigger.SetName("Tigger");
            tigger.SetPosition("Cleaner");
            Console.WriteLine($"{tigger.GetName()} {tigger.GetPosition()}");
        }
    }
}




// 접근 한정자로 공개 수준 결정하기
// 은닉성 - 클래스의 사용자(프로그래머 or 코더)에게 필요한 최소의 기능만을 노출하고 내부는 감춤
// 필드, 메소드, 프로퍼티 등 모든 요소에 사용
// public, protected, private, internal...
// 접근 한정자로 수식하지 않은 클래스의 멤버는 private로 접근 수준이 자동으로 지정

namespace AccessModifier
{
    class WaterHeater
    {
        protected int temperature;  // temperature 변수의 접근 범위가 protected - 파생클래스에서만 접근 가능

        public void SetTemperature(int temperature)
        {
            if (temperature < -5 || temperature > 42)
            {
                throw new Exception("Out of temperature range"); // if 범위에서 throw 예외던지기
            }

            this.temperature = temperature;
        }

        internal void TurnOnWater() // internal - 같은 어셈블리 코드에서만 public으로 접근 가능
        {
            Console.WriteLine($"Turn on water : {temperature}");
        }
    }

    class MainApp
    {
        static void Main(string[] args)
        {
            try // 실행하고자 하는 코드
            {
                WaterHeater heater = new WaterHeater(); // 클래스 WaterHeater의 인스턴스 생성
                heater.SetTemperature(20);
                heater.TurnOnWater();

                heater.SetTemperature(-2);
                heater.TurnOnWater();

                heater.SetTemperature(50); // 예외가 발생하여 catch블록으로 실행위치가 이동함
                heater.TurnOnWater();
            }

            catch(Exception e) // 예외가 발생했을 때 코드
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}


// 상속으로 코드 재활용하기
// 파생클래스, 기반클래스
// 기반클래스의 멤버에 접근하기 위해서 base 키워드 사용. this키워드 처럼 사용.
// 파생클래스의 생성자에서 기반클래스의 생성자에게 매개변수를 넘겨주는 방법.
// base() - 기반클래스 생성자 이용.
// 어려움 아직 해석 못함!

namespace Inheritance
{
    class Base
    {
        protected string Name;
        public Base(string Name)
        {
            this.Name = Name;
            Console.WriteLine($"{this.Name}.Base()");
        }

        ~Base()
        {
            Console.WriteLine($"{this.Name}.~Base()");
        }

        public void BaseMethod()
        {
            Console.WriteLine($"{Name}.BaseMethod()");
        }
    }

    class Derived : Base
    {
        public Derived(string Name) : base(Name)
        {
            Console.WriteLine($"{this.Name}.Derived()");
        }

        ~Derived()
        {
            Console.WriteLine($"{this.Name}.~Derived()");
        }

        public void DerivedMethod()
        {
            Console.WriteLine($"{Name}.DerivedMethod()");
        }
    }

    class MainApp
    {
        static void Main(string[] args)
        {
            Base a = new Base("a");
            a.BaseMethod();

            Derived b = new Derived("b");
            b.BaseMethod();
            b.DerivedMethod();
        }
    }
}

// 기반 클래스와 파생 클래스 사이의 형식 변환, 그리고 is와 as
// Mammal - 기반클래스, Dog, Cat - 파생클래스
// (Dog)mammal, (Cat)mammal 로 형식 변환
// 형변환을 위한 연산자 is와 as
// is - 객체가 해당 형식에 해당하는 지를 검사하여 결과를 bool값으로 반환
// ex) if (mammal is Dog)
// as - 형식변환 연산자와 같은 역할. cast강제 변환보다는 as를 사용하는게 좋음. 변환에 실패할 경우 null로 만듬.
// ex) (Dog)mammal -> mammal as Dog
// 즉, is로 형식 확인 후 as로 형 변환.

namespace TypeCasting
{
    class Mammal
    {
        public void Nurse()
        {
            Console.WriteLine("Nurse()");
        }
    }

    class Dog : Mammal // Mammal 기반 클래스.
    {
        public void Bark()
        {
            Console.WriteLine("Bark()");
        }
    }

    class Cat : Mammal // Mammal 기반 클래스.
    {
        public void Meow()
        {
            Console.WriteLine("Meow()");
        }
    }

    class MainApp
    {
        static void Main(string[] args)
        {
            Mammal mammal = new Dog(); // 기반클래스 Mammal는 파생클래스 Dog()가 생성자로 인스턴스 생성
            Dog dog;

            if (mammal is Dog)
            {
                dog = (Dog)mammal; // dog를 Dog에서 mammal로 변환
                dog.Bark();
            }

            Mammal mammal2 = new Cat();

            Cat cat = mammal2 as Cat; // cat을 Cat에서 mammal2로 변환
            if (cat != null)
                cat.Meow();

            Cat cat2 = mammal as Cat; // cat2을 Cat에서 mammal로 변환
            if (cat2 != null) // cat2가 Cat에서 mammal로 변환되었다면, cat2.Meow()반환
                cat2.Meow();
            else
                Console.WriteLine("cat2 is not a Cat"); // cat2가 Cat에서 mammal로 변환되지 못했다면 cat2는 Cat이 아님.
        }
    }
}


덧글

댓글 입력 영역