[자바의 정석 ] - 7장. 객체지향 프로그래밍Ⅱ

3️⃣ package

3.1 패키지

• 클래스의 묶음(인터페이스도 포함O)
• 같은 이름의 클래스를 패키지명으로 구별 가능
• 물리적으로 하나의 디렉토리
• 모든 클래스는 하나의 패키지에 속함
• 계층구조 구성

3.2 패키지 선언

• 클래스, 인터페이스의 소스파일 맨 위에 선언
• 주석, 공백을 제외하고 제일 처음으로 단 한 번만 선언 되어야 함
• 패키지명은 소문자로 하는 것을 원칙
• 패키지를 지정하지 않는 클래스는 '이름없는 패키지'에 속하게 됨 따라서, 패키지가 지정되지 않은 클래스들은 모두 같은 패키지에 속함

package 패키지명;

3.3 import문

• 소스파일에 사용된 클래스의 패키지에 대한 정보를 컴파일러에게 제공
• package문 과 클래스 선언 사이에 import문을 작성해야함
• 여러번 선언 O

import 패키지명.클래스명;
import 패키지명.*;

---

4️⃣ 제어자

4.1 제어자

• 클래스, 변수, 메서드 선언부에 함께 사용되어 부가적인 의미를 부여

접근제어자	public, protected, default, private
그외 제어자	static, final, abstract

4.2 static

• 하나의 변수를 모든 인스턴스가 공유
• 인스턴스를 생성하지 않고 사용 O

제어자	대상	의미
static	멤버변수	- 모든 인스턴스에 공통적으로 사용되는 클래스 변수 - 인스턴스를 생성하지 않고 사용  - 클래스가 메모리에 로드될 때사용
	메서드	- 인스턴스를 생성하지 않고 호출 가능 - static내에서 인스턴스멤버 직접 사용 불가

class Test{
	static int x= 100; //클래스 변수
    static int y=200;
    
    static{} //static 초기화 블럭
    
    static int max(int a, int b){ //클래스 메서드
    	return a;
    }

4.3 final 

제어자	대상	의미
final	클래스	- 변경, 확장 불가능 - 조상클래스가 될 수 없음
	메서드	- 변경, 재정의 불가능
	멤버변수	- 값 변경 불가능
	지역변수

final class Test{ //조상이 될 수 없는 클래스
	final int a=100; // 값을 변경할 수 없는 멤버변수
    
    final void geta(){ // 재정의 불가능한 메서드
    	final int b =a;// 값을 변경할 수 없는 지역변수
        return a;
    }
 }​

4.4 abstract

• 메서드의 선언부만 작성하고 실제 수행내용은 구현하지 않은 추상메서드
• 인스턴스 생성 불가능

제어자	대상	의미
abstract	클래스	- 클래스 내에 추상메서드가 선언
	메서드	- 선언부만 작성하고 구현부는 작성 X

 

abstract class Test{ //추상클래스
	abstract void move(); //선언부만 있는 추상메서드
}

4.5 접근제어자

• 외부로부터 데이터를 보호하기 위해 사용(캡슐화)

제어자	같은 클래스	같은 패키지	자손 클래스	전체
public	O	O	O	O
protected	O	O	O	X
default	O	O	X	X
private	O	X	X	X

 

public class Time{
	private int hour; //private로 선언하지 않았더라면 시간을 25라고 지정한다 해도 막을 방법이 없다.
    private int min;
    private int sec;
    
    public int getHour(){return hour;}
    public int setHour(){
    	if(hour<0 || hour>23) return;
        this.hour=hour;
    }
    public int getmin(){return min;}
    public int setmin(){
    	if(min<0 || min>59) return;
        this.min=min;
    }
    public int getsec(){return sec;}
    public int setsec(){
    	if(sec<0 || sec>59) return;
        this.sec=sec;
    }

get, set이란?

• get : 멤버변수를 반환하는 메서드
• set : 매개변수에 지정된 값을 검사하여 조건에 맞을 때만 멤버변수 값 변경 가능
•  

---

5️⃣ 다형성

5.1 다형성

• 한 타입의 참조변수로 여러타입의 객체를 참조할 수 있는 능력

5.2 참조변수의 형변환

• Up-casting : 자손 -> 조상 / 형변환 생략가능
• Down -casting : 조상 -> 자손 / 형변환 생략 불가능

5.3 instanceof 연산자

• 참조변수가 참조하고 있는 인스턴스 실제 타입을 알 수 있음
• 주로 조건문에 사용
• 결과값을 boolean값인 true, false로 반환

참조변수 instanceof 클래스명

5.4 참조변수와 인스턴스의 연결

• 메서드는 참조변수 타입과 상관없이 실제 인스턴스 타입 클래스에 정의된 메서드가 호출
• 인스턴스 변수는 참조변수에 따라 달라짐
•  

class Test{
	publid static voi dmain(String args[]){
    	Parent p =new Child();
        Child c =new Child();
        
        System.out.println("p.x = "+p.x);
        p.method();
        System.out.println("c.x = "+c.x);
        c.method();
    }
}
class Parent{
	int x=100;
    void method(){
    	System.out.println("Parent Method");
    }
}
class Child{
	int x=200;
    void method(){
    	System.out.println("Child Method");
    }
}

출력결과

p.x=100;
Child Method
c.x = 200
Child Method

5.5 매개변수의 다형성

• 메서드이 매개변수로 자손타입의 참조변수이면 어느 것이든 매개변수로 받아들일 수 있다.

class Product{
    int price;
    int bonuspoint;
    Product(int price){
        this.price=price;
        bonuspoint=(int)(price/10.0);
    }
}
class Tv extends Product{
    Tv(){
        super(100);
    }
    public String toString(){return "Tv";}
}
class Computer extends Product{
    Computer(){
        super(200);
    }
    public String toString(){return "Computer";}
}
class Buyer{
    int money=1000;
    int bonuspoint=0;
    void Buy(Product p){
        if(money>p.price){
            money-=p.price;
            bonuspoint=bonuspoint+p.bonuspoint;
        }
        else{
            System.out.println("잔액이 부족하여 살 수 없습니다.");
        }
    }
}
class Test{
    public static void main(String[] args) {
        Buyer b =new Buyer();

        b.Buy(new Tv());
        b.Buy(new Computer());

        System.out.println("현재 남은 돈은 "+b.money+" 입니다.");
        System.out.println("현재 보너스 점수는 "+b.bonuspoint+" 입니다.");
    }
}

출력결과

현재 남은 돈은 700 입니다.
현재 보너스 점수는 30 입니다.

5.6 여러 종류의 객체를 배열로 다루기

• 참조변수를 배열로 처리하기

class Product{
    int price;
    int bonuspoint;
    Product(int price){
        this.price=price;
        bonuspoint=(int)(price/10.0);
    }
}
class Tv extends Product{
    Tv(){
        super(100);
    }
    public String toString(){return "Tv";}
}
class Computer extends Product{
    Computer(){
        super(200);
    }
    public String toString(){return "Computer";}
}
class Buyer{
    int money=1000;
    int bonuspoint=0;
    int i=0;
    Product[] Item = new Product[10]; //구입한 제품을 저장하는 배열
    void Buy(Product p){
        if(money>p.price){
            money-=p.price;
            bonuspoint=bonuspoint+p.bonuspoint;
            Item[i++] = p; //배열에 제품 저장
        }
        else{
            System.out.println("잔액이 부족하여 살 수 없습니다.");
        }
    }
    void summary(){
        int sum=0;
        String itemlist="";

        for(int i=0;i<Item.length;i++){
            if(Item[i]==null) break;
            sum+=Item[i].price;
            itemlist+=Item[i]+", ";
        }
        System.out.println("구입한 물품의 총 가격은 "+sum+" 입니다.");
        System.out.println("구입한 물품은 "+itemlist+" 입니다.");

    }
}
class Test{
    public static void main(String[] args) {
        Buyer b =new Buyer();

        b.Buy(new Tv());
        b.Buy(new Computer());
        b.summary();

        System.out.println("현재 남은 돈은 "+b.money+" 입니다.");
        System.out.println("현재 보너스 점수는 "+b.bonuspoint+" 입니다.");
    }
}

출력결과

구입한 물품의 총 가격은 300 입니다.
구입한 물품은 Tv, Computer,  입니다.
현재 남은 돈은 700 입니다.
현재 보너스 점수는 30 입니다.

*Vector을 사용하며 배열의 크기를 알아서 관리해주기 때문에 크기에 신경쓰지 않아도 된다.

Vector item =new Vector() //Vector 생성

---

6️⃣ 추상클래스

6.1 추상클래스란?

• 미완성 메서드를 포함하고 있는 클래스
• 인스턴스 생성 불가능
• 상속을 통해 자손클래스에 의해서만 완성될 수 있음

6.2 추상메서드

• 선언부만 구성하고 구현부는 작성 X

6.3 추상클래스의 작성

• 추상화 : 클래스의 공통부분을 뽑아 조상 클래스를 만드는 것

class Marine{
	int x,y;
    void move(int x, int y){ // 내용 //}
    void stop(){// 내용 //}
    void stimpick(){// 내용 //}
 }
 class Tank{
	int x,y;
    void move(int x, int y){ // 내용 //}
    void stop(){// 내용 //}
    void changeMode(){// 내용 //}
 }
 class Dropship{
	int x,y;
    void move(int x, int y){ // 내용 //}
    void stop(){// 내용 //}
    void load(){// 내용 //}
 }

추상화 

abstract calss Unit{ //공통된 부분
	int x,y;
	abstract void move(int x, int y);
    void stop(){}
}
class Marine extends Unit{
    void move(int x, int y){ // 내용 //}
    void stimpick(){// 내용 //}
 }
class Tank extends Unit{
    void move(int x, int y){ // 내용 //}
    void changeMode(){// 내용 //}
 }
class Dropship extends Unit{
    void move(int x, int y){ // 내용 //}
    void load(){// 내용 //}
 }

---

7️⃣ 인터페이스

7.1 인터페이스란?

• 추상메서드를 갖지만 몸콩을 가진 메서드 또는 일반변수는 가질 수 없다.(only 추상메서드,상수)

7.2 인터페이스의 작성

interface 인터페이스명{
	public static final 타입 상수이름 = 값; //public static final 생략가능
    public static final 메서드명(매개변수 목록); //public static final 생략가능

7.3 인터페이스 상속

• 다중상속 가능
• 인터페이스간 상속만 가능

interface Moveavle{
	void move(int x, int y);
}
interface Attackable{
	void attack(Unit u);
}
interface Fightable extends Moveable, Attackable{}

7.4 인터페이스의 구현

• 인스턴스 생성 불가 
• 'implements'를 사용하여 클래서 작성

class Fighter implements Fightable{
	public void move(int x, int y){ //구현//}
    public void attack(Unit u){//구현//}
}

• 메서드 중 일부만 구현 할 시 abstract를 붙여 추상클래스로 생성해야함

7.6 인터페이스를 이용한 다형성

• 인터페이스 타입으로 형변환 가능
• 메서드의 매개변수 타입으로 사용 => 메서드 호출 시 해당 인터페이스를 구현한 클래스의 인스턴스를 매개변수로 제공
• 리턴타입이 인터페이스일 경우 메서드가 해당 인터페이스를 구현한 클래스의 인스턴스를 반환한다는 것을 의미

interface Parseable{
	public abstract void parse(String filename); 
    //구문분석 기능을 가진 추상메서드 parse(String filename) 
}

class ParserManager{
	public static parseable getParser(String type){ //return타입이 Parseable인터페이스
    	if(type.equals("XML")){ //type값이 xml일시
        	return new XMLParser(); //xml인스턴스 반환
        }else{
        	return new HTMLParser(); //html인스턴스 반환
     	}
    }
}
class XMLParser implements Parseable{
	public void parse(String filename){
    	System.out.println(filename+" - XML parsing completed");
    }
}
class HTMLParser implements Parseable{
	public void parse(String filename){
    	System.out.println(filename+" - HTML parsing completed");
    }
}
class Test{
	public static void main(String args[]){
    	Parseable p = ParserManager.getParser("XML"); //getParser메서드로 인해 참조변수 p는 XMl인스턴스값을 가지게 됨
        p.parse(documents.xml);
        Parseable p = ParserManager.getParser("HTML");
        p.parse(documents2.html);
    }
}

7.7 인터페이스의 장점

• 개발시간 단축
• 표준화 가능
• 독립적인 프로그래밍 가능

예시)

위와같은 상속계층도에서 SCV, Tank, Dropship에 공통기능을 제공하기 위해 인터페이스를 이용

interface Repairable{} //인터페이스 정의
class SCV extends GroupUnit implements Repairable{
	...
}
class Tank extends GroupUnit implements Repairable{
	...
}
class DropShip extends AirUnit implements Repairable{
	...
}

위 3개의 클래스는 Repairable인터페이스를 구현한 공통점이 생김

public class Test {
    public static void main(String[] args) {
        Tank tank =new Tank();
        SCV scv =new SCV();
        Marine marine =new Marine();
        DropShip dropship =new DropShip();

        scv.repair(tank); //scv가 수리
        scv.repair(dropship);
    }
}
interface Repairable{} //인터페이스 생성

class Unit{
    int hitPoint;
    final int MAX_HP;
    Unit(int hp){  
        MAX_HP=hp;
    }
}
class GroundUnit extends Unit{
    GroundUnit(int hp){
        super(hp);
    }
}
class AirUnit extends Unit{
    AirUnit(int hp){
        super(hp);
    }
}
class Marine extends GroundUnit{
    Marine(){
        super(40);
        hitPoint=MAX_HP;
    }
}
class Tank extends GroundUnit implements Repairable{
    Tank(){
        super(1500); //Tank의 hp =1500
        hitPoint=MAX_HP;
    }
    public String toString(){
        return "Tnak";
    }
}
class SCV extends GroundUnit implements Repairable{
    SCV(){
        super(60); //SCV의 hp =60
        hitPoint=MAX_HP;
    }
    void repair (Repairable r){ // SCV가 수리하도록 repair메서드 생성
        //repair메서드의 매개변수는  repairable타입으로 인터페이스 repairable에 정의된 멤버만 사용 가능 
        //하지만, 정의된 멤버가 없으므로 instanceof를 이용하여 unit클래스에 정의된 hitpoint, max_hp 사용 할 수 있도록 함
        if(r instanceof Unit){
            Unit u =(Unit)r;
            while(u.hitPoint!=u.MAX_HP){
                u.hitPoint++;
            }
            System.out.println(u.toString()+"의 수리가 끝났습니다.");
        }
    }
}
class DropShip extends AirUnit implements Repairable{
    DropShip(){
        super(125); //DropShip의 hp =125
        hitPoint=MAX_HP;
    }
    public String toString(){
        return "DropShip";
    }
}

출력결과

Tnak의 수리가 끝났습니다.
DropShip의 수리가 끝났습니다.

 

7.8 인터페이스의 이해

 

직접적인 관계

• 클래스 A를 작성하기 위해서는 클래스 B는 이미 작성 되어야함
• 클래스 B에 변경사항이 있을 경우 클래스A도 무조건 바꿔야함

class A {
	public void MethodA(B b){
    	b.MethodB();
    }
}
class B {
	public void MethodB(){
    	System.out.println("method B()");
    }
}
class Test{
	public static void main(String args[]){
    	A a=new A();
        a.methodA(new B());
    }
}

간접적인 관계

• 인터페이스르 매개체로 클래스 A가 인터페이스를 통해 클래스 B의 메서드에 접근
• 클래스 B가 변경되어도 클래스 A에 영향 X

1.  동적으로 인스턴스제공 

class A{
	void autoPlay(I i){
    	i.play();
    }
}

interface I{
	void play();
}
class B implements I{
	public void play(){
    	System.out.prinlnt("play in B class");
    }
}
class C implements I{
	public void play(){
    	System.out.prinlnt("play in c class");
    }
}
class Test{
	public static void main(String args[]){
    	A a=new A();
        a.autoPlay(new B());
        a.autoPlay(new C());
    }
}

2. 제 3의 클래스를 통해 제공

• 인스턴스 직접 생성 X , getInstance()을 통해 제공

class Test{
    public static void main(String args[]){
        A a= new A();
        a.methodA();
	}
}
class A{
	void methodA(){
    	I i=InstanceManager.getInstance();
        i.methodB();
        System.out.println(i.toString());
    }
}

interface I{
	void methodB();
}
class B implements I{
	public void methodB(){
    	System.out.println("Method in B");
    }
    public String toString(){ return "calss B"; }
}
class InstanceManager{
	public static I getInstance(){
    	return new B(); //다른 인스턴스로 변경 시 여기만 수정하면 됨
    }
}

---

8️⃣내부클래스

8.1 내부클래스란?

• 클래스 내에 선언된 클래스

8.2 내부클래스의 종류와 특징

내부클래스	특징
인스턴스 클래스	- 외부 클래스 멤버변수 선언위치에 선언
static 클래스	- 외부 클래스 멤버변수 선언위치에 선언
지역 클래스	- 외부클래스의 메서드나 초기화 블럭 안에 선언
익명 클래스	- 클래스 선언과 객체의 생성을 동시에 함(일회용)