[Java] Class에 대하여 (미완성)

안녕하세요? 주니하랑 입니다.

03월 15일 숙제로 Class에 대하여 조사하는 것을 받은 것이에요!

숙제 내용을 공유해서 여러분들께서도 공부하시는데, 많은 도움 되시기 바라겠습니다!

그럼 바로 시작 해 보겠습니다!

 

📌 Class 숙제 01

   📍 객체 지향 프로그래밍(OOP, Object-Oriented Programing)

---

 

객체 지향 프로그래밍에서는 모든 데이터를 객체(Object)로 취급하며, 이러한 객체가 바로 프로그래밍의 중심이 되는 것이에요.

객체(Object)란 간단히 이야기하자면 실 생활에서 우리가 인식할 수 있는 사물로 설명할 수 있겠습니다.

이러한 객체의 상태(State)와 행동(Behavior)을 구체화하는 형태의 프로그래밍이 바로 객체 지향 프로그래밍 입니다.

이 때! 객체를 만들어 내기 위한 설계도와 같은 개념을 클래스(Class)라고 합니다.

 

   📍 클래스(Class)

---

자바에서 클래스(Class)란 객체를 정의하는 틀 또는 설계도와 같은 의미로 사용됩니다.

자바에서는 이러한 설계도인 클래스를 가지고, 여러 객체를 생성하여 사용하게 됩니다.

클래스는 객체의 상태를 나타내는 필드(Field)와 객체의 행동을 나타내는 메서드(Method)로 구성 되는 것이에요.

즉, 필드(Field)란 Class에 포함된 변수(Variable)을 의미한답니다!

또한, 메서드(Method)란 어떠한 특정 작업을 수행하기 위한 명령문의 집합이라 할 수 있습니다.

주니하랑은 입력값을 받아 출력값을 내는 계산기라고 표현하고 싶은 것이에요!

 

     👉 Class의 예

---

public class Car {

	private String modelName;
    private int modelYear;
    private int color;
    private int maxSpeed;
    
    
    public void accelerate() {
    	System.out.println("오빠 달려!")
    }
    
    public void brake() {
    	System.out.println("멈춰라!");
    }
    
 }
 
 public class Test {
 
 	public void main(String[] args) {

	car.modelName = "람보르기니";
    car.modelYear = 2016;
    car.color = "주황색";
    car.maxSpeed = 350;
    
    car.accelerate();
    car.brake();
    
    }
 }

내 차 (myCar): 설계도에 의해 생산된 차량

친구 차(FriendCar): 설계도에 의해 생산된 또 다른 차량

 

 

   📍 객체(Object) 또는 인스턴스(Instance)

---

자바에서 Class를 사용하기 위해서는 우선 해당 Class Type의 객체(Object)를 선언해야 하는 것이에요.

이렇게 Class로부터 객체를 선언하는 과정을 Class의 인스턴스화라고 한답니다!

또한, 이렇게 선언된 해당 Class Type의 객체를 인스턴스(Instance)라고 하는 것이에요.

즉, 인스턴스란 Memory에 할당된 객체를 의미하는 것이에요.

 

자바에서는 하나의 Class로부터 여러 개의 인스턴스를 생성할 수 있습니다.

이렇게 생성된 인스턴스는 독립된 Memory 공간에 저장된 자신만의 Field를 가질 수 있답니다!

하지만, 해당 Class의 모든 메서드(Method)는 해당 Class에서 생성된 모든 인스턴스가 공유하게 된답니다!

 

 

   📍 this와 this()

---

this 참조 변수는 인스턴스가 바로 자기 자신을 참조하는데, 사용하는 변수인 것이에요. 이러한 this 참조 변수는 해당 인스턴스의 주소를 가리키고 있답니다!

 

다음 예시 코드는 Car Class의 생성자를 나타낸 예제랍니다.

public class Car {

	/* 인스턴스 변수 (필드) */
	
	private String modelName;
    private int modelYear;
    private String color;
    private int maxSpeed;
    private int currentSpeed;
    
    
    /* 생성자 */
    
    
    public Car(String modelName, int modelYear, String color, int maxSpeed) {
    	this.modelName = modelName;
        this.modelYear = modelYear;
        this.color = color;
        this.maxSpeed = maxSpeed;
        this.currentSpeed = 0;
    } // 생성자 끝
    
} // Class 끝

위의 예제처럼 생성자의 매개변수 이름과 인스턴스 변수의 이름이 같을 경우에는 인스턴스 변수 앞에 this 키워드를 붙혀야만 하는 것이에요. 그 이유는 this를 입력하지 않으면 가까이 있는 생성자의 매개변수 이름인 변수명으로 인지를 하기 때문이에요!

만약 매개변수명을 인스턴스 변수명과 다르게 한다면 굳이 this를 붙히지 않아도 된답니다!

 

이렇게 자바에서는 this 참조 변수를 사용하여 인스턴스 변수에 접근할 수 있는 것이에요.

이러한 this 참조 변수를 사용할 수 있는 영역은 인스턴스 메서드 뿐이며, Class 메서드에서는 사용할 수 없는 것이에요.

모든 인스턴스 메서드에는 this 참조 변수가 숨겨진 지역 변수로 존재하고 있답니다!

 

       👉 this()

---

this() 메서드는 생성자 내부에서만 사용할 수 있는 것이에요. 이것은 같은 클래스의 다른 생성자를 호출할 때 사용한답니다!

this() 메서드에 인수를 전달하면 생성자 중 메서드 시그니처가 일치하는 다른 생성자를 찾아 호출 해 주는 것이에요!

 

✏️ 메서드 시그니처(Method Signature)란? 메서드의 이름과 메서드의 원형에 명시되는 매개변수(인자) 리스트를 가르킨답니다!

 

다음은 this 참조 변수와 this() 메서드를 사용한 예제입니다.

public Car {
	private String modelName;
    private int modelYear;
    private String color;
    private int maxSpeed;
    private int currentSpeed;
  	
    
    public Car(String modelName, int modelYear, String color, int maxSpeed) {
    	this.modelName = modelName;
        this.modelYear = modelYear;
        this.color = color;
        this.maxSpeed = maxSpeed;
        this.currentSpeed = 0;
    }
    
    public Car() {
    	this("소나타", 2012, "검정색", 160);		// 다른 생성자 호출!
    }
    
    public String getModel() {
    	return this.modelYear + "년식" + this.modelName + " " + this.color;
    }
  } // Class 끝
    
   /* ########################################################################### */
    
    public class Method05 {
    	public static void main(String[] args) {
        	Car tcpCar = new Car();
            System.out.println(tcpCar.getModel();
        } // Main 끝
    } // Class 끝
    
    
    /* ########################################################################### */
      
    // 실행 결과
    
    // 2012년식 소나타 검정색

위의 예제에서 매개변수를 가지는 첫번째 생성자는 this 참조 변수를 사용하여 인스턴스 변수에 접근하고 있는 것이에요!

또한, 매개변수를 가지지 않는 두번째 생성자는 내부에서 this() 메서드를 이용하여 첫번째 생성자를 호출하고 있답니다!

이렇게 내부적으로 다른 생성자를 호출하여 인스턴스 변수를 초기화 할 수 있는 것이에요!

 

✏️ 단, 한 생성자에서 다른 생성자를 호출할 시 반드시 해당 생성자의 첫 줄에서만 호출할 수 있는 것 잊으면 안 되는 것이에요!

 

 

   📍 Static(정적) 키워드

---

정적(Static)은 고정된이란 의미를 갖고 있는 것이에요. Static이라는 키워드를 사용하여 Static변수와 Static 메서드를 만들 수 있는데, 다른말로 정적필드와 정적 메서드라고 하며, 이 둘을 합쳐 정적 멤버(Static Member) 혹은 클래스 멤버(Class Member)라고 하는 것이에요.

정적 필드와 정적 메서드는 객체(인스턴스)에 소속된 멤버가 아니라 클래스에 고정된 멤버라는 점을 잊으면 안 되는 것이에요. 그렇기 때문에 클래스 로더가 클래스를 로딩해서 메서드 메모리 영역에 적재할 때 클래스별로 관리 된답니다. 때문에 클래스의 로딩이 끝나는 즉시 바로 사용 가능하답니다!

 

 

       👉 정적(Class)멤버 생성

---

Static 키워드를 통해 생성된 정적 멤버들은 Heap 영역이 아닌 Static 영역에 할당이 되는 것이에요. Static 영역에 할당된 Memory는 모든 객체가 공유하여 하나의 멤버를 어디서든지 참조할 수 있는 장점을 갖지만, Garbage Collector의 관리 영역 밖에 존재하기 때문에 Static 영역에 있는 멤버들은 프로그램의 종료시까지 Memory를 할당한 채로 존재하게 된답니다. 때문에 Static을 너무 남발하게 되면 만들고자 하는 System 성능에 악영향을 줄 수 있다는 점! 잊으면 안 되는 것이에요.

또한, 인스턴스 변수는 대부분 private로 지정하고, getter와 setter를 사용해서 참조를 하게 됩니다. 그 이유는 [Java] 자바의 객체지향 프로그래밍(Object-Oriented Programming) 이 곳에서 확인하실 수 있는 것이에요! 

[Java] 자바의 객체지향 프로그래밍(Object-Oriented Programming)

 

   📍 생성자란?

---

필드는 무조건 선언만 해야 합니다. 예를 들어 meta라는 필드에 10을 넣고 싶다면 아래와 같이 추가하면 안됩니다.

public class test() { 
	private int meta = 10; // 이렇게 필드에서 초기화까지 하면 안됨. 
}

초기화는 Method나, 생성자에서만 해줘야 합니다. 즉, 내가 어떤 필드에 값을 초기화 하고 싶을 때, 생성자를 쓴다고 이해 하면 좋습니다. 생성자는 반드시 필요한 것은 아니고, 필드를 초기화할 필요가 있을 때 사용하면 되는 것 입니다.

결국 생성자는 인스턴스가 생성딜 때 호출되는 '인스턴스 초기화 메서드'라고 할 수 있습니다. 생성자는 오버로딩(같은 이름을 가진 여러 메소드 사용)이 가능 합니다.

참고로 객체를 생성할 때 new 뒤에 오는 것이 생성자 호출 입니다!

Test test new Test();

// Test();는 test 객체의 생성자를 호출하는 것

 

 

 

 

   📍 접근 지정자(제어자)

---

영어로 치면 형용사(명사를 꾸며줌)과 같은 것이에요. 클래스와 클래스 Member에게 부가적인 의미를 부여하죠!

접근 제어자: public, protected, defulat, private ( 4개 중 하나만 사용 가능)

그 외: static, final, abstract, native, transient, synchronized, volatile, strictfp

제어자는 클래스나 멤버변수와 메서드에 주로 사용되며, 하나의 대상에 여러 제어자를 조합하여 사용하는 것이에요.

접근 제어자는 한 번에 네가지 중 하나만 사용 가능 하답니다!

필드(Class 변수) 입장에서 봤을 때, 요청하는 쪽에서 나에게 함부로 접근하지 못하도록 권한을 지정할 수 있습니다. 이렇게 하는 이유를 비유로 들자면 필드 입장에서 내가 가지고 있는 물건을 아무나 와서 가져가고, 바꾸고 하면 기분이 나쁘겠지요? 그래서 이것을 못하도록 내 물건을 숨기기 위해 Class(객체)에서 선언한 변수(필드)를 은닉화를 하여 변수 자료형 앞에 Private를 작성하게 됩니다. 단, 모든 Method는 public으로 선언하는게 좋답니다.

접근 제어자는 public과 private외에도 두가지가 더 있습니다. protected와 default가 그것입니다. protected는 상속 관계에 있다면 서로 다른 패키지에 있는 클래스의 접근도 허용합니다. default는 접근 제어 지시자가 없는 경우를 의미하는데, 접근 제어자가 없는 메소드는 같은 패키지에 있고, 상속 관계에 있는 메서드에 대해서만 접근을 허용 합니다. 아래 그림은 접근 제어자 별로 접근 허용 범위를 그림으로 나타낸 것이에요. 안쪽에 있을수록 접근 통제가 삼엄하고, 밖에 있을수록 접근이 자유롭습니다.

접근 제어자는 Member 또는 Class에 사용 된답니다!

접근 제어자가 사용될 수 있는 곳 - Class, Member 변수, Method, 생성자
  - private : 같은 클래스 내 접근 가능
  - defulat : 같은 패키지 내만 접근 가능
  - protected : 같은 패키지 내와 다른 패키지의 자손 Class에서만 접근 가능
  - public : 어떤 곳에서든 접근 가능 

출처: 생활코딩

 

public > protected > (default) > private

 

 

 

 

   📍 오버로딩(Overloading)

         👉 Method Signature(메서드 시그니처)

---

메서드 오버로딩의 핵심은 바로 메서드 시그니처(Method Signature)에 있답니다!

메서드 시그니처란? 메서드의 선언부에 명시되는 매개변수의 리스트를 가리킨답니다!

만약 두 메서드가 매개변수의 개수와 타입, 그 순서까지 모두 같다면, 이 두 메서드의 시그니처는 같다고 할 수 있답니다!

 

 

         👉 Method Overloading

---

메서드 오버로딩(overloading)이란? 같은 이름의 메서드를 중복하여 정의하는 것을 의미한답니다!

자바에서는 원래 한 클래스 내에 같은 이름의 메서드를 둘 이상 가질 수 없는 것이에요.

하지만, 매개변수의 개수나 타입을 다르게 한다면? 하나의 이름으로 메서드를 작성할 수 있는 것이에요.

즉, 메서드 오버로딩은 서로 다른 시그니처를 갖는 여러 메서드를 같은 이름으로 정의하는 것이라고 할 수 있답니다!

 

이러한 메서드 오버로딩을 사용함으로써, 메서드에 사용되는 이름을 절약할 수 있는 것이에요.

또한, 메서드를 호출할 때 전달해야 할 매개변수의 타입이나, 개수에 대해 크게 신경 쓰지 않고, 호출 할 수 있답니다!

메서드 오버로딩은 객체 지향 프로그래밍의 특징 중 하나인 다형형(Polymorphism)을 구현하는 방법 중 하나랍니다.

 

메서드 오버로딩의 대표적 예로는 println()을 들 수 있는 것이에요.

println()은 전달받는 매개변수의 타입에 따라 다음과 같이 다양한 원형 중에서 적절한 원형을 호출하게 된답니다!

println()

println(boolean x)

println(char x)

println(char[] x)

println(double x)

println(float x)

println(int x)

println(long x)

println(Object x)

println(String x)

 

 

         👉 Method Overloading 조건

---

자바에서 메서드 오버로딩이 성립되기 위해서는 다음과 같은 조건을 만족해야 하는 것이에요.

첫째! 메서드의 이름이 같아야 합니다.

둘째! 메서드의 시그니처 즉, 매개변수의 개수 또는 타입이 달라야 합니다.

 

메서드 오버로딩은 반환 타입과는 관계가 없다는 점 잊으면 안 되는 것이에요. 만약 메서드의 시그니처는 같은데 반환 타입만이 다른 경우에는 오버로딩이 성립되지 않는 답니다!

 

         👉 Method Overloading 예제

---

자바 컴파일러는 사용자가 오버로딩된 함수를 호출하면, 전달된 매개변수의 개수와 타입과 같은 시그니처를 가지는 메서드를 찾아 호출한답니다.

다음은 함수의 오버로딩을 이용하여 정의한 display() 메서드의 원형 예제 입니다.

public void display (int num1)				// 전달받은 num1을 그대로 출력
public void display (int num1, int num2)	// 전달받은 두 정수의 곱을 출력
public void display (int num1, double num2)	// 전달 받은 정수와 실수의 합을 출력

 

이제 사용자가 display() 메서드를 호출하면, 컴파일러는 자동으로 같은 시그니처를 가지는 메서드를 찾아 호출한답니다!

display(10);		// 1번 display() 호출 => 10
display(10, 20);	// 2번 display() 호출 => 10 * 20 = 200
display(10, 3.14);	// 3번 display() 호출 => 10 + 3.14 = 13.14
display(10, 'a');	// 2번과 3번 모두 호출 가능!

문제는 4번과 같이 첫번째 인수로는 정수를, 두번째 인수로는 실수를 전달받는 호출입니다.

자바에서 char형 데이터는 int형 뿐만 아니라 double형으로도 타입이 변환될 수 있기 때문인 것이에요.

 

따라서 이와 같은 호출은 자바 컴파일러가 어느 시그니처의 display()를 호출해야 할지 불명확해 지는 것이에요.

자바에서는 오버로딩한 메서드의 이러한 모호한 호출을 허용하지 않으며, 위와 같은 경우 더 작은 표현 범위를 가지는 int형으로 자동 형변환을 하게 된답니다.

 

다음 예제는 위에서 살펴본 display()를 다양한 시그니처로 오버로딩하는 예제 인 것이에요.

public class Test {
	
    static void display(int num1) {
    	System.out.println(num1);
    }
    
    static void display(int num1, int num2) {
    	System.out.println(num1 * num2);
    }
    
    static void display(int num1, double num2) {
    	System.out.println(num1 + num2);
    }
    
 } // Class 끝
    
/* ########################################################### */

public class Method01 {
	public Static void main(String[] args) {
    	Test myfunc = new Test();
        
        myfunc.display(10);
        myfunc.dispaly(10,20);
        myfunc.display(10, 3.14);
        myfunc.display(10, 'a');
    } // Main 끝
 } // Class 끝
 
 
 /* #######################실 행  결 과########################## */
 
 10
 200
 13.14
 970		// a의 ASCII Code 값이 97이므로, 97 * 10이 연산됨
 
 
 

위의 예제처럼 메서드의 오버로딩은 매개변수의 타입뿐 아니라, 매개변수의 개수를 달리해도 작성할 수 있답니다!

 

 

 

 

 

📌 Class 숙제 02

   📍 상속이란?

---

Main Method에서 새로운 Class를 생성할 때 자료형 타입명을 다르게 하고, Class 변수명을 동일하게 하여 생성하게 되면 Class명을 정의하는 부분에서 extend가 나오는데, 이걸 '상속 받는다'라고 합니다.

부모 객체와 자식 객체는 엄연히 다른 코드입니다. 다른 Method에서 자식 객체를 호출할 때는 바로 사용이 가능하지만, 부모 객체를 사용하려면 Super를 거쳐서 가야 합니다.

부모 필드가 Private이면 자신만 접근이 가능하다는 의미이기 때문에 자식도 접근할 수 없습니다. 부모 필드가 Protected이면 제한적 접근이 가능하다는 의미인데, 자식 객체는 접근이 가능합니다. 상속은 결국 어떤 Class 객체를 생성하고,  기능을 넣어 쓰다가 추가적으로 기능을 더 넣고 싶을 때, 자식 Class 객체를 생성해서 사용하는 것입니다.

부모는 하나밖에 가질 수 없기 때문에 한 부모에게만 상속 받을 수 있습니다.

결국 기존 Class를 확장해서 새로운 Class를 만드는 것입니다. 기존 Class를 Base 또는 parent(부모), 상위 클래스(Super Class)라 하고, 새로 만든 Class를 파생(Derived Class) 또는 Child Class라고 합니다.

public class AdvanceWhell extends Wheel { 
	public void back() { 
    	System.out.println("뒤로 굴러간다."); 
    } // back End 
} // Class End

위의 코드에서 Class명 적는 곳에 extends 왼쪽은 자식 Class명이 오고, 오른쪽은 부모 Class명이 옵니다. 부모 Class는 하나만 사용할 수 있고, 상속을 사용하면 코드량을 많이 줄일 수 있게 됩니다.

 

결국 상속이란 기존의 클래스에 기능을 추가하거나, 재정의하여 새로운 클래스를 정의하는 것을 의미한답니다. 이러한 상속은 캡슐화, 추상화와 더불어 객체 지향 프로그래밍을 구성하는 중요한 특징 중 하나인 것이에요.

 

상속을 이용하면 기존에 정의되어 있는 클래스의 모든 필드와 메서드를 물려받아, 새로운 클래스를 생성할 수 있답니다!

 

         👉 상속의 장점

---

자바에서 클래스의 상속은 다음과 같은 장점을 갖는 것이에요.

첫째! 기존에 작성된 클래스를 재활용할 수 있다!

둘째! 자식 클래스 설계 시 중복되는 멤버를 미리 부모 클래스에 작성해 두면 자식 클래스에서는 해당 멤버를 작성하지 않아도 된다!

셋째! 클래스 간의 계층적 관계를 구성함으로 다형성의 문법적 토대를 마련한다!

 

 

         👉 자식 클래스(Child Class)

---

자식 클래스(Child Class)란 부모 클래스의 모든 특성을 물려 받아 새롭게 작성된 클래스인 것이에요.

다음은 부모 클래스와 자식 클래스 간의 포함도 입니다.

이처럼 부모 클래스는 자식 클래스에 포함된 것으로 볼 수 있는 것이에요. 따라서 부모 클래스에 새로운 필드를 하나 추가하면, 자식 클래스에도 자동으로 해당 필드가 추가된 것처럼 동작한답니다!

 

자식 클래스에는 부모 클래스의 필드와 메서드만 상속되며, 생성자와 초기화 클럭은 상속되지 않는점 참고하시길 바라는 것이에요! 또한, 부모 클래스의 접근 제어가 Private이나, Default로 설정된 멤버는 자식 클래스에서 상속받지만, 접근은 할 수 없답니다!

 

public class Parent {
	private int a = 10;
    public int b = 20;
} // class 끝

/* ####################################### */

public Child extends Parent {
	public int c = 30;
    
    pubilc void display() {
    	/* System.out.println(a); 상속받은 Private 필드 참조 */
        System.out.println(b);	// 상속받은 public 필드 참조
        System.out.println(c);	// 자기 자신이 선언한 public 필드 참조
    } // display 끝
} // Class 끝

/* ####################################### */

public class inheritance01 {
	public static void main(Strint[] args) {
    	Child ch = new Child();
        ch.display();
    } // Main 끝
} // Class 끝


/* ############# 실 행  결 과 ############### */

20
30

위 예제의 자식 클래스의 메서드에서 부모 클래스에서 상속받은 public 필드를 참조하는 것이 있는 것이에요.

이처럼 자식 클래스에서 따로 선언하지 않은 필드라도 해당 이름의 필드를 부모 클래스에서 상속 받았다면 문제가 없답니다!

하지만 주석 처리된 a 출력 문장은 해당 필드가 부모 클래스의 private 필드라면 아무리 자식이라도 접근할 수 없으므로 오류가 난답니다!

또한, 자식 클래스에서는 자기 자신이 추가 선언한 필드나 메서드를 선언하여 사용할 수 있답니다!

 

✏️ 자바에서 클래스는 단 한 개의 클래스만을 상속받는 단일 상속만 가능하답니다!

 

 

         👉 Object Class

---

자바에서는 Object 클래스는 모든 클래스의 부모 클래스 즉, 아담과 하와 혹은 단군 할아버지가 되는 클래스 인 것이에요.

따라서 자바의 모든 클래스는 자동으로 Object 클래스의 모든 필드와 메서드를 상속받게 된답니다.

 

즉, 자바의 모든 클래스는 별도로 extends 키워드를 사용하여 Object 클래스의 상속을 명시하지 않아도 Object 클래스의 모든 멤버를 자유롭게 사용할 수 있답니다.

 자바의 모든 객체에서 toString()이나, clone()과 같은 메서드를 바로 사용할 수 있는 이유가 해당 메서드들이 Object 클래스의 메서드이기 때문이랍니다.

 

 

   📍 Super와 Super()

         👉 Super 키워드

---

Super 키워드는 부모 클래스로부터 상속받은 필드나 메서드를 자식 클래스에서 참조하는데 사용하는 참조 변수인 것이에요.

인스턴스 변수의 이름과 지역 변수의 이름이 같을 경우 인스턴스 변수 앞에 this 키워드를 사용하여 구분할 수 있었던 거 기억하시나요?

이와 마찬가지로 부모 클래스의 멤버와 자식 클래스의 멤버 이름이 같을 경우 super를 사용하여 구별할 수 있답니다.

 

이렇게 자바에서는 super 참조 변수를 사용하여 부모 클래스의 멤버에 접근할 수 있답니다!

this와 마찬가지로 super 참조 변수를 사용할 수 있는 대상도 인스턴스 메서드 뿐이며, 클래스 메서드에서는 사용할 수 없는 점 잊으면 안되는 것이에요!

 

public class Parent {
	int a = 10;
} // Parent Class 끝

/* ############################################## */

public Child extends Parent {
	public void display() {
    	System.out.println(a);
        System.out.println(this.a);
        System.out.println(super.a);
    } // display 끝
} // Child Class 끝


/* ############################################## */

public class inheritance02 {
	public static void main(String[] args) {
    	Child ch = new Child();
        ch.display();
    } // Main 끝
} // inheritance02 Class 끝


/* ################# 출 력  결 과 ################ */

10
10
10

위의 예제에서 int형 변수 num은 부모 클래스인 Parent 클래스에서만 선언되어 있습니다. 따라서 지역 변수와 this 참조 변수, super 참조 변수 모두 같은 값을 출력하게 됩니다.

 

class Parent {

    int a = 10;

} // Parent 끝

/* ######################################### */

 

class Child extends Parent {

    int a = 20;

 

    void display() {

        System.out.println(a);

        System.out.println(this.a);

        System.out.println(super.a);

    } // display 끝

} // Child 끝

/* ######################################### */

public class Inheritance03 {

    public static void main(String[] args) {

        Child ch = new Child();

        ch.display();

    } // main 끝

} // Inheritance03 끝

/* ################# 출 력  결 과 ############### */

20
20
10

하지만 위의 예제에서 int형 변수 num은 자식 클래스인 Child 클래스에서도 선언 되어 있답니다.

따라서 지역 변수와 this 참조 변수는 자식 클래스에서 대입된 값을 출력하고, super 참조 변수만이 부모 클래스에 대입된 값을 출력하게 됩니다.

 

 

         👉 Super() 메서드

---

this() 메서드가 같은 클래스의 다른 생성자를 호출할 때 사용된다면, super() 메서드는 부모 클래스의 생성자를 호출할 때 사용되는 것이에요.

자식 클래스의 인스턴스를 생성하면, 해당 인스턴스에는 자식 클래스의 고유 멤버뿐만 아니라 부모 클래스의 모든 멤버까지도 포함되어 있답니다!

따라서 부모 클래스의 멤버를 초기화하기 위해 자식 클래스의 생성자에서 부모 클래스의 생성자까지 호출해야만 한답니다.

이러한 부모 클래스의 생성자 호출은 모든 클래스의 부모 클래스인 Object 클래스의 생성자까지 계속 거슬러 올라가며 수행되는 것이에요.

 

따라서 자바 컴파일러는 부모 클래스의 생성자를 명시적으로 호출하지 않는 모든 자식 클래스의 생성자 첫 줄에 자동으로 다음과 같은 명령문을 추가하여, 부모 클래스의 멤버를 초기화할 수 있도록 해 준답니다.

super();

 

하지만 자바 컴파일러는 컴파일 시 클래스에 생성자가 하나도 정의되어 있지 않아야만, 자동으로 기본 생성자를 추가 해 주는 것이에요.

만약 다음 예제처럼 부모 클래스에 매개변수를 가지는 생성자를 하나라도 선언했다면, 부모 클래스에는 기본 생성자가 자동으로 추가되지 않을 것이에요.

 

Public class Parent {
	int a;
    
    parent (int n) {
    	a = n;
    } // Parent 끝
} // Class 끝

 

그렇지만 다음 예제처럼 Parent 클래스를 상속받은 자식 클래스에서 super() 메서드를 사용하여 부모 클래스의 기본 생성자를 호출하게 된다면 오류가 발생하게 될 것이에요.

public Parent {
	int a;
    
    public Parent(int n) {
    	a = n;
    } // Parent 끝
} // Class 끝


/* ########################################## */

class Child extends Parent {
	int b;
    
    public Child() {
    	super();
        b = 20;
    } Child 끝
} Class 끝

왜냐하면 부모 클래스인 Parent 클래스에는 기본 생성자가 없기 때문인 것이에요.

따라서 매개변수를 가지는 생성자를 선언해야 할 경우 되도록 다음과 같이 기본 생성자까지 명시적으로 선언하는 것이 좋답니다!

class Parent {

    int a;

    Parent() { a = 10; }

    Parent(int n) { a = n; }

}

 

class Child extends Parent {

    int b;

    Child() {

        super();

        b = 20;

    }

 

다음은 super() 메서드가 어떻게 호출되는지 보여주는 것이에요.

class Parent {

    int a;

    Parent() { 	/* 기본 생성자 선언 */
    	a = 10; 
    }
    
    Parent(int n) { 
    	a = n; 
    }
}

 

class Child extends Parent {

    int b;
    Child() {
      //super(40);
        b = 20;

    }

    void display() {
        System.out.println(a);
        System.out.println(b);
    }
}



public class Inheritance04 {

    public static void main(String[] args) {

        Child ch = new Child();
        ch.display();
    }
}

/* ############## 실 행  결 과 ################ */

10
20

위의 예제는 그냥 실행 시 자바 컴파일러는 주석 처리된 [//super(40)] 라인에 자동으로 super(); 구문을 추가하게 될 것이에요.

따라서 변수 a는 10으로 초기화 된답니다. 하지만, [//super(40)]라인에 주석 처리를 해제하고 실행 시 부모 클래스인 Parent 클래스는 두번째 생성자에 의해 초기화 될 것입니다. 따라서 변수 a는 40으로 초기화 될 것이에요!

 

 

 

 

 

   📍 오버라이딩(overriding)

         👉 메서드 오버라이딩 (Method Overriding)

---

앞서 배운 오버로딩(overloading)이란 서로 다른 시그니처를 갖는 여러 메소드를 하나의 이름으로 정의하는 것이었습니다.

오버라이딩(overriding)이란 상속 관계에 있는 부모 클래스에서 이미 정의된 메소드를 자식 클래스에서 같은 시그니쳐를 갖는 메소드로 다시 정의하는 것이라고 할 수 있습니다.

 

자바에서 자식 클래스는 부모 클래스의 private 멤버를 제외한 모든 메소드를 상속받습니다.

이렇게 상속받은 메소드는 그대로 사용해도 되고, 필요한 동작을 위해 재정의하여 사용할 수도 있습니다.

즉, 메소드 오버라이딩이란 상속받은 부모 클래스의 메소드를 재정의하여 사용하는 것을 의미합니다.

 

자바에서는 메소드 오버라이딩을 통해 상속받은 부모 클래스의 메소드를 자식 클래스에서 직접 재정의할 수 있습니다.

다음 예제는 부모 클래스인 Parent 클래스의 display() 메소드를 자식 클래스인 Child 클래스에서 오버라이딩하는 예제입니다.

class Parent {

    void display() { 
    	System.out.println("부모 클래스의 display() 메소드입니다."); 
    }

}

class Child extends Parent {

    void display() { 
    	System.out.println("자식 클래스의 display() 메소드입니다."); 
    }

}

 

public class Inheritance05 {

    public static void main(String[] args) {

        Parent pa = new Parent();

        pa.display();

        Child ch = new Child();

        ch.display();

        Parent pc = new Child();

        pc.display();

    }

}

실행 결과

부모 클래스의 display() 메소드입니다.
자식 클래스의 display() 메소드입니다.
자식 클래스의 display() 메소드입니다.

위의 예제에서는 세번째와 같이 인스턴스의 참조가 허용되는 이유는 바로 자바에서의 다형성 때문인 것이에요.

 

 

         👉 오버라이딩 조건

---

자바에서 메소드를 오버라이딩하기 위한 조건은 다음과 같은 것이에요.

 

1. 오버라이딩이란 메소드의 동작만을 재정의하는 것이므로, 메소드의 선언부는 기존 메소드와 완전히 같아야 합니다.

    하지만 메소드의 반환 타입은 부모 클래스의 반환 타입으로 타입 변환할 수 있는 타입이라면 변경할 수 있습니다.

2. 부모 클래스의 메소드보다 접근 제어자를 더 좁은 범위로 변경할 수 없습니다

3. 부모 클래스의 메소드보다 더 큰 범위의 예외를 선언할 수 없습니다.

 

 

         👉 오버라이딩과 오버로딩의 차이

---

오버로딩(Overloding) 기존에 없는 새로운 이름이 같은 메서드를 정의 (new) (상속과 무관)
오버라이딩(Overriding) 상속받은 메서드의 내용을 변경 (Changer, modify)

 

오버로딩과 오버라이딩은 그 단어의 유사함으로 혼동하기 쉬운 것이에요. 하지만, 그 개념은 확실히 다르며, 그 차이점을 아는 것이 중요하답니다!

class Parent {

    void display() { System.out.println("부모 클래스의 display() 메소드입니다."); }

}

class Child extends Parent {

    // 오버라이딩된 display() 메소드

    void display() { System.out.println("자식 클래스의 display() 메소드입니다."); }

    void display(String str) { System.out.println(str); } // 오버로딩된 display() 메소드

}

 

public class Inheritance06 {

    public static void main(String[] args) {

        Child ch = new Child();

        ch.display();

        ch.display("오버로딩된 display() 메소드입니다.");

    }

}

실행 결과

자식 클래스의 display() 메소드입니다.
오버로딩된 display() 메소드입니다.

 

 

 

 

 

   📍 레퍼런스 형변환

---

인스턴스 간의 형변환으로 업 캐스팅(Up Casting)과 다운 캐스팅(Down Casting)이 있는 것이에요.

일반적으로 레퍼런스 형변환은 업 캐스팅을 의미한답니다.

 

         👉 업 캐스팅 (Up Casting)

---

서브 클래스의 인스턴스를 슈퍼클래스 타입으로 변환하여, 슈퍼클래스에서 서브 클래스의 인스턴스를 참조하는 것이에요.

자동 형변환도 가능하며, 참조 가능한 영역이 축소되어 접근할 수 있는 멤버가 줄어든답니다! (상속받은 멤버만 참고 가능.)

 

         👉 다운 캐스팅 (Down Casting)

---

슈퍼 클래스의 인스턴스를 서브 클래스 타입으로 변환하여, 서브 클래스에서 슈퍼 클래스의 인스턴스를 참조하는 것이에요.

자동 형변환은 불가하며, 형변환 연산자를 통해 명시적 형변환을 수행해야 하는 것이에요. 참조 가능 영역이 확대(업 캐스팅 선행 필요)된답니다!

단, 존재하지 않는 영역에 대한 참조 위험성 때문에 일반적으로 다운 캐스팅은 불가하답니다!

 

결국 업 캐스팅을 하게 되면 서브 클래스 타입의 멤버를 사용할 수 없게 되며, 다운 캐스팅으로 이 문제를 해결할 수 있답니다. 또한, 다운 캐스팅이 성립하려면? 업 캐스팅이 먼저 선행 되야 한답니다!

 

 

 

 

 

📌 Class 숙제 03

   📍 추상 메서드를 사용하는 이유?

---

 

 

 

   📍 추상 클래스 만드는 방법?

---

 

 

 

 

 

   📍 인터페이스의 사용처?

---