객체지향 프로그래밍Ⅱ

📌 상속

: 기존 클래스를 재사용하여 새로운 클래스를 작성하는 것

: (+) 코드 재사용성↑, 프로그램 생산성↑, 유지보수👍🏻

: extends 키워드 사용

class Child extends Parent { ... }

Child클래스는 Parent클래스의 멤버들을 포함

: 생성자와 초기화 블럭은 상속X

: Object 클래스는 모든 클래스의 조상

❗ 자바는 단일 상속만 지원 (명료하고 신뢰성 있는 코드를 제공하기 위해)

 

✔️ 클래스간의 관계

1️⃣ 상속관계(is-a)

2️⃣ 포함관계(has-a) : 한 클래스의 멤버변수로 다른 클래스 타입의 참조변수를 선언하는 것

 

 

📌 오버라이딩

: 조상 클래스로부터 상속받은 메서드의 내용을 변경하는 것

 

✔️ 오버라이딩 조건

1️⃣ 조상 클래스와 선언부(메서드명, 매개변수, 반환값)가 일치해야됨!

2️⃣ 접근 제어자를 조상 클래스의 메서드보다 좁은 범위로 변경X

3️⃣ 예외는 조상 클래스의 메서드보다 많이 선언X

4️⃣ 인스턴스 메서드를 static 메서드로 또는 그 반대로 변경X

 

✔️ super

: 자손 클래스에서 조상 클래스로부터 상속받은 멤버를 참조하는 데 사용되는 참조변수

: 자손클래스의 멤버가 조상 클래스의 멤버와 중복 정의되어 서로 구별해야 되는 경우에만 사용!

 

✔️ super()

: 조상 클래스의 생성자를 호출하는데 사용

: 직접 호출하지 않으면 컴파일러가 자동으로 자손 클래스 생성자 첫 줄에 super();를 추가

: 조상 클래스의 생성자 호출은 클래스의 상속관계를 거슬러 올라가면서 마지막에는 모든 클래스의 최고 조상인 Object()까지 도달

 

 

📌 제어자

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

 

✔️ static

: 클래스 변수(static 변수), 클래스 메서드(static 메서드)를 생성할 때 사용!

: 클래스 멤버는 인스턴스가 아닌 클래스에 관계 됨. 그래서 인스턴스를 생성하지 않고도 사용O

→ static 메서드는 인스턴스 멤버를 사용할 수 없음!

→ 인스턴스 메서드보다 빠르게 호출 가능!

 

✔️ final

: 변수에 사용되면 값을 변경할 수 없는 상수가 됨

: 메서드에 사용되면 오버라이딩X

: 클래스에 사용되면 다른 클래스에서 상속할 수 없음

: final이 붙은 인스턴스 변수는 생성자에서 초기화 가능O! → 따라서 각 인스턴스마다 final이 붙은 멤버변수가 다른 값을 갖도록 할 수 있음!

 

✔️ abstract

: 추상 메서드(선언부O, 구현부X)와 추상 클래스(추상 메서드를 가지고 있음을 의미)를 선언하는 데 사용!

: 추상 클래스로 인스턴스 생성 불가능!

: 추상 메서드는 상속을 통해 자식 클래스의 오버라이딩으로 구현될 수 있음!

 

✔️ 접근 제어자(public, protected, default, private)

: 멤버 변수, 메서드, 클래스를 외부에서 접근하지 못하도록 제한하는 역할

1️⃣ private

    : 같은 클래스 내에서만 접근O

2️⃣ default

    : 같은 패키지 내에서만 접근O

3️⃣ protected

    : 자손 클래스에서 접근O, 같은 패키지 내에서 접근O

4️⃣ public

    : 접근 제한X

 

📌 캡슐화

: 클래스 내부에 선언된 데이터를 보호하는 것

: 데이터(멤버 변수)가 유효한 값을 유지하도록, 외부에서 함부로 변경하지 못하도록 데이터를 감추는 것!

: 외부에서 접근할 필요가 없는 멤버들을 private으로 지정하여 복잡성을 줄이는 것 역시 캡슐화!

 

❗ 보호해야 하는 멤버변수(데이터)를 private, protected(상속을 통해 확장될 것이 예상되는 클래스일 때)로 제한하고 멤버 변수의 값을 읽고 변경할 수 있는 public메서드(ex. getter(), setter())를 제공하자!

❕(참고) 하나의 소스파일(.java)에는 public 클래스가 단 하나만 존재O, 소스파일의 이름은 반드시 public 클래스의 이름과 같아야 함!

 

✔️ 생성자의 접근 제어자

: 보통 생성자의 접근 제어자는 클래스의 접근 제어자와 같음

: 생성자를 private으로 지정하면, 외부에서 생성자에 접근X → 인스턴스 생성X

: private 생성자로 지정해 인스턴스 생성을 막고 public 메서드를 통해 인스턴스에 접근하게 함으로써 사용할 수 있는 인스턴스의 개수를 제한O

: 생성자가 private이면 다른 클래스가 상속할 수 없으므로 class에 final 키워드를 붙여주는 것이 좋음! (자식의 생성자에서 부모의 생성자를 호출해야 하는데 그럴 수 없기 때문!)

 

❗싱글톤 패턴

: 클래스의 인스턴스가 오직 1개만 생성되는 패턴

: (+) 메모리를 낭비를 막음

: (+) 다른 클래스 간 데이터 공유가 쉬움

: (-) 동시성 문제가 발생할 수 있음

: (-) 테스트가 어려움

: (-) 클라이언트가 구체 클래스에 의존(SOLID원칙 중 DIP원칙 위반)

class Singleton {

    private static Singleton s = new Singleton();
    
    private static Singleton() { ... }
    public static Singleton getInstance() {
        return s;
    }
}

 

 

📌 다형성

: 조상클래스 타입의 참조변수로 자손클래스의 인스턴스를 참조할 수 있는 것(ex. Object o = new String())

: 객체지향의 중요한 특징(상속, 캡슐화, 다형성, 추상화) 중 하나

//앞으로 계속 쓸 예제
class Animal {
    String name;
    String food;
    
    void move() { ... }
}

class Rabbit extends Animal { ... }
class Cat extends Animal { ... }

 

✔️ 참조변수의 타입은 (1)참조할 수 있는 객체의 종류와 (2)사용할 수 있는 멤버의 수를 결정!

    - 참조변수가 사용할 수 있는 멤버의 갯수는 인스턴스 멤버 갯수보다 같거나 작음

    - 따라서, 조상타입 참조변수 → 자손타입 인스턴스 O / 자손타입 참조변수 → 조상타입 인스턴스 X

    - 조상타입 참조변수 → 자손타입 인스턴스 Ok 이기 때문에 참조변수의 타입과 인스턴스의 타입이 항상 일치하지는 않음!

Animal animal = new Rabbit();

 

✔️ 참조변수 형변환

자손타입 → 조상타입(Up-casting) : 형변환 생략 Ok

조상타입 → 자손타입(Down-casting) : 형변환 생략 X

Cat cat = new Cat();
Animal animal = cat; // Up-casting
Cat cat2 = (Cat) animal; // Down-casting

❗형변환은 참조변수의 타입을 변환하는 것! 인스턴스를 변환하는 것이 아님!

Animal animal = new Animal();
Cat cat = (Cat) animal; //런타임 에러!

 

💁🏻‍♀️ 이런 실수를 하지 않으려면 어떻게 해야 할까?

💡 instanceOf 연산자를 이용! 연산결과 true를 얻었다면 참조변수가 검사한 타입으로 형변환이 가능하다는 것을 의미!

if(animal instanceOf Cat)
    Cat cat = (Cat)animal;

 

✔️ 참조변수의 타입에 관계없이 항상 실제 인스턴스의 메서드가 호출되지만, 멤버변수의 경우 참조변수의 타입에 의존.

class Animal {
    static int count = 10;
    String name = "animal_name";
    String food;
    
    void move() { 
        System.out.println("Animal is moving");
    }
}

class Dog extends Animal { 
    static int count = 0;
    String name = "dog_name";
    String food;
    
    @Override
    void move() { 
        System.out.println("A dog is moving");
    }
}

Dog dog = new Dog();
Animal animal = dog;

 

1️⃣ 중복된 멤버변수

 : 참조변수 타입과 같은 클래스의 멤버변수 반환!

dog.name //dog_name
animal.name //animal_name

 

2️⃣ 오버라이딩된 메서드

 : 인스턴스 메서드 호출!

dog.move(); //A Dog is moving
animal.move() //A Dog is moving

 

3️⃣ static 메서드

 : 참조변수 타입에 의존. 클래스명.메서드()로 호출하기

dog.count() //0
animal.count() //10

→ 참조변수 타입에 따라 사용되는 인스턴스 변수가 달라질 수 있으므로 멤버변수들은 주로 private으로 접근을 제한하고, 외부에서는 메서드를 통해서만 접근할 수 있도록 해야함! (캡슐화)

 

💁🏻‍♀️ 그럼 다형성을 쓰면 뭐가 좋은데?

💡 여러 타입(Class)를 하나의 타입으로 다룰 수 있음! → 유연하고 확장성있고, 유지보수가 편리한 프로그램을 만들 수 있음

public void feed(Rabbit rabbit) {
    System.out.println(rabbit.name + "에게 " + rabbit.food + "를 주었다!");
}

public void feed(Animal animal) {
    System.out.println(animal.name + "에게 " + animal.food + "를 주었다!");
}

 

 

📌 추상클래스

: 미완성 클래스. abstract 키워드를 사용해서 생성!

: 따라서 추상 클래스로는 인스턴스를 만들 수 없음!

: 추상 메서드(선언부O, 구현부X)를 포함하고 있음. 상속을 통해서 추상메서드를 구현해주어야 함!(필수!)

 

✔️ 추상화

: 클래스간의 공통점을 찾아내서 공통의 조상(상위클래스)을 만드는 작업

 

✔️ 구체화

: 상속을 통해 클래스를 구현, 확장하는 작업

 

✔️  조상클래스 메서드 오버라이딩 VS 추상메서드 구현

: 추상메서드는 구현이 필수지만 부모클래스 메서드를 오버라이딩 하는 것은 선택!

 

💁🏻‍♀️ 그럼 추상클래스를 왜 쓰는건데?

1️⃣ 객체들의 멤버변수와 메서드의 이름을 통일하여 소스의 가독성↑

    : 개발자가 멤버변수와 메서드를 추측할 수 있음(ex. rabbit에 food가 있으니까 dog에도 food가 있겠지?)

2️⃣ 상속과 다형성의 장점을 누릴 수 있음!

   : 추상클래스를 상속한 하위 클래스를 추상클래스로 다룰 수 있음!

 

 

📌 인터페이스

: 일종의 추상클래스(but 추상화↑) 

: 일반 메서드 또는 멤버 변수를 구성원으로 X. 오직 추상 메서드(public abstract)와 상수(public static final)만을 멤버로 가짐!

: 제어자 생략 가능(생략된 제어자는 컴파일러가 자동적으로 추가)

: 인터페이스의 Object같은 최고 조상은 따로 없음!

: 여러개의 인터페이스를 상속하는 것이 가능!

: 인터페이스를 상속하고 싶으면 implements 키워드를 사용!

interface Movable {
    void move(int x, int y);
}

class Rabbit extends Animal implements Movable {
    public void move(int x, int y) { ... }
}

 

✔️ 인터페이스를 이용한 다형성

: 인터페이스 타입으로 해당 인터페이스를 구현한 클래스의 인스턴스를 참조할 수 있음!

: 리턴타입이 인터페이스라는 것은 메서드가 해당 인터페이스를 구현한 클래스의 인스턴스를 반환한다는 것을 의미! 

 

💁🏻‍♀️ 인터페이스를 왜 쓰는데?

1️⃣ 개발 시간 단축

    : 인터페이스를 사용하는 쪽에서는 인터페이스가 구현되지 않았더라도 메서드의 선언부만 보고 프로그램을 작성할 수 있음! 인터페이스를 사용하는 쪽과 구현하는 쪽이 동시에 개발 가능!

2️⃣ 표준화

    : 프로젝트에 사용되는 기본 틀을 인터페이스로 작성한 뒤 이를 구현하여 프로그램을 작성하면 일관되고 정형화된 프로그램을 개발 가능!

3️⃣ 클래스 간에 관계를 맺어 줌!

    : 상속 관계X, 같은 조상X인 경우 인터페이스를 공통적으로 구현하도록 함으로써 관계를 맺어 줄 수 있음

    : 상속 관계(직접적인 관계)를 인터페이스를 이용해서 간접적인 관계로 변경할 수 있음

4️⃣ 독립적 프로그래밍(ex. 특정 DB에 의존적이지 않는 프로그램)

    : 인터페이스를 이용해 클래스와 클래스 간의 직접적인 관계를 간접적인 관계로 변경하면, 한 클래스의 변경이 관련된 다른 클래스에 영향을 미치지 않는 독립적인 프로그래밍이 가능!

 

✔️ 인터페이스의 이해

- 클래스를 사용하는 쪽(User)와 클래스를 제공하는 쪽(Provider)

- 메서드를 호출하는 쪽(User)에서는 사용하려는 메서드의 선언부만 알면 됨!

class User {
    private MySql db = new MySql();
    
    public void connectDb() {
        db.connectDb();
    }
}

↑ 클래스 User와 MySql(Provider)는 직접적인 관계가 있음(MySql가 변경되면 User도 영향을 받음)

 

(1) 인터페이스를 통해 Database의 선언과 구현을 분리

interface Database {
    public abstract void connectDb();
}

(2) MySql가 Database를 구현

class MySql implements Database {
    public void connectDb() {
        // 구현부
    }
}

(3) User가 Database 인터페이스에 의존하도록 변경

class User {
    Database db = new MySql();
    
    public void loadBd() {
        db.connectDb();
    }
}

- 이제 User와 MySql는 간접적인 관계! (User - Database - MySql)

 

💁🏻‍♀️ 어쨋든 User가 db를 초기화할 때, MySql()을 동적으로 제공받잖아요! 그럼 User가 아직 MySql에 의존하고 있는거 아닌가요?

💡 O! 사실 User는 여전히 MySql()에 의존적임!! 이를 해결하기 위해서 제 3의 클래스가 Database 구현체를 제공해주는 것으로 이를 해결해줄 수 있다!

class User {
    Database db = DbManager.getDb();
    
    public void loadBd() {
        db.connectDb();
    }
}

class DbManager {
    public static Database getDb() {
        return new MySql();
    }
}

 

✔️ JDK1.8 부터 디폴트 메서드와 static 클래스도 인터페이스에 추가할 수 있게 됨!

 

 

📌 내부 클래스

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

: 인스턴스 클래스, 스태틱 클래스, 지역 클래스, 익명 클래스(변수처럼 내부 클래스 선언 위치에 따라 유효범위와 접근성이 달라짐!)

 

💁🏻‍♀️ 내부 클래스 왜 쓰는데?

✔️ 해당 클래스(Outer Class)와 긴밀한 관계가 있는데 외부에는 불필요한 클래스를 내부 클래스로 만듬!

➕ 내부 클래스에서 외부 클래스의 멤버들을 쉽게 접근할 수 있음

➕ 코드의 복잡성을 줄일 수 있음(캡슐화)

 

✔️ 익명 클래스

: 클래스의 선언과 객체의 생성을 동시에 하기 때문에 단 한번만 사용! 오직 하나의 객체만을 생성할 수 있는 일회용 클래스

class Outer {
    public static void main(String[] args) {
        Button b = new Button("Start");
        b.addActionListener(new ActionListener() { //ActionListener가 인터페이스!
            public void actionPerformed(ActionEvent e) {
                // ...
            }
        })
    }

}

 

 

📌 package

: 서로 관련된 클래스들의 묶음

: 물리적으로 하나의 클래스 파일(.class)을 포함하는 하나의 디렉토리

: 클래스의 실제 이름은 패키지명을 포함한 것 → 따라서 같은 이름의 클래스 일지라도 서로 다른 패키지에 존재하는 것이 가능!

: 패키지는 점(.)을 구분자로 하여 계층구조로 구성할 수 있음

 

✔️ 패키지 선언

package 패키지명;

- 하나의 소스파일에는 첫 번째 문장으로 단 한 번의 패키지 선언만을 허용

- 모든 클래스는 반드시 하나의 패키지에 속해야함!

- 패키지를 지정하지 않은 클래스는 '이름없는 패키지'에 속하게 됨!

 

javac -d . PackageTest.java

- terminal에서 -d옵션을 줘서 자바파일(.java)을 컴파일하면 소스파일에 지정된 경로를 통해 패키지 위치를 찾아서 클래스파일(.class)을 생성

- -d뒤에는 해당 패키지의 루트 디렉토리 경로를 적어줌(↑ 위에서는 현재 디렉토리를 의미하는 . )

- 이후 패키지의 루트 디렉토리를 클래스패스(CLASSPATH)에 포함시켜야 함! 그래야 JVM이 해당 클래스를 찾을 수 있음(환경변수 설정!)

 

 

📌 import

: 사용하고자 하는 클래스의 패키지를 미리 명시 (컴파일러에게 클래스의 패키지에 대한 정보를 제공)

→ 소스코드에 사용되는 클래스이름에서 패키지명을 생략할 수 있게 해줌!

: 컴파일러는 컴파일 시점에 import문을 통해 클래스들의 패키지를 알아 낸 다음, 모든 클래스이름 앞에 패키지명을 붙여줌!

 → import문은 컴파일 속도를 조금 느리게 할 뿐, 프로그램 성능에 전혀 영향X.

import java.util.*; // import java.*;로 하면 안됨!

- *을 사용하는 것이 하위 패키지의 클래스까지 포함한 것은 X

❕ *을 사용하면 import하는 패키지 수가 많을 때는 어느 클래스가 어느 패키지에 속하는지 구별하기 어려움!

 

✔️ java.lang 패키지는 매우 빈번히 사용되는 클래스들이 속한 패키지이기 때문에 따로 import문으로 지정하지 않아도 됨! (모든 소스파일에 묵시적으로 import java.lang.*;문이 선언되어 있음)

 

✔️ static import문

: static 멤버를 호출할 때 클래스 이름을 생략할 수 있게 해줌!

import static java.lang.Math.random; //Math.random()이 아닌 random()으로 사용 가능!