[JAVA.11] 상속(Inheritance)🐇

• 객체지향의 꽃은 바로 재활용일 것이다.
  상속은 객체지향의 재활용성을 극대화시킨 프로그래밍 기법이라고 할 수 있다.
  효율성을 위한 프로그래밍이라 사고력이 필요하며 어려운 내용이기도 하다.

<Step.1> 상속(Inheritance)

• 상속(Inheritance)이란 물려준다는 의미가 있다.
  어떤 객체가 있을 때 그 객체의 변수와 메소드를
  다른 객체가 물려 받을 수 있는 기능을 말한다.

• 여기서 Unit 클래스는 부모를 뜻하고 Marine Medic Firebat은 자식을 뜻한다.

• 상속을 표현하기 위해선 extends를 붙인다.
  

<Step.2> 상속관계에 있는 클래스의 객체 생성

부모 클래스를 호출하기 위해선 부모 클래스의 생성자가 오버라이딩(재정의) 되어야 한다
ㄴsuper()을 통해 상속관계에 있는 부모클래스의 생성자를 호출할 수 있다.

• 상속 관계에서 자식 클래스의 변수 삽입시 반드시 부모클래스의 생성자가 호출이 된다.

접근지정자에 따라 protected와 public은 상속 관계에서 접근이 가능하나
private은 getter/setter에 의한 간접접근 외에 접근이 불가능하다.

<Step.3> 오버라이딩(Overriding)

• 부모것을 덮어 쓴것, 재정의 또는 변경하는 것을 말한다.
  ㄴ메소드를 정의하여 덮어쓰는 것이다. 반환값의 형도 같아야만 한다.
  ㄴ단, final은 클래스든 메소드든 변수든 오버라이딩을 할 수 없다.

★ 오버라이딩의 목적
1. 부모 클래스 메서드의 기능 변경
2. 부모 클래스 메서드의 기능 추가

showState()는 자식 클래스에서 오버라이딩되었다. (바꾼 것이다)
스피커의 볼륨의 크기를 베이스의 볼륨의 크기로 변경한 것(재정의) => 오버라이딩

• 클래스 B는 부모 클래스 A를 오버라이딩하고
  클래스 C는 클래스B를 오버라이딩했다.
  클래스 A B C를 출력하면 전체 C 클래스의 출력문만 나온다.
  ★ 오버라이딩으로 인해 A와 B가 모두 가려졌기 때문이다

<Step.4> 가변인자(Variable Arguments)

• 오버로딩을 대채할 수 있는 문법이다.
• 메소드의 여러가지의 호출 형식으로 대체할 수 있다.

ㅁ public PrintStream printf(String format, Object ...args) { ... }
ㄴ매개변수의 개수를 동적으로 지정해주는 방법이다.
ㄴ매개변수가 몇개가 올지 모르는 변수로 둔다는 뜻이다.

ㅁ 사용법(규칙):
1. 가변인자를 매개변수 중 제일 마지막에 사용해야 한다
ㄴ가변인자를 앞에 두면 메소드에서 매개변수를 가지고 올 때
ㄴ어디까지가 가변인자인지 구분을 할 수 없게 되므로 오류 발생
2. 같은 형식의 매개변수가 존재하는 오버로딩에서는 피해야 한다
ㄴ호출하여 전달해줄때 어떤 메소드로 전달해야하는지 애매모호해져서 오류 발생

<Step.5> 추상 클래스(Abstract Class)

• 기능 구현이 없이 호출방법(이름)만 클래스에 표시된 클래스이다.
  ㄴ무조건 오버라이딩해서 재정의하여 사용해야만 한다.
• 추상 클래스는 어떻게 동작해야 하는지 알 수 없으므로 객체를 생성할 수 없다.
  즉, new를 사용 할 수 없다.
  

<Step.6> 인터페이스(Interface)

• 상속 관계가 아닌 클래스에 기능을 제공하는 구조이다.
  

• 인터페이스의 특징

1. 인터페이스끼리 상속도 가능하다
2. 인터페이스가 일반 클래스를 상속할 수는 없다.
3. Java는 다중상속이 없다. 인터페이스는 기능만 있어 다중상속이 가능하다.
4. 인터페이스로 선언한 변수는 public static final로 선언한다.

<Step.7> 추상 클래스와 인터페이스

• 그렇다면 인터페이스와 추상 클래스의 차이가 무엇일까?

1. 추상클래스는 오버라이딩을 통해 재정의하여 사용해야 하며 상속과 관련이 있다.
2. 인터페이스는 단순히 기능만을 의미한다.
3. 추상클래스는 다중상속이 불가능하지만, 인터페이스는 다중 상속이 가능하다.
4. 추상클래스는 상속 관계를 쭉 타고 올라갔을때 같은 조상클래스를 상속하는데
   기능까지 완변히 똑같은 기능이 필요한 경우 주로 사용한다.
5. 인터페이스는 상속 관계를 쭉 타고 올라갔을때 다른 조상클래스를 상속하는데
   같은 기능이 필요할 경우 인터페이스 사용한다.
6. 추상클래스는 IS - A "~이다"식으로 해석된다.
7. 인터페이스는 HAS - A "~을 할 수 있는"식으로 해석된다.

• (추상클래스)는 해당 추상클래스를 상속받아서 기능을 이용하고 확장시키는데 목적
• (인터페이스)는 함수의 껍데기만 있고 그 함수의 구현을 강제한다

• 그렇다면 인터페이스와 추상 클래스의 공통점은 무엇일까?

1. 추상 메소드를 가지고 있어야 한다.
2. 인스턴스화 할 수 없다 (new 생성자 사용 X)
3. 인터페이스 혹은 추상 클래스를 상속받아 구현한 구현체의 객체를 사용해야 한다.
4. 인터페이스와 추상클래스를 구현, 상속한 클래스는 추상 메소드를 반드시 구현하여야 한다.

<Step.8> 다형성(polymorphism)

• 하나의 객체가 여러 가지 타입을 가질 수 있는 것을 의미
• 동일한 조작방법으로 동작시키지만 동작방법은 다른 것.
  ㄴ키보드를 누른다 → 결과는 다 다르다는 것과 같음.
• 자바에선 대표적으로 오버로딩, 오버라이딩, 업캐스팅, 다운캐스팅,
  인터페이스, 추상메소드, 추상클래스가 모두 다형성에 해당한다.

• 다형성의 장점

1. 유지보수 : 여러 객체를 하나의 타입으로 관리할 수 있어 유지보수가 용이하다.
2. 재사용성 : 객체의 재사용이 쉬워 재사용성이 높아진다.
3. 느슨한 결합 : 클래스 간의 의존성을 줄여 확장성은 높아지고 결합도는 낮아진다.

• 다형성의 활용
  카페에서 커피를 주문하는 것을 예로 Coffee 클래스에는 가격 정보를 담고 있다.
  Coffee 클래스를 상속받는 Amercano 클래스와 CaffeLatte 클래스가 존재한다.
  손님은 5만 원을 가지고 있다고 가정한다.

class Coffee {
    int price;

    public Coffee(int price) {
        this.price = price;
    }
}

class Americano extends Coffee {
    public Americano() {
        super(4000); // 상위 메서드 생성자 호출
    }
    // Object 클래스 toString() 메서드 오버라이딩
    public String toString() { 
        return "아메리카노";
    }
}

class CaffeLatte extends Coffee {
    public CaffeLatte() {
        super(5000);
    }
    // Object 클래스 toString() 메서드 오버라이딩
    public String toString() {
        return "카페라떼";
    }
}

class Customer {
    int money = 50000;

    // 커피 구매 메서드(다형성 활용)
    void buyCoffee(Coffee coffee) {
        if (money < coffee.price) {
            System.out.println("잔액이 부족합니다.");
            return;
        }
        money -= coffee.price;
        System.out.println(coffee + "를 구매하였습니다.");
    }

    /* 아메리카노, 카페라떼 구매 메서드를 따로 구현하지 않아도 됨
    (생략가능하므로 주석처리)
    void buyCoffee(Americano americano) {
        money -= americano.price;
    }

    void buyCoffee(CaffeLatte caffeLatte) {
        money -= caffeLatte.price;
    } */
}
public class PolymorphismEx {
    public static void main(String[] args) {
        Customer me = new Customer();
        me.buyCoffee(new Americano());
        me.buyCoffee(new CaffeLatte());

        System.out.println("현재 잔액: " + me.money);
    }
}

• 다형성 사용의 효과

1. 개별적인 커피의 구매 메서드를 따로 구현하지 않고,
   상위 클래스인 Coffee의 자료형을 매개변수로 전달받으면,
   하위 클래스 타입의 참조 변수는 매개변수로 전달될 수 있다.
2. 반복적인 코드를 줄일 수 있다.

<Step.9> Instanceof 연산자

객체가 어떤 클래스인지, 어떤 클래스를 상속받았는지 확인하는데 사용하는 연산자

class A { }
class B extends A { }   

public static void main(String[] args) {
  A mc1 = new A();
  B mc2 = new B();

  // mc1변수는 A 클래스에게 상속받았나요? true 출력
  System.out.println(mc1 instanceof A);   
  // mc2변수는 A 클래스에게 상속받았나요? A를 상속 받았기 때문(true 출력)
  System.out.println(mc2 instanceof A); 
  // mc1변수는 B 클래스에게 상속받았나요? false 출력
  System.out.println(mc1 instanceof B);   
  // mc2변수는 B 클래스에게 상속받았나요? true 출력
  System.out.println(mc2 instanceof B);   

• 모든 클래스는 Object를 상속하기 때문에 Object Instanceof Object 는
  ㄴ항상 true라는 값이 나온다.

<Step.10> 발전을 위한 문제풀이 (kama_code 출제)

1. 상속관계에 놓여있는 클래스의 생성자 정의 및 호출방식을 기본으로
   남은 고기량(돼지고기 180g, 소고기 600g, 양고기 540g)을 출력하는 메인 메소드를 정의하시오.
2. 사용자로부터 입력을 받아 상속관계에 있는 두 클래스를 만들어 적절한 생성자와 함께
   이름, 나이, 주소, 전화번호를 인자로 출력되는 프로그램을 만드시오.
3. 가로와 세로를 사용자로부터 입력을 받아서
   정사각형을 의미하는 Square클래스와 직사각형을 의미하는 Rectangle클래스를 정의하고
   둘의 면적을 출력하는 프로그램을 만드시오.
4. 불고기버거 단품 4500원, 식재료: 쇠고기패티, 케찹, 피클, 세트구매시
   콜라 1000원, 감자튀김 1500원 고정으로 추가
   치킨버거 단품 4200원, 식재료 닭고기패티, 마요네즈, 양상추,
   세트구매시 500원 할인이 되는
   클래스의 상속 관계를 사용하여 출력되는 프로그램을 만드시오.
5. 사용자로부터 이름을 입력받아 캐릭터를 생성하고 다양한 몬스터와 전투를 펼쳐
   아이템을 떨어뜨리는 간단한 RPG 게임을 만드시오.

★ 정답 및 해설 ☆

1. 기본적인 상속을 사용한 코드이다.

/*
상속관계에 놓여있는 클래스의 생성자 정의 및 호출방식을 기본으로 
남은 고기량(돼지고기 180g, 소고기 600g, 양고기 540g)을 출력하는 메인 메소드를 정의하시오.
*/

class Meat // 부모 클래스 Meat
{		
	int pig; // int형 pig 변수
	public Meat(int pig) // 생성자 오버라이딩(매개변수 pig)
	{
		this.pig=pig; // 자신의 객체 접근
	}	
}
class Cow extends Meat // Meat에 상속된 Cow 자식 클래스
{
	int cow; // int형 cow 변수
	public Cow(int pig, int cow)
	{
		super(pig); // 부모 클래스로 pig를 보냄
		this.cow = cow; // 자신의 객체 접근
	}
}

class Sheep extends Cow
{
	int sheep;
	public Sheep(int pig, int cow, int sheep)
	{
		super(pig, cow);
		this.sheep = sheep;
	}

	public void show()
	{
		System.out.println("남은 돼지고기: "+ pig + "g");
		System.out.println("남은 소고기: "+ cow + "g");
		System.out.println("남은 양고기: "+ sheep + "g");
	}

}
public class Put01
{
	public static void main(String[] args)
	{
		Sheep first = new Sheep(180,600,540);
		first.show();
	}
}

2. 역시 1번과 마찬가지로 기본적인 상속을 사용한 코드이다.

/*
사용자로부터 입력을 받아 상속관계에 있는 두 클래스를 만들어 적절한 생성자와 함께
이름, 나이, 주소, 전화번호를 인자로 출력되는 프로그램을 만드시오.
*/

import java.util.Scanner;

class Person01
{
	public String name;
	int age;
	
	public Person01(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
    
	public void PersonShow()
	{
		System.out.println("=====================");
		System.out.println("이름: "+name);
		System.out.println("나이: "+age);
	}
}

class Person02 extends Person01
{
	private String address;
	private String number;
	
	public Person02(String name,int age,String address, String number)
	{
		super(name,age);
		this.address = address;
		this.number = number;
	}
	
	public void show()
	{
		PersonShow();
		System.out.println("주소: "+address);
		System.out.println("전화번호: "+number);
		System.out.println("=====================");
	}
}

public class Put02
{
	public static void main(String[] args)
	{
		Scanner scan = new Scanner(System.in);
		System.out.println("이름 입력: ");
		String name = scan.nextLine();
		System.out.println("주소 입력: ");
		String address = scan.nextLine();
		System.out.println("전화번호 입력: ");
		String number = scan.nextLine();
		System.out.println("나이 입력: ");
		int age = scan.nextInt();
		Person02 info = new Person02(name, age, address, number);
		info.show();
	}
}

3. 역시 기본적인 상속을 이용한 코드이다.

/*
가로와 세로를 사용자로부터 입력을 받아서 
정사각형을 의미하는 Square클래스와 직사각형을 의미하는 Rectangle클래스를 정의하고
둘의 면적을 출력하는 프로그램을 만드시오.
*/

class Square // 정사각형 부모 클래스
{
	// 멤버 변수
	private int x; // 한변 정보 은닉
	
	public Square(int x) // 생성자
	{
		this.x=x;
	}	
	public void ShowSquare()
	{
		System.out.println("정사각형의 면적: "+x*x);
	}
}

class Rectangle
{
	// 멤버 변수
	private int width; // 가로 정보 은닉
	private int height; // 세로 정보 은닉
	
	public Rectangle(int width, int height) // 생성자
	{
		this.width = width;
		this.height = height;
	}
	
	public void ShowRectangle()
	{
		System.out.println("직사각형의 면적: "+width*height);
	}
}

public class Put03
{
	public static void main(String[] args)
	{
		Scanner scan = new Scanner(System.in);
		System.out.println("직사각형의 가로: ");
		int w = scan.nextInt();
		System.out.println("직사각형의 세로: ");
		int h = scan.nextInt();
		System.out.println("정사각형의 한 변: ");
		int j = scan.nextInt();
       	Rectangle rec = new Rectangle(w,h);
       	rec.ShowRectangle();

 		Square sqr = new Square(j);
       	sqr.ShowSquare();	
	}
}

4. 조금 복잡해진 프로그램이다. 프로그램은 이벤트 또는 친절이 들어가면
   난이도가 상승한다.
   중요한 건 기능이 있다면 놓치지 말고 하나하나 추가하는 것이다.
   치킨 버거는 세트를 주문시 500원을 할인하는데
   super.price()-500 => 부모 클래스의 계산식에서 500원 할인하는 포인트 중요하다.
   결국 상속은 왔다갔다 하면서 재활용을 잘 사용하는데 중요성이 있다.

/*
불고기버거 단품 4500원, 식재료: 쇠고기패티, 케찹, 피클, 세트구매시 
콜라 1000원, 감자튀김 1500원 고정으로 추가
치킨버거 단품 4200원, 식재료 닭고기패티, 마요네즈, 양상추, 
세트구매시 500원 할인이 되는
클래스의 상속 관계를 사용하여 출력되는 프로그램을 만드시오.
*/

//햄버거를 추상화
class Burger
{
	/*
	 * 멤버변수 : 버거명, 가격, 패티, 소스, 야채 인자생성자 멤버메소드 : 
	 * 가격반환(getter), 햄버거정보출력
	 */
	private String burgerName; //버거명 정보 은닉
	private int price; //버거명 정보 은닉
	private String patty; //패티 정보 은닉
	private String sauce; //소스 정보 은닉
	private String vegetable; //야채 정보 은닉

	// 인자생성자
	public Burger(String burgerName, int price, String patty, String sauce, String vegetable)
	{
		super();
		this.burgerName = burgerName;
		this.price = price;
		this.patty = patty;
		this.sauce = sauce;
		this.vegetable = vegetable;
	}

	// getter/setter : private으로 간접 접근하기 위해
	public String getBurgerName()
	{
		return burgerName;
	}

	public void setBurgerName(String burgerName)
	{
		this.burgerName = burgerName;
	}

	public int getPrice()
	{
		return price;
	}

	public void setPrice(int price)
	{
		this.price = price;
	}

	public String getPatty()
	{
		return patty;
	}

	public void setPatty(String patty)
	{
		this.patty = patty;
	}

	public String getSauce()
	{
		return sauce;
	}

	public void setSauce(String sauce)
	{
		this.sauce = sauce;
	}

	public String getVegetable()
	{
		return vegetable;
	}

	public void setVegetable(String vegetable)
	{
		this.vegetable = vegetable;
	}

	// 햄버거 정보 출력
	public void showBurger()
	{
		System.out.println(burgerName);
		System.out.println("가격:" + price);
		System.out.printf("식재료:%s, %s, %s\n", patty, sauce, vegetable);
	}

}

// 햄버거의 기본가격 추상화
class HamburgerPrice
{
	// 멤버변수
	Burger burger;// 디폴트(default) 접근지정자로 설정
	final int COKE = 1000; // 최종 상수처리 
	final int POTATO = 1500; // 최종 상수처리 

	// 인자생성자 : 상수는 이미 초기화되어 있으므로 햄버거 객체만 초기화한다.
	public HamburgerPrice(Burger burger)
	{
		this.burger = burger;
	}

	// 기본가격계산 : 햄버거 + 콜라 + 프렌치프라이 가격의 합
	public int price()
	{
		// 햄버거의 price는 private 이므로 getter를 통해 가져와야 함.
		int total = burger.getPrice() + COKE + POTATO;
		return total;
	}

	// 햄버거와 결제금액 출력
	public void showPrice()
	{
		burger.showBurger();// 햄버거의 정보 출력
		System.out.println("세트결제금액:" + price());
		System.out.println("==========================");
	}
}

// 햄버거의 세트가격 (기본가격을 상속)
class SetPrice extends HamburgerPrice
{

	// 인자생성자
	public SetPrice(Burger burger)
	{
		// 부모클래스에 정의된 인자생성자 호출
		super(burger);
	}

	// 세트가격계산(오버라이딩) : 500원 할인된 가격으로 계산함.
	@Override
	public int price()
	{
		// 부모의 기본가격 계산식에서 500원 차감
		return super.price() - 500;
	}

	// 햄버거와 세트가격을 출력(오버라이딩)
	@Override
	public void showPrice()
	{
		// 디폴트 접근지정자는 동일 패키지에서는 접근을 허용함.
		burger.showBurger();
		System.out.println("세트할인금액:" + price());
		System.out.println("============================");
	}
}

public class Put04
{
	public static void main(String[] args)
	{

		// 치즈버거 객체 생성
		Burger burger1 = new Burger("불고기버거", 4500, "쇠고기패티", "케챱", "피클");
		// 치킨버거 객체 생성
		Burger burger2 = new Burger("치킨버거", 4200, "닭고기패티", "마요네즈", "양상추");

		// 치즈버거를 기본가격으로 구매
		HamburgerPrice price1 = new HamburgerPrice(burger1);
		price1.showPrice(); // 4500원

		// 치킨버거를 세트가격으로 구매
		HamburgerPrice price2 = new SetPrice(burger2);
		price2.showPrice(); // 4200원
	}
}

5. 코드와 클래스가 굉장히 많고 길다.
   게임을 만드는데는 원래 어마어마한 코드가 필요하다.
   자바에서 핵심은 클래스를 한 파일안에 모두 몰아넣을 수 있지만
   클래스는 반드시 다른 파일에 나누어서 하나씩 담는 것이 개발에 헤깔리지도 않을뿐더러
   장점이 많다.

핵심은 상속! 큰 그룹이 무엇이며, 그 안에 어떠한 상속 관계에 있는 클래스들이 있는지를
짜야한다. 그 다음 그 그룹 클래스마다 작은 디테일한 기능들을 만들어주면 된다.

• 게임의 메인 코드이다. 패키지명 Main 안에 만들어준다.

package Main;

import java.util.Scanner;

import Character.*;

import Map.*;

public class GameMain {

	public static void main(String[] args) {
		// 사용자로부터 입력을 받는다.
		Scanner sc = new Scanner(System.in);
		// hero 객체를 생성
		Hero hero = new Hero();
		// 메뉴
		System.out.println("*******RPG GAME*******");
		System.out.println("1. 전사");
		System.out.println("2. 마법사");
		System.out.println("3. 궁사");
		System.out.printf("직업의 번호를 입력하세요. : ");
		int num = sc.nextInt();
		
		// 1번, 전사를 선택시 초기화 셋팅
		if(num == 1) {
			
			System.out.println("전사가 선택되었습니다.");
			hero = new Warrior(); // 캐릭터는 전사
			hero.defense = 25; // 방어력
			hero.power = 15; // 공격력
			hero.level = 1; // 레벨
			hero.hp = 80; // 체력
			hero.mp = 0; // 마력
			
		}
		// 2번, 마법사를 선택시 초기화 셋팅
		else if(num == 2) {
			
			System.out.println("마법사가 선택되었습니다.");
			hero = new Magician();// 캐릭터는 마법사
			hero.defense = 10; // 방어력
			hero.power = 18; // 공격력
			hero.level = 1; // 레벨
			hero.hp = 60; // 체력
			hero.mp = 60; // 마력
		
		}
		// 3번, 궁사를 선택시 초기화 셋팅
		else if(num == 3) {
			
			System.out.println("궁사가 선택되었습니다.");
			hero = new Archer();// 캐릭터는 궁사
			hero.defense = 5; // 방어력
			hero.power = 20; // 공격력
			hero.level = 1; // 레벨
			hero.hp = 50; // 체력
			hero.mp = 0; //마력
		
		}
		
		// 이름을 선택할 값을 받는다.
		System.out.printf("영웅의 이름을 입력하세요. : ");
		hero.name = sc.next();
		System.out.println("이름이 정상적으로 입력되었습니다.");
		System.out.println("게임에 입장하였습니다.");
		
		// 게임 틀에서 나가지 못하도록 무한루프
		while(true) {
			
			System.out.println("*********************");
			System.out.println("현재 "+ hero.name + "의 이름 : " + hero.name);
			System.out.println("현재 "+ hero.name + "의 레벨 : " + hero.level);
			System.out.println("현재 "+ hero.name + "의 힘 : " + hero.power);
			System.out.println("현재 "+ hero.name + "의 방어력 : " + hero.defense);
			System.out.println("현재 "+ hero.name + "의 HP : " + hero.hp);
			System.out.println("현재 "+ hero.name + "의 MP : "  + hero.mp);
			System.out.println("현재 "+ hero.name + "의 경험치 : "  + hero.experience);
			System.out.println("현재 "+ hero.name + "의 돈 : "  + hero.money + "원");
			System.out.println("*********************");
			
			System.out.println("1. 사냥터");
			System.out.println("2. 무기 상점");
			System.out.println("3. 포션 상점");
			System.out.printf("입장할 장소를 입력하세요. : ");
			num = sc.nextInt();
			
			// 사냥터 입장
			if(num == 1) {
				// 몬스터 객체 생성
				Monster monster = new Monster();
				System.out.println("사냥터에 입장하였습니다.");
				System.out.println("1. 너구리");
				System.out.println("2. 살쾡이");
				System.out.println("3. 들개");
				System.out.println("4. 멧돼지");
				System.out.printf("사냥한 몬스터를 입력하세요. : ");
				num = sc.nextInt();
				
				// 너구리 몬스터 초기화
				if(num == 1) {
					
					monster = new Racoon();
					monster.name = "너구리";
					monster.hp = 100;
					monster.mp = 0;
					monster.level = 1;
					monster.power = 20;
					monster.defense = 5;
					monster.money = 10;
					monster.experience = 10;
					System.out.println(monster.name + "과 전투를 시작합니다.");
				}
				
				// 살쾡이 몬스터 초기화
				if(num == 2) {
					
					monster = new WildCat();
					monster.name = "살쾡이";
					monster.hp = 2000;
					monster.mp = 0;
					monster.level = 5;
					monster.power = 100;
					monster.defense = 20;
					monster.money = 30;
					monster.experience = 50;
					System.out.println(monster.name + "과 전투를 시작합니다.");
				}
				
				// 들개 몬스터 초기화
				if(num == 3) {
					
					monster = new WildDog();
					monster.name = "들개";
					monster.hp = 3000;
					monster.mp = 0;
					monster.level = 15;
					monster.power = 300;
					monster.defense = 30;
					monster.money = 50;
					monster.experience = 100;
					System.out.println(monster.name + "과 전투를 시작합니다.");
				}
				
				// 멧돼지 몬스터 초기화
				if(num == 4) {
					
					monster = new WildPig();
					monster.name = "멧돼지";
					monster.hp = 10000;
					monster.mp = 0;
					monster.level = 30;
					monster.power = 1000;
					monster.defense = 80;
					monster.money = 200;
					monster.experience = 300;
					System.out.println(monster.name + "과 전투를 시작합니다.");
				}
				// 공격의 틀을 벗어나지 못하도록 무한루프
				while(true) {
					
					System.out.println(hero.name + "의 공격입니다.");
					// 여기서 처리하기 위해서 호출한다.
					monster.attacked(hero.attack()); 
					
					// 몬스터의 체력이 0이면
					if(monster.hp <= 0) {
						
						System.out.println(monster.name + "가 죽었습니다.");
						// 경험치와 돈이 증가
						hero.experience += monster.experience;
						hero.money += monster.money;
						break;
					}
					
					System.out.println(monster.name + "의 공격입니다.");
					// 여기서 처리하기 위해서 호출한다.
					hero.attacked(monster.attack());
					
					// 죽으면 게임을 이어나가기 위해 체력 1로 부활한다
					if(hero.hp <= 0) {
						
						System.out.println(hero.name + "이 죽었습니다.");
						hero.hp = 1;
						System.out.println(hero.name + "이 체력" + hero.hp + "으로 부활했습니다.");
						break;
					}
				}
				// 무기 상점
			}else if(num == 2) {
				// 무기상점 객체 생성
				WeaponStore weaponstore = new WeaponStore();
				System.out.println("무기 상점에 입장하였습니다.");
				System.out.println("1. 공동 무기 (50원)");
				System.out.println("2. 공동 방패 (50원)");
				System.out.println("현재 돈이 " + hero.money  + "있습니다.");
				System.out.printf("원하시는 물건을 입력하세요. : ");
				
				num = sc.nextInt();
				// 상점 거래를 위해 플레이어의 돈을 temp 변수에 넣는다.
				int temp = hero.money;
				
				// 플레이어의 돈이 음수가 아닐 경우 구매가 가능
				if((hero.money = weaponstore.show(hero.money,num)) != -1) 
				{
					
					System.out.println("구입이 완료되었습니다.");
					// 무기를 구매할 경우
					if(num == 1) {
						// 공격력 5가 증가
						hero.power += 5;
					}
					// 방패를 구매할 경우
					if(num == 2) {
						// 방어력 5가 증가
						hero.defense += 5;
						
					}
					
					System.out.println(temp + "원 남았습니다.");
					
				}else {
					System.out.println("돈이 부족합니다.");
					System.out.println(temp + "원 남았습니다.");
				}
				// 포션 상점 입장
			}else if(num == 3) {
				
				// 포션 상점 객체 생성
				PotionStore potionstore = new PotionStore();
				System.out.println("포션 상점에 입장하였습니다.");
				System.out.println("1. 공격력 증가 포션 (30원)");
				System.out.println("2. 방어력 증가 포션 (30원)");
				System.out.println("3. 경험치 증가 포션 (100원)");
				System.out.println("4. HP 증가 포션 (10원)");
				System.out.println("5. MP 증가 포션 (10원)");
				System.out.printf("원하시는 물건을 입력하세요. : ");
				
				// 입력값을 int 정수 num 변수에 저장한다.
				num = sc.nextInt();
				// 돈을 temp 에 역시 넣는다.
				int temp = hero.money;
				// 플레이어의 돈이 음수가 아닐 경우 구매가 가능
				if((hero.money = potionstore.show(hero.money,num)) != -1) {
					
					System.out.println("구입이 완료되었습니다.");
					
					
					if(num == 1) {
						// 공격력 증가 +3 
						hero.power += 3;
					}
					
					if(num == 2) {
						// 방어력 증가 +3 
						hero.defense += 3;	
					}
					if(num == 3) {
						// 경험치 증가 +50 
						hero.experience += 50;	
					}
					if(num == 4) {
						// 체력 증가 +50 
						hero.hp += 50;
					}
					if(num == 5) {
						// 마력 증가 +50 
						hero.mp += 50;
					}
					
					System.out.println(temp + "원 남았습니다.");
					
				}else {
					System.out.println("돈이 부족합니다.");
					System.out.println(temp + "원 남았습니다.");
				}
			}
			// 레벨에 x80한만큼 경험치를 가지고 있을 경우를 레벨업 기준
			if(hero.experience  >= hero.level * 80) 
			{
				// 레벨이 1 오른다.
				hero.level += 1;
				System.out.println(hero.name + "의 레벨이" + hero.level + "이 되었습니다.");
				// 돈은 레벨의 x50한 만큼 준다
				hero.money += hero.level * 50;
				System.out.println("레밸업 기념으로 돈이 " + hero.level * 50 + "원 증가하여 ");
				System.out.println(hero.money + "원이 되었습니다.");
				hero.experience = 0; // 경험치 초기화
			}
			
		}
	}
}		

• Map 클래스이다. 패키지명 Map을 먼저 만들어주고 그 안에 만들어주는 것 주의!

package Map;
// 지도 클래스는 이름을 반환한다
public class Map {
	String  name;
}

• PotionStore 클래스이다. 패키지명 Map을 먼저 만들어주고 그 안에 만들어주는 것 주의!

package Map;
//Map 부모 클래스에 상속된 PotionStore
public class PotionStore extends Map
{
	// 멤버 변수와 초기화를 직접한다
	int powerPotion = 30;
	int defensePotion = 30;
	int experiencePotion = 100;
	int hpPotion = 10;
	int mpPotion = 10;
	
	// 멤버 메소드
	public int show(int money, int num) 
	{
		
		name = "포션 상점";
		System.out.println(name + "에서 물건을 구매 시도하는 중입니다.");
		// 힘포션을 샀을때
		if(num == 1) 
		{
			// 돈이 있어야 하며
			if(powerPotion <= money) 
			{
				// 가진 돈에서 값을 뺀다
				return money - powerPotion;
			}
		}
		
		if(num == 2) {
			if(defensePotion <= money) {
				return money - defensePotion;
			}
		}
		
		if(num == 3) 
		{
			if(experiencePotion <= money) 
			{
				return money - experiencePotion;
			}
		}
		
		if(num == 4) 
		{
			if(hpPotion <= money) 
			{
				return money - hpPotion;
			}
		}
		
		if(num == 5) 
		{
			if(mpPotion <= money) 
			{
				return money - mpPotion;
			}
		}
		return money;
	}
}

• WeaponStore 클래스이다. 패키지명 Map을 먼저 만들어주고 그 안에 만들어주는 것 주의!

package Map;
//Map 부모 클래스에 상속된 WeaponStore
public class WeaponStore extends Map 
{
	// 직접 초기화한 멤버변수
	int commonWeapon = 50;
	int commonShield = 50;
	
	// 멤버 메소드
	public int show(int money, int num) {
		
		name = "무기 상점";
		System.out.println(name + "에서 물건을 구매 시도하는 중입니다.");
		// 공통 무기를 살 경우
		if(num == 1) {
			// 돈이 있을 경우 -> 가격을 뺀 값을 반환
			if(commonWeapon <= money) {
				return money - commonWeapon;
			}
		}
		
		if(num == 2) {
			if(commonShield <= money) {
				return money - commonShield;
			}
		}
		
		return money;
	}
}

• 패키지명 Character을 먼저 만들어주고 그 안에 만들어주는 것 주의!

package Character;

import java.util.Scanner;

// hero 부모 클래스에 상속된 Archer
public class Archer extends Hero {
	// 멤버 메소드
	public int attack() {
		
		Scanner sc = new Scanner(System.in);
		System.out.println("1. 화살 공격");
		System.out.println("2. 연속 화살 공격");
		System.out.printf("공격 번호를 입력하세요 : ");
		int num = sc.nextInt();
		// 능력치를 0으로 초기화 해 놓는다.
		int sum = 0;
		// 화살공격
		if(num == 1) {
			// 레벨의 15배+공격력 15배+방어력 15배의 데미지로 들어간다.
			sum += level * 15;
			sum += power * 15;
			sum += defense * 15;
			System.out.println("데미지는 " + sum + " 입니다.");
			return sum;
			// 연속 화살 공격
		}else if(num == 2) {
			// 레벨의 10배+공격력 20배+방어력 10배의 데미지로 들어간다.
			sum += level * 10;
			sum += power * 20;
			sum += defense * 10;
			System.out.println("데미지는 " + sum + " 입니다.");
			return sum;
			
		}
		System.out.println("데미지는 " + sum + " 입니다.");
		return sum;
	}
	
	//Archer.attacked을 불렀을 경우
	public void attacked(int sum) {
		// 방어력이 더 크면 피해를 입지 않는다.
		if(defense >= sum) {
			hp = hp - 0;
		}else 
		{
			//체력+방어력에서 데미지를 뺀 값이 체력으로 남는다.
			hp = hp + defense - sum;
		}
	}
}

• 패키지명 Character을 먼저 만들어주고 그 안에 만들어주는 것 주의!

package Character;
// 캐릭터 클래스
public class Character {
// 이름과 hp mp 레벨이 멤버변수로 은닉화
	public String name;
	public int hp;
	public int mp;
	public int level;
}

• 패키지명 Character을 먼저 만들어주고 그 안에 만들어주는 것 주의!

package Character;
//Character 부모 클래스에 상속된 Hero
public class Hero extends Character {
	// 직접적으로 멤버변수 선언과 초기화
	public int power;
	public int defense;
	public int money = 0;
	public int experience = 0;
	// 멤버 메소드를 불렀을때 공격력을 반환
	public int attack() {
		return power;
	}
	//Hero.attacked을 불렀을 경우
	public void attacked(int sum) {
		// 값보다 방어력이 더 크면
		if(defense >= sum) {
			// 피해를 입지 않는다
			hp = hp - 0;
		}else 
		{
			// 그 외는 체력과 방어력을 더한 값에서 데미지만큼 빼서 체력으로 남음
			hp = hp + defense - sum;
		}
	}
}

• 패키지명 Magician을 먼저 만들어주고 그 안에 만들어주는 것 주의!

package Character;

import java.util.Scanner;
//hero 부모 클래스에 상속된 Magician
public class Magician extends Hero {
	// 멤버 메소드
	public int attack() {
		// 능력치를 초기화
		int sum = 0;
		
		// 마력이 10보다 크거나 같을때만 사용 가능
		if(mp >= 10) {
			
			Scanner sc = new Scanner(System.in);
			System.out.println("1. 파이어볼");
			System.out.println("2. 워터볼");
			System.out.printf("공격 번호를 입력하세요 : ");
			int num = sc.nextInt();
		
		// 파이어볼 : 레벨의 10배+공격력의 15배+방어력의 5배가 데미지로
		if(num == 1) {
			
			sum += level * 10;
			sum += power * 15;
			sum += defense * 5;
			System.out.println("데미지는 " + sum + " 입니다.");
			//마력이 5 깎인다
			mp = mp - 5;
			return sum;
			
		// 워터볼 : 레벨의 8배+공격력의 13배+방어력의 10배가 데미지로	
		}else if(num == 2) {
			
			sum += level * 8;
			sum += power * 13;
			sum += defense * 10;
			System.out.println("데미지는 " + sum + " 입니다.");
			//마력이 5 깎인다
			mp = mp - 5;
			return sum;
		}
		
		System.out.println("데미지는 " + sum + " 입니다.");
		return sum;
		
		// 마력이 10보다 작을 경우
		}else 
		{
			System.out.println("MP가 남아있지 않습니다.");
			return sum;
		}
	}
	//Magician.attacked을 불렀을 경우
	public void attacked(int sum) {
		// 방어력이 데미지보다 크면 데미지 없음
		if(defense >= sum) {
			hp = hp - 0;
		}else 
		{
			// 그 외는 체력과 방어력을 더한 값에 데미지를 뺀 값이 체력으로 남아 반환
			hp = hp + defense - sum;
		}
	}
}

• 패키지명 Monster을 먼저 만들어주고 그 안에 만들어주는 것 주의!

package Character;

//Character 부모 클래스에 상속된 Monster
public class Monster extends Character{
	// 멤버변수 은닉화
	public int power;
	public int defense;
	public int money;
	public int experience;
	
	// 어택 멤버 메소드를 불렀을때 공격력을 반환한다
	public int attack() {
		return power;
	}
	
	public void attacked(int sum) {
		
		if(defense >= sum) 
		{
			hp = hp - 0;
		}
		else {
			hp = hp + defense - sum;
		}
	}
}

• 패키지명 Racoon을 먼저 만들어주고 그 안에 만들어주는 것 주의!

package Character;

public class Racoon extends Monster {
	
	public int attack() {
		
		System.out.println("데미지는 " + power + " 입니다.");
		return power;
		
	}
	
	public void attacked(int sum) {
		
		if(defense >= sum) {
			hp = hp - 0;
		}else {
			hp = hp + defense - sum;
		}
	}
}

• 패키지명 Warrior을 먼저 만들어주고 그 안에 만들어주는 것 주의!

package Character;

import java.util.Scanner;
//Hero 부모 클래스에 상속된 Warrior
public class Warrior extends Hero {
		
	public int attack() {
		
		Scanner sc = new Scanner(System.in);
		System.out.println("1. 쓰러스트");
		System.out.println("2. 삼단 베기");
		System.out.printf("공격 번호를 입력하세요 : ");
		int num = sc.nextInt();
		
		int sum = 0;
		
		if(num == 1) {
			
			sum += level * 10;
			sum += power * 30;
			System.out.println("데미지는 " + sum + " 입니다.");
			return sum;
		}else if(num == 2) {
			
			sum += level * 20;
			sum += power * 15;
			sum += defense * 15;
			System.out.println("데미지는 " + sum + " 입니다.");
			return sum;
		}
		System.out.println("데미지는 " + sum + " 입니다.");
		return sum;
	}
	
	public void attacked(int sum) {
		
		if(defense >= sum) {
			hp = hp - 0;
		}else {
			hp = hp + defense - sum;
		}
	}
}

• 패키지명 WildCat을 먼저 만들어주고 그 안에 만들어주는 것 주의!

package Character;
//WildCat 클래스는 Monster가 부모 클래스 상속
public class WildCat extends Monster {
	// 멤버 메소드
	public int attack() {
		
		System.out.println("데미지는 " + power + " 입니다.");
		return power;
		
	}
	//WildCat.attacked을 불렀을 경우
	public void attacked(int sum) {
		// 데미지가 방어력보다 작으면 피해 없음
		if(defense >= sum) {
			hp = hp - 0;
		}else {
			// 그 이외는 체력+방어력-데미지 = 체력으로 남는다.
			hp = hp + defense - sum;
		}
	}
}

• 패키지명 WildDog을 먼저 만들어주고 그 안에 만들어주는 것 주의!

package Character;
//WildDog 클래스는 Monster가 부모 클래스 상속
public class WildDog extends Monster {
	// 멤버 메소드
	public int attack() {
		
		System.out.println("데미지는 " + power + " 입니다.");
		return power;
		
	}
	//WildDog.attacked을 불렀을 경우
	public void attacked(int sum) {
		// 데미지가 방어력보다 작으면 피해 없음
		if(defense >= sum) {
			hp = hp - 0;
		}else {
			// 그 이외는 체력+방어력-데미지 = 체력으로 남는다.
			hp = hp + defense - sum;
		}
	}
}

• 패키지명 WildPig을 먼저 만들어주고 그 안에 만들어주는 것 주의!

package Character;
// WildPig 클래스는 Monster가 부모 클래스 상속
public class WildPig extends Monster {
	// 멤버 메소드
	public int attack() {
		
		System.out.println("데미지는 " + power + " 입니다.");
		return power;
		
	}
	//WildPig.attacked을 불렀을 경우
	public void attacked(int sum) {
		// 데미지가 방어력보다 작으면 피해 없음
		if(defense >= sum) {
			hp = hp - 0;
		}else {
			// 그 이외는 체력+방어력-데미지 = 체력으로 남는다.
			hp = hp + defense - sum;
		}
	}
}

• 이렇게 상속까지 끝이 났다. 상속은 효율을 극대화하고 알고리즘을 짜는 것이기 때문에
  지능과 논리 사고가 필요한 파트이다.
  다음 포스팅에도 역시 꿀 떨어지는 포스팅은 계속된당!