Java 개념정리 15일차

[중첩 클래스]

로컬 클래스
▪ 중첩 클래스를 메소드 내에서 선언할 수 있음
▪ 접근 제한자 및 static 붙일 수 없음
▪ 인스턴스 필드와 메소드만 선언할 수 있고 정적 필드와 메소드는 선언 불가

 

로컬 클래스
▪ 생성자 또는 메소드 내부에서 다음과 같이 선언된 클래스
▪ 생성자와 메소드가 실행될 동안에만 객체를 생성할 수 있음

 

바깥 클래스의 멤버 접근 제한
▪ 정적 멤버 클래스 내부에서는 바깥 클래스의 필드와 메소드를 사용할 때 제한이 따름
▪ 정적 멤버 클래스는 바깥 객체가 없어도 사용 가능해야 하므로 바깥 클래스의 인스턴스 필드와
인스턴스 메소드는 사용하지 못함
바깥 클래스의 객체 접근
▪ 중첩 클래스 내부에서 바깥 클래스의 객체를 얻으려면 바깥 클래스 이름에 this를 붙임

 

[중첩 클래스의 접근 제한]

 바깥 필드와 메소드에서 사용 제한
▪ 바깥 클래스에서 인스턴스 멤버 클래스 사용하는 경우

 

멤버 클래스에서 사용 제한
▪ 멤버 클래스 내부에서 바깥 클래스의 필드와 메소드에 접근하는 경우

 

로컬 클래스에서 사용 제한
▪ 메소드의 매개 변수나 로컬 변수를 로컬 클래스에서 사용할 때의 제한
▪ 메소드가 종료되어도 계속 실행 상태로 존재하는 로컬 스레드 객체의 경우 등
▪ 매개 변수나 로컬 변수를 final 키워드로 선언해야 함
▪ 자바 8부터는 final 선언 하지 않아도 final 특성 부여되어 있음

 

중첩 클래스에서 바깥 클래스 참조 얻기
▪ 바깥 클래스의 이름을 this 앞에 붙임

실행 사진 및 출력결과

 

출력결과

B-field
B-method
A-field
A-method

실행코드

package sec01;

public class A {
	// A의 인스턴스 필드와 메소드
	int field1;
	String field = "A-field";
	void method1() {}
	void method() {
		System.out.println("A-method");
	}
	
	// A의 정적 필드와 메소드
	static int field2;
	static void method2() {}
	
	//인스턴스 멤버 클래스
	class B {
		// B 인스턴스 필드
		String field = "B-field";
		void method() {
			//A의 인스턴스 필드와 메소드 사용
			field1 = 10;	// (o)
			method1();		// (o)
			//A의 정적 필드와 메소드 사용
			field2 = 10;	// (o)
			method2();		// (o)
			System.out.println("B-method");
		}
		
		// B 인스턴스 메소드
		void print() {
			//B 객체의 필드와 메소드 사용
			System.out.println(this.field);
			this.method();
			//A 객체의 필드와 메소드 사용
			System.out.println(A.this.field);
			A.this.method();
		}
	}
	// 정적 멤버 클래스
	static class c {
		void method() {
			//A의 인스턴스 필드와 메소드 사용
//			field1 = 10;	// (x)
//			method1();		// (x)
			//A의 정적 필드와 메소드 사용
			field2 = 10;	// (o)
			method2();		// (o)
		}
	}
	
	// A의 인스턴스 메서드
	void useB() {
		B b = new B();
		b.print();
	}
}

 

package sec01;

public class AEx {

	public static void main(String[] args) {
	// A 객체 생성
		A a = new A();
		
		// A 메서드 호출
		a.useB();

	}

}

---

[중첩 인터페이스]

중첩 인터페이스
▪ 클래스의 멤버로 선언된 인터페이스
▪ 해당 클래스와 긴밀한 관계 맺는 구현 클래스 만들기 위함
▪ 인스턴스 멤버 인터페이스와 정적 멤버 인터페이스 모두 가능함

 

중첩 인터페이스
▪ 해당 클래스와 긴밀한 관계를 맺는 구현 객체를 만들기 위해 클래스의 멤버로 선언된 인터페이스
▪ 안드로이드와 같은 UI 프로그램에서 이벤트를 처리할 목적으로 많이 활용

 

실행 사진 및 출력결과

 

출력결과

Ok 버튼을 클릭했습니다.
Cancel 버튼을 클릭했습니다.

실행코드

package sec02;

public class Button {
	//정적 멤버 인터페이스
	public static interface ClickListener {
		// 추상 메소드
		void onClick();
	}
	
	// 필드
	private ClickListener clickListener;
	
//	public ClickListener getClickListener() {
//		return clickListener;
//	}
	
	public void  setClickListener(ClickListener clickListener) {
		this.clickListener = clickListener;
	}
	
	public void click() {
		this.clickListener.onClick();
	}
}

 

package sec02;

//import sec02.Button.ClickListener;

public class ButtonEx {

	public static void main(String[] args) {
		//Ok 버튼 객체 생성
		Button btnOk = new Button();
		
		// 로컬 클래스
		//Ok 버튼 클릭 이벤트를 처리할 ClickListener 구현 클래스
		class OkListener implements Button.ClickListener {
			@Override
			public void onClick() {
				System.out.println("Ok 버튼을 클릭했습니다.");
			}
		}
		
//		Ok 버튼 객체에 ClickListener 구현 객체 주입
		btnOk.setClickListener(new OkListener());
		
		// Ok 버튼 클릭하기
		btnOk.click();
		
		//----------------------------------------------------------------
		
		// Cancle 버튼 객체 생성
		Button btnCancel = new Button();
		
		//Cancel 버튼 클릭 이벤트를 처리할 ClickListener 구현 클래스(로컬 클래스)
		class CancelListener implements Button.ClickListener {
			@Override
			public void onClick() {
				System.out.println("Cancel 버튼을 클릭했습니다.");
			}
		}
		
//		Cancel 버튼 객체에 ClickListener 구현 객체 주입
		btnCancel.setClickListener(new CancelListener());
		//Cancel 버튼 클릭하기
		btnCancel.click();
	}

}

---

익명 객체
▪ 이름이 없는 객체. 명시적으로 클래스를 선언하지 않기 때문에 쉽게 객체를 생성할 수 있음
▪ 필드값, 로컬 변수값, 매개변수값으로 주로 사용
익명 자식 객체
▪ 부모 클래스를 상속받아 생성되는 객체
▪ 부모 타입의 필드, 로컬 변수, 매개변수의
값으로 대입할 수 있음
익명 구현 객체
▪ 인터페이스를 구현해서 생성되는 객체
▪ 인터페이스 타입의 필드, 로컬변수, 매개변수
의 값으로 대입할 수 있음
▪ 안드로이드와 같은 UI 프로그램에서 이벤트를 처리하는 객체로 많이 사용

 

익명 (anonymous) 객체
▪ 이름이 없는 객체
▪ 어떤 클래스를 상속하거나 인터페이스를 구현하여야 함

 

익명 자식 객체 생성
▪ 일반적인 경우 부모 타입의 필드나 변수 선언하고 자식 객체를 초기값으로 대입하는 경우
• 부모 클래스 상속하여 자식 클래스 선언
• new 연산자 이용하여 자식 객체 생성 후 부모 타입의 필드나 변수에 대입

 

자식 클래스를 재사용하지 않고 특정 위치에서만 사용하려는 경우
• 익명 자식 객체 생성하여 사용
• 필드 선언할 때 초기값으로 익명 자식 객체 생성하여 대입

 

 

[익명 자식 객체 생성]

• 메소드 내에서 로컬 변수 선언 시 초기값으로 익명 자식 객체 생성하여 대입

• 메소드 매개 변수가 부모 타입일 경우 메소드 호출하는 코드에서 익명 자식 객체 생성하여 매개값으로 대입

▪ 익명 자식 객체에 새롭게 정의된 필드 및 메소드는 익명 자식 객체 내부에서만 사용되고 외부에서는 접근할 수 없음

 

실행 사진 및 출력결과

 

출력결과

일반 타이어가 굴러갑니다.
익명 자식 Tire 객체1이 굴러갑니다.
익명 자식 Tire 객체2가 굴러갑니다.
익명 자식 Tire 객체2가 굴러갑니다.

실행코드

package Tire;

public class Car {
	// 필드에 Tire 객체 대입
	private Tire tire1 = new Tire();

	// 필드에 익명 자식 객체 대입
	private Tire tire2 = new Tire() {
		@Override
		public void roll() {
			System.out.println("익명 자식 Tire 객체1이 굴러갑니다.");
		}
	};

	// 메소드(필드 이용)
	public void run1() {
		tire1.roll();
		tire2.roll();
	}

	// 메소드 (로컬변수 이용)
	public void run2() {
		// 로컬 변수에 익명 자식 객체 대입
		Tire tire = new Tire() {
			@Override
			public void roll() {
				System.out.println("익명 자식 Tire 객체2가 굴러갑니다.");
			}
		};
		tire.roll();
	}

	// 메소드(매개변수 이용)
	public void run3(Tire tire) {
		tire.roll();
	}
}

 

package Tire;

public class Tire {
	public void roll() {
		System.out.println("일반 타이어가 굴러갑니다.");
	}
}

package Tire;

public class CarEx {

	public static void main(String[] args) {
		// Car 객체 생성
		Car car = new Car();
		// 익명 자식 객체가 대입된 필드 사용
		car.run1();
		// 익명 자식 객체가 대입된 로컬 변수 사용
		car.run2();
		// 익명 자식 객체가 대입된 매개변수 사용
		car.run3(new Tire() {
			@Override
			public void roll() {
				System.out.println("익명 자식 Tire 객체2가 굴러갑니다.");
			}
		});
	}

}

---

[익명 구현 객체 생성]

 인터페이스 타입의 필드 혹은 변수 선언 후 구현 객체를 초기값으로 대입하는 경우
▪ 구현 클래스가 재사용되지 않고 특정 위치에서만 사용되는 경우 – 익명 구현 객체 생성

위의 코드에서 

객체를 대입하는걸로 변경

 

---

---

실행 사진 및 출력결과

 

출력결과

TV를 켭니다.
TV를 끕니다.
에어컨을 켭니다.
에어컨을 끕니다.
난방을 켭니다.
난방을 끕니다.

실행코드

package inter;

public class Home {
	// 필드에 익며 ㅇ구현 객체 대입
	private RemoteControl rc = new RemoteControl() {
		
		@Override
		public void turnOn() {
			System.out.println("TV를 켭니다.");
			
		}
		
		@Override
		public void turnOff() {
			System.out.println("TV를 끕니다.");
			
		}
	};
	// 메소드(필드 이용)
	public void use1() {
		rc.turnOn();
		rc.turnOff();
	}
	// 메소드(로컬변수 이용)
	public void use2() {
		//로컬 변수에 익명 구현 객체 대입
		RemoteControl rc = new RemoteControl() {
			
			@Override
			public void turnOn() {
				System.out.println("에어컨을 켭니다.");
				
			}
			
			@Override
			public void turnOff() {
				System.out.println("에어컨을 끕니다.");
				
			}
		};
		rc.turnOn();
		rc.turnOff();
	}
	// 메소드(매개변수 이용)
	public void use3(RemoteControl rc) {
		rc.turnOn();
		rc.turnOff();
	}
}

package inter;

public interface RemoteControl {
	// 추상 메서드
	void turnOn();
	void turnOff();
}

package inter;

public class HomeEx {

	public static void main(String[] args) {
		//Home 객체 생성
		Home home = new Home();
		//익먕 구현 객체가 대입된 필드 사용
		home.use1();
		//익명 구현 객체가 대입된 로컬 변수 사용
		home.use2();
		//익명 구현 객체가 대입된 매개변수 사용
		home.use3(new RemoteControl() {
			
			@Override
			public void turnOn() {
				System.out.println("난방을 켭니다.");
				
			}
			
			@Override
			public void turnOff() {
				System.out.println("난방을 끕니다.");
				
			}
		});

	}

}

---

[라이브러리]

라이브러리 추가하기
▪ 프로그램 개발 시 활용할 수 있는 클래스와 인터페이스들을 모아놓은 것
▪ 일반적으로 JAR 압축 파일(~.jar) 형태. 클래스와 인터페이스의 바이트코드 파일(~.class )들이 압축
▪ 라이브러리 JAR 파일을 사용하려면 ClassPath(클래스를 찾기 위한 경로)에 추가
▪ 콘솔(명령 프롬프트 또는 터미널)에서 프로그램을 실행할 경우: java 명령어를 실행할 때
-classpath로 제공. 또는 CLASSPATH 환경 변수에 경로 추가
▪ 이클립스 프로젝트에서 실행할 경우: 프로젝트의 Build Path에 추가

실행 사진 및 출력결과

출력결과

A-method 실행
B-method 실행

실행코드

package pakc1;

public class A {
	// 메소드
	public void method() {
		System.out.println("A-method 실행");
	}
}

package pack2;

public class B {
	// 메소드
	public void method() {
		System.out.println("B-method 실행");
	}
}

package app;

import pack2.B;
import pakc1.A;

public class Main {

	public static void main(String[] args) {
		// 라이브러리에서 가져온 A 클래스 사용
		A a = new A();
		a.method();
		
		// 라이브러리에서 가져온 B 클래스 사용
		B b = new B();
		b.method();

	}

}
// cmd에서 실행
// E:\eclipse_java\my_app\bin>java -cp E:\eclipse_java\my_lib\dist\my_lib.jar;. app.Main

 

 

---