개발자가 된 핏짜

예외 처리 Exception Handling

• 프로그램에서 예외가 발생했을 경우, 프로그램의 갑작스러운 종료를 막고, 정상 실행을 유지하기 위해 예외 처리를 해야 함
• 자바 컴파일러는 일반 예외가 발생할 가능성이 있는 코드를 발견하면 컴파일 에러를 발생시켜 예최처리 코드를 개발자가 강제적으로 작성하도록 요구함
• 실행 예외의 경우에는 개발자의 경험을 바탕으로 예외 처리 코드를 작성해야 함

예외 처리 코드

• try-catch-finally 블록은 생성자 내부와 메소드 내부에서 작성되어 일반 예외와 실행 예외가 발생할 경우 예외 처리를 할 수 있도록 해줌

1. try 블록에는 예외 발생 가능 코드가 위치

2. try 블록의 코드가 예외 발생 없이 정상 실행되면 catch 블록의 코드는 실행되지 않고 finally 블록의 코드를 실행;

    try 블록의 코드에서 예외가 발생하면 즉시 실행을 멈추고 catch 블록으로 이동하여 예외 처리 코드 실행 -> finally 블록 코드 실행

3. finally 블록은 생략 가능; 예외 발생 여부와 상관 없이 항상 실행할 내용이 있을 경우에만 finally 블록을 작성함;

    try 블록과 catch 블록에서 return문을 사용하더라도 finally 블록은 항상 실행됨

예외 종류에 따른 처리 코드

다중 catch

• 다중 catch 블록을 작성해서 블록5 내부 다양한 예외 처리
• catch 블록의 예외 클래스 타입은 try 블록에서 발생된 예외의 종류를 말함
• try 블록에서 해당 타입의 예외가 발생하면 catch 블록을 실행함
• catch 블록이 여러 개일지라도 단 하나의 catch 블록만 실행 -> 하나의 예외가 발생하면 즉시 실행을 멈추고 해당 catch 블록으로 이동

catch 순서

• 다중 catch 블록을 작성할 때 주의할 점: 상위 예외 클래스가 하위 예외 클래스보다 아래쪽에 위치해야함
• 하위 예외는 상위 예외를 상속했기 때문에 상위 예외 타입도 되기 때문임

예외 떠넘기기

• 경우에 따라서 메소드를 호출한 곳으로 예외를 떠넘길 수 있음 -> throw 키워드 사용
• throw 키워드: 메소드 선언부 끝에 작성되어 메소드에서 처리하지 않은 예외를 호출한 곳으로 떠넘기는 역할
• throw 키워드 뒤에 떠넘길 예외 클래스를 쉼표로 구분해서 나열해주면 됨

리턴타입 메소드이름(매개변수, ...) throws 예외클래스1, 예외클래스2, ... {
}

또는

리턴타입 메소드이름(매개변수, ....) throws Exception {
}

• throw 키워드가 붙어있는 메소드는 반드시 try 블록 내에서 호출되어야 함
• catch 블록에서 떠넘겨 받은 예외를 처리해야함

public void method1() {

try {

  method2();

} catch(ClassNotFoundException e){

  //예외 처리 코드

  System.out.println("클래스가 존재하지 않습니다.");

  }

}



public void method2() throws ClassNotFoundException {

 Class claszz = class.forName("java.lang.String2");

}



==> 호출한 곳에서 예외 처리 예시

확인문제

• try{} 블록에는 예외가 발생할 수 있는 코드를 작성한다
• catch {} 블록은 try {} 블록에서 발생한 예외를 처리하는 블록이다.
• try{} 블록에서 return 문을 사용하면 finally {} 블록은 실행되지 않는다. (x)
• catch{} 블록은 예외의 종류별로 여러 개를 작성할 수 있다.
•  
• 생성자나 메소드의 선언 끝부분에 사용되어 내부에서 발생된 예외를 떠넘긴다.
• throws 뒤에는 떠넘겨야 할 예외를 쉼표(,)로 구분해서 기술한다.
• 모든 예외를 떠넘기기 위해 간단하게 throws Exception으로 작성할 수 있다.
• 새로운 예외를 발생시키기 위해 사용된다. (x)

• 예외(exception): 사용자의 잘못된 조작 또는 개발자의 잘못된 코딩으로 인해 발생하는 프로그램 오류
• 예외 처리(exception handling): 프로그램을 종료하지 않고 정상 실행 상태가 유지되도록 할 수 있음
• 자바는 예외 처리 유무를 확인하고 예외 처리 코드가 없다면 컴파일이 안됨

예외와 예외 클래스

• 일반 예외: exception
• 실행 예외:runtime exception
• RuntimeException 클래스 기준으로 구분

실행 예외

• 자바 컴파일러가 체크하지 않기 때문에 개발자가 예외 처리 코드를 작성해야 함

NullPointerException

• 객체 참조가 없는 상태, 즉 null 값을 갖는 참조 변수로 객체 접근 연산자인 도트(.)를 사용했을 때 발생
• 객체가 없는 상태에서 객체를 사용하려고 할때 생기는 예외

ArrayIndexOutOfBoundsException

• 배열에서 인텍스 범위를 초과할 경우 생기는 실행 예외

NumberFormantException

• 문자열을 숫자로 변환 할 때 숫자로 변환될 수 없는 문자가 포함되어 있을 때 발생

ClassCastException

• 타입변환은 상위클래스와 하위 클래스 간에 발생하고 구현 클래스와 인터페이스 간에 발생하는데 이런 관계가 아닐 때 발생하는 예외
• instanceof 연산자 사용해서 타입 변환 전에 변환 가능한지 확인하기

확인문제

• 예외는 사용자의 잘못된 조작 개발자의 잘못된 코딩으로 인한 프로그램 오류를 말한다.
• RuntimeException의 하위 클래스는 컴파일러가 예외처리 코드를 체크하지 않는다.
• 예외는 클래스로 관리된다.
• Exception의 하위 클래스는 모두 일반 예외에 해당한다. (x)

익명 객체

• 익명(anonymous) 객체: 이름이 없는 객체
• 어떤 클래스를 상속하거나 인터페이스를 구현해야 만들 수 있음

[상속]
부모클래스 변수 = new 부모클래스(){....};

[구현]
인터페이스 변수 = new 인터페이스() {....};

익명 자식 객체 생성

• 자식 클래스가 재사용되지 않고 오직 특정 위치에서 사용할 경우 -> 익명 자식 객체 사용

부모클래스 [필드|변수] = new 부모클래스(매개값, ...){

  //필드

  //메소드

};

• 익명 자식 객체에 새로 정의된 필드와 메소드는 익명 자식 객체 내부에서만 사용하고 외부에서는 접근 x
• 익명 자식 객체는 부모 타입 변수에 대입되므로 부모 타입에 선언된 것만 사용 가능

익명 구현 객체 생성

• 구현 클래스가 재사용 되지 않고 오직 특정 위치에서 사용하는 경우, 익명 구현 객체 사용

인터페이스[필드|변수] = new 인터페이스(){ //인터페이스에 선언된 추상 메소드의 실제 메소드 선언 
	//필드 
	//메소드
};

중첩 클래스 (nested class)

• 클래스 내부에 선언한 클래스
• 중첩 클래스를 사용하면 두 클래스의 멤버들을 쉽게 접근할 수 있고 외부에는 불필요한 관계 클래스를 감춤으로서 코드의 복잡성을 줄일 수 있음

중첩 인터페이스 nested interface

• 인터페이스를 클래스 내부에서 선언하는 경우
• 해당 클래스와 긴밀한 관계를 맺는 구현 클래스를 만들기 위해서 사용

중첩 클래스

• 멤버 클래스: 클래스의 멤버로서 선언되는 중첩 클래스
• 로컬 클래스: 생성자 또는 메소드 내부에서 선언되는 중첩 클래스
• 멤버 클래스는 클래스나 객체가 사용 중이라면 언제든지 재사용이 가능하지만 로컬 클래스는 메소드 실행할 때만 사용되고 메소드가 종료되면 없어짐

중첩 클래스 바이트 코드 파일 => A $ B . class

• A는 바깥 클래스, B는 멤버 클래스

로컬 클래스 바이트 코드 파일 => A $1 B .class

• A는 바깥 클래스, B는 로컬 클래스

인스턴스 멤버 클래스

• static 키워드 없이 중첩 선언된 클래스
• 인스턴스 멤버 클래스는 인스턴스 필드와 메소드만 선언이 가능하고 정적 필드와 메소드는 선언할 수 없음

class A {
	/**인스턴스 멤버 클래스**/
    class B {
    	B() {} //생성자
        int field1; //인스턴스 필드
        //static int field2; // 정적필드 (x)
        void method1() {} //인스턴스 메소드
        //static void method2() {} // 정적 메소드 (x)
        }
 }

정적 멤버 클래스

• static 키워드로 선언된 클래스
• 모든 종류의 필드와 메소드를 선언 할 수 있음

class A {
	/**정적 멤버 클래스**/
    static class C {
    	C() {} //생성자
        int field1; //인스턴스 필드
        static int field2; // 정적필
        void method1() {} //인스턴스 메소드
        static void method2() {} // 정적 메소드
        }
 }

로컬 클래스

메소드 내에서 중첩 클래스 선언

• 로컬 클래스는 접근 제한자 및 static을 붙일 수 없음
• 로컬 클래스는 메소드 내부에서만 사용되므로 접근을 제한할 필요가 없음
• 로컬 클래스 내부에는 인스턴스 필드와 메소드만 선언할 수 있음
• 정적 필드와 메소드는 선언할 수 없음
• 로컬 클래스는 메소드가 실행될 때 메소드 내에서 객체를 생성하고 사용해야 함

중첩 클래스의 접근 제한

• 멤버 클래스 내부에서 바깥 클래스의 필드와 메소드에 접근할 때는 제한이 있음
• 메소드의 매개변수나 로컬 변수를 로컬 클래스에서 사용할 때도 제한이 있음

바깥 필드와 메소드에서 사용 제한

• 바깥 클래스에서 인스턴스 멤버 클래스를 사용할 때 제한
• 인스턴스 멤버 클래스는 바깥 클래스의 인스턴스 필드의 초기값이나 인스턴스 메소드에서 객체를 생성할 수 있음
• 정적 필드의 초기값이나 정적 메소드에서는 객체를 생성할 수 없음
• 정적 멤버 클래스는 모든 필드의 초기값이나 모든 메소드에서 객체를 생성할 수 있음

멤버 클래스에서 사용제한

• 멤버 클래스가 인스턴스 또는 정적으로 선언됨에 따라 멤버 클래스 내부에서 바깥 클래스의 필드와 메소드에 접근할 때에도 제한이 있음
• 인스턴스 멤버 클래스 안에서는 바깥 클래스의 모든 필드와 모든 메소드에 접근 가능
• 정적 멤버 클래스 안에서는 바깥 클래스의 정적필드와 메소드에만 접근할 수 있고 인스턴스 필드와 메소드에는 접근할 수 없음

로컬클래스에서 사용 제한

• 메소드의 매개 변수나 로컬 변수를 로컬 클래스에서 사용할 때 제한
• 로컬 클래스의 객체는 메소드 실행이 종료되면 없어지는 것이 일반적이지만 로컬 스레드 객체를 사용하면 계속 실행상태로 존재
• 매개 변수나 로컬 변수가 수정되어 값이 변경되면 로컬 클래스에 복사해둔 값과 달라지므로 문제를 해결하기 위해 매개변수나 로컬 변수를 final로 선언할것을 요구 -> 자바 8부터는 final 선언을 하지 않아도 값이 수정될 수 없도록 final 특성을 부여함

중첩 클래스에서 바깥 클래스 참조 얻기

• 중첩 클래스에서 this 키워드를 사용하면 바깥 클래스의 객체 참조가 아니라, 중첩 클래스의 객체 참조가 됨
• 중첩 클래스 내부에서 this.필드, this.메소드()로 호출하면 중첩 클래스의 필드와 메소드가 사용됨
• 중첩 클래스 내부에서 바깥크 ㄹ래스의 객체 참조를 얻으려면 바깥 클래스의 이름을 this 앞에 붙여주면 됨

바깥클래스.this.필드;
바깥클래스.this.메소드();

중첩 인터페이스

• 클래스 멤버로 선언된 인터페이스
• 인터페이스를 클래스 내부에서 선언하는 이유는 해당 클래스와 긴밀한 관계를 맺는 구현 클래스를 만들기 위해서임
• 중첩 인터페이스는 인스턴스 멤버 인터페이스와 정적멤버 인터페이스 모두 가능
• 인스턴스 멤버 인터페이스는 바깥 클래스의 객체가 있어야 사용 가능
• 정적 멤버 인터페이스는 바깥 클래스의 객체 없이 바깥 클래스만으로 바로 접근 가능
• UI 프로그래밍에서 이벤트를 처리할 목적으로 많이 활용

class A {
	[static] interface I {
    void method();
    }
}

확인문제

• 인스턴스 멤버 클래스는 바깥 클래스의 객체가 있어야 사용될 수 있다. (o)
• 정적 멤버 클래스는 바깥 클래스의 객체가 없어도 사용될 수 있다 (o)
• 인스턴스 멤버 클래스는 내부에는 바깥 클래스의 필드와 메소드를 사용할 수 있다. (o)
• 정적 멤버 클래스 내부에는 바깥 클래스의 인스턴스 필드를 사용할 수 있다. (x)
• 로컬 클래스는 생성자 또는 메소드 내부에 선언된 클래스를 말한다. (o)
• 로컬클래스도 필드와 생성자를 가질 수 있다. (o)
• 로컬 클래스는 static 키워드를 이용해서 정적 클래스로 만들 수 있다. (x)
• final 특성을 가진 매개 변수나 로컬 변수만 로컬 클래스 내부에서 사용할 수 있다. (o)

인터페이스의 다형성

• 프로그램 소스 코드는 변함 없지만 구현 객체를 교체함으로써 프로그램의 실행결과가 다양해짐

자동 타입 변환 promotion

• 자동타입변환 : 구현 객체가 인터페이스 타입으로 변환 되는 것
• 인터페이스 구현 클래스를 상속해서 자식 클래스를 만들었다면 자식 객체 역시 인터페이스 타입으로 자동 타입 변환 가능
• 필드의 다형성과 매개 변수의 다형성을 구현할 수 있음

필드의 다형성

• 매개 변수의 다형성: 매개 변수 타입이 인터페이스일 경우 어떠한 구현 객체도 매개값으로 사용할 수 있고, 어떤 구현 객체가 제공되느냐에 따라 메소드의 실행결과가 다양해짐

강제타입변환 (casting)

• 구현 객체가 인터페이스 타입으로 자동 타입 변환하면, 인터페이스에 선언된 메소드만 사용가능 -> 제약
• but, 경우에 따라서 구현 클래스에 선언된 필드와 메소드를 사용해야 하는 경우 발생 -> 강제타입변환(casting) 사용 -> 다시 구현 클래스 타입으로 변환 -> 구현 클래스의 필드와 메소드 사용

객체 타입 확인

• 강제 타입 변환은 구현 객체가 인터페이스 타입으로 변환되어 있는 상태에서 가능
• 어떤 구현 객체가 변환되어 있는지 모르는 상태에서 강제타입변환 할 경우 ClassCastException 에러가 발생할 수 있음
  • -> instanceof 연산자를 사용해서 인터페이스 타입으로 변환된 객체 확인

확인문제

• 구현 객체는 인터페이스 타입으로 자동 변환된다 (o)
• 부모 클래스가 인터페이스를 구현하면 자식 클래스로부터 생성된 객체는 인터페이스 타입으로 자동 변환할 수 있다. (x)
• 인터페이스 변수에 대입된 객체를 원래 구현 클래스 타입으로 변환하는 것을 강제 타입 변환이라고 한다 (o)
• 메소드의 매개변수 타입이 인터페이스이면 매개값으로 모든 구현 객체를 대입하면 자동 타입 변환이 된다 (o)
• 다형성을 구현하기 위한 조건은 메소드의 재정의와 타입 변환이다 (o)
• 클래스 상속과 인터페이스는 모두 메소드 재정의와 티압 변환 기능이 제공되므로, 어떤 방법을 사용하든 다형성 구현이 가능하다. (o)
• 매개 변수 타입이 클래스라면 해당 클래스로 생성된 객체만 대입이 가능하다 (x)
• 매개 변수의 타입이 인터페이스라면 모든 구현 객체가 대입이 가능하다 (o)

인터페이스

• 개발 코드와 객체가 서로 통신하는 접점 역할
• 개발 코드가 인터페이스의 메소드를 호출하면 인터페이스는 객체의 메소드를 호출
• 개발 코드를 수정하지 않고 사용하는 객체를 변경할 수 있음
• 코드 변경 없이 실행 내용과 리턴값을 다양화 할 수 있음

인터페이스 선언

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

• 인터페이스 선언은 class 키워드 대신에 interface 키워드 사용
• 인터페이스는 상수 필드와 추상 메소드만을 구성 멤버로 가짐
• 객체를 생성할 수 없기 때문에 생성자를 가질 수 없음

interface 인터페이스이름 {
	//상수
    타입 상수이름 = 값;
    //추상 메소드
    타입 메소드이름(매개변수, ...);
}

상수 필드(constant field) 선언

• 인터페이스에 고정된 값으로 실행시에 데이터 변경 불가능

[public static final] 타입 상수이름 = 값;

추상메소드 선언

• 인터페이스의 메소드는 실행 블록이 필요 없는 추상 메소드로 선언
• 추상 메소드는 리턴 타입 메소드 이름, 매개 변수만 기술되고 중괄호 {} 를 붙이지 않는 메소드

인터페이스 구현

• 인터페이스 메소드를 호출하면 인터페이스는 객체의 메소드를 호출함
• 객체는 인터페이스에서 정의된 추상 메소드와 동일한 메소드 이름, 매개 타입, 리턴 타입을 가진 실체 메소드를 가져야함 -> 구현 객체(implement object), 구현 객체를 생성하는 클래스는 구현 클래스

구현 클래스

• 클래스 선언 부에 Implements 키워드를 추가하고 인터페이스 이름을 명시
• 인터페이스에 선언된 추상 메소드의 실체 메소드를 선언해야 함

public class 구현클래스이름 Implements 인터페이스이름 {

  //인터페이스에 선언된 추상 메소드의 실체 메소드 선언

}

• 구현 클래스가 작성되면 new 연산자로 객체를 생성할 수 있음
• 인터페이스로 구현 객체를 사용하려면 인터페이스 변수 선언 후 구현 객체를 대입
• 인터페이스 변수는 참조 변수로 구현 객체가 대입될 경우 구현 객체의 번지를 저장

다중 인터페이스 구현 클래스

• 다중 인터페이스를 구현하는 경우, 구현 클래스는 모든 인터페이스의 추상메소드에 대해 실체 메소드를 작성해야 함

인터페이스 사용

• 클래스를 선언할 때 인터페이스는 필드, 생성자, 또는 메소드의 매개변수, 생성자 또는 메소드의 로컬 변수로 선언 될 수 있음

1. 인터페이스가 필드타입으로 사용 -> 필드에 구현 객체를 대입 가능

2. 인터페이스가 생성자의 매개 변수 타입으로 사용 -> new 연산자로 객체를 생성할 때 구현 객체를 생성자의 매개값으로 대입 가능

3. 인터페이스가 로컬 변수 타입으로 사용 -> 변수에 구현 객체를 대입할 수 있음

4. 인터페이스가 로컬 매개 변수 타입으로 사용될 경우 ->메소드 호출 시 구현 객체를 매개값으로 대입 가능

• 구현 객체가 인터페이스 타입에 대입되면 인터페이스에 선언된 추상 메소드를 개발 코드에서 사용 가능

확인문제

• 인터페이스는 객체 사용 방법을 정의해놓은 타입이다 (o)
• new 연산자를 이용해서 인터페이스 객체를 만들 수 있다 (x)
• 인터페이스는 상수 필드와 추상 메소드를 갖는다 (o)
• 구현 클래스는 Implements 키워드로 인터페이스를 기술해야 한다 (o)
• 클래스를 선언할 때 인터페이스 타입의 필드를 선언할 수 있다 (o)
• 생성자의 매개 타입이 인터페이스일 경우 매개값으로 구현 객체를 대입한다 (o)
• 인터페이스 타입의 로컬 변수는 선언할 수 없다 (x)
• 메소드의 매개 타입이 인터페이스일 경우 매개값으로 구현 객체를 대입한다 (o)

추상 클래스

• 객체를 직접 생성할 수 있는 클레스들의 공통적인 특성을 추철해서 선언한 클래스
• 추상클래스가 부모, 실체 클래스가 자식으로 구현되어 실체 클래스는 추상 클래스의 모든 특성을 물려받고 추가적인 특성(필드, 메소드)을 가질 수 있음

추상 클래스의 용도

• 공통된 필드와 메소드의 이름을 통일할 목적
• 실체 클래스를 작성할 때 시간 절약
• 작성해야할 클래스가 다수이고 이 클래스들이 동일한 필드와 메소드를 가져야 할 경우, 설계자는 공통된 부분을 춯상 클래스로 설계하는 것이 좋음
• 추상 클래스를 상속해서 구체적인 클래스를 만듦

추상 클래스 선언

public abstract class 클래스 {
	//필드
    //생성자
    //메소드
}

• abstract를 붙이면 new 연산자를 이용해서 객체 못만들고 상속을 통해 자식 클래스만 만들 수 있음
• new 연산자로 직접 호출할 수는 없지만 자식 객체가 생성될 때 super(...)를 호출해서 추상 클래스 객체를 생성
• 추상 클래스도 생성자가 반드시 있어야 함

public abstract class Phone {
	//필드
    public String owner;
    
    //생성자
    public Phone(String owner) v{
    	this.owner =owner;
    }
    
    //메소드
    public void turnOn() {
      System.out.println("폰 전원을 켭니다.");
    }
    public void turnOff() {
      System.out.println("폰 전원을 끕니다.");
    } 
  }

• 부모 클래스의 super(owner) 코드로 생성자를 호출함

public abstract class SmartPhone extends Phone {
    
    //생성자
    public SmartPhone(String owner) v{
    	super(owner);
    }
    
    //메소드
    public void internetSearch() {
      System.out.println("인터넷 검색을 합니다.");
    }
    
    } 
  }

추상 메소드와 재정의

• 추상클레스는 실체 클래스의 멤버(필드, 메소드)를 통일하는 게 목적
• 모든 실체들이 가지고 있는 메소드의 실행 내용일 동일하면 추상 클래스에 메소드를 작성
• 메소드 선언만 통일하고 실행 내용은 실체 클래스마다 달라야 하는 경우 -> 추상 클래스는 추상 메소드 선언 가능

[public | protected] abstract 리턴타입 메소드이름(매개변수, ...);

• 추상 클래스 설계 시 하위 클래스가 실행 내용을 반드시 채우도록 강제하고 싶은 메소드가 있을 경우 추상 메소드 선언
• 자식 클래스는 반드시 추상 메소드를 재정의해서 실행 내용 작성해야함 -> 아니면 컴파일 에러 발생

확인문제

• 추상 클래스는 직접 new 연산자로 객체를 생성할 수 없다 (o)
• 추상 클래스는 부모 클래스로만 사용 (o)
• 추상 클래스는 실체 클래스들의 공통된 특성(필드, 메소드)로 구성된 클래스이다. (o)
• 추상 클래스에는 최소한 하나의 추상 메소드가 있어야 한다 (x)
• 추상 메소드는 선언부만 있고 실행 블록을 가지지 않는다 (o)
• 추상 메소드는 자식 클래스에서 재정의 해서 실행 내용을 결정해야 한다 (o)
• 추상 메소드를 재정의 하지 않으면 자식 클래스도 추상 클래스가 되어야 한다 (o)
• 추상 메소드가 있더라도 해당 클래스가 꼭 추상 클래스가 될 필요는 없다 (x)

자동타입변환 promotion

• 프로그램 실행 도중에 자동적으로 타입 변환이 일어남

부모 타입 변수 = 자식 타입;

• 자식은 부모의 특징과 기능을 상속받기 때문에 부모와 동일하게 취급될 수 있음
• 바로 위의 부모가 아니더라도 상속 계층에서 상위 타입이면 자동 타입 변환이 일어날 수 있음
• 부모 타입으로 자동타입 변환된 이후 부모 클래스에 선언된 필드와 메소드만 접근 가능
• 변수는 자식 객체를 참조하지만 변수로 접근 가능한 멤버는 부모 클래스만 가능
• 예외-> 메소드가 자식 클래스에서 재정의된 경우 자식 클래스의 메소드가 대신 호출됨

필드의 다형성

• 다형성을 구현하기 위해서 부모타입으로 자동 타입 변환이 필요함
• 필드의 타입을 부모 타입으로 선언하면 다양한 자식 객체들이 저장될 수 있기 때문에 필드 사용 결과가 달라질 수 잇음 -> 필드의 다형성
• 객체들이 다른 객체로 교체 될 수 있어야 함
• 자동 타입 변환을 이용해서 필드값을 교체함으로써 메소드를 수정하지 않아도 다양한 실행결과를 얻게 됨 -> 필드의 다형성

매개 변수의 다형성

• 자동 타입 변환은 주로 메소드를 호출할 때 발생
• 매소드 호출시 매개 변수의 타입과 동일한 매개값을 지정하는 것이 정석이지만 매개값을 다양화 하기 위해 매개 변수에 자식 객체를 저장할 수도 있음
• 매개 변수 타입이 클래스일 경우, 해당 클래스의 객체뿐만 아니라 자식 객체까지도 매개값으로 사용 가능

강제 타입 변환 (casting)

• 자식타입 변수 = (자식타입) 부모타입;
• 자식타입이 부모 타입으로 자동 타입 변환 된 후 다시 자식 타입으로 변환할 때 사용
• 자식에 선언된 필드와 메소드를 꼭 사용해야 할 때 강제 타입 변환을 해서 다시 자식 타입으로 변환 후 자식의 필드와 메소드 사용

객체 타입 확인 instanceof 연산자

• 어떤 객체가 어떤 클래스의 인스턴스인지 확인하기 위해 사용

boolean result = 좌항(객체) instanceof 우향(타입)

• 매개값의 타입을 조사할 때 주로 사용
• 메소드 내에서 강제 타입 변환이 필요한 경우 매개값이 어떤 객체인지 instanceof 연산자로 확인하고 안전하게 강제 타입 변환
• 타입 확인 안하고 강제 타입 변환 시도시 ClassCastException 발생할 수 있음

확인문제

• 자식 객체는 부모 타입으로 자동 타입 변환 된다 (o)
• 부모 객체는 항상 자식 타입으로 강제 타입 변환 된다 (x)
• 자동 타입 변환을 이용해서 필드와 매개 변수의 다형성을 구현한다. (o)
• 강제 타입 변환 전에 instanceof 연산자로 변환 가능한지 검사하는 것이 좋다 (o)

• 상속을 이용하면 부모 클래스의 수정으로 모든 자식 클래스들도 수정되는 효과를 가져오기 때문에 유지 보수 시간을 최소화 가능

클래스 상속

• 프로그램에서는 자식이 부모를 선택

class 자식 클래스 extends 부모클래스 {

//필드

//생성자

//메소드

}

• 단 하나의 부모 클래스만 상속 가능
• 부모 클래스에서 private 접근 제한 필드와 메소드는 상속 대상 x
• 다른 패키지라면 default 접근 제한 필드와 메소드는 상속 대상 x

부모 생성자 호출

• 모든 객체는 클래스의 생성자를 호출해야만 생성
• 부모 생성자는 자식 생ㅎ성자의 맨 첫출에서 호출됨
• super()는 부모의 기본 생성자를 호출함 ->컴파일러가 자동 생성

메소드 재정의 (오버라이딩 overriding)

• 부모의 메소드와 동일한 시그니처 (리턴타입, 메소드 이름, 매개 변수 목록)을 가저야 함
• 접근 제한을 더 강하게 재정의할 수 없음
• 새로운 예외를 throws할 수 없음
• @Override 어노테이션을 붙여주면 컴파일러가 확인도 해줌 -> 안붙여도 상관 x but 추천

부모 메소드 호출

• super.부모메소드()
• 자식 클래스 내부에서 재정의된 부모 클래스의 메소드를 호출할 때 사용

final 클래스와 final 메소드

• 상속할 수  없는 final 클래스
• final 클래스는 부모 클래스가 될 수 없음
• 재정의할 수 없는 final 메소드
• final 메소드는 자식 클래스에서 재정의 할 수 없음

확인문제

• 자바는 다중 상속을 허용한다. (x)
• 부모의 메소드를 자식 클래스의 재정의(오버라이딩)할 수 있다. (o)
• 부모의 private 접근 제한을 갖는 필드와 메소드는 상속의 대상이 아니다 (o)
• protected 멤버는 같은 패키지의 모든 클래스와 다른 패키지의 자식클래스만 접근할 수 있다 (o)
• 부모의 메소드는 숨김 효과가 나타난다 (o)
• 재정의 시 접근 제한을 더 강하게 할 수 있다 (x)
• @Override를 붙이면 컴파일러가 재정의를 확인한다 (o)
• 부모 메소드를 호출하고 싶다면 super 키워드를 사용할 수 있다 (o)

final 클래스, final 필드, final 메소드에 관한 설명 o,x 

• 모두 상속과 관련이 있다 (x) -> 필드는 상속과 관련이 없음
• final 메소드를 가진 클래스는 부모 클래스가 될 수 없다 (x) -> 재정의 할 수 없다
• final 메소드는 재정의 할 수 없다 (o)
• final 클래스는 final 필드가 반드시 있어야 한다 (x)

• 패키지: 파일 시스템의 폴더 기능 + 클래스를 유일하게 만들어주는 식별자 
• 패키지가 다르면 클래스 이름이 동일해도 다른 클래스로 인식

상위패키지.하위패키지.클래스

패키지 선언

package 상위패키지.하위패키지;

public class ClassName{ ... }

• 패키지는 클래스의 일부
• 패키지 이름
  • 숫자로 시작해서는 안되고 _, $를 제외한 특수 문자 사용 x
  • java로 시작하는 패키지는 자바 표준 API에서만 사용하므로 사용 x
  • 모두 소문자로 작성하는 것이 관례

import문

• import문으로 해당 패키지의 클래스 또는 인터페이스를 가져와 사용할 것을 컴파일러에게 알려줌

import 상위패키지.하위패키지.클래스이름;

import 상위패키지.하위패키지.*;

• *를 이용해서 해당 패키지에 소속된 클래스들을 사용할 것을 알려줌
• import문은 개수에 제한이 없음
• 상위 패키지를 import했다고 하위까지 import되는 것은 아님

접근 제한자(Access Modifier)

• public : 외부 클래스가 자요롭게 사용
• protected: 같은 패키지 또는 자식 클래스에서 사용할수 있음
• private: 외부에서 사용 x
• default: 같은 패키지에 소속된 클래스에서만 사용

클래스의 접근 제한

//defalut 접근 제함

class 클래스 { ... }



//public 접근 제한

public class 클래스 { ... }

public 접근 제한

• 클래스를 다른 개발자가 사용할수 있도록 라이브러리 클래스로 개발한다면 반드시 public 접근 제한을 갖도록 해야함
• 인터넷으로 배포되는 라이브러리 클래스도 모두 public 접근 제한을 가지고 있음

생성자의 접근 제한

• public 접근 제한: 모든 패키지에서 제한없이 생성자 호출
• protected 접근 제한 : 같은 패키지에 속하는 클래스에서 생성자 호출 가능; 다른 패키지여도 해당 클래스의 자식클래스라면 생성자호출가능
• default 접근 제한: 같은 패키지 내에 제한없이 생성자 호출 가능
• private 접근 제한: 오직 클래스 내부에서만 생성자 호출하고 객체를 만들수 있음

필드와 메소드의 접근 제한

//필드 선언

[public | protected | private ] [static] 타입 필드;



/메소드 선언

[public | protected | private ] [static] 리턴 타입 메소드(..) { ... }

• public : 제한 없음
• protected: 다른 패키지에 속하는 클래스에서 필드와 메소드를 사용가능; 다른 패키지 클래스가 자식 클래스라명 사용 가능
• default: 같은 패키지 제한 없고 다른패키지 x
• private: 오직 클래스 내부에서만 사용

Getter와 Setter 메소드

• 일반적으로 객체 지향 프로그래밍에서는 객체의 필드를 객체 외부에서 직접적으로 접근하는 것을 막는다
• 외부에서 마음대로 변경할 경우 객체의 무결성이 깨질 수 있기 때문
• 메소드를 필드를 변경하는 방법을 선호
• 필드는 외부에서 접근할 수 없도록 막고 메소드는 공개해서 외부에서 메소드를 통해 필드에 접근하도록 유도
• 메소드는 매개값을 검증해서 유효한 값만 객체의 필드로 저장할 수 있기 때문 -> Setter
• 외부에서 객체의 데이터를 읽을 때도 메소드를 사용 -> Getter
• 클래스를 선언할 때 가능하다면 필드를 private으로 선언해서 외부로부터 보호하고 필드에 대한 Setter와 Getter 메소드를 작성해서 필드값을 안전하게 변경/사용
• Getter: 필드의 값을 외부로 리턴해주는 메소드
• Setter: 외부에서 값을 받아 필드를 변경하는 메소드

• 외부에서 필드값 read only로 하려면 Getter 메소드만 선언 또는 Setter 메소드에 private 접근 제한 선언

확인문제

• 접근 제한자는 클래스, 필드, 생성자, 메소드의 사용을 제한한다. (o)
• public 접근 제한은 아무런 제한 없이 해당 요소를 사용할 수 있게 한다. (o)
• default 접근 제한은 해다 클래스 내부에서만 사용을 허가한다. (x)
• 외부에서 접근하지 못하도록 하려면 private 접근 제한을 해야 한다. (o)

• 클래스 멤버를 인스턴스 멤버와 정적 멤버로 구분해서 선언할 수 있음
• 인스턴스 멤버: 객체마다 가지고 있는 멤버
• 정적 멤버: 클래스에 위치시키고 객체들이 공유하는 멤버

인스턴스 멤버와 this

• 인스턴스 멤버: 객체(인스턴스)를 생성한 후 사용할 수 있는 필드와 메소드
• 인스턴스 멤버 선언

public class Car {

//필드

int gas;



//메소드

void set Speed(int speed) {....}

}

• 메모리 블록 내부에 인스턴스 필드 등이 사용되는 경우가 있음
• 인스턴스 필드가 사용되면 메소드는 객체 없이 실행할 수 없음

this

• 객체 내부에서 인스턴스 멤버에 접근하기 위해 this를 사용
• 객체는 자신을 this라고 함
• 주로 생성자와 메소드의 매개 변수 이름이 필드와 동일한 경우, 인스턴스 멤버인 필드임을 명시할 때 사용

정적 멤버와 static

• 정적 멤버: 클래스에 고정된 멤버로 객체를 생성하지 않고 사용할 수 있는 필드와 메소드
• 정적 멤버 선언 -> static 키워드를 추가적으로 붙이면 됨

public class 클래스 {

//정적 필드

static 타입 필드 [=초기값];



//정적 메소드

static 리턴 타입 메소드( 매개변수선언, ...) {...}

}

• 클래스에 고정된 멤버로 클래스 로더가 클래스(바이트 코드)를 코딩해서 메소드 메모리 영역에 적재할 때 클래스별로 관리
• 객체마다 가지고 있어야 할 데이터라면 인스턴스 필드로 선언
• 객체마다 가지고 있을 필요가 없는 공용 데이터라면 정적 필드로 선언

정적 멤버 사용

• 클래스 이름과 함께 도트(.) 연산자로 접근

클래스.필드;

클래스.메소드(매개값, ...);

정적 메소드 선언 시 주의할 점

• 정적 메소드를 선언할 때는 내부에 인스턴스 필드나 인스턴스 메소드를 사용할 수 없음
• this 키워드도 사용 불가능
• 정적 메소드에서 인스턴스 멤버를 사용하고 싶다면 객체를 먼저 생성하고 참조 변수로 접근

싱글톤(Singleton)

• 전체 프로그램에서 단 하나의 객체만 만들도록 보장해야 하는 경우
• 클래스 외부에서 new 연산자로 생성자를 호출할 수 없도록 막아야 함 -> private 접근 제한자 붙이기
• 자신의 타입인 정적 필드를 선언하고 자신의 객체를 생성해 초기화
• 외부에서 호출할 수 있는 정적 메소드 getInstance() 선언하고 정적 필드에서 참조하고 있는 자신의 객체를 리턴

public class 클래스 {

//정적 필드

private static 클래스 singleton = new 클래스();



//생성자

private 클래스() {}



//정적 메소드

static 클래스 getInstance() {

   return singleton;

}

}

• 외부에서 객체를 얻는 유일한 방법은 getInstance() 메소드를 호출하는 방법 -> 단 하나의 객체만 리턴

final 필드와 상수

• final 필드: 초기값이 최종적인 값이 되어서 프로그램 실행 도중에 수정할 수 없음

final 타입 필드 [=초기값];

• final 필드의 초기값을 주는 방법
  • 필드 선언시 주는 방법
  • 생성자에서 주는 방법

상수 constant

• final 필드는 상수가 아님 
• 객체마다 저장되고, 생성자의 매개값을 통해서 여러 가지 값을 가질 수 있기 때문에 상수 x
• 상수는 static이면서 final 이어야함

static final 타입 상수= 초기값;

• 상수 이름은 모두 대문자로 작성
• 혼합된이름은 (_)로 연결

확인문제

• 정적 멤버는 static으로 선언된 필드와 메소드를 말한다 (o)
• 인스턴스 필드는 생성자에서 초기화될 수 없다.(x)
• 정적 필드와 메소드는 객체 생성 없이 클래스를 통해 접근할 수 있다. (o)
• 인스턴스 필드와 메소드는 객체를 생성하고 사용해야 한다 (o)
• final 필드와 상수는 초기값이 저장되면 값을 변경할 수 없다 (o)
• final 필드와 상수는 생성자에서 초기화 될 수 있다. (x)
• 상수의 이름은 대문자로 작성하는 것이 관례이다 (o)
• 상수는 객체 생성없이 클래스를 통해 사용할 수 있다 (o)

메소드 선언부 method signiture

• 리턴 타입: 메소드가 리턴하는 결과의 타입 푷시
• 메소드 이름: 메소드의 기능이 드러나도록 식별자 규칙에 맞게 이름을 지어준다
• 매개 변수 선언: 메소드를 실행할 때 데이터를 받기 위한 변수를 선언
• 메소드 실행 블록: 실행할 코드를 작성

메소드 선언

• 메소드 선언은 선언부와 실행 블록으로 구성

리턴 타입

• 리턴값의 타입 == 실행한 후의 결과값
• 메소드는 리턴값이 있을 수도 있고 없을 수도 있으나 리턴값이 있을 경우 리턴 타입이 선언부에 명시되어야 함

메소드 이름

• 숫자로 시작하면 안되고 $와_를 제외한 특수문자 사용 금지
• 관례적으로 메소드 이름은 소문자로 작성
• 서로 다른 단어가 혼합된 이름이라면 뒤이어 오는 단어의 첫 글자는 대문자로 작성

매개 변수 선언

• 메소드가 실행할 때 필요한 데이터를 외부로부터 받기 위해 사용

매개 변수의 개수를 모를 경우

• 매개 변수를 배열 타입으로 선언하는 것

int sum1(int[] values){ }

int sum2(int ...values) { }

리턴문

• 리턴값이 있는 메소드
• return 리턴값;
• return문이 없다면 컴파일 에러가 발생
• return문이 실행되면 메소드는 즉시 종료

리턴값이 없는 메소드:void

• void로 선언된 메소드에서 return은 메소드 실행을 강제 종료 시키는 역할을 함

메소드 호출

• 메소드는 클래스 내.왜부의 호출에 의해 실행됨
• 클래스 내부의 다른 메소드에서 호출할 경우 단순한 메소드 이름으로 호출하면 되지만
• 클래스 외부에서 호출할 경우, 클래스로부터 객체를 생성한 뒤 참조변수를 이요해서 메소드를 호출해야함
• 객체가 존재해야 메소드도 존재하기 때문

객체 내부에서 호출

메소드(매개값, ...);

타입 변수 = 메소드(매개값, ...);

객체 외부에서 호출

• 외부 클래스에서 메소드를 호출하려면 클래스로부터 객체를 생성해야함
• 메소드는 객체에 소속된 멤버이므로 객체가 존재하지 않으면 메소드도 존재하지 않기 때문

클래스 참조변수 = new 클래스 (매개값,..);

• 객체가 생성되었다면 참조 변수와 함께 도트(.) 연산자를 사용해서 메소드를 호출
  
  

참조변수.메소드(매개값, ...);

타입 변수 = 참조변수.메소드(매개값, ...);

메소드 오버로딩

• 클래스 내에 같은 이름의 메소드를 여러개 선언하는 것
• 매개 변수의 타입, 개수, 순서 중 하나가 달라야 함
• 매개값을 다양하게 받아 처리 할 수 있음
• 이름만 다르다고 해서 오버로딩이 아님

확인 문제

• 리턴값이 없는 메소드는 리턴 타입을 void로 해야한다.
• 리턴 타입이 있는 메소드는 리턴값을 지정하기 위해 반드시 return문이 있어야한다
• 매개값의 개수를 모를 경우 ... 를 이용해서 매개 변수를 선언할 수 있다.
• 같은 이름의 메소드를 여러 개 선언하는 것을 메소드 오버로딩이라고 한다.

메소드 오버로딩에 대한 설명으로 맞는 것에 O/X

• 동일한 이름의 메소드를 여러개 선언 하는 것을 말한다. (o)
• 반드시 리턴 타입이 달라야 한다. (x)
• 매개 변수의 타입, 개수, 순서를 다르게 선언해야 한다.(o)
• 매개 값을 타입 및 개수에 따라 호출될 메소드가 선택된다 (o)

MemberService

public class MemberService {
    boolean login(String id, String password) {
        if (id.equals("hong") && password.equals("12345")) {
            return true;
        } else {
            return false;
        }
    }

    void logout(String id){
        System.out.println("로그아웃 되었습니다.");
    }
}

생성자 constructor

new 연산자로 클래스로부터 객체를 생성할 때 호출되어 객체의 초기화를 담당

객체 초기화

• 필드를 초기화하거나 메소드를 호출해서 객체를 사용할 준비를 하는 것
• new 연산자에 의해 생성자가 실행되면 힙 영역에 객체가 생성되고 객체의 번지 리턴
• 리턴된 객체의 번지는 클래스 변수에 저장

기본 생성자 default constructor

[public] 클래스() {}

• 클래스가 public class로 선언되면 기본 생성자에도 public이 붙지만 클래스가 public 없이 선언되면 기본 생성자에도 public 없음

생성자 선언

클래스( 매개변수선언, ....){  객체 초기화 코드}

• 리턴 타입이 없고 클래스 이름과 동일
• 블록 내부에 객체 초기화 코드가 작성됨
• 필드에 초기값을 저장하거나 메소드를 호출하여 객체 사용전에 필요한 준비를 함
• 매개 변수는 new 연산자로 생성자를 호출할 때 외부의 값을 생성자 블록 내부로 전달하는 역할을 함

필드 초기화

• 클래스로부터 객체가 생성될 때 필드는 기본 초기값으로 자동 설정됨
• 초기화하는 방법
• 필드를 선언할 때 초기값을 주는 방법
• 생성자에게 초기값을 주는 방법

생성자 오버로딩

• 매개변수를 달리하는 생성자를 여러개 선언하는 것

다른 생성자 호출: this()

• 생성자에서 다른 생성차를 호출할 때 this()코드를 사용
• 생성자의 첫 줄에서만 허용
• this()의 매개값은 호출되는 생성자의 매개 변수에 맞게 제공해야 함
• this() 다음에는 추가적인 실행문들이 올 수 있음
• 호출되는 생성자의 실행이 끝나면 원래 생성자로 돌아와서 다음 실행문을 진행

확인 문제

• 객체를 생성하려면 생성자 호출이 반드시 필요한 것은 아니다. (x)
• 생성자는 다른 생성자를 호출하기 위해 this()를 사용할 수 있다. (o)
• 생성자가 선언되지 않으면 컴파일러가 기본 생성자를 추가한다. (o)
• 매개 변수의 수, 타입, 순서가 다른 생성자를 여러 개 선언할 수 있다. (o)

Member 클래스 작성

public class Member {
    
    String name;
    String id;
    
    public Member(String name, String id){
        this.name = name;
        this.id = id;
    }
}

Board 클래스 작성

public class Board {
    
    String title;
    String content;
    String writer;
    String date;
    int hitcount;
    
    Board(String title, String content, String writer, String date, int hitcount){
        this.title = title;
        this.content = content;
        this.writer = writer;
        this.date =date;
        this.hitcount = hitcount;
    }
    
    Board(String title, String content){
        this(title, content, "로그인한 회원아이디", "현재 컴퓨터 날짜", 0);
    }
    
    Board(String title, String content, String writer){
        this(title, content,writer,"현재 컴퓨터 날짜", 0);
    }
    
    Board(String title, String content, String writer, String date){
        this(title, content,writer,date,0);
    }
    
}

필드

객체의 고유 데이터, 객체가 가져야 할 부품, 객체의 현재 상태 데이터를 저장하는 곳

필드 선언

• {} 블록에 존재
• 위치는 상관 없음
• 단, 생성자와 메소드 중괄호 {} 내부에는 선언 될 수 없음
• 생성자와 메소드 중괄호 블록 내부에 선언된 것은 모두 로컬 변수
• 타입 필드 [=초깃값];
• 선언형태는 변수와 피슷하지만 필드는 변수가 아님
• 초기값이 저장되지 않은 필드는 객체 생성 시 자동으로 기본 초기값으로 설정됨
• 참조 타입은 객체를 참조하고 있지 않은 상태인 null로 초기화

필드 사용

• 필드값을 읽고 변경하는 작업
• 클래스 내부의 생성자나 메소드에서 사용할 경우 필드 이름으로 일고 변경하면 됨
• 클래스 외부에서 사용할 경우 우선적으로 클래스로부터 객체를 생성한 뒤 필드를 사용
• 필드가 객체에 소속된 데이터이므로 객체가 있어야 필드도 존재함
• 변수가 객체를 참조하게 되면 도트(.) 연산자를 사용해서 필드에 접근
• 도트(.)연산자는 객체 접근 연산자

확인 문제

• 필드는 메소드에서 사용할 수 있다. (o)
• 필드는 클래스 블록 어디서든 선언할 수 있다(생성자, 메소드 내부 제외) (o)
• 필드는 객체 외부에서 접근할 수 없다. (x)
• 필드는 초기값을 주지 않더라도 기본값으로 자동 초기화 된다. (o)

Member Class 선언하기

public class Member {

    String name;
    String id;
    String password;
    int age;

    public static void main(String[] args) {
        Member member = new Member();
        member.name = "최하얀";
        member.age =23;

        System.out.println("이름: "+member.name);
        System.out.println("나이: "+member.age);
    }
}

객체 지향 프로그래밍 OOP:Object-Oriented Programming

객체란?

• 물리적으로 존재하거나 추상적으로 생각할 수 있는 것 중에서 자신의 속성을 가지고 있으면서 식별 가능한 것.
• 객체는 속성과 동작으로 구성
• 객체 모델링(Object Modeling): 현실 세계의 객체를 소프트웨어 객체로 설계하는 것

객체의 상호작용

• 객체들 사이의 상호작용 수단은 메소드
• 객체가 다른 객체의 기능을 이용하는 것 == 메소드 호출
•  

메소드 호출

• 리턴값 = 전자계산기객체.메소드(매개값1, 매개값2,...);
• int result = Calculator.add(10,20);

객체 간의 관계

• 객체는 개별적으로 사용될 수 있으나, 대부분 다른 객체와 관계를 맺고 있음
  • 집합관계: 하나는 부품, 하나는 완성품
  • 사용관계: 객체간의 상호작용; 객체는 다른 객체의 메소드를 호출하여 원하는 결과를 얻음
  • 상속관계: 상위객체를 기반으로 하위 객체를 생성하는 관계

객체와 클래스

• 클래스: 설계도; 객체를 생성하기 위한 필드와 메소드와 정의되어 있음
• 인스턴스: 클래스로부터 만들어진 객체

객체 지향 프로그래밍 개발

1. 클래스 설계

2. 설계된 클래스를 가지고 사용할 객체를 생성

3. 생성된 객체를 이용

클래스 선언

• public 접근 제한자: 파일이름과 동일한 이름의 클래스 선언에만 붙일 수 있음
• 파일 이름과 일치하지 않는 클래스 선언에 public 접근 제한자를 붙이면 컴파일 에러가 발생
• 소스 파일 하나당 동일한 이름의 클래스 하나를 선언하는 것이 좋음

객체 생성과 클래스 변수

• 클래스로부터 객체를 생성하려면 new 연산자를 사용
• new 클래스();
• new는 클래스로부터 객체를 생성시키는 연산자
• new 연산자 뒤에 생성자가 오고 생성자는 클래서()형태를 가지고 있음
• new 연산자로 생성된 객체는 Heap 영역에 생성됨
• 힙영역에 객체 생성 후 객체의 번지를 리턴
• 대부분의 객체 지향 프로그램은 라이브러리와 실행 클래스가 분리되어 있음

클래스의 구성 멤버

• 필드: 객체의 고유 데이터, 부품 객체, 상태 정보를 저장;
  • 생성자와 메소드 전체에서 사용되며 객체가 소멸 되지 않는 한 객체와 함께 존재
• 생성자: 생성자는 new 연산자로 호출되는 특별한 중괄호 {} 블록; 
  • 객체 생성 시 초기화 담당
  • 클래스 이름으로 되어있고 리턴 타입으 잆음
• 메소드: 객체의 동작에 해당하는 중괄호{} 블록
  • 메소드를 호출하면 중괄호 블록에 있는 모든 코드들이 일괄적으로 실행
  • 필드를 읽고 수정하는 역할 + 다른 객체를 생성해서 다양한 기능을 수행
  • 객체 간의 데이터를 전달하는 수단
  • 외부로부터 매개값을 받아 실행 + 실행 후 결과 값을 외부로 리턴