class Car
    {
        // member field
        //string name;
        //int year;
        /*
        public string Name
        {
            get
            {
                return this.name;
            }
            set
            {
                this.name = value;
            }
        }
        public int Year
        {
            get
            {
                return this.year;
            }
            set
            {
                this.year = value;
            }
        }
        */

        // property
        public string Name
        {
            get;
            set;
        }
        public int Year
        {
            get;
            set;
        }

        // constructor
        public Car() : this(“Avante”, 2013)
        {
        }

        public Car(string name, int year)
        {
            this.Name = name;
            this.Year = year;
        }

        // method
        public void Print()
        {
            Console.WriteLine(“자동차 {0} 년도 {1}”, this.Name, this.Year);
        }
    }

  class Program
    {
        static void Main(string[] args)
        {
            Car c1 = new Car();
            c1.Print();
            c1.Name = “Accent”;
            c1.Print();
            Console.WriteLine(c1.Name);

            Car c2 = new Car(“Sonata”, 2012);
            c2.Print();
        }

public class Counter
{
    private Counter() { }
    public static int currentCount;
    public static int IncrementCount()
    {
        return ++currentCount;
    }
}

class TestCounter
{
    static void Main()
    {
        // If you uncomment the following statement, it will generate
        // an error because the constructor is inaccessible:
        // Counter aCounter = new Counter();   // Error

        Counter.currentCount = 100;
        Counter.IncrementCount();
        Console.WriteLine(“New count: {0}”, Counter.currentCount);

        // Keep the console window open in debug mode.
        Console.WriteLine(“Press any key to exit.”);
        Console.ReadKey();
    }
}
// Output: New count: 101

// protected_keyword.cs
using System;
class A
{
    protected int x = 123;
}

class B : A
{
    static void Main()
    {
        A a = new A();
        B b = new B();

        // Error CS1540, because x can only be accessed by
        // classes derived from A.
        // a.x = 10;
       
        // OK, because this class derives from A.
        b.x = 10;  
    }
}

// protected_keyword_2.cs
using System;
class Point
{
    protected int x;
    protected int y;
}

class DerivedPoint: Point
{
    static void Main()
    {
        DerivedPoint dpoint = new DerivedPoint();

        // Direct access to protected members:
        dpoint.x = 10;
        dpoint.y = 15;
        Console.WriteLine(“x = {0}, y = {1}”, dpoint.x, dpoint.y);
    }
}

    class Base
    {
        public void Print() { Console.WriteLine(“Base Print”); }
    }

    class Derived : Base
    {
        public void Print() { Console.WriteLine(“Derived Print”); }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Base b = new Base();
            Derived d = new Derived();
            Base e = d;
            b.Print(); // Base Print
            d.Print(); // Derived Print (부모클래스의 메소드와 같은 이름으로 메소드를 정의하면 부모의 메소드는 숨겨짐)
            e.Print(); // Base Print (원래 e는 Derived 객체이나 Base 데이타형이므로 Base의 Print 메소드 호출)
        }
    }

    class Base
    {
        public void Print() { Console.WriteLine(“Base Print”); }
    }

    class Derived : Base
    {
        public new void Print() { Console.WriteLine(“Derived Print”); } // 부모클래스의 Print 메소드는 새로 정의
        public void BasePrint() { base.Print(); } // 부모클래스의Print는 여전히 사용 가능
    }

    class Program
    {
        static void Main(string[] args)
        {
            Base b = new Base();
            Derived d = new Derived();
            Base e = d;
            b.Print(); // Base Print
            d.Print(); // Derived Print (부모클래스의 메소드와 같은 이름으로 메소드를 새로 정의)
            d.BasePrint();
            e.Print(); // Base Print (원래 e는 Derived 객체이나 Base 데이타형이므로 Base의 Print 메소드 호출)
        }
    }

    class Base
    {
        public virtual void Print() { Console.WriteLine(“Base Print”); }
    }

    class Derived : Base
    {
        public override void Print() { Console.WriteLine(“Derived Print”); } // 부모클래스의 Print 메소드는 재정의
        public void BasePrint() { base.Print(); } // 부모클래스의Print는 여전히 사용 가능
    }

    class Program
    {
        static void Main(string[] args)
        {
            Base b = new Base();
            Derived d = new Derived();
            Base e = d;
            b.Print(); // Base Print
            d.Print(); // Derived Print (부모클래스의 메소드와 같은 이름으로 메소드를 재정의)
            d.BasePrint();
            e.Print(); // Derived Print (원래 e는 Derived 객체이므로 late-binding에 의해서 Base의 Print 메소드 호출)
        }
    }

    class Car
    {
        // member field
        private bool disel;     // disel은 파생 클래스에서 사용하지 못함
        protected bool gasoline;// gasoline은 파생 클래스에서 사용가능하나 클래스 외부에서는 호출하지 못함
        protected int wheel = 4;// wheel은 파생 클래스에서 사용가능하나 클래스 외부에서는 호출하지 못함

        // constructor
        protected Car() { disel = true; gasoline = true;  }
        protected Car(int wheel) { this.wheel = wheel; disel = false; gasoline = false; }

        // method
        protected void Move()
        {
            if (disel)
                Console.Write(“Car 디젤 “);
            Console.WriteLine(“바퀴 {0} 자동차가 굴러다닌다”, wheel);
        }
    }

    class Sedan : Car
    {
        // member field
        private bool gasoline;  // 파생 클래스에서 기반클래스에 멤버필드명이 같다면 default는 자신의 멤버부터 호출 & Sedan.gasoline은 Car.gasoline을 숨김 => private new bool gasoline와 같은 의미

        // constructor
        public Sedan() { gasoline = false;  }                      // Sedan() : base() 호출
        public Sedan(int wheel) : base(wheel) { gasoline = true; } // Sedan(int wheel) : base(int wheel)를 호출 – protected 생성자는 기반 클래스의 생성자 호출 base에서 사용됨

        // method
        public void SedanMove()
        {
            if (base.gasoline)                              // base의 gasoline과 this의 gasoline을 구분해야하는 경우
                Console.Write(“Car 가솔린 “);
            if (this.gasoline)
                Console.Write(“SedanCar 가솔린 “);
            Console.WriteLine(“바퀴 {0} 승용차가 굴러다닌다”, wheel);
        }

        static void Main(string[] args)
        {
            // error CS1540: ‘Car’형식의 한정자를 통해 보호된 ‘Car.Car()’ 멤버에 액세스할 수 없습니다. 한정자는 ‘Sedan’ 형식이거나 여기에서 파생된 형식이어야 합니다.
            //Car myCar = new Car();    // 기반 클래스 생성자 Car()는 상속되지 않음. 따라서 new를 이용하여 객체를 생성할 수 없음.
            //myCar.Move();             //  myCar 객체없이 myCar.Move() 호출할 수 없음
            //Console.WriteLine(“마이카의 바퀴는 {0}개 이다.”, myCar.wheel); // myCar 객체없이 myCar.wheel 호출할 수 없음

            // 바퀴 4개 디젤 자동차
            Sedan myCar1 = new Sedan();
            myCar1.Move();       // Car를 상속받았기 때문에 Move() 메소드를 사용할 수 있음
            myCar1.SedanMove();  // Sedan 자신의 메소드 사용가능
            Console.WriteLine(“마이카의 바퀴는 {0}개 이다.”, myCar1.wheel); // 상속된 객체에서 기반 객체의 protected 멤버 필드 호출가능

            Console.WriteLine();

            // 바퀴 6개 가솔린 자동차
            Sedan myCar2 = new Sedan(6);
            myCar2.Move();       // Car를 상속받았기 때문에 Move() 메소드를 사용할 수 있음
            myCar2.SedanMove();  // Sedan 자신의 메소드 사용가능
            Console.WriteLine(“마이카의 바퀴는 {0}개 이다.”, myCar2.wheel); // 상속된 객체에서 기반 객체의 protected 멤버 필드 호출가능
        }
    }

class BankAccount
    {
        double balance;
        string name;
        static double interest;

        public BankAccount() : this(1000, “HCI”)
        {
        }

        public BankAccount(double balance, string name)
        {
            this.balance = balance;
            this.name = name;
            BankAccount.interest = 0.7; // 0.7%
        }

        public void Deposit(double amount)
        {
            balance = balance + amount;
        }

        public void Withdrawl(double amount)
        {
            balance = balance – amount;
        }

        public void Print()
        {
            Console.WriteLine(“{0}의 계좌 잔고는 {1}”,
                name, balance + balance * BankAccount.interest * 0.01);
        }

        public static void InterestRate(double interest)
        {
            BankAccount.interest = interest;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            BankAccount b = new BankAccount(5000, “HCI222222222222”);
            b.Print();

            b.Deposit(1000);
            b.Print();

            b.Withdrawl(500);
            b.Print();

            BankAccount.InterestRate(1.5); // 1.5%
            b.Print();

            BankAccount b2 = new BankAccount();
            b2.Print();
        }
    }

// const
public const int Millennium = 2000;
public const double PI = 3.141592;

// readonly
public static readonly int ThisYear = 2010;
public class MyClass
{
    public readonly double PI;
    public MyClass()
    {
        PI = 3.141592;
    }
}