객체 지향 프로그래밍과 클래스

객체 : 세상의 모든 것을 지칭
속성 : 데이터
기능 : 메소드
클래스 : 객체를 만들기 위한 청사진

• 클래스 선언 형식

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace cs13_Class
{
    class Cat  // 같은 namespace안에 있기 때문에 main에서 객체 생성 가능
    {
        #region <멤버변수 - 속성>
        public string Name;           // 고양이 이름
        public string Color;          // 색상
        public sbyte Age;             // 고양이 0~255
        #endregion

        #region <멤버메소드 - 기능>
        public void Meow()           // 기본이 private임
        {
            Console.WriteLine("{0} - 야옹!!",Name);
        }
        public void Run()            // public은 main에서도 접근 가능
        {
            Console.WriteLine("{0} - 달린다.",this.Name);
        }
        #endregion

    }

    internal class Program          // Program.cs 전체에서 사용가능
    {
        static void Main(string[] args)
        {
            Cat helloKitty = new Cat();     // helloKitty 객체 생성
            helloKitty.Name = "헬로키티";
            helloKitty.Color = "흰색";
            helloKitty.Age = 50;
            helloKitty.Meow();
            helloKitty.Run();

            // 객체를 생성하면서 속성 초기화
            Cat nero = new Cat() {
                Name = "검은고양이 네로",
                Color = "검은색",
                Age = 27,
            };
            nero.Meow();
            nero.Run();

            Console.WriteLine("{0}의 색상은 {1} , 나이는 {2}세 입니다. ",helloKitty.Name,helloKitty.Color,helloKitty.Age);
            Console.WriteLine("{0}의 색상은 {1} , 나이는 {2}세 입니다. ",nero.Name,nero.Color,nero.Age);
        }
    }
}

얕은 복사와 깊은 복사

얕은복사 : 객체를 복사할 때 참조만 살짝 복사
깊은복사 : 객체를 힙에 새로 할당해서 그곳에 자신의 멤버를 일일이 복사해 넣습니다.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace cs14_deepcopy
{
    class SomeClass
    {
        public int SomeField1;
        public int SomeField2;

        public SomeClass DeepCopy()
        {
            SomeClass newCopy = new SomeClass();
            newCopy.SomeField1 = this.SomeField1;       //Call by value
            newCopy.SomeField2 = this.SomeField2;

            return newCopy;
        }

        #region < this >
        class Employee
        {
            private string Name;

            public void SetName(string Name)
            {
                this.Name = Name;       // 멤버변수(속성)과 메서드의 매개변수 이름이 대소문자까지 완전 똑같을때
            }
        }

        class ThisClass
        {
            int a, b, c;

            public ThisClass()
            {
                this.a = 1;
            }
            public ThisClass(int b):this()
            {
                this.b = b;
            }

            public ThisClass(int a, int b, int c) : this(b)
            {
                this.c = c;
            }
        }

        #endregion
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("얕은 복사 시작");      // source와 targer이 (주소를 복사) 값이 공유됨

            SomeClass source = new SomeClass();
            source.SomeField1 = 100;
            source.SomeField2 = 200;

            SomeClass target = source;
            target.SomeField2 = 300;

            Console.WriteLine("source.SomeField1 => {0} source.SomeField1 => {1}", source.SomeField1, source.SomeField2);
            Console.WriteLine("target.SomeField1 => {0} target.SomeField1 => {1}", target.SomeField1, target.SomeField2);


            Console.WriteLine("깊은 복사 시작");

            SomeClass s = new SomeClass();
            s.SomeField1 = 100;
            s.SomeField2 = 200;

            SomeClass t = s.DeepCopy();         //깊은 복사
            t.SomeField2 = 300;
            Console.WriteLine("s.SomeField1 => {0} s.SomeField1 => {1}", s.SomeField1, s.SomeField2);
            Console.WriteLine("t.SomeField1 => {0} t.SomeField1 => {1}", t.SomeField1, t.SomeField2);

        }
    }
}

This

접근 한정자의 종류

• public
  • 클래스의 내/외부 모든 곳에서 접근 가능
• protected
  • 클래스의 외부에서는 접근 X , 파생클래스 접근 O
• private
  • 클래스의 내부에서만 접근 O , 파생클래스 접근 X
• internal
  • 같은 어셈블리에 있는 코드에서만 public으로 접근할 수 있습니다. 다른 어셈블리에 있는 코드에서는 private와 같은 수준의 접근성을 가집니다.
• protected internal
• private protected

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace cs16_Inheritance
{
    class Base
    {
        //자식클래스에서 상속받으려면 private는 사용 X
        protected string Name;
        private string Color;   //만약에 상속을 할거면 private을 protected로 변경!
        public int Age;

        public Base(string Name, string Color, int Age)
        {
            this.Name = Name;
            this.Color = Color;
            this.Age = Age;

            Console.WriteLine("{0}.Base()",Name);
        }
        public void BaseMethod()
        {
            Console.WriteLine("{0}.BaseMethod()", Name);
        }

        public void GetColor()
        {
            Console.WriteLine("{0}.Base() {1}", Name, Color);
        }
    }

    class Child : Base      // 상속받은 이후 Base의 Name,Color,Age를 새로 만들거나 하지 않음
    {
        public Child(string Name,string Color,int Age) : base(Name, Color, Age)
        {
            Console.WriteLine("{0}.Child()", Name);
        }

        public void ChildMethod()
        {
            Console.WriteLine("{0}.ChildMethod()", Name);
        }
/*        public string GetColor()
        {
         //   return Color;       // 부모클래스에서 상속받은 Color가 private여서 접근 불가능
        }
*/
    }

    internal class Program
    {
        static void Main(string[] args)
        {
            Base B = new Base("NameB", "White",1);
            B.BaseMethod();
            B.GetColor();

            Console.WriteLine();

            Child C = new Child("NameC", "Black", 0);
            C.BaseMethod();
            C.ChildMethod();
            C.GetColor();       //Base.GetColor Black...C에서 Color 접근 불가
        }
    }
}