Day06 JAVA Studying

Q. 추상 메서드 사용법과 의미
 
추상 메서드는 자바에서 추상 클래스나 인터페이스 내에서 선언되는 메서드로, 구현이 없이 메서드의 시그니처(리턴 타입, 메서드 이름, 매개변수)만을 가지는 메서드입니다. 추상 메서드는 다음과 같은 사용법과 의미를 가집니다:

추상 메서드의 선언:

추상 메서드는 abstract 키워드를 사용하여 선언됩니다.
추상 메서드는 세미콜론으로 끝나며, 중괄호({})를 포함하지 않습니다.
추상 메서드는 접근 제어자, 리턴 타입, 메서드 이름, 매개변수 목록으로 구성됩니다.
추상 메서드는 구현이 없으므로 메서드 몸체({})가 없습니다.
추상 메서드는 자식 클래스에서 반드시 오버라이딩되어 구현되어야 합니다.
 
추상 클래스에서의 추상 메서드:

추상 클래스는 abstract 키워드를 사용하여 정의되는 클래스입니다.
추상 클래스는 일반적으로 공통된 특징과 동작을 가진 클래스를 표현하기 위해 사용됩니다.
추상 클래스 내에는 추상 메서드뿐만 아니라 일반 메서드도 포함될 수 있습니다.
추상 클래스를 상속받은 하위 클래스는 추상 메서드를 반드시 구현해야 합니다.

인터페이스에서의 추상 메서드:

인터페이스는 interface 키워드를 사용하여 정의되는 타입입니다.
인터페이스는 다른 클래스들에게 특정한 동작을 보장하기 위해 사용됩니다.
인터페이스는 모든 메서드가 추상 메서드로 선언되어 있습니다.
인터페이스를 구현하는 클래스는 인터페이스의 모든 메서드를 반드시 구현해야 합니다.
추상 메서드의 주요 의미는 다형성과 메서드의 일관성을 제공하는 것입니다. 추상 메서드를 사용하여 공통된 동작을 정의하고, 자식 클래스에서 해당 메서드를 구체적으로 구현함으로써 다양한 객체들 간에 일관된 인터페이스를 제공할 수 있습니다. 추상 메서드를 사용하면 메서드 호출 시 동적 바인딩이 발생하므로, 객체의 실제 타입에 따라 적절한 메서드가 호출되어 다형성을 구현할 수 있습니다. 또한, 추상 클래스나 인터페이스를 사용하여 추상 메서드를 정의함으로써 메서드의 구현 강제성을 부여하여 일관성을 유지할 수 있습니다.
 

// 추상 클래스
abstract class Animal {
    String name;
    
    // 추상 메서드
    public abstract void sound();
    
    // 일반 메서드
    public void eat() {
        System.out.println(name + " is eating.");
    }
}

// 추상 클래스를 상속받은 하위 클래스
class Dog extends Animal {
    public Dog(String name) {
        this.name = name;
    }
    
    // 추상 메서드 구현
    public void sound() {
        System.out.println(name + " is barking.");
    }
}

// 추상 클래스를 상속받은 다른 하위 클래스
class Cat extends Animal {
    public Cat(String name) {
        this.name = name;
    }
    
    // 추상 메서드 구현
    public void sound() {
        System.out.println(name + " is meowing.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
        dog.sound(); // Dog 클래스에서 재정의한 sound() 메서드 호출
        dog.eat(); // Animal 클래스의 일반 메서드 호출
        
        Cat cat = new Cat("Whiskers");
        cat.sound(); // Cat 클래스에서 재정의한 sound() 메서드 호출
        cat.eat(); // Animal 클래스의 일반 메서드 호출
    }
}

Buddy is barking.
Buddy is eating.
Whiskers is meowing.
Whiskers is eating.

---

 
Q. 동적바인딩과 정적바인딩의 의미
 
정적 바인딩(Static Binding):
정적 바인딩은 컴파일 시간에 결정되며, 변수나 메서드가 어떤 클래스 또는 객체와 연결되는지를 컴파일러가 결정하는 바인딩 방식입니다. 컴파일러는 변수의 선언 타입 또는 메서드 호출 시 사용되는 참조 타입에 기반하여 바인딩을 수행합니다. 정적 바인딩은 일반적으로 정적 메서드나 private 메서드와 같이 컴파일 시간에 결정되는 정적인 성격의 바인딩에 사용됩니다. 
 
내 객체를 접근할 수 있는 레퍼런스 변수로 접근하는 방식 (번역시간에 일어나는 바인딩)
 
- 강사님
1. 부모의 레퍼런스 객체로 자식의 객체에 접근하는 방식 (프로그램 실행시간에 일어나는 바인딩)
 
동적 바인딩(Dynamic Binding):
동적 바인딩은 실행 시간에 실제 객체의 타입에 기반하여 바인딩이 수행되는 바인딩 방식입니다. 동적 바인딩은 다형성의 핵심적인 개념으로, 메서드 오버라이딩과 관련이 있습니다. 동적 바인딩은 객체의 실제 타입을 확인하고, 해당하는 메서드를 호출합니다. 이는 실행 시간에 객체의 타입을 결정하는 다형성의 특징을 반영합니다.
 
바인딩 = 식별자(identifier)와 그에 대응하는 값 또는 동작을 연결하는 과정을 말합니다. 
 
 
- 강사님
1. 부모의 레퍼런스로 자식의 객체에 접근하는 방식
2. 부모의 멤버를 인식함으로써 부모가 가지고 있는 멤버만 접근할 수 있다.
 
- 동적바인딩

class Animal {
    public void sound() {
        System.out.println("동물이 소리를 낸다.");
    }
}

class Dog extends Animal {
    public void sound() {
        System.out.println("멍멍");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.sound(); // 동적 바인딩
    }
}

멍멍
 
- 정적바인딩

class Animal {
    public void sound() {
        System.out.println("동물이 소리를 낸다.");
    }
}

class Dog extends Animal {
    public void sound() {
        System.out.println("멍멍");
    }
    
    public void bark() {
        System.out.println("왕왕");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.sound(); // 정적 바인딩
        animal.bark(); // 정적 바인딩
    }
}

동물이 소리를 낸다.
 
동적 바인딩은 실행 시간에 실제 객체의 타입을 기반으로 메서드를 호출하여 다형성을 구현하는 반면,
 정적 바인딩은 컴파일 시간에 변수의 타입을 기반으로 메서드를 호출하여 정적인 동작을 수행합니다.
 

---

- 강사님
인터페이스
1. 추상클래스보다 더 추상화
2. 상수, 추상메소드
3. 다중상속을 대체한다.(클래스끼리는 단일 상속만 됨)
4. 클래스가 인터페이스를 여러개 받을 수 있다.
5. implements
6. 인터페이스 끼리는 다중상속이 허용된다.
 
인터페이스(Interface)는 객체 지향 프로그래밍에서 사용되는 중요한 개념으로, 클래스와 클래스 사이 또는 클래스와 클라이언트 사이의 계약(Contract)을 정의하는 역할을 합니다. 인터페이스는 일종의 계약서로서, 클래스가 지켜야 할 규칙과 메서드의 구현을 강제하여 일관성 있는 프로그래밍을 도와줍니다.

package test;

interface A{
	final static int MAX = 100;
	
	public abstract void disp();
	
}

interface B{
	final static int MAX = 100;
	
	public abstract void disp1();
	
}

interface C extends A, B{
	final static int MAX = 100;
	
	public abstract void disp2();
	
	
}

public class study36 implements A, B, C{

	@Override
	public void disp() {
		
	}

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

	@Override
	public void disp2() {
		// TODO Auto-generated method stub
		
	}
	
	
	public static void main(String[] args) {
		C c = new study36();
		c.disp();
		c.disp1();
		c.disp2();
	}
}

// 인터페이스 선언
interface Printable {
    void print(); // 추상 메서드 선언
}

// 인터페이스 구현
class MyClass implements Printable {
    public void print() {
        System.out.println("Printing...");
    }
}

public class Main {
    public static void main(String[] args) {
        Printable printable = new MyClass();
        printable.print(); // 인터페이스 메서드 호출
    }
}

printing...

---

- 강사님
inner class
 *  outter class의 멤버로써 존재
 *  outter class의 필드를 직접적으로 사용이 가능한 클래스
 *  event 처리시 많이 사용
 *  outter class의 객체를 생성하고 inner class의 객체를 생성후 사용.
 * 
 * 1. Member inner class (필수)
 * 2. static inner class
 * 3. local inner class
 * 4. anonymous inner class (익명 내부 클래스) (필수)
 
1. Member Inner Class (멤버 내부 클래스 또는 인스턴스 내부 클래스):
Member Inner Class는 다른 클래스 내부에 선언된 클래스로, 해당 클래스의 인스턴스 멤버로 동작합니다. 멤버 내부 클래스는 외부 클래스의 인스턴스 멤버에 접근할 수 있고, 내부 클래스의 인스턴스를 생성하기 위해서는 외부 클래스의 인스턴스가 먼저 생성되어야 합니다.

public class OuterClass {
    private int outerVariable;
    
    public class InnerClass {
        private int innerVariable;
        
        public void innerMethod() {
            outerVariable = 10;  // 외부 클래스의 인스턴스 변수에 접근
            innerVariable = 20;  // 내부 클래스의 인스턴스 변수에 접근
            System.out.println("Inner method");
        }
    }
}

----
OuterClass outer = new OuterClass();
OuterClass.InnerClass inner = outer.new InnerClass();
inner.innerMethod();

Inner method

---

 
2. Static Inner Class (정적 내부 클래스):
Static Inner Class는 다른 클래스 내부에 선언된 클래스로, 해당 클래스의 정적 멤버로 동작합니다. 정적 내부 클래스는 외부 클래스의 인스턴스에 종속되지 않으므로, 외부 클래스의 인스턴스 생성 없이도 직접 생성하고 사용할 수 있습니다.
 

public class OuterClass {
    private static int outerVariable;
    
    public static class InnerClass {
        private int innerVariable;
        
        public void innerMethod() {
            outerVariable = 10;  // 외부 클래스의 정적 변수에 접근
            innerVariable = 20;  // 내부 클래스의 인스턴스 변수에 접근
            System.out.println("Inner method");
        }
    }
}
-----
OuterClass.InnerClass inner = new OuterClass.InnerClass();
inner.innerMethod();

Inner method

---

3. Local Inner Class (지역 내부 클래스):
Local Inner Class는 메서드 내부에 선언된 클래스로, 해당 메서드 내에서만 유효한 지역 변수와 함께 사용됩니다. 지역 내부 클래스는 메서드 내에서만 접근 가능하며, 메서드가 호출될 때마다 새로운 인스턴스가 생성됩니다.
 

package test;

public class study37_3 {
    private int outerVariable = 10; // 외부 클래스의 인스턴스 변수로 변경

    public void outerMethod() {
        // 외부 클래스의 인스턴스 변수로 사용되므로 int outerVariable = 10; 라인은 삭제

        class InnerClass {
            private int innerVariable;

            public void innerMethod() {
                outerVariable = 20; // 외부 클래스의 인스턴스 변수에 접근하여 값을 변경
                innerVariable = 30; // 내부 클래스의 인스턴스 변수에 접근하여 값을 변경
                System.out.println("Inner method");
            }
        }

        InnerClass inner = new InnerClass(); // 지역 내부 클래스의 인스턴스 생성
        inner.innerMethod(); // 내부 클래스의 메서드 호출
    }

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

Inner method

---

4. Anonymous Inner Class (익명 내부 클래스):
Anonymous Inner Class는 이름이 없는 내부 클래스로, 클래스 선언과 동시에 인스턴스를 생성합니다. 주로 인터페이스나 추상 클래스를 구현하거나 상속받는 형태로 사용되며, 일회성으로 사용되는 간단한 클래스를 구현할 때 유용합니다.
 

public class OuterClass {
    public void outerMethod() {
        Runnable runnable = new Runnable() {
            public void run() {
                System.out.println("Anonymous inner class");
            }
        };
        
        Thread thread = new Thread(runnable);  // 익명 내부 클래스를 사용한 쓰레드 생성
        thread.start();  // 쓰레드 실행
    }
}
----
OuterClass outer = new OuterClass();
outer.outerMethod();

Anonymous inner class