🌊 ._.sori🪽

📚 참고한 책

- 기본적인 개념을 정리하고 추가적으로 궁금한 것들을 정리했습니다 -

🐥 🐥 🐥

✔️   예외_ 457p

• 예외

: 연산 오류, 숫자 포맷 오류 등과 같이 상황에 따라 개발자가 해결할 수 있는 오류를 의미한다.

• 에러

: 자바 가상 머신 자체에서 발생하는 오류로 개발자 해결할 수 없는 오류를 의미한다.

예외는 개발자가 해결할 수 있는 오류를 말한다고 했는데, 이때 오류를 수정해서 해결하는 것이 아닌 오류가 발생했을 때 차선책을 선택하는 것을 말한다.에러는 아예 처리자체를 할 수 없는 오류인 블루스크린 같은 것을 말한다.

자바에서 예외의 최상위 클래스는 Exception 클래스고, 에러의 최상위 클래스는 Error 클래스다. 이 두 개의 클래스는 Throwable 클래스를 상속한다. 따라서 에러와 예외 모두 Throwable 클래스의 모든 기능을 포함한다. 

✔️   일반 예외_ 458p

• 일반 예외

: 컴파일 전에 예외 발생 문법을 검사하며 예외 처리를 하지 않으면 문법 오류가 발생하여 컴파일이 불가하다.

• InterruptedException

: 일정 시간 동안 해당 쓰레드를 멈추게 만든다.

 Thread thread = new Thread(() -> {
            try {
                System.out.println("작업 시작: 5초 대기 중");
                Thread.sleep(5000);  // 5초 대기
                System.out.println("작업 완료");
            } catch (InterruptedException e) {
                System.out.println("스레드가 인터럽트되었습니다.");
            }
        });

쓰레드는 프로그램 실행 과정에서 CPU를 사용하는 최소 단위로, 프로세스 내에 존재한다. 즉, 일반적으로 자바 프로그램은 커다란 하나의 작업을 작은 작업들로 나누어 각각 쓰레드에 할당한 후 실행된다. 동시에 여러 쓰레드가 실행되니 전체 작업을 빨리 끝낼 수 있도록 해준다.

사용자가 전체 작업을 취소하여 종료해야할 경우, 쓰레드가 종료할 때까지 기다리는 것이 아닌 작업이 더이상 필요하지 않으니 실행을 그만두고 리소스들을 정리한 후 종료하도록 알린다. 이때 인터럽트가 사용된다.

이때 만약 쓰레드가 어딘간에 블로킹 되어있다면 인터럽트를 체크하고 종료 로직을 넣어놨어도 인터럽트 로직 실행은 영원히 실행되지 않을 수 있다. 그렇기에 sleep에서 벗어나 인터럽트 로직이 실행될 수 있도록 해야하는데 Interrupted Exception을 try-catch를 이용하여 처리하거나 메서드 시그니처에 명시해서 메서드 호출자에게 처리를 위임해야한다.

여기서 중요한 것은 Interrupted Exception은 반드시 적절하게 처리해야한다는 것이다. 만약 Interrupted Exception을 무시하는 코드가 여기저기 남발한다면 실행이 종료되지 않고 kill-9로 강제 종료해야한다.

• ClassNotFoundException

: JVM이 클래스 이름을 문자열로 받아서 로딩하려고 할 때, 해당 클래스가 존재하지 않아 찾지 못하는 경우 발생한다.

public class ClassNotFoundExample {
    public static void main(String[] args) {
        try {
            Class.forName("com.example.NotExistClass");
        } catch (ClassNotFoundException e) {
            System.out.println("클래스를 찾을 수 없습니다: " + e.getMessage());
        }
    }
}

Class.forName("클래스명")을 사용할 때 주로 발생하는 예외다. ClassNotFoundException는 checked Exception이라 반드시 try-catch로 처리해야 한다.

• IOException

: 자바 입출력에서 주로 보이는 일반 예외로, 콘솔이나 파일에 데이터를 쓰거나 읽을 때 발생한다.

    try {
            BufferedReader reader = new BufferedReader(new FileReader("test.txt"));
            String line = reader.readLine();
            System.out.println("파일 내용: " + line);
            reader.close();
        } catch (IOException e) {
            System.out.println("파일을 읽는 중 오류가 발생했습니다: " + e.getMessage());
        }

FileReader와 BufferedReader를 이용하여 test.txt 파일의 첫 줄을 읽는다. 파일이 존재하지 않거나 읽는 중 문제가 생기면
IOException이 발생한다. 제대로 실행을 하고자 원한다면 같은 폴더에 test.txt 파일이 제대로 존재하는지 확인을 해야한다. 

• FileNotFoundException

: IOException의 하위 클래스이며, 파일을 읽을 때 해당 경로에 파일이 없거나 쓰기 권한이 없는 파일에 접근하려고 할 때 발생한다.

  try {
            FileInputStream fis = new FileInputStream("test.txt");
        } catch (FileNotFoundException e) {
            System.out.println("파일을 찾을 수 없습니다: " + e.getMessage());
        }

test.txt 파일이 없는 경우 발생한다.

• CloneNotSupportedException

: Cloneable 인터페이스를 상속하지 않은 클래스의 객체를 복사하기 위해 clone( ) 메서드를 호출하면 발생한다.

class Person implements Cloneable {
    String name;

    Person(String name) {
        this.name = name;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class CloneExample {
    public static void main(String[] args) {
        Person person1 = new Person("Alice");

        try {
            Person person2 = (Person) person1.clone();
            System.out.println("복제 성공");
        } catch (CloneNotSupportedException e) {
            System.out.println("복제할 수 없습니다: " + e.getMessage());
        }
    }
}

Object 클래스의 메서드 중 clone( )은 자신의 객체를 복사한 클론 객체를 생성해 리턴하는 메서드로 반드시 Cloneable 인터페이스를 상속해야한다.

clone 메서드는 Java의 최상위 클래스인 java.lang.Object 클래스에서 정의된 메서드로 그 안에 protected로 정의되어 있다. 하위 클래스에서 super.clone( )을 호출해야 복제된다. 만약 clone 메서드를 외부에서 사용하려면 protected -> public으로 오버라이딩해야 한다.

✔️   실행 예외_ 463p

• 실행 예외

: 컴파일 전이 아닌 실행할 때 발생하는 예외로, 예외 처리를 따로 하지 않더라도 문법 오류가 발생하지 않고 프로그램이 강제 종료된다.

• ArithmeticException

: 연산 자체가 불가능할 때 발생한다.

        try {
            int a = 10;
            int b = 0;
            int result = a / b; 
            System.out.println("결과: " + result);
        } catch (ArithmeticException e) {
            System.out.println("산술 오류 발생: " + e.getMessage());
        }

위의 코드는 분모가 0인 경우로 연산이 불가하여 예외가 발생한 경우이다. 만약 이렇게 오류가 발생했을 경우를 대비해 result 값이 -1 혹은 1000 등의 값을 넣은 코드를 try-catch로 감싸 프로그램이 종료되지 않도록 막으면서 결과 값을 보고 연산 코드에서 오류가 발생했음을 발견한다.

• ClassCastException

: 상속 관계에 있는 클래스 간의 다운 캐스팅이 불가능할 때,  다운캐스팅을 시도하면 발생하거나 잘못된 형변환을 하면 발생한다.

        Object obj = "나는 문자열입니다";  // String 객체

        try {
            Integer num = (Integer) obj;  // 잘못된 형변환
        } catch (ClassCastException e) {
            System.out.println("형변환 오류 발생: " + e.getMessage());
        }

class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}

public class CastExample {
    public static void main(String[] args) {
        Animal animal = new Cat();  // 실제 객체는 Cat

        try {
            Dog dog = (Dog) animal;  // 잘못된 다운캐스팅
        } catch (ClassCastException e) {
            System.out.println("형변환 오류: " + e.getMessage());
        }
    }
}

• ArrayIndexOutOfBoundException

: 배열의 인덱스를 잘못 사용했을 때 발생한다.

        int[] numbers = {10, 20, 30};

        try {
            System.out.println(numbers[3]); // 인덱스 3은 존재하지 않음
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("배열 인덱스 오류 발생: " + e.getMessage());
        }

• NumberFormatException

: 문자열을 숫자 또는 실수로 변환할 때 문자열이 변환하고자 하는 숫자 형식이 아니면 변환이 실패하는데 이때 발생한다.

        String input = "123ABC";  // 숫자가 아닌 문자가 포함된 문자열

        try {
            int number = Integer.parseInt(input);  // 예외 발생
            System.out.println("변환된 숫자: " + number);
        } catch (NumberFormatException e) {
            System.out.println("숫자 형식 오류: " + e.getMessage());
        }

• NullPointerException

: 참조 변수가 실제 객체를 가리키고 있지 않은 상황에서 필드나 메서드를 호출할 때 발생한다.

        String text = null;  // 문자열 변수에 null 할당

        try {
            System.out.println("문자열 길이: " + text.length());  // 예외 발생
        } catch (NullPointerException e) {
            System.out.println("널 포인터 예외 발생: " + e.getMessage());
        }

위의 코드에서 text는 null 값이다. null은 위칫값을 저장하는 참조 변수의 초깃값으로만 사용할 수 있으며, 현재 가리키고 있는 객체가 없다는 것을 의미한다.

📚 참고한 책

- 기본적인 개념을 정리하고 추가적으로 궁금한 것들을 정리했습니다 -

🐥 🐥 🐥

✔️   익명 이너 클래스_ 436p

• 익명 이너 클래스

: 이름을 알 수 없는 이너 클래스를 의미하며, 인스턴스 익명 클래스와 지역 익명 이너 클래스가 있다.

• 이너클래스와 익명 이너 클래스 비교하기.

interface MyInterface {
    public abstract void myMethod1();
}

class OuterClass {
     MyInterface inner = new InnerClass();
     void myMethod2(){
         inner.myMethod1();
     }
     
     class InnerClass implements MyInterface {
         public void myMethod1() {
             System.out.println("인스턴스 이너 클래스!");
         }
     }
}

public class PracticeInnerClass {
     public static void main(String[] args) {
     
         OuterClass outer = new OuterClass();
         outer.myMethod2();
     }
}

위의 코드는 이너클래스에서 인터페이스를 상속 받아 인터페이스 myMethod1을 구현한 코드이다. 출력되는 코드는 'myMethod1!'이 출력될 것이다. 위의 코드가 익명 이너 클래스 코드와 어떻게 다른지 비교하면 더 좋을 것 같다.

interface MyInterface {
    public abstract void myMethod1();
}

class OuterClass {

	 MyInterface myinter = new MyInterface() {
         public void myMethod1() {
              System.out.println("익명 이너 클래스");
         }
     };
     
     void myMethod2() {
         myinter.myMethod1();
     }    
     
}

public class PracticeAnonymousClass {
     public static void main(String[] args) {
     
         OuterClass outer = new OuterClass();
         outer.myMethod2();
     }
}

익명 이너 클래스는 인터페이스인 MyInterface를 참조 변수 타입으로 받아 생성자를 호출했다. 그리고 그 생성자 중괄호 안에 인터페이스의 추상 메서드인 myMethod1를 구현했다. 그러면 컴파일러가 알아서 MyInterface를 상속받아 클래스를 내부적으로 생성한 후(익명 클래스) 해당 클래스로 객체를 생성해 참조 변수에 대입한다.

익명 이너 클래스를 사용하면서 주의해야할 것은 항상 부모 타입으로만 선언할 수 있으며, 부모타입으로 선언되었기에 부모에게 없는 메서드는 호출할 수 없다.

Q. 그런데 인터페이스는 객체를 생성할 수 없는데, 익명 이너 클래스는 어떻게 인터페이스 객체를 생성한걸까?

A. 위의 설명과 같다. 해당 코드가 오류 없이 실행되는 이유는, 인터페이스 자체를 인스턴스화한 것이 아니라, 컴파일러가 인터페이스를 구현한 익명 클래스를 자동으로 생성해서 그 인스턴스를 생성했기 때문이다. 쉽게 말하면, 우리가 코드에서 인터페이스를 직접 사용하는 것처럼 보이지만, 실제로는 인터페이스를 구현한 이름 없는 클래스가 내부에서 생성되어 그 객체가 인터페이스 타입 변수에 저장되었기 때문에 가능한 것이다.

Q. 책에 보면 '메서드를 호출을 할 수 없으므로 애초에 만들 필요가 없을까? 그렇지 않다. 오버라이딩 메서드 내부에서는 호출할 수 있으므로 작성해야할 내용이 많을 때 메서드를 분리해 작성하는 것이 효율적이며, 이때 익명 이너 클래스 정의식 내부에 추가 메서드를 정의해 사용하는 것이 편할 수 있다.'라고 되어있다. 이게 무슨 말일까?

A. 문장을 차근차근 살펴보겠다. 오버라이딩 메서드 내부란 위의 코드에서는 OuterClass에 있는 myMethod1을 의미한다. 해당 메서드는 인터페이스에 있는 메서드를 오버라이딩 한 것이다. 위에서 설명하길 익명 이너 클래스는 항상 부모 타입으로만 선언되기 때문에 부모에게 없는 메서드는 호출할 수 없다고 했지만 만약 어떤 기능을 myMethod1 안에서 실행되는 것으로 충분하다면 굳이 외부에 만들지 말고 myMethod1에 원하는 메서드를 구현하여, 원래 있던 메서드와 분리해 작성하면 된다고 하는 것이다. 쉽게 한 줄로 정리하자면 새로운 메서드를 만들고 싶을 경우 부모에게 없는 메서드여도, 오버라이딩 메서드 내부에 만들면 된다라고 하는 것이다.

✔️   익명 이너 클래스를 활용한 인터페이스 타입의 입력매개변수 전달_ 439p

• 인터페이스 타입의 입력매개변수 전달 방법_ 코드: 익명이너클래스 + 참조변수활용X

interface Messenger {
    void send(String message);
}

class MessageProcessor {
    void process(Messenger messenger) {
        messenger.send("익명 이너 클래스 메시지 전송!");
    }
}

public class Main {
    public static void main(String[] args) {
        MessageProcessor processor = new MessageProcessor();
        
        // 참조 변수 없이 익명 이너 클래스를 직접 인자로 전달
        processor.process(new Messenger() {
            public void send(String message) {
                System.out.println("보낸 메시지: " + message);
            }
        });
    }
}

인터페이스 타입의 입력 매개변수를 전달하는 방법은 총 4가지가 있다. 자식 클래스를 직접 생성하여 참조 변수명을 활용하는 방법과 참조 변수명 없이 활용하는 방법이 있다. 그리고 익명 이너 클래스를 활용하는데 이때 참조 변수명을 활용하는 방법과 참조 변수명을 활용하지 않는 방법이 있다. 

객체 참조 변수의 역할은 객체의 참좃값을 전달하기 위함이다. 단순히 객체의 참좃값만을 전달하고자 한다면 굳이 참조 변수를 사용하지 않고 메서드 입력매개변수 위치에서 바로 객체를 생성하면 생성된 객체의 참좃값이 메서드로 전달될 것이다.

✔️   이너 인터페이스_ 444p

• 정적 이너 인터페이스

: 클래스 내부에 인터페이스를 정의하여 해당 클래스에 의존적인 기능을 수행한다.

// 구현 클래스

class Outer {
    interface MyInterface {
        void hello();
    }
}

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

        Outer.MyInterface obj1 = new Outer.MyInterface() {
            public void hello() {
                System.out.println("익명 클래스!!");
            }
        };
        obj1.hello();

        class Impl implements Outer.MyInterface {
            public void hello() {
                System.out.println("구현 클래스!!");
            }
        }

        Outer.MyInterface obj2 = new Impl();
        obj2.hello();
    }
}

이너 인터페이스는 무조건 정적 이너 인터페이스만 존재할 수 있다. 만약 static 제어자를 생략하면, 컴파일러가 자동으로 추가해준다. 위의 코드에서 컴파일을 하게 되면 내부 인터페이스의 바이트 코드는 'Outer$MyInterface.class'로 형성된다. 아우터 클래스 내에 속해 있는 인터페이스도 당연하게 인터페이스므로 직접 객체 생성은 불가하다. 그래서 객체 생성을 하기 위해 다른 클래스로부터 상속을 받거나, 익명 이너 클래스를 활용해야한다.

위의 코드에선 두가지 모두를 반영한 코드로, obj1이라는 객체를 생성한 방법 그리고 Impl 클래스를 만들어 Outer.MyInterface를 상속한 방법을 보여주고 있다.

• 이벤트 처리 방법

class Button {

    // 인터페이스 OnClickListener타입을 가지는 ocl 변수인 필드
    OnClickListner ocl;
    
    // OnClickListener타입의 ocl 변수를 인자로 받아
    // Button 클래스의 ocl 변수를 재정의하는 setOnClickListener 메서드
    void setOnClickListener(OnClickListener ocl) {
         this.ocl = ocl;
    }
    
    // 클래스 내부에 있는 인터페이스
    // 추상 메서드 onClick이 있음을 정의
    interface OnclickListener {
        public abstract void onClick();
    }
    
    void click() {
         ocl.onClick();
    }
}

public static void main(String[] ar) {
    // Button 클래스의 객체인 button1
    Button button1 = new Button();
    
    // Button 클래스의 내부 인터페이스를 익명 클래스로 구현
    button1.setOnClickListener(new Button.OnClicklistener() {
        @Override
        public void onClick() {
             System.out.println("개발자 1. 음악재생");
        }
    });
    button1.click();
}

main에서 Button 클래스의 객체인 button1이 만들어지고, 이 객체는 OnClickListener 타입의 ocl 필드를 가지고 있다. OnClickListener에서 onClick 메서드를 구현하고 있으며 setOnclickListener는 이 객체를 받아서 버튼 안에 있는 ocl 필드에 저장한다. this.ocl = ocl로 개발자가 전달한 동작을 버튼이 기억하게 된다.

button1.click();로 버튼이 클릭되면, onClick 메서드가 호출되어 "개발자 1. 음악재생"이 출력된다.

📚 참고한 책

- 기본적인 개념을 정리하고 추가적으로 궁금한 것들을 정리했습니다 -

🐥 🐥 🐥

✔️   인스턴스 멤버 이너 클래스_ 426p

• 인스턴스 멤버 이너 클래스

: 아우터 클래스 내에서 인스턴스인 객체 내부 멤버의 형태로 존재하는 클래스

class OuterClass {

    public int a = 1;
    protected int b = 2;
    private int c = 3;
    
    void outerMethod(){
        System.out.println("아우터클래스!");
    }    

    class InnerClass {
        
        void innerMethod() {
            System.out.println(a);
            System.out.println(b);
            System.out.println(c);
            
            outerMethod();
        }
    }    
     
}

public class PraticeInnerClass1 {
    public static void main(String[] args) {
    
        OuterClass outer = new OuterClass();
        
        OuterClass.InnerClass inner = outer.new InnerClass();
        
        inner.innerMethod();
        
    }
}

멤버 이너 클래스 중 하나인 인스턴스 멤버 클래스는 객체 내부의 멤버의 형태로 존재한다. 객체의 멤버란, 해당 클래스에 있는 필드나 메서드를 이야기 하는데 해당 클래스 내부에 클래스가 생긴다면 이 클래스도 멤버라는 것이다. 그렇기에 인스턴스 멤버 이너 클래스는 아우터 클래스의 모든 접근 지정자의 멤버에 접근할 수 있게 된다.

자바는 컴파일을 수행하면 각 클래스별로 바이트 코드인 .class 파일이 생성된다. 이너 클래스 마찬가지로 생성된다. 하지만 그 형태는 아우터 클래스와는 다를 수 있다. 아우터 클래스는 'OuterClass.class'라고 생성이 될 것이다. 그러면 아우터 클래스 안에 있는 인스턴스 멤버 클래스는 'OuterClass$InnerClass.class'로 파일이 생성된다. 그 이유는 당연하게도 아우터 클래스 내부에 있기 때문에 그것을 표시하고자 생성된다.

InnerClass 내에 innerMethod가 있다. innerMethod를 사용하고자 하여 인스턴스 멤버 클래스의 객체를 생성하려한다. 인스턴스 멤버 클래스의 객체를 생성하기 위해서는 먼저 아우터 클래스의 객체 생성이 필요하다. 그 후에 아우터 클래스 내에 있는 이너 클래스이니, 생성한 아우터 클래스 객체의 참조 변수를 이용해 객체 내부에 있는 이너 클래스의 생성자를 호출한다. 그러면 OuterClass.InnerClass inner = outer.new InnerClass( );가 된다.

위의 코드에서 innerMethod를 보면 아우터 클래스 필드에 접근하고 있다. 접근 가능한 이유는 InnerClass 내에 OuterClass의 멤버와 동일한 이름이 없기 때문인데, 만약 같은 이름이 InnerClass내에 존재한다면 섀도잉이 발생해 InnerClass 내부 필드의 값으로 변경되어 출력될 것이다. 그럼 동일한 이름을 가진 상태에서 아우터 클래스의 멤버에 접근하고자 한다면 어떻게 해야할까? 'OuterClass.this.a'를 붙이면 된다. OuterClass를 붙이지 않으면 InnerClass의 멤버에 접근하니 유의해야한다.

✔️   정적 멤버 이너 클래스_ 431p

• 정적 멤버 이너 클래스

: 이너 클래스 앞에 static이 포함된 클래스다.

class OuterClass {
    int a = 1;
    static int b = 2;
    
    void outerMethod1() {
        System.out.println("인스턴스 메서드!");
    }
    
    static void outerMethod2() {
        System.out.println("정적 메서드!");
    }    
     
    
    static class InnerClass {
        void innerMethod() {
            System.out.println(b);
            outerMethod();
        }
    }
}

public class PracticeInnerClass2 {
    public static void main(String[] args) {
        OuterClass.InnerClass inner = new OuterClass.InnerClass();
        
        inner.innerMethod();
    }
}

static이 포함된 이너 클래스는 static 특성을 지니게 된다. 그 특징이 아우터 클래스 내에 static이 붙은 멤버만 정적 이너 클래스 내부에서 사용할 수 있게 한다. 또 다른 특성을 살펴보자. 위의 코드를 살펴보면 main에서 아우터 클래스의 객체를 만들지 않고 바로 정적 이너 클래스의 객체를 생성한 것을 볼 수 있다. 아우터 클래스 내에 있는 정적 이너 클래스도 정적 멤버이므로 클래스명으로 바로 접근 가능하다.

✔️   지역 이너 클래스_ 433p

• 지역 이너 클래스

: 메서드 내에서 정의되는 클래스

class OuterClass {
    int a = 1;
    
    void outerMethod(){
        int b = 2;
        
        class InnerClass {
            void innerMethod() {
                System.out.println(a);
                System.out.println(b);
            }
        }
        
    InnerClass inner = new InnerClass();
    inner.innerMethod();
    }
}

public class PracticeInnerClass3 {
    public static void main(String[] args) {
        
        OuterClass outer = new OuterClass();
        outer.outerMethod();
        
    }
}

지역 이너 클래스는 정의된 메서드 내부에서만 사용 가능하며, 지역 이너 클래스를 선언 이후 바로 객체를 생성해서 사용한다는 특징이 있다. 메서드가 호출이 되면 그때만 메모리에 로딩되기 때문에 정적 영역과는 다른 특성을 가지고 있다. 정적 영역은 객체가 생성되기 전에 먼저 메모리에 로딩되어있다.

메서드 내부에 있는 변수는 지역 변수라고 한다. 지역 이너 클래스가 지역 변수를 사용하고자 하면 해당 지역 변수가 final로 선언되어있어야 한다. 만약 final을 선언하지 않아도 컴파일러가 알아서 해당 지역 변수에 추가해준다. 또 해당 지역 변수의 값이 변동된다면 컴파일러 에러가 발생한다.

Q. 지역 변수에만 final을 붙여야하는 이유가 뭘까?

A. 메서드가 끝이 나더라도 지역 이너 클래스의 객체는 메서드 밖에서 살아남을 수 있다. 그런데 메서드 내에 있는 변수인 지역 변수는 메서드가 끝나면 사라지게 된다. 지역 이너 클래스의 객체는 살아남아서 활동해야하는데, 변수가 끝나버리면 해당 클래스는 제대로 사용할 수 없게된다. 그렇기에 final을 붙여 해당 값이 변동되지 못하도록하고 값을 복사하여 메서드가 끝이나도 사용할 수 있게 해준다.

📚 참고한 책

- 기본적인 개념을 정리하고 추가적으로 궁금한 것들을 정리했습니다 -

🐥 🐥 🐥

✔️   추상클래스_ 395p

• 추상클래스

: 메서드 본채가 완성되지 않은 미완성 메서드로, 메서드의 기능을 정의하는 중괄호 자체가 없으며 명령어의 끝을 알리는 세미클론으로 끝난다.

abstract class A {
    abstract void abc();    
    void bcd() {
    }
}

추상 메서드를 1개 이상 포함하고 있는 클래스는 반드시 추상 클래스로 정의해야한다. 일반적으로 추상 클래스는 메서드의 기능이 정의되어 있지 않는 미완성 메서드인 중괄호가 없는 형태의 메서드가 1개 이상 존재한다는 의미이다. 추상 클래스의 형식은 class 키워드 앞에 abstract를 붙여 표현한다.

추상 클래스의 주의해야할 점은, 중괄호의 여부이다. 만일 중괄호가 있는 상태로 코드를 완성하면 그 메서드는 '아무런 기능을 하지 않는 완성된 메서드'라고 기능을 명확히 정의하게 된다.

추상 클래스는 내부의 미완성 메서드를 지니고 있기 때문에 객체를 직접 생성할 수 없다. 그 이유는 힙 메모리의 특성 때문이다. 힙 메모리는 값이 비어있는 필드를 저장할 수 없는 특성을 지녔는데, 이로 인해 미완성된 메서드를 가진 추상 클래스는 A a = new A( )와 같이 생성자 호출 자체를 할 수 없다.

• 추상 클래스 객체 생성하는 방법 : 1. 추상 클래스를 상속한 일반 클래스

abstract class A {
	abstract void abc();
}

class B extends A {
	void aaa() {
    	System.out.println("자식 클래스로 추상 클래스 이용하기");
    }
}

public class AbstractClass_1 {
	public static void main(String[] args) {
    	A b1 = new B();
        A b2 = new B();
        
        b1.aaa();
        b2.aaa();
    }
}

B는 추상 클래스를 상속했다. B가 일반 클래스로 역할을 하고 싶다면, 추상 클래스를 상속했기에 추상 메서드의 구체적으로 어떤 역할을 할 것인지 정의해야한다. 만약 객체를 여러개 만들어야하는 상황이라면 위의 코드와 같이 자식 클래스를 직접 정의하는 것이 더 적절한다.

• 추상 클래스 객체 생성하는 방법 : 2. 이너클래스 

abstract class A {
    abstract void abc();
}

public class AbstractClass {
    public static main(String[] args) {
    
        A a1 = new A();
            void abc() {
                System.out.println("이너클래스로 이용하기");
            }
        };
                  
        a1.aaa();
}

이너클래스를 이용하는 것은, A( )는 컴파일러가 클래스 A를 상속받아 aaa( ) 메서드를 오버라이딩한 익명 클래스의 생성자를 호출하는 것이다. 이 경우 클래스 A의 생성자를 호출하는 것이 아니다. 익명 이너 클래스를 활용한 장점으로는 코드가 간결해 보인다는 점이 있지만, 상속한 경우와 달리 객체를 여러개 만들기엔 적합하지 않다. 

✔️   인터페이스_ 402p

• 인터페이스

: 서로 다른 시스템이나 장치, 또는 사용자 간의 정보 교환을 위한 접점이나 경계면

interface abc {
    public static final int a = 1;
    public abstract void abc();
}

인터페이스 내부의 모든 필드는 public static final로 정의되어있고, static과 default 메서드 이외의 모든 메서드는 public abstract로 정의되어있다. 클래스는 class라고 이름 앞에 붙여주었다면, 인터페이스는 interface임을 이름 앞에 명시한다. 제어자를 명시적으로 적지 않았어도 public static final과 public abstract는 자동으로 추가된다.

Q. 인터페이스 내 필드에 static과 final을 붙이는 이유는?

A. 인터페이스는 기능의 약속을 정의하는 곳으로 "어떤 기능을 제공하겠다."라는 메서드 이름과 규약만 가지고 있다. 인터페이스는 행위에 대한 약속만 하지, 변수에 대해서는 기본적으로 정의하지 않기 때문에 인터페이스 내의 변수는 기본적으로 변하지 않는 상수여야만 한다. 여기서 static은 클래스(인터페이스) 자체에 붙어있는 것으로 객체 생성 없이 접근 가능하며, final은 한 번 정의한 값은 변경되지 않는 특성을 부여해준다.
인터페이스는 인스턴스를 만들 수 없기 때문에 변수에 static을 붙여 인터페이스 내에 저장되도록 하여 접근가능하게 만들고, 인터페이스는 메서드를 관리하는 곳이기 때문에 변경되는 변수에 의해 메서드의 변동이 생기는 것을 방지해야함으로 final을 붙인다.

Q. 인터페이스와 추상 클래스의 차이점은 무엇이며 어떤 상황에 맞춰 써야하는가?

A. 인터페이스는 메서드의 이름만 정의해두는 곳이다. 인터페이스를 상속받은 클래스에서 구체화가 이루어져 정확히 이 메서드가 어떤 기능을 가지는지 정의한다. 추상 클래스는 추상화가 들어있는 클래스라고 생각하면 된다. 일반 변수, 상수 모두 정의할 수 있으며 공통 기능과 약속된 기능도 함께 있다. 접근제어자도 자유롭게 지정가능하다.
인터페이스는 다양한 클래스들이 공통 없이 제각각 동작하는 경우 사용한다. 혹은 다중 구현이 필요하거나 특정 역할로 나눌 때 사용한다. 추상 클래스의 경우 기본 형태는 유지하면서 세부적인 동작을 다르게 하고 싶을 때 사용한다. 같은 타입끼리 묶고 공통 코드를 재사용한다고 생각하면 된다.

• 인터페이스의 상속

class ABC extends myClass implements myInterface1, MyInterface2 {

}

인터페이스는 미완성 메서드를 완성하기 때문에 상속하는 의미인 extends가 아닌 구현하는 의미인 implements를 사용한다. 그래서 인터페이스에 정의된 메서드는 자식 클래스에서 모두 구현되어야 제대로 작동된다.

1. 한 클래스는 인터페이스를 다중 상속 가능하다.
클래스는 두 부모 클래스에 동일한 이름의 필드 혹은 메서드가 존재하면 어느 부모 클래스의 필드(메서드)를 가져올지 혼동하여 오류가 발생하게 되고 그것을 막고자 클래스는 다른 클래스를 다중 상속하는 것을 막고 있다. 하지만 인터페이스를 다중 상속하는 것은 가능하다. 왜냐하면 모든 필드가 public static final로 정의되어 각 인터페이스 내에 존재하기 때문에 저장 공간이 겹치지 않기 때문이다. 메서드의 경우 어차피 자식 클래스에서 완성되기 때문에 문제되는 부분이 없다.

2. 한 클래스는 하나의 클래스와 여러 인터페이스를 동시에 상속할 수 있다.
클래스만 다중 상속하지 않는다면 문제될 건 없다. 다만 상속할 경우 순서에 유의해야한다. 반드시 처음에 클래스 먼저 상속해주고 그 다음 인터페이스를 상속해야한다.

3. 인터페이스는 인터페이스를 상속할 수 있다.
인터페이스는 인터페이스를 상속할 수 있지만 이때 implements가 아닌 extends로 상속해야한다. 예시를 들어보자면 interface myInterface1 extends myInterface2의 형식이 될 것이다.

4. 인터페이스는 클래스를 상속하지 않는다.
인터페이스는 완성되지 않은 테두리만 있는 메서드를 가진다. 그런데 완성된 메서드를 지닌 클래스를 상속하게 된다면 인터페이스의 의미가 사라지게 되니 클래스는 인터페이스에 상속되지 못한다.

5. 모든 자식 클래스의 구현 메서드는 public만 가능하다.
하위 클래스에 오버라이딩이 수행될 때 접근 지정자는 부모 메서드의 접근 지정자와 접근 범위가 같거나 커야 한다. 인터페이스의 모든 필드와 메서드는 public으로 강제되어있어서 인터페이스를 상속받는 모든 자식 클래스는 public 접근 지정자만 가져야한다.

인터페이스의 객체 생성 방법은 추상 클래스와 동일하다.

• 인터페이스의 디폴트 메서드

interface myInterface {
    public default void myMethod {
    
    }
}

myInterface가 여러 클래스에 상속되어 사용되고 있다고 가정하자. 무수히 많은 클래스에 사용되고 있는 와중에 인터페이스 내에 새로운 메서드가 추가된다면? myInterface를 상속하고 있는 모든 클래스에 오류가 발생할 것이다. 그 이유는 인터페이스에 정의된 메서드는 상속한 클래스에서 모두 구현되어야하는데, 새로 추가된 메서드는 모든 클래스에 구현되지 않아서 오류가 발생했다. 이런 문제점을 해결하고자 추가된 것이 default 메서드이다. 디폴트 메서드는 인터페이스 내부에 완성된 메서드를 삽입하여 자식 클래스에서 이 메서드를 반드시 오버라이딩 하지 않아도 되는 것이다. 

• 인터페이스의 super

interface myInterface {
    default void myMethod(){
        System.out.println("MyInterface의 메서드 출력");
     }
}

class myClass implements myInterface {
    @Override
    public void myMethod(){
        myInterface.super.myMethod();
        System.out.println("myClass의 메서드 출력");
    }
}

myClass.myMethod( );를 호출한다면, super로 인해 인터페이스의 메서드가 호출된 후 그 다음에 클래스의 메서드가 호출될 것이다. super를 클래스에 사용할 땐, 그냥 메서드명 앞에 super.을 붙이면 됐는데 인터페이스의 경우 인터페이스명.super.메서드명을 붙였다는 차이가 있다. 아마 그 이유는 인터페이스는 다중 상속이 가능하기 때문에, 어떤 인터페이스의 메서드를 방문할 것인지 정확하게 적어야하는 듯 하다.

• 인터페이스의 static

interface MyInterface {
    static void greet() {
        System.out.println("Hello from Interface!");
    }
}

public class Main {
    public static void main(String[] args) {
        MyInterface.greet(); 
    }
}

인터페이스에 static 메서드를 사용할 수 있는데, 이런 경우 Main 클래스에 보이는 것과 같이 객체를 생성하지 않고 바로 인터페이스의 greet 메서드를 호출할 수 있게 됐다. 이렇게 되면 오버라이딩 신경쓸 것 없이 독립적으로 존재 가능하며, static 메서드를 외부로 빼지 않아도 되어 개발자 입장에선 좀 더 편리해진다.

📚 참고한 책

- 기본적인 개념을 정리하고 추가적으로 궁금한 것들을 정리했습니다 -

🐥 🐥 🐥

✔️   final 제어자_ 379p

• final 변수

: 한 번 대입된 값을 수정할 수 없으며, 한 번 대입된 값이 최종 값이 된다.

class A {
    int a;
    final int b;
    
    A() {
        a = 3;
        b = 5;
    }
}

class B {
    int a = 3;
    final int b = 5;
    
    B() {
    }
}

클래스 A는 선언과 값의 대입을 분리하였다. 클래스 B는 선언과 값을 동시에 대입했다. 이때 final 필드를 값과 동시에 선언하지 않았을 경우 값의 초기화는 반드시 생성자에서 이뤄져야한다. final 필드는 일반 필드와 다르게, 강제 초기화되지 않는다. 그래서 값이 대입한 후 값을 입력하는 행위 자체는 할 수 없다.

Q. 왜 생성자에서 초기화를 하도록 할까?

A. 그 이유는 객체마다 다른 값을 가질 수 있도록 하기 위함이다.

class Car {
    final String model;

    Car(String model) {
        this.model = model;
    }

    void printModel() {
        System.out.println("차 모델 이름은 무엇입니까? : " + model);
    }
}

public class Main {
    public static void main(String[] args) {
        Car car1 = new Car("Tesla");
        Car car2 = new Car("BMW");

        car1.printModel(); // Car model: Tesla
        car2.printModel(); // Car model: BMW
    }
}

만약 선언과 값을 같이 대입한다면 각 객체마다 같은 값을 가져야만 할 것이다. 상황에 따라 객체마다 다른 값을 가지는 것이 필요할 수 있다. 그렇기에 생성자를 통해 final 변수 값을 대입한다면 위의 코드와 같이 객체마다 다른 값을 가지게 할 수 있다.

• 상수 영역

: 힙 영역의 Permanent area(고정 영역)에 생성되어 Java 프로세스의 종료까지 계속 유지되는 메모리 영역

class A{
    int a;
    final int b;
    
    A() {
        a = 3;
        b = 5;
    }
}

필드는 멤버이므로 final 필드이든, 아니든 객체 속에 포함된다. 하지만 객체가 만들어질 때 final로 선언된 필드 값은 상수 영역에 1개가 복사된다. final로 선언된 모든 필드 값은 상수 영역에 복사되므로 첫 번째 메모리 영역을 상수 영역이라고 부른다. 이때 값의 복사는 선언한 후 최초로 값이 초기화될 때 딱 한 번 일어난다.

final이 붙지 않은 스택 메모리의 변숫값은 자신이 만들어진 메서드가 종료되면 메모리에 사라진다. 하지만 이벤트를 처리할 대 메모리에서 사라진 그 변수를 다시 사용해야하는 경우가 있는데, 이런 경우를 위해서 복사본을 하나 만들어 놓고 원본이 삭제되더라도 그 값을 활용할 수 있게 만들었다.

- 상수풀 영역

• final 메서드

: 최종 메서드라고 불리며 메서드 기능 변경이 이뤄지지 않는다. (오버리이딩 X)

class A {
    void abc() {
    }
    
    final void bcd() {
    }
}

• final 클래스

: 최종 클래스라고 불리며, 더 이상 자식 클래스가 없으며 상속 자체가 불가하다.

final class A{

}

final 클래스와 비슷한 것이 String 클래스가 있다. String 클래스도 final 클래스로 정의되어 있어서 마찬가지로 String 클래스를 상속받아 자식 클래스로 이용할 수 없다.

Q. String과 final의 차이점은?

A. String은 불변 객체로 한 번 생성된 문자는 변경할 수 없다. 그 점은 final과 같지만, String은 참조(주소)를 변경할 수 있다. 

public class Test {
    public static void main(String[] args) {
        String str = "Hello";
        str = "World";
        System.out.println(str);
    }
}

"Hello"의 값이 "World"로 변경되는게 아니다. str이 새로운 참조를 만들어 거기에 "World" 값을 저장하는 것이다. 즉, String은 새로운 문자열을 할당할 순 있다.

- string

✔️   abstract 제어자_ 387p

• 추상 메서드

: 중괄호가 없으며, 무슨 기능을 정의할지 정해지지 않은 미완성 메서드다.

abstract class Animal {
    abstract void cry() {}
}

class Cat extends Animal {
    void cry() {
        System.out.println("야옹");
    }
}

class Dog extends Animal {
    void cry() {
        System.out.println("왈왈");
    }
}

Animal animal1 = new Cat();
Animal animal2 = new Dog();

animal1.cry();
animal2.cry();

추상 메서드를 1개 이상 포함하고 있는 클래스는 반드시 추상 클래스로 정의해야한다. abstract 제어자의 장점은 문법 오류가 발생했음을 알려주는 것이다. 예를 들어 Cat 클래스와 Dog 클래스에 cry 메서드가 아닌 cRy 메서드가 정의되었다고 가정하자. 일반클래스로 정의했을 경우 출력이 되지 않을 뿐 별다른 경고문이 뜨지 않는다. 하지만 abstract 제어자를 사용하여 코드를 작성할 경우 이렇게 정의된 메서드와 다른 메서드가 실행된다면 오류가 발생할 것이다.

실제 업무에서는 내가 작성한 코드를 가지고 다른 사람이 사용하는 경우가 있을 것이다. 어떤 오류가 나타나지 않고 엉뚱한 결과가 나온다면 다른 개발자는 어디서 오류가 났는지 찾아야할 것이다. 하지만 abstract는 이를 상속한 모든 자식 클래스 내부에는 항상 cry( )메서드가 있어야하기 때문에 오류를 보고 문제를 해결할 수 있을 것이다.

📚 참고한 책

- 기본적인 개념을 정리하고 추가적으로 궁금한 것들을 정리했습니다 -

🐥 🐥 🐥

✔️   메서드 오버라이딩_ 329p

• 메서드 오버라이딩

: 부모 클래스에게 상속받은 메서드와 동일한 이름의 메서드를 재정의하는 것으로, 부모의 메서드를 자신이 만든 메서드로 덮어쓰는 개념

class A {
    void print() {
         System.out.println("A 클래스")
    }
}

class B extends A {
    @Override
    void print() {
         System.out.println("B 클래스")
    }
}

public class MethodOverrideing_1 {
     public static void main(String[] args) {
         
         A aa = new A();
         aa.print();
         
         B bb = new B();
         bb.print();
         
         A ab = new B();
         ab.print();
     }
}

먼저 A aa = new A( );에서 일어나는 일을 살펴보면 힙 메모리에 A( ) 생성자로 객체가 생성되고, 이를 A 타입으로 선언한 참조 변수 aa가 이 객체를 가리키고 있을 것이다. 그런데 이때 A 객체 내부에는 실제 메서드의 위치 정보만 저장되어있고, 실제 print( )는 메서드 영역에 정의되어 있다. 이런 경우는 당연하게 "A 클래스"가 출력될 것이다.

B bb = new B( );는 처음에 A 객체 내의 print( )가 메서드 영역에 생성되고 그 후 B 객체가 생성된다. 그러면 A객체의 실제 print( )는 메서드 영역에 저장되고 그 후  B 객체의 print( ) 메서드도 같은 print( ) 영역에 저장된다. 즉 후에 생긴 B의 print( ) 메서드가 먼저 생긴 A의 print( ) 메서드를 덮어쓰기, 오버라이딩하게 되는 것이다. 그래서 bb.print( )를 하게 되면 "B 클래스"가 출력된다.

A ab = new B( )인 경우를 살펴보자. 처음 생성되는 과정은 B bb = new B( );와 같다. 여기서 다른 점은 A 타입의 참조 변수를 사용하고 있으므로 참조 변수가 A 객체를 가리키고 있다는 것이다. 따라서 ab.print( )는 실제 A 객체의 print( ) 메서드를 호출하는 것되는데, A 객체가 가리키는 print( ) 메서드는 이미 B 객체로 오버라이딩 된 경우이므로 결론적으로 출력되는 값은 "B 클래스"가 되는 것이다.

이때 오버라이딩은 덮어쓰기는 아니다. 덮어쓰는 것은 이전에 있던 것을 삭제하고 새로운 파일로 바꾸는 것이다. 하지만 오버라이딩은 원래 있던 것에 새로운 메서드가 올라 타는 것으로 생각하면 된다.

• 부모 클래스 타입으로 객체를 선언하는 경우

class Animal {
    void cry() {
         
    }
}

class Bird extends Animal {
    void cry() {
         System.out.println("짹짹")
    }
}

class Cat extends Animal {
    void cry() {
         System.out.println("냐옹")
    }
}

class Dog extends Animal {
    void cry() {
         System.out.println("멍멍")
    }
}

public class MethodOverrideing_1 {
     public static void main(String[] args) {
         
         Animal bb = new Bird();
         Animal cc = new Cat();
         Animal dd = new Dog();
         
         bb.cry();
         cc.cry();
         dd.cry();
     }
}

참조 변수는 모두 Animal 타입이지만, 각각 서로 다른 메서드로 오버라이딩 됐으므로 cry( ) 메서드는 서로 다른 출력 결과를 보인다. 여기서 Animal 클래스 내부에 아무런 기능도 수행하지 않는 cry( ) 메서드가 있기에 다른 결과가 보일 수 있는 것이다. 이것은 다형적 표현으로 자식 클래스들의 객체를 부모 클래스인 Animal 타입으로 선언할 수 있지만, 만일 부모 클래스에 cry( ) 메서드가 없다면 다른 자식 클래스는 cry( ) 메서드를 호출할 수 없다.

• 메서드 오버로딩

: 이름은 동일하지만, 시그니처가 다른 여러 개의 메서드를 같은 공간에 정의하는 것.

Q. 메서드 오버라이딩과 메서드 오버로딩의 차이점은?

A. 오버라이딩은 시그니처까지 완벽하게 동일한 파일을 같은 공간에 복사하는 것으로 이해하면 되고, 오버로딩은 시그니처는 다르지만 일름만 동일한 파일을 같은 공간에 복사한 것으로 이해하면 된다.

class Car {
    void sound1() {
         System.out.println("부릉부릉")
    }
    
    void sound2() {
        System.out.println("부르릉부르릉")
    }
}

class Car1 extends Car {
    void sound1() {
         System.out.println("빵빵")
    }
    
    void sound2(int a) {
         System.out.println("빠아앙")
    }
}

여기서 sound1은 메서드 오버라이딩이 된다. 상속받은 메서드와 리턴 타입 그리고 시그니처가 완벽하게 동일하기 때문이다. sound2는 Car 클래스에서 입력매개변수가 없는 메서드였지만, 클래스 Car1에서 입력매개변수로 정숫값 1개를 받게 되므로 메서드 시그니처가 달라 오버로딩이 되는 것이다.

그러면 이때 클래스 Car1에서 사용할 수 있는 메서드는 총 3개가 된다. sound1은 Car 클래스와 Car1 클래스 모두 동일한 메서드로 1개, Car에 있는 sound2 메서드, Car1에 있는 정숫값 하나를 받는 sound2 메서드를 사용할 수 있기 때문이다.

• 메서드 오버라이딩과 접근지정자

: 오버라이딩할 때는 상속받은 메서드의 접근 지정자와 범위가 같거나 넓은 접근 지정자를 사용한다.

class A {
    protected void abc() {}
}

class B extends A {
    public void abc() {}
}

class C extends A {
    protected void abc() {}
}

class D extends A {
    void abc() {}
}

class E extends A {
    private void abc() {}
}

오버라이딩을 할 때 접근지정자와 같거나 더 넓은 접근지정자만 사용가능하다 했으니, void abc( ) 와 private void abc( )는 사용할 수 없다.

✔️   인스턴스 필드의 중복_ 340p

• 인스턴스 필드의 오버라이딩

class A {
    int m = 3;
}

class B extends A {
	int m = 4;
}

인스턴스 필드는 동일한 이름으로 정의해도 오버라이딩되지 않는다. 그 이유는 저장 공간이 완벽하게 분리되어있기 때문이다. 메서드 오버라이딩을 살펴보았을때, 인스턴스 메서드 영역에 부모 클래스 메서드가 생성되고 그 위에 자식 클래스 메서드가 생성되기 때문에 오버라이딩이 발생된다고 설명했다.

인스턴스 필드의 경우 B 객체가 생성되기 전 부모 객체 A 객체가 먼저 생성될 것이고 그 후 클래스 B에서 추가한 내용을 포함하는 객체가 만들어질 것이다. 여기까진 메서드 생성 과정과 비슷하다. 하지만 인스턴스 필드는 m=3과 m=4인 총 두 개의 필드가 만들어져 저장공간이 완벽하게 분리된다는 것이 큰 차이가 되겠다.

만약 B b = new B( ); 선언하고 b.m의 값을 확인할 경우 4가 나올 것이다. b가 가리키고 있는 번지가 100번인 경우, 100번에는 B 객체의 m = 4 값이 들어있기 때문이다. A a = new B( )로 생성한 경우 A 타입이므로 A 가리키고 있을 것이고 그 번지가 200으로 B 객체의 번지와 다를 것이다. 그러므로 객체가 오버라이딩되지 않는다.

• 정적 필드의 중복

A.m = 3;
B.m = 4;

B b = new B();
b.m = 4;

정적 필드의 저장 공간은 정적 영역의 클래스 내부에 만들어지고 모든 객체가 공유한다. 스택에 포함된 A객체와 B객체에는 m의 값이 저장되어있지 않고, 클래스 영역 어디에 저장되어있는지 가리킬 것이다. 그러므로 클래스 A와 B 내에 포함된 정적 필드의 저장공간은 완벽하게 분리되기 때문에 오버라이딩은 발생하지 않는다.

정적메서드의 경우는 어떤지 살펴보면, 정적필드와 같음을 알 수 있다. 정적메서드도 마찬가지로 클래스 내부에 존재하지 않고, 다른 공간에 저장되기 때문에 오버라이딩은 발생하지 않는다.

결론적으로 중복이 되어 오버라이딩이 발생하는 경우는 인스턴스 메서드의 경우만 해당되는 것을 알 수 있었다. 인스턴스 필드, 정적 필드, 정적 메서드 모두 각 객체의 저장이 완벽하게 분리되기 때문에 오버라이딩은 발생하지 않는다.

✔️   super_ 349p

• super 키워드

: 부모의 객체를 가리키며, 필드명의 중복으로 가려진 부모의 필드 또는 메서드를 호출하기 위해 사용한다.

class A {
    void abc() {
        System.out.println("A 클래스의 abc()");
    }
}

class B extends A{
    void abc() {
        System.out.println("B 클래스의 abc()");
    }
    
    void bcd() {
         super.abc();
    }
}

B bb = new B();

bb.bcd();

super을 써서 abc를 호출하게 되면 부모 클래스인 A 클래스의 abc( )가 실행된다.

Q. this와 super의 차이점은?

A. this는 자기 객체를 가리키는 참조 변수명이다. this( ) 메서드는 자신의 또 다른 생성자를 호출하고, 생성자 내에서만 사용할 수 있으면 항상 첫 줄에 위치해야한다. super는 부모의 객체, super( )는 부모의 생성자를 의미한다.

class A {
    void abc() {
        System.out.println("A 클래스의 abc()");
    }
}

class B extends A{
    void abc() {
        System.out.println("B 클래스의 abc()");
    }
    
    void bcd() {
         abc();
    }
}

B bb = new B();

bb.bcd();

super을 쓰지 않고 abc( )를 자식클래스의 메서드에서 호출하게되면 this 키워드가 추가되어 실행된다. 그러면 클래스 B에 있는 abc( ) 실행 코드는 클래스 B 내부에 있는 abc( )를 실행하게 된다. 그렇기에 만약 부모 클래스의 코드가 자식 클래스에서 실행되길 원하는 경우 super키워드를 추가해야한다.

• super( ) 메서드

class A {
    A() {
        this(3);
        System.out.println("A 생성자1")
    }
    
    A(int a) {
        System.out.println("A 생성자2")
    }
}

class B extends A {
    B() {
         this(3);
         System.out.println("B 생성자1")
    }
    
    B(int a) {
         System.out.println("B 생성자2")
    }
}

A aa1 = new A();
A aa2 = new A(3);

B bb1 = new B();
B bb2 = new B(3);

aa1은 클래스 A에 있는 기본 생성자가 호출된다. 가장 첫 코드는 this(3)으로 내부에 있는 정수값 하나를 받는 메서드를 찾아 실행한다. 그러면 A(int a)가 실행되고 "A 생성자2"가 출력되고 그 다음 "A 생성자1"이 출력된다. aa2는 3을 인자로 가지기 때문에 클래스 A에 있는 A(int a)가 실행된다. 자식 클래스가 아니라서 컴파일이 자동으로 붙이는 것 없이 "A 생성자2"가 출력된다.

bb1은 메서드 B에 있는 this(3)가 먼저 실행된다. this로 내부에 있는 B(int a)가 실행되면서 이때 B(int a)의 가장 첫 줄엔 super가 붙게된다. 물론 이 super는 컴파일이 자동적으로 붙인 것이다. super로 인해 부모 클래스가 실행되게 되고 부모 클래스의 가장 기본 생성자에 있는 this(3)으로 인해 A(int a)가 실행되어 "A 생성자2"가 가장 먼저 출력된다. 그 다음은 "A 생성자1"이 출력으로 A( ) 메서드를 마무리 짓는다. 그러면 다시 클래스 B로 돌아와 super가 진행된 다음 코드를 실행하므로 "B 생성자 2"가 출력되고  B( ) 메서드의 "B 생성자1"로 마무리된다. 객체 bb2는 클래스 B의 기본 생성자만 실행되지 않을 뿐, 나머지 과정은 동일하다.

여기서 가장 중요한 사실은 모든 생성자의 첫 줄에서는 반드시 this( ) 또는 super( )가 있어야한다는 것이다. 만일 아무것도 써주지 않으면 컴파일러는 super( )를 자동으로 삽입한다. 즉, 생성자를 호출할 때는 항상 부모 클래스의 생성자가 한 번은 호출된다는 것이다. 그리고 부모클래스에 기본 생성자가 없을 경우 컴파일러 오류가 발생한다. (super( )가 자동적으로 추가되는데, 기본 생성자가 없이 어떤 인자를 받는 메서드만 있을 경우 오류 발생)

• 정리

: super( )는 자식클래스의 메서드 가장 첫 줄에 컴파일러가 자동으로 추가하여 부모 클래스가 실행되도록 한다.

  this.는 부모클래스와 자식클래스에 중복되는 이름의 메서드가 있는 경우, 자식클래스에서 그 메서드를 실행하고자 할 때 컴파일러가 자동으로 내부 클래스의 메서드가 실행되도록 this.를 추가한다.

📚 책 소개하기

내가 사용한 자바완전정복 책 링크!
ㄴ 김동형 지음, 이지스퍼블리싱

이 책을 고르게 된 이유는 친구의 추천이었다. 굉장히 꼼꼼하게 적혀있어 이해하기 쉽다는 이유로 친구는 이 책을 골랐다고 했다. 나도 그래서 그냥 따라샀다. 실제로 책을 살펴보니 굉장히 꼼꼼하게 정리되어있다. 다른 책은 본 적이 없어 비교가 불가하지만, 내 생각으론 처음 자바를 공부한다면 이 책을 가지고 충분히 따라갈 수 있을 듯 하다. 모두들 화이팅!!

🐰

✔️   상속_ 307p

• 상속

: 부모 클래스의 멤버(필드, 메서드, 이너 클래스)를 내려받아 자식 클래스 내부에 포함시키는 자바 문법 요소

class Human {
     String name;
     int age;
     void eat() {}
     void sleep() {}
}

class Student extends Human {
    int studentID;
    void goToSchool() {}
}

Human h = new Human();
h.name = "김자바";
h.age = 1;
h.eat;

Student s = new Student();
s.name = "김완전";
s.age = 2;
s.studentID = 12;

클래스를 상속할 때는 extends 키워드를 사용하며, 클래스명 다음에 extends 부모 클래스명(extends Human)으로 표기하면 된다. Student 클래스는 Human 클래스에 없는 필드와 메서드를 추가적으로 구성하면 되는데, 이를 통해 코드의 중복성을 제거하는 장점이 있다. 또한 '학생은 학생이다.' 말고 '학생은 사람이다.' 라는 말이 추가되면서 다형적 표현이 가능해진다. 다형성이란, 1개의 객체를 여러 가지 모양으로 표현하는 것이다.  '사람은 학생이다.' 라는 말을 살펴보면 이는 옳지 않다는 걸 알 수 있다. 상속이 다형성이란 장점을 가지지만 '자식 클래스는 부모 클래스다.' 라는 말이 성립되지 않을 수 있으니 유의해야한다.

Student 클래스는 필드 3개, 메서드 3개를 가지게 된다.

Q. 코드의 중복 제거를 위해 상속을 사용하는 것이 더 효율적일까?

A. 그것은 아니다. 코드의 중복을 제거하는 것보다 상속을 사용하는 것이 프로젝트를 더 복잡하게 만들 수 있다. 오히려 간단한 코드의 경우 각각의 클래스에 넣어 작성하는 것이 효율적이고 빠를 수 있다.

• 다중 상속

class B {
    int data = 3;
}

class C {
    int data = 4
}

class A extends B, C {
    ...
}

A a = new A();
System.print.out(a.data);

자바는 다중상속을 지원하지 않는다. 그 이유는 클래스 B와 클래스 C에 data 필드를 포함하고 있으니 A 입장에서 어느 data를 가져와야할지 혼동하기 때문이다. 즉 모호성을 발생시키기 때문에 다중상속을 허용하지 않는다.

• 상속할 때의 메모리 구조

class A {
    int m;
    void abc() {}
}

class B extends A {
    int n;
    void bcd() {}
}

B b = new B();

자식 클래스와 부모 클래스는 JVM에 의해 로딩되는데, 이것을 클래스 로딩이라고 한다. 이제 클래스가 로딩되면 메서드 영역에 클래스에 대한 정보를 저장한다. 그 후 실제 객체는 힙 메모리에 생성된다. 처음에 부모 클래스 객체를 생성하고 그 후 자식 클래스에서 추가한 필드와 메서드가 객체에 추가된다. 즉, 자식 클래스 객체의 내부에 부모 클래스 객체가 포함된다.

참조 변수 b는 B 타입으로 선언됐다. 그렇기에 B 타입 객체만을 가리킬 수 있는데, 객체 B 안에는 부모 클래스도 함께 존재하기 때문에  자식 클래스 객체에서 부모 클래스의 멤버를 사용할 수 있게 된다.

• 생성자의 상속 여부

class A {
    A() {
    }
}

class B extends A {
}

생성자는 자식 클래스인 B 클래스에 상속되지 않는다. 그 이유는 생성자를 클래스 B가 상속하게되면 클래스명과 생성자명이 달라지면서 생성자가 될 수 없다. 메서드가 되기 위해선 리턴 타입을 정해야하는데, 리턴 타입도 없어서 메서드가 될 수 없다. 결국 자식 클래스가 생성자를 받게되면 오류가 발생하게된다.

✔️   업캐스팅과 다운캐스팅_ 319p

• 캐스팅

: 등호를 중심으로 항상 왼쪽과 오른쪽의 자료형이 일치해야하는데, 자료형이 다른 경우 타입을 변화해주는 것을 의미한다.

• 업캐스팅

: 범위가 좁은 쪽에서 넓은 쪽으로 캐스팅된다. (자식 클래스에서 부모 클래스로 변환)

class A {}
class B extends A {}
class C extends B {}

B b1 = new B();
A a1 = b1;

C c2 = new C();
B b2 = (B) c2;

업캐스팅은 컴파일러가 자동으로 타입을 변환해준다. 그래서 A a1 = (A) b1;으로 적지 않아도 (A)를 컴파일러가 알아서 추가한다. 클래스 A는 클래스 B를 상속한다. 클래스 B는 클래스 C를 상속한다. 그러면 b1은 A타입으로 변환할 수 있다. 그리고 C는 B와 A로 타입을 변환할 수 있다.

좀 더 쉽게 설명하자면 A 클래스가 사람, B 클래스가 학생이라고 가정한다면 '학생은 사람이다.'는 언제나 맞는 말이니 업캐스팅이 가능할 것이다.

• 다운캐스팅

: 범위가 넓은 쪽에서 좁은 쪽으로 캐스팅된다. (부모 클래스에서 자식 클래스로 변환)

class A {}
class B extends A {}
class C extends B {}

A a1 = new A();
B b1 = (B) a1;

A a2 = new B();
B b2 = (B) a2;
C c2 = (C) a2;

A타입인 생성자 a1은 B타입으로 다운 캐스팅 될 수 없다. 왜냐하면 클래스 A는 클래스 B나 C를 상속하고 있지 않다. 그러므로 B b1= (B) a1;은 오류가 발생한다.

생성자 a2를 살펴보자. 여기서 참조 변수 타입과 실제 객체 타입이 동일하지 않다. 참조 변수 타입은 A가 되고 실제 객체 타입은 B가 된다. 메모리로 살펴보면 B는 A 클래스를 상속하므로 힙 메모리에 이미 B타입 안에 A타입이 있는 형태일 것이다. 결국 실제 객체 타입은 B가 되면서, a2는 B 객체를 가리키게 된다. 그러므로 a2는 B타입으로 다운 캐스팅이 가능하다.

그러면 c2를 살펴보자. 클래스 B는 클래스 C를 상속하지 않는다. 힙 메모리에 C타입 객체가 존재하지 않는다. (만들어진 적이 없기 때문에) 그렇기에 ClassCastException을 발생시킨다.

결론적으로 다운캐스팅은 참조 변수 타입보다 실제 객체 타입에 중점을 둔다. 실제 객체 타입이 어느 클래스를 상속하는지에 따라 다운캐스팅의 여부가 결정된다.

Q. 참조 변수 타입과 실제 객체 타입의 차이점은?

A. 참조 변수 타입은 컴파일 시점에 영향을 미친다. 참조 변수 타입에 따라 호출 가능한 메서드와 접근 가능한 필드에 제한이 생기는데, 정적 바인딩으로 동작한다. 상위 타입으로 선언할 경우 자식 클래스의 객체를 참조할 수 있다. (다형성)
new 키워드를 통해 생성된 객체 타입으로 런타임 시점에 영향을 미친다. 실제 객체 타입에 따라 동작에 영향을 미치는데 동적 바인딩으로 동작한다. (캐스팅)

✔️   타입에 따른 차이점_323p (내용 다름)

• 실제 객체 타입

: 런타임 시점에 영향을 주며, 동적바인딩으로 동작한다.

• Cat 타입, Cat 생성자

interface Animal {
    void sound();
}

class Cat implements Animal {
    @Override
    public void sound() {
        System.out.println("Meow");
    }

    public void scratch() {
        System.out.println("Cat is scratching");
    }
}

public class Main {
    public static void main(String[] args) {
        Cat a2 = new Cat();
        a2.sound();   
        a2.scratch(); 
    }
}

생성자 a2는 참조 변수 타입과 실제 객체 타입이 Cat으로 동일하다. 이런 경우 a2는 Cat에 있는 메서드를 사용해야한다. 그렇기에 sound 값은 "Meow"가 될 것이다. scratch는 잘 실행되어 "Cat is scratching"으로 출력될 것이다.

• Animal 타입, Cat 생성자

interface Animal {
    void sound(); 
}

class Cat implements Animal {
    @Override
    public void sound() {
        System.out.println("Meow");
    }

    public void scratch() {
        System.out.println("Cat is scratching");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal a2 = new Cat();
        a2.sound();

        a2.scratch();
    }
}

오버라이딩된 메서드를 살펴볼 것이다. 인터페이스인 Animal을 상속하는 Cat 클래스는 sound( ) 메서드를 가졌지만, Animal 인터페이스도 똑같이 sound( ) 메서드가 있다.

참조 변수 타입은 Animal이고 실제 객체 타입은 Cat인 생성자 a2는 sound( )메서드와 scratch( )메서드를 호출하고자 한다. 이때 sound 메서드는 오버라이딩이 되어 Cat의 sound 메서드가 호출되어 (동적바인딩) "Meow"가 출력될 것이다. 그런데 Animal 클래스에는 scratch 메서드가 존재하지 않았다. 그렇기에 Animal 타입인 a2는 scratch 메서드는 불러올 수 없다.

• 참조 변수 타입

: 컴파일 시점에 영향을 주며, 정적 바인딩으로 동작한다.

interface Animal {
    void sound(); 
}

class Cat implements Animal {
    @Override
    public void sound() {
        System.out.println("Meow");
    }

    public void scratch() {
        System.out.println("Cat is scratching");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal a2 = new Cat(); 
        a2.sound();

        Cat a = (Cat) a2;
        a.scratch();
    }
}

위의 코드에서 a2.scratch는 오류가 발생했다. 그렇다면 오류가 발생하지 않게 하기 위해서는 생성자 a2를 다운캐스팅 해주면 된다. a2가 Animal 타입을 가지고 있어서 Animal에 있는 메서드만 실행가능했다. 그러면 a2를 Cat 타입으로 바꿔주면 된다. 참조 변수 타입을 변경하기 위해 다운캐스팅을 해줬다. 그러면 scratch 메서드를 사용할 수 있다.

✔️   instanceof_ 326p

• instanceof

:  캐스팅 가능 여부를 불리언 타입으로 확인할 수 있다.

C c = new C();

System.out.println(c instanceof A);

[ 참조 변수 instanceof 타입 ] 형식으로 쓰이며, 캐스팅이 가능하면 true로 불가능하면 false로 확인할 수 있다. instanceof 키워드를 사용하면 상속 관계나 객체를 만든 생성자를 직접 확인하지 않고도 캐스팅 가능 여부를 확인할 수 있다.

📚 책 소개하기

내가 사용한 자바완전정복 책 링크!
ㄴ 김동형 지음, 이지스퍼블리싱

이 책을 고르게 된 이유는 친구의 추천이었다. 굉장히 꼼꼼하게 적혀있어 이해하기 쉽다는 이유로 친구는 이 책을 골랐다고 했다. 나도 그래서 그냥 따라샀다. 실제로 책을 살펴보니 굉장히 꼼꼼하게 정리되어있다. 다른 책은 본 적이 없어 비교가 불가하지만, 내 생각으론 처음 자바를 공부한다면 이 책을 가지고 충분히 따라갈 수 있을 듯 하다. 모두들 화이팅!!

🐰

✔️   멤버 및 생성자의 접근 지정자_ 280p

• 4종류의 접근지정자

:  public, protected, default(혹은 package), private

• 접근 범위

:  public > protected > default > private

• 다른 클래스를 상속하여 받은 경우

public class A {
    
    public int a = 1;
    protected int b = 2;
    int c = 3;
    private int d = 4;
    
    public void print() {
        System.out.println(a + " ");
        System.out.println(b + " ");
        System.out.println(c + " ");
        System.out.println(d + " ");     
    }
}

public class B extends A{

    public void print() {
        System.out.println(a + " ");
        System.out.println(b + " ");
    }
}

클래스 B는 클래스 A를 상속했다. 그러면 다른 패키지의 모든 클래스에서 사용 가능한 pubic이 붙은 변수 a와 다른 패키지의 자식 클래스에서 사용 가능한 protected가 붙은 변수 b를 클래스 B에서 사용할 수 있다.

그런데 원래 다른 클래스의 변수나 메서드를 사용하려면 객체 생성을 해줘야한다. 하지만 상속은 객체 생성 없이 바로 클래스 A의 변수나 메서드를 사용할 수 있다.

• 다른 클래스를 상속하지 않은 경우

public class A {
    
    public int a = 1;
    protected int b = 2;
    int c = 3;
    private int d = 4;
    
    public void print() {
        System.out.println(a + " ");
        System.out.println(b + " ");
        System.out.println(c + " ");
        System.out.println(d + " ");     
    }
}

public class B {

    A a = new A(); // 객체 생성!!!
     
    public void print() {
        // public인 변수 a만 가능
        System.out.println(a + " ");
    }
}

✔️   클래스 접근 지정자와 생성자 접근 지정자_ 285p

• default 클래스를 import 하는 경우

import abc.bcd.A;

class A {
 ...
}

import abc.bcd.A;

class B {
 ...
}

클래스 앞에는 private와 default만 붙을 수 있다. 그런데 default는 동일 패키지 내 모든 클래스에서만 사용가능하기 때문에, 다른 패키지에 import하는게 불가능하다. 그러니 위의 코드는 오류가 발생할 것이다.

만약 public 클래스에 생성자를 추가한다면, 그 생성자 앞에 접근지정자를 붙이지 않아도 public이 붙을 것이다. 이렇듯 자동으로 추가되는 생성자의 접근 지정자는 클래스의 접근 지정자에 따라 결정되며, 자동이 아닌 직접 접근 지정자를 붙여주는 경우 클래스의 접근 지정자를 따라 붙일 필요는 없다.

클래스에는 public과 default만 앞에 붙을 수 있었다. 그러면 생성자에 자동으로 추가되는 접근 지정자도 public 혹은 default가 될 것이다. 생성자가 default라면 다른 패키지에는 사용불가한다는 점을 유의하면 된다.

Q. 클래스 앞에 private와 default만 붙을 수 있는 이유는?

A. private를 클래스에 붙는다면 접근자체가 불가능하게되어 클래스의 의미 자체가 없어질 것이다. 그렇다면 protected는 안되면서 default는 되는 이유가 무엇인지 추측해봐야한다. protected는 상속이 된다. 이 점이 default와 차이점인데, 아마 상속이 붙어서 protected는 클래스에 붙이지 않은 것 같다. (예외가 생기는 느낌?)_ 명확한 답을 못찾음

• public 클래스에 default 생성자의 경우

Package abc.bcd;

public class A {
    A() {
    }
}

package bcd.cde;

import abc.bcd.A;

class C {
    public static void main(String[] ar) {
        A a = new A();
    }
}

public 접근 지정자를 가진 클래스 A에는 default 접근 지정자를 가진 생성자가 있다. 클래스 A는 public이니 다른 클래스에 import가 가능하다. 그런데 생성자 A는 default로 다른 클래스에 호출이 불가하다. 만약 클래스 C가 클래스 A를 상속한다해도 생성자 A는 default 접근 지정자를 가지기 때문에 사용할 수 없다.

✔️   인스턴스 필드와 정적 필드_ 292p

• 인스턴스 멤버

: 객체 안에 있을 대 사용할 수 있는 상태가 되는 멤버

• 정적 멤버

: static이 붙어 있는 멤버

class A {
    int m = 3;
    static int n = 5;
}

// 인스턴스 필드의 활용 방법
A a = new A();
System.out.println(a.m);

// static 필드 활용 방법
System.out.println(A.n);

인스턴스 필드 m은 객체 내부에 생성된다. 그래서 m을 사용하려면 객체를 먼저 생성해야 한다. 또한 저장 공간이 힙 메모리에 위치하므로 저장 공간에 값을 읽거나 쓰기 위해서 참조 변수명을 사용해야한다.

정적 필드 n은 클래스 내부에 저장 공간을 지니고 있기 때문에 객체 생성 없이 클래스명. 멤버명인 A.n으로 바로 사용할 수 있다. 물론 인스턴스처럼 참조 변수명.멤버명인 a.m과 같이 사용가능하다. 하지만 그렇게 사용한다면 정적 멤버를 만들 필요가 없으므로 권장하는 방법은 아니다.

A a1 = new A();
A a2 = new A();

a1.n = 7;
a2.n = 8;

정적 필드 n에 값 7과 8을 차례로 넣었다. 아마 인스턴스 변수 m에 넣었다면 a1.m은 7이 되고 a2.m은 8이 될 것이다. 하지만 정적 변수는 a1.n과 a2.n 모두 8이 나왔다.

객체 생성은 힙 메모리에서 이뤄지고 인스턴스 필드는 객체 내부에 생성되므로 각 데이터 값을 두 객체 안에 저장하게 된다. 값을 읽으려고 한다면 따로 객체 생성이 되어있는 a1과 a2 내부의 값만 가져오면 된다.

정적 필드는 클래스 A안에 실제 데이터 값을 저장한다. 그러면 힙 메모리에 있는 객체 안에는 데이터 값의 위치를 저장하는 것이다. 그러면 결국 두 객체는 클래스 A를 가리키게 되니 값 7이 들어가면 a1을 통해 클래스 A 안에 7을 저장하게 된다. 그 후 a2를 통해 값 8을 넣으면 이 또한 클래스 A를 가리키니 7의 값은 사라지고 8이 저장되게 된다.

✔️   인스턴스 메서드와 정적 메서드_ 298p

class A {
    void abc() {
        System.out.pritnln("인스턴스 메서드");
    }
    
    static void avc() {
        System.out.println("정적 메서드");
    }
}

A a1 = new A();
a1. abc();

A.bcd();

인스턴스 메서드를 활용하는 방법도 인스턴스 필드와 같다. 객체를 생성하고 사용한다. 정적 메서드의 경우 클래스명으로 바로 접근하여 사용할 수 있다.

정적 메서드는 인스턴스 메서드나 인스턴스 필드를 사용할 수 없다. 그 이유는 인스턴스 멤버는 객체 생성이 필수인데, 정적 멤버를 사용하는 이유가 객체 생성 없이 실행하기 원하기 때문이다. 또한 정적 메서드 내부에는 this 키워드는 올 수 없다. 왜냐하면 this 자체가 현재 객체를 참조하는 것이기 때문이다. this는 인스턴스 멤버를 참조하는 역할을 하기 때문에 정적 메서드에 올 수 없다.

📚 책 소개하기

내가 사용한 자바완전정복 책 링크!
ㄴ 김동형 지음, 이지스퍼블리싱

이 책을 고르게 된 이유는 친구의 추천이었다. 굉장히 꼼꼼하게 적혀있어 이해하기 쉽다는 이유로 친구는 이 책을 골랐다고 했다. 나도 그래서 그냥 따라샀다. 실제로 책을 살펴보니 굉장히 꼼꼼하게 정리되어있다. 다른 책은 본 적이 없어 비교가 불가하지만, 내 생각으론 처음 자바를 공부한다면 이 책을 가지고 충분히 따라갈 수 있을 듯 하다. 모두들 화이팅!!

🐰

✔️   필드와 지역변수 이름이 다른 경우_ 253p

• 필드 

:  클래스에 포함된 변수

• 지역변수

:  메서드에 포함된 변수

Class A {
    int m;
    int n;
    
    void init(int a, int b) {
        int c;
        c = 3;
        
        m = a;
        n = b;
    }
}

해당 코드는 필드와 지역변수의 이름이 다른 경우이다. 필드는 클래스가 시작하는 맨 위에 정의된 변수인데, 여기서는 m과 n을 말한다. 메서드의 파라미터는 a와 b가 된다. 파라미터는 지역변수다. a는 m에 옮기고, b는 n에 옮기는 것이 메서드 init이 해야할 일이다. 이때는 필드와 파라미터의 이름이 다르기 때문에 m과 n 앞에 this.를 붙이지 않아도 컴파일러가 자동으로 등록해준다.

✔️   필드와 지역변수 이름이 같은 경우_ 255p

Class A {
    int m;
    int n;
    
    void init(int m, int n) {
        m = m;
        n = n;
    }
}

public class pratice {
    public static void main(String[] args) {
        
        A a = new A();
        
        a.init(3,4);
        
        System.out.println(a.m);
        System.out,println(a.n);
     }
}

해당 코드는 필드와 메서드의 파라미터 이름이 같은 경우다. 인자 3과 4를 다른 클래스에서 받아왔다. 각 값은 init 메서드의 파라미터 m과 n에 들어있게 된다. m과 n을 필드에 저장하고 싶었을 것이다. 하지만 필드와 파라미터의 이름이 같은 바람에 파라미터m을 파라미터 m에 옮기고 파라미터 n을 파라미터 n에 옮기게 된다. 그래서 클래스 필드값 m과 n을 의미하는 a.m과 a.n은 결국 출력하게 되더라고 값이 나오지 않는다.

✔️   this를 주로 쓰는 경우 (책에 없음)

잘못된 정보가 있을 수 있습니다

B b = new B();
A a = new A(b);

a.addDataToB("Hello World!");

객체를 생성했다. 클래스 B는 b라는 이름으로 객체를 생성했고, 클래스 A는 a라는 이름으로 객체를 생성했다. 그런데 아래 코드를 보면 알겠지만, 클래서 A는 클래스 B가 가지고 있는 메서드를 사용하고자 한다. 또 addDataToB 메서드가 클래스 B에 있는 메서드를 사용하고 있다. 그렇기 때문에 객체 a는 객체 b를 인자로 생성자 A에게 보내야 한다.

만약 그렇게 보내지 않으면 오류가 발생한다. 

Q. 객체를 생성할 때 인자 b로 보내지 않는다면?

A. 오류가 발생한다. 그 이유는 객체 a를 생성하기 전, 이미 객체 생성에서 클래스 B를 b라고 지정했기 때문이다. 이 코드는 일반적인 변수를 가지고 있는 필드가 아니다. 다른 클래스를 필드로 설정한 경우이기 때문에 클래스 B도 객체를 생성해야하고, 타입 B를 가져야하기 때문에 인자 b를 보내야한다.

// 데이터 저장소
public class B {

    // 필드 data
    private String data;

    // 데이터 저장한다.
    public void saveData(String data) {
        
        // 인자로 받은 data를 필드로 옮긴다.
        this.data = data;
    }

    // 데이터를 꺼낸다.
    public String getData() {
        // 필드로 리턴한다.
        return this.data;
    }
}

// 데이터를 저장소에 저장하고 값을 출력
public class A {

    // 클래스 B를 필드로 정의.
    private final B b;
    
    // 생성자 A로 저장소 b의 필드 값을 인자로 받는다.
    // 인자로 받은 값을 A 클래스 필드 b에 저장
    public A(B b) {
        this.b = b;
    }
    
	// 클래스 B에 있는 메서드를 사용할 메서드.
    public void addDataToB(String data) {
        b.saveData(data);
    }

    // B의 메서드에 결과값을 보여주는 메서드.
    public void printDataFromB() {
        System.out.println("A: 저장된 데이터 -> " + b.getData());
    }
}

생성자 A에게 인자가 잘 도착했다. 그러면 이제 생성자는 필드로 보내 클래스 B에게 B의 메서드를 사용할 것임을 알려야한다. 즉, 타입 B를 가진 필드를 초기화한다는 의미이다. 생성자의 매개변수에 b가 들어오고 this.b에게 값을 넘길 것이다. this.b는 필드의 b를 말한다. 그래서 인자로 받은 b라는 값 (클래스 B를 품고 있는)은 필드로 보내지게 된다.

여기서 직관적인 이해가 잘 가지 않았다. 그래서 나는 필드로 값이 갔다는 의미를, 타입 B를 가진 b가 자신과 똑같은 타입인 필드를 만나 일하라고 한대 쳤다는 식으로 받아드리기로 했다. 아무튼 그렇게 필드의 값은 b로 초기화된다. 그러면 이제 클래스 B가 가진 메서드를 마음껏 쓸 수 있게 되는 것이다. 

B b = new B();
A a = new A(b);

a.addDataToB("Hello World!");

다시 처음으로 돌아오겠다. a.addDataToB는 객체 a(클래스 A)를 통해 addDataToB라는 메서드를 사용하겠다는 것이다. 그래서 해당 메서드에 "Hello World!"라는 재료를 넣겠다는 것이다. 그러면 우리는 A a = new A(b);를 통해 클래스 A에 있는 모든 것을 사용할 수 있도록 다 준비시켜놨다. 그러니 문제없이 a.addDataToB는 돌아갈 것이다.

a.addDataToB는 String 타입이 오면 실행되도록 설정했다. "Hello World!"는 String 타입이니 문제가 없다. 제대로 된 재료가 들어간 것이다. 그리고 addDataToB는 "Hello World!"를 data라는 것으로 포장하여 다음 코드를 실행한다.

b. saveData(data)는 data 값(Hello World!)을 클래스 B에 있는 saveData라는 이름을 가진 메서드로 보낼 것이다.

// 데이터 저장소
public class B {

    // 필드 data
    private String data;

    // 데이터 저장한다.
    public void saveData(String data) {
        
        // 인자로 받은 data를 필드로 옮긴다.
        this.data = data;
    }

    // 데이터를 꺼낸다.
    public String getData() {
        // 필드로 리턴한다.
        return this.data;
    }
}

saveData는 data라는 포장으로 감싸진 Hello World를 받았다. 이 data는 필드 data에 보내지게 되고 나중에 다른 메서드가 data에 있는 값이 필요해지면 가져다 쓸 것이다. (getData처럼)

public class Car {
    String color;  // 자동차의 색깔
    int speed;     // 자동차의 속도

    // 생성자 정의
    public Car(String color, int speed) {
        this.color = color; // 필드 초기화
        this.speed = speed; // 필드 초기화
    }
}

public class Main {
    public static void main(String[] args) {
        // 생성자를 사용해 초기값을 설정
        Car myCar = new Car("red", 100);

        System.out.println("색깔: " + myCar.color + ", 속도: " + myCar.speed);
    }
}

위의 코드는 클래스를 필드로 받는 경우였다. 이번 코드는 단순한 코드로 어떤 값을 받는 것이다. 객체를 생성했고 그 안에 두 값을 넣었다. 하나는 String 타입이고, 다른 하나는 int 타입이다. 그러면 Car 클래스로 가서, 두 타입을 가지고 있는 생성자를 찾는다. 맞는 생성자를 찾아 각 값을 인자로 받고, 받은 인자는 필드를 초기화하여 저장한다. 

다시 Main클래스로 가겠다. myCar.color와 myCar.speed를 출력하고자 한다. myCar는 Car 클래스를 타입으로 지정한 객체 이름이다. 그러면 Car 클래스에 있는 color라는 이름을 가진 필드 값과 speed라는 이름을 가진 필드 값을 가져오겠다는 의미이다. 우리는 위에서 red와 100이라는 값을 보낸 전적이 있다. 그리고 그것을 필드에 초기화시켰기 때문에 red와 100이라는 값이 출력된다.

✔️   this( ) (259p)

Class A {
    int m1, m2, m3. m4;
    
    A() {
        m1 = 1;
        m2 = 2;
        m3 = 3;
        m4 = 4;
    }
    
    A(int a) {
        this();
        m1 = a;
    }
   
   A(int a, int b){
       this(a);
       m2 = b;
   }
}

this( )를 쓰면 바로 위에 있는 생성자를 들고 온다. A(int a)는 생성자 A가 int 타입인 인자 하나를 받겠다는 의미이다.

A(int a)는 this( );를 가지고 있으니까, 바로 위에 있는 A( )에 있는 값을 받을 것이다. 그러면 m1부터 m4까지 받는데 그 후 m1은 a 값으로 옮겨 담겠다는 의미니 최종적으로 m1의 값만 다르고 m2에서 m4까지 A( )와 값이 같을 것이다.

A는 int 타입인 a와 b인 두개의 매개변수를 정의했다. this(a)는 바로 위에 있는 생성자 A(int a)를 의미한다. A(int a)에서 a는 m1에 옮길 것을 명시했으니 m1은 받아온 a 값으로 변경될 것이다. 그리고 m2는 b의 값으로 바뀔 것이다.

📚 책 소개하기

내가 사용한 자바완전정복 책 링크!
ㄴ 김동형 지음, 이지스퍼블리싱

이 책을 고르게 된 이유는 친구의 추천이었다. 굉장히 꼼꼼하게 적혀있어 이해하기 쉽다는 이유로 친구는 이 책을 골랐다고 했다. 나도 그래서 그냥 따라샀다. 실제로 책을 살펴보니 굉장히 꼼꼼하게 정리되어있다. 다른 책은 본 적이 없어 비교가 불가하지만, 내 생각으론 처음 자바를 공부한다면 이 책을 가지고 충분히 따라갈 수 있을 듯 하다. 모두들 화이팅!!

🐰

✔️   필드와 지역변수_ 222p

• 필드 

:  클래스에 포함된 변수

• 지역변수

:  메서드에 포함된 변수

Class A {
	
    m과 n은 필드
    int m = 1;
    int n = 2;
    
    void B() {
    	k는 지역변수
    	int k = 3;
        System.out.println(k);
    }
}

필드와 지역변수의 큰 차이점은 생성되는 메모리의 위치다. 메모리는 클래스 영역 - 스택 영역 - 힙 영역으로 나눠져있는데, 그 중 필드는 힙 영역에 생성되고 지역변수는 스택 영역에 생성된다.

필드의 경우 힙 영역에 생성되어 자바 가상 머신이 자동으로 삭제하지 않아 객체가 사라지지 않는 한 절대로 삭제되지 않는다. 하지만 스택 영역에 저장된 지역변수의 경우 중괄호가 닫혀 메서드가 종료되면 자바 가상 머신이 자동으로 삭제한다. 고로 지역변수가 메모리에서 통째로 삭제되는 것이다.

이때 힙 영역에는 지역변수의 메서드 번지만 존재한다. 메서드에 관한 내용은 클래스 영역에 있다.

• 필드와 지역변수의 초깃값

Class A {
    int m;
    int n;
    
    void B() {
    int k;
    System.out.println(k);
    }
    
    A a = new A();
    System.out.println(a.m);
    System.out.println(a.n);
    a.B();
}

m과 n은 필드에 있다. 필드에 있는 변수는 초기화를 하지 않아도 힙 메모리의 특성상 강제로 초기화를 하기 때문에 값이 0으로 출력된다. 하지만 지역변수는 아니다. 지역변수의 값을 초기화하지 않으면 오류가 발생한다. 저장공간이 빈 공간으로 있기 때문에 오류가 발생하는 것이다. 그렇기에 System.out.println(k)와 a.B는 제대로 동작하지 않는다.

✔️   리턴타입의 메서드_ 229p

• 메서드

: 클래스의 기능에 해당하는 요소

리턴 타입이 없는 경우
void print() {
    System.out.println("안녕");
}

리턴 타입이 int, 입력매개변수가 있는 경우
int sum(int a, int b) {
	return a + b
}

리턴 타입이 없는 경우 void를 사용하여 명시하면 된다. sum 메서드는 매개변수로 a와 b를 받는다. a와 b 값은 더해지며 그 값을 int형으로 return 하게 된다. 여기서 a와 b는 지역변수명이 된다.

Q. void로 리턴 타입이 없는 메서드의 경우 return을 사용할 수 없나?

 A. 사용할 수 있다. 다만 주로 어떤 값을 돌려주기보다, 조건에 맞으면 메서드를 종료시켜라와 같이 메서드의 종료에 초점을 맞춰 사용한다.

public void print() {
    if(a < 0) {
        System.out.println("메서드 종료")
        return;
    }
    
    System.out.println("a는 " + a);
}

불필요한 코드 실행을 방지하며 주로 메서드 종료를 원할 때 return을 사용한다.

• 클래스 외부 호출

: 클래스 외부에서 사용하려면 객체를 생성하면 된다.

class A {
    int data() {
         return 3;
    }
}

public class B {
     public static void main(String[] args) {
    	객체 생성
        A a = new A();       
        System.out.println("data = " + a.data());
    }
}

• 클래스 내부 호출

: 클래스 내부에 있는 메서드끼리는 객체 생성없이 호출할 수 있다.

public class A {
    public static void main(String[] args) {    
        print();
    }
    
    public static void print() {
       System.out.println("안녕");
    }
}

메서드에 static이 붙어 있으면 static이 붙은 필드 또는 메서드만 호출할 수 있다.

✔️   기본 자료형과 참조자료형의 입력매개변수 차이_ 235p

•  기본 자료형 입력매개변수

Class A {

   public static int twice(int a) {
      a = a * 2;
      return a;
   }

   public static void main(String[] ar) {
      int a = 3;
      int k1 = twice(a);
   }
   
}

k1이 a를 가져가 twice 메서드를 이용하면 a는 6이라는 값으로 return하게 된다. 그러면  k1은 6이 된다. 이때 변수 a는 3에서 6의 값으로 변동되겠지만 지역변수 a이기 때문에 main에 있는 a는 변동되지 않는다. 지역변수는 해당 메서드가 종료되면 사라지게 된다. 그러므로 twice 메서드가 a를 가져다 수행해도 그것은 복사된 것이기에 main 함수의 변수 a 값은 변동되지 않고 마무리된다.

•  참조 자료형 입력매개변수

public class A {
   public static void main(String[] args) {
      int[] array = new int[] {1,2,3};
      modify(array);
      }
      
   public static void modify(int[] a) {
      a[0] = 4;
      a[1] = 5;
      a[2] = 6;
   }
}

modify에 넘겨진 배열, 참조자료형은 스택 메모리에 실제 객체가 아닌 객체의 위칫값을 저장하게 된다. 그렇기에 객체의 참좃값이 전달되어 복사된다. 그러면 main에 있는 배열과 modify에 이용된 배열 모두 같은 객체를 바라보게 된다. modify 메서드에서 배열의 값을 변경하게 되면 main에 있는 배열도 같이 바뀌게 되는 이유다.

✔️   오버로딩된 메서드_ 239p

•  메서드 시그니처

: 메서드를 구분하는 기준 역할로 메서드명, 자료형이 기준이 된다. (리턴 타입은 시그니처가 아니다)

•  오버로딩

: 같은 이름이지만 자료형이 다른 것

public static void print() {
   System.out.println("데이터 없음");
}

public static void print(int a) {
   System.out.println(a);
}

public static void print(double a) {
   System.out.println(a);
}

✔️   생성자 특징_ 247p

•  생성자

: 객체를 생성하는 역할을 지닌 클래스의 내부 구성 요소로 클래스와 같은 이름이며 리턴타입이 없다. 

Class A {

    필드
    int m;
    
    메서드 work
    void work() {
        ...
    }
    
    생성자 A
    /* A() {
    
    } */
    
}

Class B {
    
    int m;
    
    void work() {
        ...
    }
    
    
    B(int a) {
    	this.a = a;
    }
}

public class pratice {
    public static void main(String[] args){
        
        A a = new A();
        B b = new B();
        B b = new B(1);
 
        a.work();
        b.work();
 
    }
}

꼭 생성자를 써야하는 것은 아니다. 생성자를 쓰지 않아도 컴파일러가 자동적으로 생성자를 넣어 작동시킨다. 그런데 클래스 B처럼 단 하나의 생성자라도 있으면 모든 생성자를 만들어줘야한다. 현재 기본 생성자 B를 코드에 적지 않았다. 그렇게되면 오류가 발생한다.

•  다양한 생성자

Class A {

    A() {
        System.out.println("첫번째 생성자");
    }
    
    A(int a) {
        System.out.println("두번째 생성자");
    }
}

public class pratice {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new A(2);
     }
}

메서드처럼 생성자도 오버로딩을 할 수 있다. 위의 코드는 기본 생성자 모양으로만 객체를 생성한 것과 int형 값을 입력으로 받아 생성자를 호출하는 객체를 만들었다.