namespace AbstractClassEx
{
abstract class MyAbstractClass
{
protected void protectedMethod()
{
Console.WriteLine("์ถ์ํด๋์ค์ protected method");
}
public void publicMethod()
{
Console.WriteLine("์ถ์ํด๋์ค์ public method");
}
public abstract void abstractMethod();
// ์ธํฐํ์ด์ค์์๋ ์ถ์๋ฉ์๋๊ฐ ๊ธฐ๋ณธ์ ์ผ๋ก public์ด๊ธฐ ๋๋ฌธ์ ๋ฐํํ์
๋ง ์ฌ์ฉํ์ง๋ง
// ์ถ์ํด๋์ค์์๋ ์ถ์๋ฉ์๋์ ์ ํ์ ๋ฐ abstract ํค์๋๋ฅผ ์ฌ์ฉํด์ค์ผ ํ๋ค.
}
class Child : MyAbstractClass
{
public override void abstractMethod()
// ์ด๋ override ํค์๋๋ฅผ ์ฌ์ฉํ์ฌ ์ถ์ํด๋์ค ๋ด ์ถ์๋ฉ์๋๋ฅผ ์ฌ์ ์ํ๋ค.
{
Console.WriteLine("์ถ์ํด๋์ค์ AbstractMethod ํธ์ถ");
protectedMethod();
}
}
class Program
{
static void Main(string[] args)
{
MyAbstractClass ma = new Child();
ma.abstractMethod();
ma.publicMethod();
}
}
}
Output
์ถ์ํด๋์ค์ AbstractMethod ํธ์ถ
์ถ์ํด๋์ค์ protected method
์ถ์ํด๋์ค์ public method
์ถ์ํด๋์ค
: ์ธํฐํ์ด์ค์ ๋น์ทํ๋ค ํ์ง๋ง, ์ถ์ํด๋์ค
๋ ๊ตฌํ(๋ชธํต)๋ถ
๋ฅผ ๊ฐ์ง ์ ์๋ค. = ๊ตฌํ๋ถ๋ฅผ ์๊ฐ์ง ์๋ ์๋ค.
- ์ถ์ํด๋์ค๋ ๊ตฌํ์ ๊ฐ์ง ์ ์์ง๋ง ์ธ์คํด์ค๋ฅผ ๋ง๋ค ์ ์๋ค.
- ์ฌ์ฉํ๋ ํ์ ์๋ abstract์ class๋ฅผ ์ฌ์ฉํ๋ค.
์ถ์ํด๋์ค ์ ์ธ ํ์
abstract class ํด๋์ค๋ช
{
...
// ํด๋์ค์ ๋์ผ
}
์ถ์ ํด๋์ค
๋ ํด๋์ค
์ ๋ฌ๋ฆฌ ์ถ์๋ฉ์๋
๋ฅผ ๊ฐ์ง๊ณ ์๋ค.
์ถ์ ํด๋์ค
๋ ๋ชจ๋ ๋ฉค๋ฒ์ ์ ๊ทผ ์ ํ์๋ฅผ ์ฌ์ฉํ์ง ์์ ๊ฒฝ์ฐ private์ผ๋ก ์ค์
๋๋ค.
- ๋จ, ์ถ์๋ฉ์๋๋ ์๋จ. ๊ตฌํ๋ถ๊ฐ ์๋ ๋ฉ์๋์ ํ์ ํ์ฌ private์ผ๋ก ์ค์ ๋๋๊ฒ.
์ถ์ ๋ฉ์๋
๋ฅผ ์ง์ ํ ๋ abstract
ํค์๋๋ฅผ ์ฌ์ฉํ๋ค.
์ถ์๋ฉ์๋์ ํ์
public abstract void A();
- ์ถ์ ๋ฉ์๋๋
private
์ ์ฌ์ฉํ ์ ์๋ค => ์ธ๋ถ์์ ๊ตฌํํ์ฌ ์ฌ์ฉํด์ผํ๊ธฐ ๋๋ฌธ์
- ๋ฐ๋ผ์
public
, protected
, internal
, protected internal
์ค ํ๋๋ฅผ ์ฌ์ฉํด์ผํ๋ค.
override
ํค์๋๋ฅผ ์ฌ์ฉํ์ฌ ์ถ์ํด๋์ค
๋ด ์ถ์๋ฉ์๋
๋ฅผ ์ฌ์ ์
ํ๋ค.