객체 지향 문법 3/3

생성자

인스턴스를 생성할 때 사용한다.

클래스 작성시 생성자를 만들지 않으면 기본생성자가 생성된다.

기본 생성자는 매개변수를 하나도 받지 않는 생성자이다.

생성자는 리턴타입이 없고, 클래스이름과 같다.

public class Car {

    private  String name;
    public Car(){
        System.out.println("자동차 생성");
    }

    public Car(String name){
        this.name = name;
    }

    public void printName(){
        System.out.println("자동차 이름: "+name);
    }
}

-------------------------------------

public class CarExam(){
    public static void main(String[] args) {
        Car c1 = new Car(); //"자동차 생성" 출력
        System.out.println(c1); //c1이 가지는 toString()메소
        c1.printName(); //String 타입 name이 참조하는 것이 없으므로 "자동차 이름: null

        System.out.println("-------------");
        Car c2 = new Car("egg"); //"자동차 이름: egg"출력
        c1.printName();
    }
}

 

 

생성자 오버로딩 : 생성자의 매개변수 개수가 다르거나, 타입이 다른 메소드 생성자를 여러 개 가질 수 있다.

public class User {
    private  String  email;
    private  String  password;
    private  String name;

    public  User(String name, String email){
        this.email = email;
        this.name = name;
    }

    //생성자 오버라이딩
    public User(String name, String email, String password){
        this.email = email;
        this.name = name;
        this.password = password;
    }

    public String getEmail() {
        return email;
    }

    public String getPassword() {
        return password;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "User{" +
                "email='" + email + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
}

public class UserExam {
    public static void main(String[] args) {
        User user = new User("계란","abcde@naver.com");

        System.out.println(user);

        User user2 = new User("홍길동","korea@naver.com","1234");

        System.out.println(user2.getName());
        System.out.println(user2.getEmail());
        System.out.println((user2.getPassword()));
    }
}

실행결과

User{email='abcde@naver.com', name='계란'}
홍길동
korea@naver.com
1234

암호는 민감한 정보이므로, toString()메소드 오버라이딩 시 출력을 하지 않았다.

 

Immutable 객체:  생성자에서 넣어준 값을 리턴해주는 기능만 있는 객체를 말한다. 외부에 전달은 하는데 값 변경을 원하지 않는 객체

Pdf 같이 읽을 수 있는 기능만 있음

 

toString() 메소드를 오버라이딩 하면 이 객체가 가진 정보를  문자열로 반환한다.

 

 

this생성자

this는 인스턴스 자기 자신을 참조할 때 사용하는 키워드로,  

this() 생성자는 자기 자신의 생성자를 말하고, 생성자 안에서만 사용가능하다.

this() 생성자는 super생성자를 제외한 어떤 문구보다 생성자 블록에서 가장 윗단에 적어야 한다.

1번코드와 2번코드는 같은 역할을 한다.

1번코드
public  User(String name, String email){
        this(name, email, null);
    }
    
2번코드
public  User(String name, String email){
        this.email = email;
        this.name = name;
    }

 

super생성자

super는 인스턴스 부모를 참조할 때 사용하는 키워드로,

super() 생성자는 부모 생성자를 의미하고, 생성자 안에서만 사용가능하다.

생성자 안에서 첫번째 줄에만 올 수 있다.

생성자는 무조건 super()생성자를 호출해야 한다. 작성하지 않았으면 자동으로 부모의 기본생성자가 호출된다.

 

생성자가 없으면 기본생성자가 만들어지는데, 이 기본생성자에는 아무코드가 입력되지 않은 것이 아니라, super() 코드가 자동으로 입력된다.

즉, 부모의 생성자를 호출하는 코드가 자동삽입된다. 생성자를 하나 만들어준다면 기본생성자는 생성되지 않고, 이러면 자식클래스의 생성자에서 오류가 난다.

자식클래스의 생성자는 부모클래스의 기본생성자를 super()로 호출하는데, 부모클래스의 기본생성자가 없으므로 오류가 발생하는 것이다.

이를 방지하기 위해선 자식 클래스의 생성자에서 super()가 아닌  부모클래스의 생성자에 맞는 매개변수를 입력해야 한다.

 

정리하면 부모클래스에 기본생성자가 없으면 자식클래스의 생성자에서는 부모클래스의 생성자를 super()를 사용해서 직접 호출해야한다. 

 

---

추상 클래스

미완성 클래스, 메소드 몇개가 구현되지 않고 선언만 되어있는 클래스이다.

 

추상 클래스는 인스턴스가 될 수 없고, 상속받는 자손이 인스턴스가 된다.

abstract 키워드를 사용하여 클래스를 정의하며 1개 이상의 추상 메소드를 가진다.  이때, 추상 메소드는 없어도 괜찮다.

추상 클래스를 상속받을 경우 반드시 추상메소드를 구현해줘야 한다.

public abstract class 클래스명 {...}

 

추상메소드 Car를 만드는 사람은 run()메소드가 필요하다고 생각을 했는데, run()은 자동차마다 기능을 다르게 구현해야 한다고 생각했다.

따라서 Car 클래스에서는 run() 메소드를 추상메소드로 선언만 하고, Car클래스를 상속받는 Bus클래스에서 메소드 오버라이딩을 통해 구체적으로 기능을 구현해야 한다.

 

public abstract class Car {
    public abstract  void run();
}


------------------------------------

public class Bus extends Car{
    @Override
    public void run() {
        System.out.println("후륜구동");
    }
}

------------------------------------

public class CarExam {
    public static void main(String[] args) {
        Bus b= new Bus();
        b.run();
    }
}

        //Car c = new Car(); -> 오류발생
        //추상 클래스이므로 인스턴스가 될 수 없다. 사용하려면
        Car c = new Bus();

 

---

템플릿 메소드 패턴으로 추상 클래스 개념 다지기

 

추상 클래스는 템플릿 메소드 패턴에서 가장 많이 쓰인다.

템플릿 메소드 패턴은 실행 순서가 정해져 있고

개별 구현 되는 특정 메소드 외 다른 메소드들을 동일한 동작을 하는 패턴이다.

 

어떤 컨트롤러를 만든다고 생각하자. 기능은 3가지인데, "초기화"와 "마무리"는 항상 같은 코드이고, "실행" 만 변경할 수 있다고 하자.

Controller의 종류가 여러개이다.
초기화 - 항상 같은 코드
실행 - 다른 코드
마무리 - 항상 같은 코드

package fw;

public abstract class Controller {
    public void init(){
        System.out.println("초기화");
    }
    public void close(){
        System.out.println("마무리");
    }
    public abstract void run();

    //내가 가지고 있는 메소드를 순서를 가지고 호출: 템플릿 메소드
    public void execute(){
        //execute()메소를 실행하면 자신의 init,run,close 메소드가 호출된다.
        this.init();
        this.run();
        this.close();

    }
}

package myproject;
import fw.Controller;

public class FirstController extends Controller {
    @Override
    public void run() {
        System.out.println("별도로 동작하는 코드");
    }

}

package myproject;

import fw.Controller;

public class ControllerMain {
    public static void main(String[] args) {
        Controller c1 = new FirstController(); //자식 클래스 참조
        //순서대로 호출해야 하므로 excute()메소드 호출
        c1.execute();
    }
}

실행하면

초기화
별도로 동작하는 코드
마무리

출력되는데, 자식클래스에서 오버라이딩한 메소드가 호출되는 것을 볼 수 있다.

즉, 부모클래스를 상속받음으로 매번 변하는 코드만 구현하도록 만들었다. 그리고 exceute()만 호출해도 자동으로 init()과 close()가 호출되는 것을 볼 수 있다.

이때, 사용자가 실수로 초기화 코드만 실행하면 

실행화면

초기화

즉, 원하지 않은 방법을 사용하는 것이다. 이말은 init(), close(),run()는 사용자가 직접 호출하면 안되는 것. 이때, 사용할 수 있는 것이 접근지정자 중 protected이다. 

protected 키워드 : 같은 패키지이거나 상속받았을 경우 접근 가능하다.

package fw;/*
Controller의 종류가 여러개이다.
초기화 - 항상 같은 코드
실행 - 다른 코드
마무리 - 항상 같은 코드

 */

public abstract class Controller {
    protected void init(){
        System.out.println("초기화");
    }
    protected void close(){
        System.out.println("마무리");
    }
    protected abstract void run();

    //내가 가지고 있는 메소드를 순서를 가지고 호출: 템플릿 메소드
    public void execute(){
        //execute()메소를 실행하면 자신의 init,run,close 메소드가 호출된다.
        this.init();
        this.run();
        this.close();

    }
}

또한 자식클래스에서 변경할 메소드인 run()만 오버라이딩 해야 하는데, init(), close()를 오버라이딩 할 수 있다.

메소드가 오버라이딩 되면 무조건 자식클래스의 메소드가 실행되는데, 이를 방지하기 위해서 final 키워드를 사용한다.

final이 붙은 메소드는 오버라이딩이 금지된다.

final의 반대 : abstract

 

---

final 클래스, 불변객체 String

 

부모가 될 수 없는 클래스

abstract클래스는 인스턴스가 될 수 없으므로, 반드시 후손클래스가 필요한데, final 클래스는 상속을 금지시킨다.

대표적인 final클래스는 String클래스

public final class 클래스명 { ... }

 

 

public class StringExam {
    public static void main(String[] args) {
        String str1="hello";
        String str2="hello";
        String str3= new String("hello");;
        String str4= new String("hello");

        if(str1 == str2)
            System.out.println("str1 == str2");
        if(str1 == str3)
            System.out.println("str1 == str3");
        if(str3 == str4)
            System.out.println("str3 == str4");

    }
}

실행결과
str1 == str2

new로 생성하지 않으면 상수 취급됨

str1과 str2모두 같은 “hello”를 참조함.

 

new가 쓰이면 항상 힙메모리에 새로운 객체가 생성됨.

str3,str4는 다른 영역의 hello를 참조하는 것이다.

 

레퍼런스 타입에서 == : 같은 것을 참조하느냐 (o), 값이 같냐 (x)

따라서 String 사용할 땐 new를 사용하지 않는 것이 좋다. new사용할때 마다 메모리 사용하기 때문

        if(str1.equals(str2)){
            System.out.println("값이 같다.");
        }
        String s = str1.toUpperCase();
        System.out.println(s);
        System.out.println(str1);
    }
    
    실행 결과
    
    값이 같다.
    HELLO
    hello

값이 같냐 : equals()메소드 

String은 불변클래스이기 때문에 str1이 참조하는 String은 변하지 않음

String은 항상 내부적으로 새로운 문자열을 만들어서 리턴한다. 그래서 String이 가지고 있는 모든 메소드는 자기 자신을 변화시키지 않는다.

StringBuffer 클래스는 String과 비슷하지만 내부가 변한다.

String / StringBuffer/ StringBuilder

 

---

접근제한자

1) private : 같은 클래스 내에서만 접근 가능

2) default : 같은 패키지 내에서만 접근 가능

3) protected : 같은 패키지 내에서, 그리고 다른 패키지의 자손 클래스에서 접근 가능

4) public : 접근 제한이 전혀 없다.

접근제한자	클래스 내부	동일 패키지	하위 클래스	그 외
public	O	O	O	O
protected	O	O	O	X
default	O	O	X	X
private	O	X	X	X

 

---

인터페이스

 

설계: 어떤 기능을 만들 지부터 고민하고, 만들 기능들은 관련된 것끼리 묶은 후 이름을 지어준다.

 

인터페이스 : 기능들의 목록을 가지고 있으며 메소드가 선언만 되어있는데,  추상클래스처럼  new를 사용하여 인스턴스를 생성할 수 없다.

껍데기라고 생각하자. 설계 단계에서 정확한 메소드 구현을 하지 않아도, 틀을 잡는데 유용하다.

 

[public] interface 인터페이스이름 { ... }

 

인터페이스는 기능이 선언만 되어있는 것이다. 

인터페이스 메소드는 모두 추상메소드

인터페이스의 모든 필드는 public static final이어야 하며, 모든 메소드는 public abstract여야 한다.

이 둘은 생략이 가능하다.

public static: 메모리에 인스턴스를 만들지 않아도 올라갈 수 있다.

public interface LottoMachine {
    int MAX_BALL_COUNT = 45;
    int RETURN_BALL_COUNT = 6;
    public void setBalls(Ball[] balls); //Ball[] : Ball 여러개를 받겠다. 45개 받기
    public void mix(); //공을 섞는다.
    public Ball[] getBalls();//6개의 공을 반환.

}

배열맛보기

Ball b1 = new Ball(1);
    ....
Ball b45 = new Ball(45);

공이 45개 필요함 -> 배열 이용
Ball[] balls = new Ball[45]; //Ball인스턴스를 45개 참조할 수 있는 배열을 만든다.

balls[0] = new Ball(1);
    ....
balls[44] = new Ball(45);