1. 단일 상속과 다중 상속에 대해서 설명하세요 .
1) 상속 : 기존 클래스 -> 재사용하여 -> 새로운 클래스를 선언하는 것.
super,상위,부모,기초 sub,하위,자식,파생
2) 장점 : _
3) 선언 형식 : extends 키워드 사용.
// 단일상속
class A enxteds B{
}
// 다중 상속
class A enxteds B, C, D{
}
4) 자바는 다중 상속을 지원하지 않는다.
5) 왜 ? 지원하지 않는 이유 ? _
10:07 수업 시작~
2. [@Override] 애노테이션(Annotation)에 대해서 설명하세요.
1) 애노테이션(Annotation) 용어 정의 X
2) @애노테이션명
3) @Override 의미 ?
class A{
public void disp() throw IOException{
// 구현 코딩.
}
}
class B extends A{
// disp() 물려받아졌습니다.
// 재정의 함수
// 컴파일러에게 밑에 있는 메서드는 오버라딩한 메서드이다라고 알려줘서
// 컴파일러가 체크를 해서 컴파일 에러 발생시켜요.
@Override
public void disp() throw IOException{
// 다른 코딩 수정
}
}
void main(){
B obj = new B();
obj.disp(); // 호출됨.
}
3. [오버라이딩 조건]에 대해서 설명하세요 .
1) 부모의 접근지정자 보다 범위 같거나 커야 한다.
2)
3)
4)
5)
4. super 키워드에 대해서 설명하세요 .
super 부모객체 참조변수 super의 용도
this 자기자신 참조변수 this의 용도
5. final 키워드에 대해서 설명하세요.
- 클래스 앞에
public final SalesMan extends Regular{
}
- 메서드 앞에
- 필드 앞에
지역변수 앞에
매개변수 앞에
6. abstract 키워드에 대해서 설명하세요.
1) 왜 ? 메서드, 클래스
2) 추상메서드 : 몸체가 선언이 안된 메서드를 불완전한 메서드라고 하고 앞에 abstract 키워드를 붙인다.
3) 추상 클래스 :
- 여러 클래스에 공통적으로 사용될 수 있는 클래스를 추상클래스로 만든다.
4) 추상화 : 클래스 간의 공통점(멤버)을 찾아내서 공통의 조상으로 만드는 작업.
예) 모든 사원들의 공통적 멤버를 선언한 Employee 클래스를 추상클래스로 만드는 작업.
- 지난 금요일 수업할 때 abstract 키워드 어떤 경우에 어떤 곳에 abstract 키워드 사용했던가요?
- 사원이라면 공통적으로 갖고 있어야 할 멤버들을 선언한
// 객체를 생성할 수 없는 불완전한 클래스
abstract class Employee{
// 가상(virtual) 메서드 선언
// {} 몸체를 구현하지 않은 불완전 메서드를 선언
// 추상(abstract) 메서드
abstract void getPay(); // 왜 ?
//{
// return 0;
//}
}
class Regular extends Employee{
// 기본급 필드
// 급여계산해서 반환하는 메서드
@Override
getPay(){}
}
final class SalesMan extends Regular{
// 판매량, 커미션 필드
@Override
getPay(){}
}
class Temp extends Employee{
// 하루일당, 근무일수 필드
@Override
getPay(){}
}
// 자식 객체를 생성해서 부모 타입에 참조할 수 있다.
// 클래스 간의 형변환
// 업캐스팅
// 다형성
E emp = new R();
emp.
E emp = new S();
emp.급여계산X
7. 클래스(OOP)의 특징에 대해서 상세히 설명하세요.
1) 캡슐화( 은닉화 ) 접근지정자를 통해서 멤버를 보이지 않도록 하는 것.( 숨기는 것 )
3) 상속성 - ~~
4) 추상화 - 클래스 간의 공통점(멤버)을 찾아내서 공통의 조상으로 만드는 작업.
5) 다형성 -
8. [] 대괄호 안에 있다. 없다 골라서 적으세요.
1) 메서드에 static과 abstract를 함께 사용할 수 [ X , O ].
static 키워드 의미
abstract 키워드 의미
2) 클래스에 static과 final을 동시에 사용할 수 [ ].
3) abstract메서드의 접근 제어자가 private일 수 [ ].
4) 메서드에 private과 final을 같이 사용할 필요 [ ].
9. 다형성에 대해서 설명하세요 .
10. 참조형( 클래스 )의 형변환에 대해서 설명하세요.
클래스 간의 형변환
업캐스팅( upcastring) , 자동 형변환
다운 캐스팅( downcastring ) , 강제 형변환 ( cast 연산자 )
Employee emp = new Employee(이,주,연,입);
Regular emp2 = emp;
11. instanceof 연산자에 대해서 설명하세요.
12. [매개변수 다형성]에 대해서 설명하세요 . ***
E emp1 = new R();
E emp2 = new S();
E emp3 = new T();
사원정보출력( emp1 ); // 정규직
사원정보출력( emp2 ); // 영업직
사원정보출력( emp3 ); // 임시직
void 사원정보출력( E emp ){ // emp 매개변수 다형성.
}
13. 여러 타입의 객체 배열에 대해서 설명하세요.
E emp1 = new R();
E emp2 = new S();
E emp3 = new T();
// 여러 타입의 객체 배열
E[] emps = {
new R(),
new S(),
new T()
};
14. "싱글톤 클래스"를 구현하는 방법에 대해서 설명하세요...
1) 접근지정자 + 생성자
pu blic
protected
default
private
2) 생성자 앞의 접근지정자 == 메서드 앞의 접근지정자 의미
3) private 생성자(){} 의미 : 외부에서 객체 절대 생성 X
객체가 꼭 1개만 생성되도록하는 것 : 싱글톤
4) 싱글톤 의미.
public class Ex01 {
public static void main(String[] args) {
/*
// 9:40 제출
// Cannot instantiate the type Employee
// E 클래스(타입)는 인스턴스화 할 수 없다.
// new 객체 생성 X
// 왜? 추상클래스이기 때문에
Employee emp = new Employee("홍길동", "서울", "010-1234-1234","2022.02.11") ;
// 에러 난 이유 ?
// 업캐스팅 : R 자식 객체를 생성해서 E 부모 타입에 참조 ( 자동 형변환 )
// *** 다운캐스팅 : E 부모 객체를 R 자식 타입에 참조 ( 강제 형변환 )
// ClassCastException: 다운캐스팅하다가 에러 발생.
if ( emp instanceof Regular ) {
// 다운캐스팅...
Regular emp2 = (Regular)emp;
}
System.out.println("= end =");
// 11:10 수업 시작
// 에러 발생한 이유 ? 업캐스팅 한 후에 -> 다운캐스팅할 수 있다.
*/
} // main
} // class
public static void main(String[] args) {
/*
// 9:40 제출
// Cannot instantiate the type Employee
// E 클래스(타입)는 인스턴스화 할 수 없다.
// new 객체 생성 X
// 왜? 추상클래스이기 때문에
Employee emp = new Employee("홍길동", "서울", "010-1234-1234","2022.02.11") ;
// 에러 난 이유 ?
// 업캐스팅 : R 자식 객체를 생성해서 E 부모 타입에 참조 ( 자동 형변환 )
// *** 다운캐스팅 : E 부모 객체를 R 자식 타입에 참조 ( 강제 형변환 )
// ClassCastException: 다운캐스팅하다가 에러 발생.
if ( emp instanceof Regular ) {
// 다운캐스팅...
Regular emp2 = (Regular)emp;
}
System.out.println("= end =");
// 11:10 수업 시작
// 에러 발생한 이유 ? 업캐스팅 한 후에 -> 다운캐스팅할 수 있다.
*/
} // main
} // class
public class Ex02 {
public static void main(String[] args) {
// 추상클래스로 객체 생성할 수 없다.
// Player p = new Player();
// 추상클래스 업캐스팅 = new CDPlayer();
// 추상클래스도 일종의 클래스이기 때문에 업캐스팅 가능하다.
// AudioPlayer p = new CDPlayer();
Player p2 = new CDPlayer();
p2.play(10);
p2.stop();
// 멤버변수에는 abstact 안붙나요? X
} // main
} // class
abstract class Player{
// 필드
boolean pause; // 작동 중지
int currentPos; // 현재 위치
// 생성자
Player(){}
// 추상 메서드 2개
abstract void play(int pos);
abstract void stop();
}
abstract class AudioPlayer extends Player{
// 필드
// 생성자
// 메서드
// 부모로 부터 물려받은 추상메서드를 오버라이딩하지 않으면 그 클래스는 추상클래스가 된다.
@Override
void play(int pos) {
System.out.println("추상메서드를 오버라이딩 완료!!!");
}
// 하나라도 추상 메서드를 가지면 추상클래스이다.
}
class CDPlayer extends AudioPlayer{
// 필드
// 생성자
// 메서드
@Override
void stop() {
System.out.println("추상메서드를 오버라이딩 완료!!!");
}
}
public class Ex02 {
public static void main(String[] args) {
// 추상클래스로 객체 생성할 수 없다.
// Player p = new Player();
// 추상클래스 업캐스팅 = new CDPlayer();
// 추상클래스도 일종의 클래스이기 때문에 업캐스팅 가능하다.
// AudioPlayer p = new CDPlayer();
Player p2 = new CDPlayer();
p2.play(10);
p2.stop();
// 멤버변수에는 abstact 안붙나요? X
} // main
} // class
abstract class Player{
// 필드
boolean pause; // 작동 중지
int currentPos; // 현재 위치
// 생성자
Player(){}
// 추상 메서드 2개
abstract void play(int pos);
abstract void stop();
}
abstract class AudioPlayer extends Player{
// 필드
// 생성자
// 메서드
// 부모로 부터 물려받은 추상메서드를 오버라이딩하지 않으면 그 클래스는 추상클래스가 된다.
@Override
void play(int pos) {
System.out.println("추상메서드를 오버라이딩 완료!!!");
}
// 하나라도 추상 메서드를 가지면 추상클래스이다.
}
class CDPlayer extends AudioPlayer{
// 필드
// 생성자
// 메서드
@Override
void stop() {
System.out.println("추상메서드를 오버라이딩 완료!!!");
}
}
public class Ex02 {
public static void main(String[] args) {
// 추상클래스로 객체 생성할 수 없다.
// Player p = new Player();
// 추상클래스 업캐스팅 = new CDPlayer();
// 추상클래스도 일종의 클래스이기 때문에 업캐스팅 가능하다.
// AudioPlayer p = new CDPlayer();
Player p2 = new CDPlayer();
p2.play(10);
p2.stop();
// 멤버변수에는 abstact 안붙나요? X
} // main
} // class
abstract class Player{
// 필드
boolean pause; // 작동 중지
int currentPos; // 현재 위치
// 생성자
Player(){}
// 추상 메서드 2개
abstract void play(int pos);
abstract void stop();
}
abstract class AudioPlayer extends Player{
// 필드
// 생성자
// 메서드
// 부모로 부터 물려받은 추상메서드를 오버라이딩하지 않으면 그 클래스는 추상클래스가 된다.
@Override
void play(int pos) {
System.out.println("추상메서드를 오버라이딩 완료!!!");
}
// 하나라도 추상 메서드를 가지면 추상클래스이다.
}
class CDPlayer extends AudioPlayer{
// 필드
// 생성자
// 메서드
@Override
void stop() {
System.out.println("추상메서드를 오버라이딩 완료!!!");
}
}
public class Ex03 {
public static void main(String[] args) {
} // main
} // class
/*
class Marine{ // 해병대원
int x, y; // 현재 위치
void move(int x, int y) {}
void stop() {}
void stimPack() { }
}
class Tank{ // 탱크
int x, y; // 현재 위치
void move(int x, int y) {}
void stop() {}
void changeMode() {} // 공격모드 변환
}
class DropShip{ // 수송선
int x, y; // 현재 위치
void move(int x, int y) {}
void stop() {}
void load() {}
void unload() {}
}
*/
/*
// 유닛 : Marine, Tank, DropShip
// 공통으로 하는 것들을 추상화- 추상 클래스 선언
abstract class Unit{
int x, y; // 현재 위치
abstract void move(int x, int y);
abstract void stop();
}
class Marine extends Unit{ // 해병대원
@Override
void move(int x, int y) {
// 구현 O
}
@Override
void stop() {
// 구현 O
}
void stimPack() {
}
}
class Tank extends Unit{ // 탱크
@Override
void move(int x, int y) {
// 구현 O
}
@Override
void stop() {
// 구현 O
}
void changeMode() {} // 공격모드 변환
}
class DropShip extends Unit{ // 수송선
@Override
void move(int x, int y) {
// 구현 O
}
@Override
void stop() {
// 구현 O
}
void load() {}
void unload() {}
}
*/
public class Ex03 {
public static void main(String[] args) {
} // main
} // class
/*
class Marine{ // 해병대원
int x, y; // 현재 위치
void move(int x, int y) {}
void stop() {}
void stimPack() { }
}
class Tank{ // 탱크
int x, y; // 현재 위치
void move(int x, int y) {}
void stop() {}
void changeMode() {} // 공격모드 변환
}
class DropShip{ // 수송선
int x, y; // 현재 위치
void move(int x, int y) {}
void stop() {}
void load() {}
void unload() {}
}
*/
/*
// 유닛 : Marine, Tank, DropShip
// 공통으로 하는 것들을 추상화- 추상 클래스 선언
abstract class Unit{
int x, y; // 현재 위치
abstract void move(int x, int y);
abstract void stop();
}
class Marine extends Unit{ // 해병대원
@Override
void move(int x, int y) {
// 구현 O
}
@Override
void stop() {
// 구현 O
}
void stimPack() {
}
}
class Tank extends Unit{ // 탱크
@Override
void move(int x, int y) {
// 구현 O
}
@Override
void stop() {
// 구현 O
}
void changeMode() {} // 공격모드 변환
}
class DropShip extends Unit{ // 수송선
@Override
void move(int x, int y) {
// 구현 O
}
@Override
void stop() {
// 구현 O
}
void load() {}
void unload() {}
}
*/
public class Ex04 {
public static void main(String[] args) {
// 12:05 수업 시작
/*
* [인터페이스(interface)]
* 1. 자바의 자료형
* - 기본형 8가지
* - 참조형 - 배열, 클래스, 인터페이스
* 2. 참조타입
* 3. 일종의 추상 클래스
* 4. 차이점 : 필드 선언 X, 일반 메서드 선언 X
* 100% 추상메서드, 상수 만을 가지는 추상 클래스
* 5. 기본 클래스
* 6. 인터페이스 그 자체만으로 사용되기 보다는 다른 클래스를 작성하는 데 도움을 줄 목적으로 작성된다.
* 7. 모든 필드는 public static final 이다. ( 생략을 해도 )
* 모든 메서드는 public abstract 이다. ( 생략을 해도 )
* 8. JDK1.8 부터는 인터페이스 안에
* 1) static 메서드
* 2) default 메서드
* 를 선언할 수 있다.
*
* 9. 인터페이스 끼리 상속이 가능하다.
* - extends 키워드를 사용한다.
* 10. 인터페이스는 다중상속이 가능하다.
*
* 11. 인터페이스를 구현할 때는 implements 키워드를 사용해서 클래스를 선언한다.
*
* */
Tank t = new Tank();
DropShip s = new DropShip();
Fighter f = new Fighter();
SCV scv = new SCV();
scv.repair(t); // Repairable r
scv.repair(s); // Repairable r
// 인터페이스 매개변수 다형성
// scv.repair(f); 수리하는 메서드에 매개변수 사용할 수 조차 없네요..
System.out.println(" end ");
} // main
} // class
class Unit{
int currentHP; // 유닛의 체력
int x; // 유닛의 위치(x좌표)
int y; // 유닛의 위치(y좌표)
}
// 하늘 유닛
class AirUnit extends Unit{
}
// 땅 유닛
class GroundUnit extends Unit{
}
// 왜 ? 굳이 move() 메서드만을 가진 인터페이스를 따로 이렇게 선언해야하나?
// java ~~able == 을 할 수 있다.
interface Movable{ // 이동
// 상수 , 추상메서드 + static, default 메서드 선언
void move(int x, int y); // public abstract 생략
}
interface Attackable{ // 공격
void attack( Unit u); // 공격 + 공격대상유닛
}
// 인터페이스 다중 상속
interface Fightable extends Movable, Attackable{
//
}
//class Fighter implements Movable, Attackable{
class Fighter implements Fightable{
@Override
public void move(int x, int y) {
// 구현
}
@Override
public void attack(Unit u) {
// 구현
}
}
class Tank extends GroundUnit implements Fightable, Repairable{
@Override
public void move(int x, int y) {
// 구현
}
@Override
public void attack(Unit u) {
// 구현
}
// int currentHP; // 유닛의 체력
// int x; // 유닛의 위치(x좌표)
// int y; // 유닛의 위치(y좌표)
}
class Marine extends Unit implements Fightable{
@Override
public void move(int x, int y) {
// 구현
}
@Override
public void attack(Unit u) {
// 구현
}
}
class DropShip extends AirUnit implements Fightable, Repairable{
@Override
public void move(int x, int y) {
// 구현
}
@Override
public void attack(Unit u) {
// 구현
}
}
// 안에 상수X, 추상메서드 X, s, d 메서드 X 인터페이스 선언
// 이유 ? 이 인터페이스를 구현한 클래스는 수리가 가능한 클래스이다.
interface Repairable { }
// 수리할 수 있는 클래스 : 탱크, 수송선, SCV - Repairable 구현한 Unit O
// 수리할 수 없는 클래스 : Fighter, Marine X
class SCV extends GroundUnit implements Repairable{
SCV(){
}
// 고치는 메서드
void repair( Repairable r ) { // 인터페이스 매개변수 다형성
if ( r instanceof Unit) {
Unit u = (Unit)r;
// 수리하는 코딩
System.out.println( u + " 의 수리 완료!!!");
} //
}
}
// 질문) 추상메서드가 존재하지 않는데도 추상클래스가 될 수 있을까요? 가능하다.
// 의도 ? 물려받는 자식 부터 객체를 생성하세요...
/*
abstract class Person{
String name;
int age;
void dispInfo() {
System.out.println("구현");
}
}
*/
public class Ex05 {
public static void main(String[] args) {
// 자바 문법에서 1개만 면접관으로 질문을 해야 하다면 - 다형성
// **** 인터페이스 ****
/*
* [ 인터페이스의 장점 ]
* 1. 개발 시간을 단축시킬 수 있다.
* - 인터페이스만 작성이 되면 + 사용하는 곳에서 개발 진행할 수 있기 때문에
* 인터페이스를 구현한 클래스 X
* 2. 표준화가 가능하다.
* IDBConn 인터페이스를 A, B 등등 개발자 구현하더라도 일관되고 정형화된 프로그램 개발이 가능하다. .
* 3. 서로 관련없는 클래스 들에게 관계를 맺어 줄 수 있다.
* 서로 관련없는 == 상속관계가 아닌 클래스 들도 같은 인터페이스를 구현하고 있다면
* 관계를 맺어줄 수 있다.
* */
// 오라클 DB 서버
// MySQL DB 서버
// 등등
/*
DBConn con = new DBConn();
con.open(); // DB 서버에 연결
// CRUD
con.select(); // 데이터 조회
con.insert(); // 데이터 추가
con.update(); // 데이터 수정
con.delete(); // 데이터 삭제
//
con.close(); // DB 서버 닫기
*/
// 인터페이스를 사용해서 업캐스팅 가능
// 오라클
//IDBConn con = new OracleDBConn();
// MS SQL 서버
IDBConn con = new MSSQLDBConn();
con.open(); // DB 서버에 연결
// CRUD
con.select(); // 데이터 조회
con.insert(); // 데이터 추가
con.update(); // 데이터 수정
con.delete(); // 데이터 삭제
//
con.close(); // DB 서버 닫기
} // main
} // class
// 오라클 DBMS <-연동-> 자바 프로그램 : 데이터 처리( CRUD )
/*
class DBConn{
void open() {
// 모든 구현이 되어져 있다.
}
void close() {}
void insert() {}
void select() {}
void update() {}
void delete() {}
}
*/
public class Ex06 {
public static void main(String[] args) {
String docType = "XML";
// new XMLParser()
// new HTMLParser()
// 인터페이스 업캐스팅
// 인터페이스 다형성
Parseable.method1();
Parseable parser = ParserManager.getParser(docType);
parser.parse("ex01.xml");
parser.print(); // 인쇄까지 해 주면 좋은 것 같다라는 생각을 5년 뒤에 하게 되었다.. ( 가정 )
// 방금 디폴트 한번만 더 설명가능하실까요?
// 디폴트가 방금 부분에서 사용되기 편한지. 잘 모르겠어서요
} // main
} // class
interface Parseable{
// 구문 분석하는 메서드
void parse(String fileName);
// 5년 뒤~ 추가
// jdk 1.8
// default 메서드 추가...
default void print() {
System.out.println("기본 코딩");
}
// void print(); // 추상메서드 추가~~
static void method1() {
System.out.println("기본 코딩..");
}
}
// 수 백개의 클래스 존재...한다고 가정하자.
// 5년동안 그 인터페이스를 구현한 클래스가 왜 오류가 났을 까요?
// ㄴ 여기서 잘모르겠습니다..
class XMLParser implements Parseable{
@Override
public void parse(String fileName) {
System.out.println("XML 파일 구문 분석 메서드");
}
// 디폴트 메서드는 무시된다..
// 직접 추가 구현
/*
public void print() {
// 구현
}
*/
}
class HTMLParser implements Parseable{
@Override
public void parse(String fileName) {
System.out.println("html 파일 구문 분석 메서드");
}
}
// 위에 구문분석 여러 개의 클래스를 관리는 관리자( Manager ) 클래스 존재..
class ParserManager{
// 인터페이스 다형성
// 리턴자료형 : Parseable 인터페이스
public static Parseable getParser(String docType){
if( docType.equals("XML"))
return new XMLParser();
else if(docType.equals("html"))
return new HTMLParser();
else
return null;
}
}
public class Ex07 {
public static void main(String[] args) {
// TODO Auto-generated method stub
}
}
interface IA{
void aaa(); // 추상 메서드
}
interface IB{
void bbb();
}
interface IC extends IA,IB{
// void aaa();
// void bbb();
void ccc();
}
// abstract class Ex00 implements IA{
class Ex00 implements IC{
@Override
public void aaa() {
}
@Override
public void bbb() {
// TODO Auto-generated method stub
}
@Override
public void ccc() {
// TODO Auto-generated method stub
}
}
* @subject 내부 클래스 (inner class )
* @content - 사용빈도 낮다.
*
* 내부 클래스의 종류
* 1) 인스턴스 클래스 - 외부클래스의 필드 선언위치에 선언
* , 외부클래스의 인스턴스 멤버처럼 다루어진다.
* 역할 : 주로 외부클래스의 인스턴스 멤버들과 관련된 작업에 사용될 목적.
* class 외부클래스{
* // 인스턴스 변수
* // :
* // :
* {
* // 초기화 블럭
* class 내부클래스{ // 3) 지역클래스
* }
*
* }
*
*
* class 내부 클래스{ 1) 인스턴스 클래스
* }
* static class 내부 클래스{ 2) 스태틱 클래스
* }
*
* // 외부클래스 메서드
* void print(){
* //
* //
* class 내부클래스{ 3) 지역 클래스
* }
* }
* }
* 2) 스태틱 클래스 - 외부클래스의 필드 선언위치에 선언
* , 외부클래스의 static 멤버처럼 다루어진다.
*
* 3) 지역 클래스 - 외부클래스의 메서드나 초기화 블럭 안에 선언
* 4) 익명 클래스 Ex08_02.java
*/
public class Ex08 { // 외부 클래스( outer class )
// 내부 클래스( inner class)
// 전체적인 코딩의 복잡성을 줄일 수 있다. ( 캡슐화 )
class Test{
// 외부 클래스의 멤버를 바로 직접적으로 사용할 수 있다. - 접근성, 보안성
}
// has-a 관계
// new Test(); 결합성이 높은 좋지 않은 코딩.
// t 인스턴스 변수
// Test t = new Test( this );
public static void main(String[] args) {
// 3:20 수업 시작~
// static 메서드 안에서 인스턴스 변수 사용 못하기 때문에 에러..
// t.
} // main
} // class
// 다른 클래스에서도 Test 클래스를 자주 사용한다면 외부 클래스로 선언..
// 클래스 선언
/*
class Test{
// Test 안에서 Ex08 클래스의 멤버를 사용하고 싶어요..
private Ex08 p;
Test( Ex08 obj){
p = obj;
}
// 다른 메서드에서 p 필드를 통해서 Ex08의 멤버를 사용할 수 있다..
}
*/
* @subject 내부 클래스 (inner class )
* @content - 사용빈도 낮다.
*
* 내부 클래스의 종류
* 1) 인스턴스 클래스 - 외부클래스의 필드 선언위치에 선언
* , 외부클래스의 인스턴스 멤버처럼 다루어진다.
* 역할 : 주로 외부클래스의 인스턴스 멤버들과 관련된 작업에 사용될 목적.
* class 외부클래스{
* // 인스턴스 변수
* // :
* // :
* {
* // 초기화 블럭
* class 내부클래스{ // 3) 지역클래스
* }
*
* }
*
*
* class 내부 클래스{ 1) 인스턴스 클래스
* }
* static class 내부 클래스{ 2) 스태틱 클래스
* }
*
* // 외부클래스 메서드
* void print(){
* //
* //
* class 내부클래스{ 3) 지역 클래스
* }
* }
* }
* 2) 스태틱 클래스 - 외부클래스의 필드 선언위치에 선언
* , 외부클래스의 static 멤버처럼 다루어진다.
*
* 3) 지역 클래스 - 외부클래스의 메서드나 초기화 블럭 안에 선언
* 4) 익명 클래스 Ex08_02.java
*/
public class Ex08 { // 외부 클래스( outer class )
// 내부 클래스( inner class)
// 전체적인 코딩의 복잡성을 줄일 수 있다. ( 캡슐화 )
class Test{
// 외부 클래스의 멤버를 바로 직접적으로 사용할 수 있다. - 접근성, 보안성
}
// has-a 관계
// new Test(); 결합성이 높은 좋지 않은 코딩.
// t 인스턴스 변수
// Test t = new Test( this );
public static void main(String[] args) {
// 3:20 수업 시작~
// static 메서드 안에서 인스턴스 변수 사용 못하기 때문에 에러..
// t.
} // main
} // class
// 다른 클래스에서도 Test 클래스를 자주 사용한다면 외부 클래스로 선언..
// 클래스 선언
/*
class Test{
// Test 안에서 Ex08 클래스의 멤버를 사용하고 싶어요..
private Ex08 p;
Test( Ex08 obj){
p = obj;
}
// 다른 메서드에서 p 필드를 통해서 Ex08의 멤버를 사용할 수 있다..
}
*/
* @subject 익명클래스( anonymous class ) == 무명 클래스 == 이름이 없다.
* @content
* 1. 클랫의 선언과 동시에 객체 생성하는 이름이 없는 클래스.
* 2. 단 한번만 사용될 수 있다. 오직 하나의 객체만 생성할 수 있는 일회성 클래스이다.
* 3. 주로 GUI애플리케이션(AWT,Swing)에 이벤트 처리 사용
* 4. 익명 클래스의 선언 형식
* (1) 형식
* new 부모클래스(){
* // 부모클래스의 메서드만 오버라이딩해서 사용할 수 있다.
* }
* (2) 형식
* new 인터페이스(){
* // 인터페이스의 추상메서드만 오버라이딩해서 사용할 수 있다.
* }
*
*/
public class Ex08_02 {
public static void main(String[] args) {
// Ctrl + mouseover
// 익명 클래스
Employee emp = new Employee() {
@Override
public int getPay() {
return 300000;
}
};
System.out.println( emp.getPay() );
} // main
} // class
* @subject 익명클래스( anonymous class ) == 무명 클래스 == 이름이 없다.
* @content
* 1. 클랫의 선언과 동시에 객체 생성하는 이름이 없는 클래스.
* 2. 단 한번만 사용될 수 있다. 오직 하나의 객체만 생성할 수 있는 일회성 클래스이다.
* 3. 주로 GUI애플리케이션(AWT,Swing)에 이벤트 처리 사용
* 4. 익명 클래스의 선언 형식
* (1) 형식
* new 부모클래스(){
* // 부모클래스의 메서드만 오버라이딩해서 사용할 수 있다.
* }
* (2) 형식
* new 인터페이스(){
* // 인터페이스의 추상메서드만 오버라이딩해서 사용할 수 있다.
* }
*
*/
public class Ex08_02 {
public static void main(String[] args) {
// Ctrl + mouseover
// 익명 클래스
Employee emp = new Employee() {
@Override
public int getPay() {
return 300000;
}
};
System.out.println( emp.getPay() );
} // main
} // class
* @subject 익명클래스( anonymous class ) == 무명 클래스 == 이름이 없다.
* @content
* 1. 클랫의 선언과 동시에 객체 생성하는 이름이 없는 클래스.
* 2. 단 한번만 사용될 수 있다. 오직 하나의 객체만 생성할 수 있는 일회성 클래스이다.
* 3. 주로 GUI애플리케이션(AWT,Swing)에 이벤트 처리 사용
* 4. 익명 클래스의 선언 형식
* (1) 형식
* new 부모클래스(){
* // 부모클래스의 메서드만 오버라이딩해서 사용할 수 있다.
* }
* (2) 형식
* new 인터페이스(){
* // 인터페이스의 추상메서드만 오버라이딩해서 사용할 수 있다.
* }
*
*/
public class Ex08_02 {
public static void main(String[] args) {
// Ctrl + mouseover
// 익명 클래스
Employee emp = new Employee() {
@Override
public int getPay() {
return 300000;
}
};
System.out.println( emp.getPay() );
} // main
} // class
public class Ex08_03 {
public static void main(String[] args) {
new MyForm();
} // main
} // class
class MyForm extends Frame{
// 버튼 생성
Button btnExit = null;
// 디폴트 생성자
MyForm(){
// btnExit
this.btnExit = new Button();
this.btnExit.setLabel("Exit");
//
this.setTitle("윈폼");
this.setSize(400, 400);
// this.addWindowListener( new 윈도우어댑터() ); // 2) 객체 생성
// 1) 클래스 선언 + 2) 객체 생성 ==> 익명클래스 구현.
this.addWindowListener(
new WindowAdapter() {
@Override
public void windowClosing(WindowEvent e) {
System.out.println("프로그램 종료!!!");
System.exit(-1);
}
}
);
// 버튼 클릭할때 이벤트 처리 등록 - ActionListener 익명클래스 사용.
this.btnExit.addActionListener(
new ActionListener() { // 인터페이스
@Override
public void actionPerformed(ActionEvent e) {
System.out.println(" 버튼 클릭됨....");
System.exit(-1);
}
}
);
this.add( this.btnExit );
this.setVisible(true);
// X 닫기 버튼 클릭..
}
} // MyForm
/*
// 1) 클래스 선언
class 윈도우어댑터 extends WindowAdapter{
@Override
public void windowClosing(WindowEvent e) {
System.out.println("프로그램 종료!!!");
System.exit(-1);
}
}
*/
public class Ex08_03 {
public static void main(String[] args) {
new MyForm();
} // main
} // class
class MyForm extends Frame{
// 버튼 생성
Button btnExit = null;
// 디폴트 생성자
MyForm(){
// btnExit
this.btnExit = new Button();
this.btnExit.setLabel("Exit");
//
this.setTitle("윈폼");
this.setSize(400, 400);
// this.addWindowListener( new 윈도우어댑터() ); // 2) 객체 생성
// 1) 클래스 선언 + 2) 객체 생성 ==> 익명클래스 구현.
this.addWindowListener(
new WindowAdapter() {
@Override
public void windowClosing(WindowEvent e) {
System.out.println("프로그램 종료!!!");
System.exit(-1);
}
}
);
// 버튼 클릭할때 이벤트 처리 등록 - ActionListener 익명클래스 사용.
this.btnExit.addActionListener(
new ActionListener() { // 인터페이스
@Override
public void actionPerformed(ActionEvent e) {
System.out.println(" 버튼 클릭됨....");
System.exit(-1);
}
}
);
this.add( this.btnExit );
this.setVisible(true);
// X 닫기 버튼 클릭..
}
} // MyForm
/*
// 1) 클래스 선언
class 윈도우어댑터 extends WindowAdapter{
@Override
public void windowClosing(WindowEvent e) {
System.out.println("프로그램 종료!!!");
System.exit(-1);
}
}
*/
public class Ex09 {
public static void main(String[] args) {
// 4:23 수업 시작~
/*
* 1. 프로그램 오류 ? 프로그램 오작동 또는 비정상 종료되는 원인
* 2. 오류 발생 시점 1) + 2) = 빌드오류
* 1) 컴파일 오류
* 2) 실행 오류 == 런타임 오류
* (1) 에러( error ) : 메모리 부족, 스택 오버플로워 에러, 복구할 수 없는 심각한 오류
* Error 클래스
* ㄴ 자식클래스
* (2) 예외( exception ) : 수습될 수 있는 비교적 덜 심각한 실행 오류
* Exception 클래스
* ㄴ 자식 클래스
* 3) 논리적 오류( 가장 어려운 오류 )
* int a = Integer.MAX_VALUE;
* long b = a + 100;
* syso b; -21.........
*
* 3. 예외 클래스의 계층 구조
* Object
*
* Throwable
*
* Exception Error
*
* RuntimeException IOException OutOfMemoryError
* ㄴ ArithmeticException
* ㄴ NullPointException
* ㄴ IndexOutOfBoundsException
* ㄴ ClassCastException
* ㄴ
* 4. 예외 처리 방법
* 1) try~catch문
* 2) throws 문
*
* - 예외 처리 정의 ? 프로그램 실행 시 발생할 수 있는 예기치 못한 예외의 발생에 대비한 코드를 작성하는 것.
* - " 목적 ? 프로그램의 비정상 종료를 막고, 정상적인 실행상태를 유지하기 위해..
*
* 5. 코딩 후 실행 ( Ctrl + F11 )을 하면 예외가 발생 -> 예외처리 X -> 출력 + 비정상적으로 종료.
* -> 예외처리 ( try~ catch 문 ) O
* JVM의 "예외처리기"가 발생한 예외( uncaught exception)을 받아서
* try~catch문에 예외객체를 전달해 준다.
* */
} // main
} // class
public class Ex10 {
public static void main(String[] args) {
int a = 0, b = 0;
InputStream source = System.in;
Scanner scanner = new Scanner( source );
try {
System.out.print("> a, b 두 정 수 입력 ? ");
a = scanner.nextInt();
b = scanner.nextInt();
} catch (InputMismatchException e) {
System.out.println("입력 실수 예외 발생");
System.exit(-1); // 프로그램 종료~ == return;
}
// 오류 : 컴 X, 실 O( 에러, [예외] ), 논 X 오류
// JVM의 예외처리기에 의해서 ArithmeticException 객체가 생성되어졌고 예외처리 X -> 출력, 비정상 종료.
/*
아래 코딩을 예외 처리라고 하지 않는다.
if( b == 0 ) {
System.out.println("0으로 나눌 수 없습니다.");
return; // main 메서드를 빠져나간다는 의미는 프로그램을 종료
}
*/
try {
double c = a / b;
System.out.printf("%d / %d = %.2f\n", a, b, c);
} catch (ArithmeticException e) {
System.out.println("산술적 예외 발생 + 처리");
}
//
//
//
System.out.println("= 정상적 종료 =");
} // main
} // class
public static void main(String[] args) {
int a = 0, b = 0;
InputStream source = System.in;
Scanner scanner = new Scanner( source );
// 다중 catch 블럭을 사용할 수 있어요..
// ( 주의 사항 ) 부모 예외 클래스를 밑에 코딩한다.
try {
System.out.print("> a, b 두 정 수 입력 ? ");
a = scanner.nextInt(); // a InputMismatchException
b = scanner.nextInt();
double c = a / b;
System.out.printf("%d / %d = %.2f\n", a, b, c);
} catch (ArithmeticException e) {
System.out.println("산술적 예외 발생 + 처리");
} catch (InputMismatchException e) {
System.out.println("입력 실수 예외 발생");
} catch (Exception e) { // 다형성
System.out.println("모든 예외의 부모 Exception 클래스 이기에 제일 밑에 catch 블럭을 위치시킨다.");
}
System.out.println("= 정상적 종료 =");
} // main
} // class
public class Ex10_03 {
public static void main(String[] args) {
int a = 0, b = 0;
InputStream source = System.in;
Scanner scanner = new Scanner( source );
// 다중 catch 블럭을 사용할 수 있어요..
// ( 주의 사항 ) 부모 예외 클래스를 밑에 코딩한다.
try {
System.out.print("> a, b 두 정 수 입력 ? ");
a = scanner.nextInt(); // a InputMismatchException
b = scanner.nextInt();
double c = a / b;
System.out.printf("%d / %d = %.2f\n", a, b, c);
} catch (ArithmeticException | InputMismatchException e) {
// JDK 1.7 부터
// 여러 catch 블럭을 | 연산자를 사용해서 하나의 catch블럭으로 처리할 수 있다.
// [ 멀티 catch 블럭 ] != 다중 catch 블럭
System.out.println( " 1 : "+ e.toString() ); // 모든 예외 정보를 출력
System.out.println("2 : ");
e.printStackTrace() ; // 예외 메시지 정보 출력.
System.out.println("3 : " + e.getMessage() ); // 예외 메시지 정보
} catch (Exception e) { // 다형성
System.out.println("모든 예외의 부모 Exception 클래스 이기에 제일 밑에 catch 블럭을 위치시킨다.");
}
System.out.println("= 정상적 종료 =");
} // main
} // class
