[Java] 클래스, 상속, 동적 바인딩, 추상 메소드, 인터페이스, super

Class(클래스)

• 객체를 정의하는 툴, 또는 설계도와 같은 의미로 사용된다.
• 클래스는 멤버(member)로 속성을 표현하는 필드(field)와 기능을 표현하는 메소드(method)를 가진다.
• 필드 : 객체의 상태
• 메소드 : 객체의 행동
• 인스턴스(Instance) 
  • 클래스를 사용하기 위해 해당 클래스 타입의 객체(Object)를 선언해야 한다.
  • 클래스의 인스턴스화 : 클래스로부터 객체를 선언하는 과정
  • 인스턴스는 선언된 해당 클래스 타입의 객체이다. -> 인스턴스는 메모리에 할당된 객체
• 메소드(method)
  
  • 메소드 : 특정 작업을 수행하기 위한 명령문의 집합
  • 중복 코드 최소화 -> 가독성 향상
  • 유지보수 용이
• 생성자(consructor)
  • 생성된 객체의 필드를 초기화해주는 메소드
  • 객체의 생성과 동시에 인스턴스 변수를 원하는 값으로 초기화할 수 있다.
  • 생성자도 메소드 이기 때문에, 메소드 오버로딩 가능 하지만, return X
  • 1. class는 무조건 생성자를 1개 이상 갖는다. : 없으면 default constructor 자동 생ㅅ어
  • 2. class 이름과 동일
  • 3. instance 초기화 담당
• 필드(field)
  • 클래스에 포함된 변수(variable)

class { -> instance 생성 

1) fields

2) constructors

3) methods

}

public class Student{
	// fields (변수)
	String stuName; // String -> class -> reference Type -> 문자
	String stuNum; // 학번(00231123) : 연산이 필요하면 int, 아니면 사용하기 편한 String
	int stuAge; // 나이 - 숫자
	String stuDept; // 학과 - 문자열
	
	// 생성자 - 클래스 이름과 동일, 메소드와 유사(메소드는 Return이 있음)
	// 인스턴스를 초기화해주는 역할 
	// default constructor 
	Student() {
		
	}
	
	// methods (함수)
	public static void main(String args[]) {
		Student stu = new Student(); // instance 생성 : new + constructor
		// . operator ( . 연산자 )
		stu.stuName = "홍길동"; 
		stu.stuNum = "00231123";
		stu.stuAge = 20;
		stu.stuDept = "컴퓨터";
		
		System.out.println();
	}
}

 

 

상속(inheritance)

• 부모 class가 가지는 내용을 확장해서 자식 class를 만드는 방식
• 기존 클래스에 기능을 추가하거나 재정의해서 새로운 클래스를 정의하는 것
• 장점
  • 기존 클래스를 재활용 가능
  • 중복 멤버를 미리 부모 클래스에 작성하면 자식 클래스에서 작성하지 않아도 된다.
  • 클래스 간의 계층 관계를 구성함으로써 다형성의 문법적 토대를 마련한다.

• 자바의 다중 상속이 없는 이유?
  • 두 곳에서 동시에 상속을 받으면 같은 변수가 올 수 있는 문제점을 배제

class Human {
    // String name
}
class Person {
    String name; // 이름
    String mobile; // 전화번호
}

// tightly coupled
class Student extends Person{
    String dept; // 학과
}

class Teacher extends Person{
    String subject; // 과목
}

class Staff extends Person{
    int salary; // 월급
}

 

Object 클래스

• 모든 클래스의 부모 클래스
• 기존 Object에 있는 메소드들을 오버라이딩해서 사용
  • equals() : 해당 인스턴스를 매개변수로 전달받는 참조 변수와 비교하여 결과 반환
  • toString() : 인스턴스에 대한 정보를 문자열로 반환
  • clone() : 해당 인스턴스를 복제해, 새로운 인스턴스를 생성하고 반환한다.
    
    • clone()은 필드만 복제하기 때문에, 배열같은 경우 오버라이딩을 통해 재정의해야한다.

 

Constructor 상속은 어떻게?

• 기본적으로 생성자는 상속되지 않는다.
• super와 super()
  • super : 현재 사용하는 객체의 referenct -> type이 상위 타입
    • this와 마찬가지로, 부모 클래스 멤버와 자식 클래스 멤버 이름이 같을 경우 super 키워드로 구별
  • super() : 상위 클래스의 생성자 호출
    • 부모 클래스의 멤버를 초기화하려면, 자식 클래스의 생성자에서 부모 클래스의 생성자까지 호출해야 한다.
    • 기본 생성자가 아닌 다른 생성자를 선언했으면, 컴파일러가 자동으로 부모 클래스의 멤버를 초기화줄 수 없다.
    • 생성자를 따로 선언하고, 기본 생성자가 없으면 자식 클래스에서 super()호출 시 에러 발생
    • 되도록 기본 생성자까지 명시적으로 선언해주기

class Parent {
    int a;
    Parent() { a = 10; }
    Parent(int n) { a = n; }
}
 
class Child extends Parent {
    int b;
    Child() {
        super();
        b = 20;
    }

 

 

동적 바인딩(dynamic binding)

•  객체에 대한 type이 상위 타입이라 할지라도, 만약 override된 method에 하위에 존재한다면 overriding 된 method를  사용
• 다형성을 사용하여 메소드를 호출할 때 발생하는 현상
• 실행 시간(runtime), 파일을 실행하는 시점에 결정된다.
• 실제 참조 객체는 서브 클래스 -> 서브 클래스 메소드 호출

정적 바인딩(static binding)

• 컴파일(compile) 시간에 의해 결정된다.
• 변수의 타입이 super 클래스여서 super클래스의 메소드 호출

class SuperClass {

    // static method
    static int staticCall(String msg){
        System.out.println(msg);
        return 100;
    }

    // fields
    int a = staticCall("1번입니다."); // 4번째 출력 : line 3 실행
    static int b = staticCall("2번입니다."); // 1번째 출력
    // static : 프로그램 시작 시 최초에 한 번 생성만 되고 초기화된다.
    // 인스턴스를 생성하지 않아도 바로 사용 가능

    // constructor
    public SuperClass(){  // 생성자 전에 필드 공간이 만들어 져야 한다. -> line 10
        staticCall("3번입니다."); // 5번째 출력 : 필드 공간 생성 후 실행 -> line 23 복귀
    }

    // constructor overloading
    public SuperClass(int i){
        this(); // 자신의 클래스가 가지고있는 다른 생성자를 호출 -> line 16
        staticCall("4번입니다."); // 6번째 출력 -> line 40으로 복귀
    }

    // method
    public void myFunc(){
        System.out.println("5번입니다."); // -> 9번째 출력
    }
}

class InheritanceTest extends SuperClass {
    // fields
    int c = staticCall("6번입니다."); // -> 7번째 출력 -> line 40 복귀
    static int d = staticCall("7번입니다."); // 2번째 출력

    // constructor
    public InheritanceTest(){ // 객체 생성
        super(100); // 상위 클래스의 생성자(100) 호출 -> line 21
        staticCall("8번입니다."); // 생성자 전에 필드 공간 생성 -> line 34 -> 8번째 출력
        super.myFunc(); // -> 상위 클래스의 myFunc 메소드 실행
    }

    @Override
    public void myFunc(){
        System.out.println("9번입니다."); // 10번째 출력
    }

    public static void main(String[] args) {
        System.out.println("10번입니다."); // 3번째 출력 : static -> main 실행
        SuperClass obj = new InheritanceTest(); // 객체 생성 -> line 38
        obj.myFunc(); // obj의 타입 SuperClass 이지만 동적바인딩으로 line 45

        // 객체에 대한 type이 상위 타입이라 할지라도
        // 만약 override된 method에 하위에 존재한다면
        // method는 overriding 된 method를 사용한다.
        // 동적 바인딩(dynamic binding)
    }
}

// 2->7->10->1->3->4->6->8->5->9

---

 

abstract 제어자

• 추상 메소드를 만들 때 사용

 

추상 클래스(Abstract Class)

• 추상 메소드가 1개라도 클래스 내부에 존재하면, 해당 클래스는 추상 클래스
• 추상 메소드는 선언만 -> 메소드가 하는 일이 정의되지 않았다.
• 추상 클래스는 인스턴스를 생성할 수 없다.
• 자식 클래스에서 오버라이딩 해서 사용

public abstract class UpperClass {
    // field
    String name;
    int age;

    // method
    public abstract void printAll();
        // abstract method
}

class subClass extends UpperClass{

    @Override
    public void printAll(){
        // TODO Auto-generated method stub
    }
}

 

인터페이스(Interface)

• 추상 클래스의 특별한 케이스
• 모든 메소드가 추상 메소드이다.
• 모든 필드는 public static final -> 안에 들어가 있는 필드는 모두 상수
  • public 어디에서나 접근 가능, static 전역, final 상수화
• 추상 메소드와는 다르게, 다중 implements 가능

interface myInterface {
    // fields
    //public static final
    int kk=0;
    String aa = "Hello";

    // abstract methods
    public abstract void printAll();
    public abstract void myPrint();
}

class MyClass implements myInterface{
    // 상속이랑 같은 개념을 사용한다.
    // is - A 관계 성립!!
    // 인터페이스 안에 있는 값들을 확장해서 새로운 클래스(인터페이스)를 구현한다는 의미
    // 인터페이스 안에서 내가 구현한 해당 인터페이스의 모든 내용들을 오버라이딩 해줘야한다.
    // generate 사용 -> 오버라이드 메소드
    @Override
    public void printAll() {

    }

    @Override
    public void myPrint() {

    }
}

 

 

인터페이스, 클래스 구현 예시

abstract class Myclass extends Human implements Aniaml
// Myclass에서 Human 상속, Animal interface를 구현한다는 뜻

abstract class Myclass extends Human implements Aniaml, MyInterface
// 인터페이스는 다중 구현 가능