중첩 클래스란 클래스 내부에 선언한 클래스를 말한다. 중첩 클래스를 사용하면 두 클래스의 멤버들을 서로 쉽게
접근할 수 있고, 외부에는 불필요한 관계 클래스를 감춤으로써 코드의 복잡성을 줄일 수 있다는 장점이 있다.
package sec01.exam04;
public class Test {
class NestedClass { // 중첩 클래스
}
}
인터페이스도 클래스 내부에 선언할 수 있는데, 이런 인터페이스를 중첩 인터페이스라고 한다.
인터페이스를 클래스 내부에 선언하는 이유는 해당 클래스와 긴밀한 관계를 맺는 구현 클래스를 만들기 위해서
package sec01.exam04;
public class Test {
interface NestedInterface { // 중첩 인터페이스
}
}
중첩 클래스
중첩 클래스는 클래스 내부에 선언되는 위치에 따라서 두 가지로 분류한다.
1. 멤버 클래스 : 클래스의 멤버로서 선언되는 중첩 클래스를 멤버 클래스라고 한다.
- 멤버 클래스는 클래스나 객체가 사용 중이라면 언제든지 재사용이 가능하다.
2. 로컬 클래스 : 생성자 또는 메소드 내부에서 선언되는 중첩 클래스를 로컬 클래스라고 한다.
- 로컬 클래스는 메소드를 실행할 때만 사용되고 메소드가 종료되면 없어 진다.
인스턴스 멤버 클래스
인스턴스 멤버 클래스는 static 키워드 없이 중첩 선언된 클래스
인스턴스 필드와 메소드만 선언이 가능하고 정적 필드와 메소드는 선언할 수 없다.
일반적으로 A클래스 외부에서 B객체를 생성하는 일은 거의 없음
정적 멤버 클래스
정적 멤버 클래스는 static 키워드로 선언된 클래스를 말함
정적 멤버 클래스는 모든 종류의 필드와 메소드를 선언할 수 있다.
A 클래스 외부에서 정적 멤버 클래스 C의 객체를 생성하기 위해서는 A객체를 생성할 필요가 없고
밑에 처럼 C 객체를 생성하면 됨
로컬 클래스
중첩 클래스는 메소드 내에서도 선언할 수 있는데, 이것을 로컬 클래스라고 한다.
로컬 클래스 내부에는 인스턴스 필드와 메소드만 선언할 수 있고 정적 필드와 메소드는 선언할 수 없음
바깥 필드와 메소드에서 사용 제한
바깥 클래스에서 인스턴스 멤버 클래스를 사용할 때 제한이 있다.
멤버 클래스에서 사용 제한
멤버 클래스가 인스턴스 또는 정적으로 선언됨에 따라 멤버 클래스 내부에서 바깥 클래스의 필드의 필드와
메소드에 접근할 때에도 제한이 따름
로컬 클래스에서 사용 제한
매개 변수와 로컬 변수를 로컬 클래스 내부에서 사용할 때 매개변수와 로컬 변수가 final 특성을 갖게 됨 ( 변경 불가 )
package sec01.exam04;
// 로컬 클래스에서 사용 제한
public class Outter {
public void method2(int arg) {
int localVariable = 1;// 로컬 클래스
// arg = 100; // final 특성을 갖음
// localVariable = 100;
class Inner {
public void metod() {
int result = arg + localVariable;
}
}
}
}
중첩 클래스에서 바깥 클래스 참조 얻기
선언
package sec01.exam04;
public class Outter2 {
String field = "Outter=field";
void method() {
System.out.println("Outter-method");
}
class Nested {
String field = "Nested-method";
void method() {
System.out.println("Nested-method");
}
void print() {
System.out.println(this.field);
this.method();
System.out.println(Outter2.this.field);
Outter2.this.method();
}
}
}
실행
package sec01.exam04;
public class OutterEX {
public static void main(String[] args) {
Outter2 outter2 = new Outter2();
Outter2.Nested nested = outter2.new Nested();
nested.print();
}
}
<결과>
Nested-method
Nested-method
Outter=field
Outter-method
중첩 인터페이스
class A {
[static] interface I {
void method();
}
}
중첩 인터페이스는 클래스의 멤버로 선언된 인터페이스를 말한다.
중첩 인터페이스는 인스턴스 멤버 인터페이스와 정적 멤버 인터페이스 모두 가능 하다.
인스턴스 멤버 인터페이스는 바깥 클래스의 객체가 있어야 사용 가능하고,
정적 멤버 인터페이스는 바깥 클래스의 객체 없이 바깥 클래스만으로 바로 접근할 수 있다.
주로 정적 멤버 인터페이스를 많이 사용하는데 UI 프로그래밍에서 이벤트를 처리할 목적으로 많이 활용
예) Button을 클릭했을 때 이벤트를 처리하는 객체를 받고 싶다고 가정, 그렇다고 아무 객체나 받으면 안되고
Button 내부에 선언된 중첩 인터페이스를 구현한 객체만 받아야 한다면 밑에 처럼 코딩
중첩 인터페이스
package sec01.exam05;
public class Button {
// 인터페이스 타입 필드
OnClicListener listener;
// 매개변수의 다형성
void setOnClicListener(OnClicListener listener) {
this.listener = listener;
}
// 구현 객체의 onClick() 메소드 호출
void touch() {
listener.onClick();
}
// 중첩 인터페이스
static interface OnClicListener {
void onClick();
}
}
구현 클래스 1
package sec01.exam05;
public class CallListener implements Button.OnClicListener{
@Override
public void onClick() {
System.out.println("전화를 겁니다.");
}
}
구현 클래스 2
package sec01.exam05;
public class MessageListener implements Button.OnClicListener{
@Override
public void onClick() {
System.out.println("메시지를 보냅니다.");
}
}
버튼 이벤트 처리 ( 실행 )
package sec01.exam05;
public class ButtonEx {
public static void main(String[] args) {
Button btn = new Button();
btn.setOnClicListener(new CallListener());
btn.touch();
btn.setOnClicListener(new MessageListener());
btn.touch();
}
}
<결과>
전화를 겁니다.
메시지를 보냅니다.
익명 객체
익명 객체는 이름이 없는 객체를 말한다. 익명 객체를 만들려면 조건이 있는데 어떤 클래스를 상속하거나
인터페이스를 구현해야만 한다. 일반적인 경우 다음과 같이 명시적으로 클래스 이름을 주고 선언한다.
위에 상속, 구현이 일반적인 경우
밑에 익명객체를 생성할 때 경우
인터페이스
package sec02.exam01;
public interface Iaa {
void method();
}
class Cbb implements Iaa {
@Override
public void method() {
}
}
실행
package sec02.exam01;
public class Ex1 {
public static void main(String[] args) {
Cbb a1 = new Cbb(); // 일반적인 방법
Iaa a2 = new Iaa() { // 익명의 객체 생성
@Override
public void method() {
}
};
}
}
익명의 객체 생성
인터페이스
package sec02.exam03;
public interface Animal {
void sound();
}
인터페이스 이용
package sec02.exam03;
// 인터페이스 이용
public class Driver {
void drive(Animal animal) {
animal.sound();
}
}
구현 객체
package sec02.exam03;
public class Dog implements Animal {
@Override
public void sound() {
System.out.println("멍멍");
}
}
실행
package sec02.exam03;
public class AniEx {
public static void main(String[] args) {
// 구현 객체 호출
Dog d1 = new Dog();
d1.sound();
Driver driver = new Driver();
driver.drive(d1);
//익명의 객체 생성으로 고양이 소리가 나오게 하세요.
Animal cat = new Animal() {
@Override
public void sound() {
System.out.println("야옹");
}
}; cat.sound();
// 익명의 객체 다른 호출 방법
driver.drive(new Animal() {
@Override
public void sound() {
System.out.println("야옹");
}
});
}
}
익명의 객체 생성 2
UI 클래스
package sec02.exam04;
public class Button {
// UI 클래스
// 인터페이스 타입 필드
onClickListener listener; // 버튼에 리스너 등록
// Setter // 매개 변수의 다형성
public void setListener(onClickListener listener) {
this.listener = listener;
}
// 구현 객체의 onClick() 메소드 호출
void touch() {
listener.onClick();
}
// 중첩 인터페이스
static interface onClickListener {
void onClick();
}
}
구현객체
package sec02.exam04;
// 구현 객체
public class CallListener implements Button.onClickListener {
@Override
public void onClick() {
System.out.println("전화를 겁니다.");
}
}
실행
package sec02.exam04;
public class ButtonEx {
public static void main(String[] args) {
Button bt = new Button();
bt.setListener(new CallListener());
bt.touch();
}
}
<결과>
전화를 겁니다.
익명의 객체 생성 3
UI 클래스
package sec02.exam04;
//UI 클래스
public class Window {
// 버튼 2개 생성
Button button1 = new Button();
Button button2 = new Button();
// 버튼 마다 기능 부여
public Window() {
button1.setListener(new Button.onClickListener() {
@Override
public void onClick() {
System.out.println("메시지를 보내다.");
}
});// 메시지
}
}
실행
package sec02.exam04;
public class WinEx {
public static void main(String[] args) {
Window w = new Window();
w.button1.touch();
// 메시지를 보낸다 출력하기
// 전화를 겁니다 출력하기
w.button2.setListener(new Button.onClickListener() {
@Override
public void onClick() {
System.out.println("전화를 겁니다.");
}
});
w.button2.touch();
}
}
<결과>
메시지를 보내다.
전화를 겁니다.
Maria DB 연결 ( insert ) DB에 추가_JAVA
package maria0612;
import java.sql.Connection; // JDBC 연결
import java.sql.DriverManager; // 데이터베이스 드라이버를 등록하고 연결을 관리
import java.sql.ResultSet;
import java.sql.SQLException; // JDBC에서 발생하는 예외를 처리
import java.sql.Statement; // SQL 문을 실행하기 위해 사용
import java.util.Scanner;
public class JdbcEx {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
Connection con = null;
Statement stmt = null; // insert, select 등의 명령을 위한 변수
ResultSet rs = null; // select 후에 자료를 메모리에 받아오는 변수
String url = "jdbc:mariadb://localhost:3307/jspdb";
String user = "root";
String pass = "maria";
Class.forName("org.mariadb.jdbc.Driver");// add throws ClassNotFoundException
System.out.println("드라이버 로딩!");
con = DriverManager.getConnection(url, user, pass);
System.out.println("접속 성공!");
Scanner sc = new Scanner(System.in);
System.out.print("이름 입력=>");
String name = sc.nextLine();
System.out.print("주소 입력=>");
String addr = sc.nextLine();
System.out.print("전화번호 입력=>");
String phone = sc.nextLine();
String sql = "insert into person(name, addr, phone ) values"
+"('"+name+"','"+addr+"','"+phone+"')";
stmt = con.createStatement();
int ret = stmt.executeUpdate(sql);
System.out.printf("%d 건 입력!\n", ret);
}
}
Maria DB 연결 ( Select ) DB에 테이블 검색_JAVA
package maria0612;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Scanner;
public class SelectEx {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
Connection con = null;
Statement stmt = null; // insert, select 등의 명령을 위한 변수
ResultSet rs = null; // select 후에 자료를 메모리에 받아오는 변수
String url = "jdbc:mariadb://localhost:3307/jspdb";
String user = "root";
String pass = "maria";
Class.forName("org.mariadb.jdbc.Driver");// add throws ClassNotFoundException
System.out.println("드라이버 로딩!");
con = DriverManager.getConnection(url, user, pass);
System.out.println("접속 성공!");
Scanner sc = new Scanner(System.in);
System.out.print("검색=>");
String search = sc.nextLine();
String sql = "select * from person where name like '%"+search+"%'";
stmt = con.createStatement();
rs = stmt.executeQuery(sql); // select의 경우만
while(rs.next()) { // next() id 1번부터 출력 됨
int id = rs.getInt("id");
String name = rs.getString("name");
String addr = rs.getString("addr");
String phone = rs.getString("phone");
System.out.printf("%d, %s, %s, %s\n", id, name, addr, phone);
}
}
}
시스템 분석, 설계, 구현 등 시스템 개발 과정에서 시스템 개발자와 고객 또는 개발자 상호 간의 의사소통이 원할하게
이루어지도록 표준화한 대표적인 객체지향 모델링 언어
UBL의 구성 요소 ( 사관다 = 사과한다 )★
- 사물(객체)
- 관계
- 다이어그램
2. 사물
다이어그램 안에서 관계가 형성될 수 있는 대상들을 말한다.
모델을 구성하는 가장 중요한 기본 요소★
사물의 종류
- 구조 사물
시스템의 개념적, 물리적 요소를 표현, 클래스, 유스케이스, 컴포넌트, 인터페이스, 노드 등
- 행동 사물
시간과 공간에 따른 요소들의 행위를 표현, 상호작용, 상태 머신
-그룹 사물
요소들을 그룹으로 묶어서 표현, 패키지
- 주해 사물
부가적인 설명이나 제약조건 등을 표현, 노트
A등급
UML - 관계
1. 관계
관계는 사물과 사물 사이의 연광성을 표현하는 것
관계의 종류
- 연관 관계
- 집합 관계 - 포함 관계 - 일반화 관계
- 의존 관계
- 실체화 관계
2. 연관 관계
2개 이상의 사물이 서로 관련되어 있는 관계
양방향 관계의 경우 화살표를 생략하고 실선으로만 연결한다.
다중도( 연관에 참여하는 객체의 개수 )를 선 위에 표기
다중도 ( ..을 ~ 같은 개념으로 생각하자 )
0..1 : 연관된 객체가 없거나 1개만 존재함
0..* 또는 * : 연관된 객체가 없거나 다수일 수 있음
1..* : 연관된 객체가 적어도 1개 이상임
n..m : 연관된 객체가 최소 n개에서 최대 m개임
사람ㅡ>집 ( 사람은 자기가 소유하고 있는 집에 대해 알고 있지만, 집은 누구에 의해 자신이 소유되고 있는지 모른다 )
선생님ㅡ학생 ( 선생님은 학생을 가르치고, 학생은 선생님으로 부터 가르침을 받는다. )
3. 집합 관계
하나의 사물이 다른 사물에 포함되어 있는 관계
(부분.Part)에서 (전체,Whole)으로 속이 빈 마름모(◇)를 연결하여 표현
예) 프린터는 컴퓨터에 연결해서 사용할 수 있으며, 다른 컴퓨터에 연결해서 사용 할 수도 있다.
4. 포함 관계
집합관계 특수한 형태로, 포함하는 사물의 변화가 포함되는 사물에게 영향을 미치는 관계
포함하는 쪽(전체,Whole)과 포함되는 쪽 (부분.Part)은 서로 독립될 수 없고 생명주기를 함께한다.
(부분.Part)에서 (전체,Whole)으로 속이 채워진 마름모(◆)를 연결하여 포함한다.
예) 문을 열 수 있는 키는 하나이며, 해당 키로 다른 문은 열 수 없다. 문이 없어지면 키도 더 이상 필요 없다.
5. 일반화 관계
하나의 사물이 다른 사물에 비해 더 일반적이거나 구체적인 관계
일반적인 개념을 상위(부모), 보다 구체적인 개념을 하위(자식)라고 부른다.
구체적(하위)인 사물에서 일반적(상위)인 사물 쪽으로 속이 빈 화살표를 연결
예) 커피에는 아메리카노와 에스프레소가 있다.
6. 의존 관계
서로에게 영향을 주는 짧은 시간 동안만 연관을 유지하는 관계이다.
사물(이용자)이 영향을 받는 사물(제공자)쪽으로 점선 화살표를 연결하여 표현
예) 등급이 높으면 할인율을 적용, 낮으면 할인율을 적용하지 않는다.
7. 실체화 관계
사물이 할 수 있거나 해야 하는 기능으로, 서로를 그룹화 할 수 있는 관계이다.
예) 비해깅는 날 수 있고 새도 날 수 있다. 그러므로 비행기와 새는 날 수 있다는 행위로 그룹화 할 수 있다.
A등급
UML - 다이어그램
1. 다이어그램
다이어그램은 사물과 관계를 도형으로 표현한 것이다.
정적 모델링에서는 주로 구조적 다이어그램을 사용
동적 모델링에서는 주로 행위 다이어그램을 사용
2. 구조적 다이어그램의 종류 ( 클객 컴배 복패 )
- 클래스 다이어그램 : 클래스와 클래스가 가지는 속성, 클래스 사이의 관계를 표현함
- 객체(Object) 다이어그램 : 럼바우 객체 모델링에 활용
- 컴포넌트(Component) 다이어그램 : 실제구현 모듈인 컴포넌트 간의 관계나 컴포넌트 간의 인터페이스를 표현 구현 단계 - 배치(Deployment) 다이어그램 : 결과물, 프로세스, 컴포넌트 등 물리적 요소들의 위치를 표현 구현 단계 - 복합체 구조(Composite) 다이어그램 : 클래스나 컴포넌트가 복합 구조를 갖는 경우 그 내부 구조를 표현함 - 패키지(Package)다이어그램 : 유스케이스나 클래스 등의 모델 요소들을 그룹화한 패키지들의 관계를 표현
3. 행위적 다이어그램의 종류 ( 유시(순차)커상활타 )
- 유스케이스(Use Case) 다이어그램 : 사용자의 요구를 분석하는 것으로, 기능 모델링 작업에 사용함 - 순차 = 시퀀스(Sequence) 다이어그램 : 시스템이나 객체들이 주고 받는 메시지 교환 - 커뮤니케이션(Communucation) 다이어그램 : 동작에 참여하는 객체, 객체들 간의 연관 관계를 표현 - 상태(State) 다이어그램 : 하나의 객체가 자신이 속한 클래스의 상태 변화 / 럼바우 동적 모델링 - 활동(Activity) 다이어그램 : 객체의 처리 로직이나 조건에 따른 처리의 흐름을 순서에 따라 표현 - 상호작용 개요(Interaction Overview) 다이어그램 : 제어흐름 - 타이밍(Timing) 다이어그램
4. 스테레오 타입(Stereotype)
UML에서 표현하는 기본 기능 외에 추가적인 기능을 표현 하는 것
길러멧 겹화살괄호<< >> 사이에 표현할 형태를 기술 한다.
<<include>> : 연결된 다른 UML 요소에 대해 포함 관계에 있는 경우
<<extends>> : ..................확장 관계
<<interface>> : 인터페이스를 정의하는 경우
<<exception>> : 예외를 정의하는 경우
<<constructor>> : 생성자 역할을 수행하는 경우
C등급
유스케이스 다이어그램
1. 기능 모델링
개발될 시스템이 갖춰야 할 기능을 사용자와 공유하기 위해 그림으로 표현 하는 것
기능 모델링의 종류
- 유스케이스 다이어그램
- 액티비티 다이어그램
2. 유스케이스 다이어그램
개발될 시스템을 이용해 수행할 수 있는 기능을 사용자의 관점에서 표현한 것
D등급
활동 다이어그램
사용자의 관점에서 시스템이 수행하는 기능을 처리 흐름에 따라 순선대로 표현한 것
A등급
클래스 다이어그램
1. 정적 모델링
사용자가 요구한 기능을 구현하는데 필요한 자료들의 논리적인 구조를 표현한 것이다.
구조적인 관점(View)에서 표현, 정적 모델링은 객체들을 클래스로 추상화하여 표현한다.
2. 클래스 다이어그램
클래스와 클래스가 가지는 속성, 클래스 사이의 관계를 표현한 것이다.
4. 연관 클래스
연관 관계에 있는 두 클래스에 추가적으로 표현해야 할 속성이나 오퍼레이션이 있는 경우 생성하는 클래스이다.
매우 손쉽고 빠르게 교체할 수 있다. 프로그램 소스 코드는 변함이 없는데, 구현 객체를 교체함
으로써 프로그램의 실행 결과가 다양해진다. 이것이 인터페이스의 다형성 이다.
위에 이미지처럼 I 인터페이스를 이용해서 프로그램을 개발했다. I 인터페이스를 구현한 클래스로
처음에는 A 클래스를 선택했는데, 테스트를 해보니 A 클래스에 문제가 있다는 것을 알았다. 그래서
B 클래스와 교체한 후 단 한 줄만 수정해서 프로그램을 재실행할 수 있다.
자동 타입 변환
구현 객체가 인터페이스 타입으로 변환되는 것은 자동 타입 변환에 해당한다. 자동 타입 변환은 프로그램
실행 도중에 자동적으로 타입 변환이 일어나는 것을 말한다.
인터페이스 구현 클래스를 상속해서 자식 클래스를 만들었다면 자식 객체 역시 인터페이스 타입으로
자동 타입 변환할 수 있다.
자동 타입 변환을 이용하면 필드의 다형성과 매개 변수의 다형성을 구현할 수 있다. 필드와 매개변수의 타입을
인터페이스로 선언하면 다양한 구현 객체를 대입해서 실행결과를 다양하게 만들 수 있다.
필드의 다형성
한국 타이어와 금호 타이어는 공톡적으로 타이어 인터페이스를 구현했기 때문에 모두 타이어 인터페이스에
있는 메소드를 가지고 있다. 따라서 타이어 인터페이스로 동일하게 사용할 수 있는 교체 가능한 객체에 해당한다.
인터페이스
package sec01.exam04_0;
public interface Tire {
public void roll();
}
구현클래스 1
package sec01.exam04_0;
public class HankookTire implements Tire {
@Override
public void roll() {
System.out.println("한국타이어가 굴러갑니다.");
}
}
구현클래스 2
package sec01.exam04_0;
public class KumhoTire implements Tire {
@Override
public void roll() {
System.out.println("금호타이어가 굴러갑니다.");
}
}
필드 다형성
package sec01.exam04_0;
public class Car {
// 인터페이스 타입 필드 선언과 초기 구현 객체 대입
Tire frontLeftTire = new HankookTire();
Tire frontRightTire = new HankookTire();
Tire backLeftTire = new HankookTire();
Tire backRightTire = new HankookTire();
//인터페이스에서 설명된 roll() 메소드 호출
void run() {
frontLeftTire.roll();
frontRightTire.roll();
backLeftTire.roll();
backRightTire.roll();
}
}
실행
package sec01.exam04_0;
public class CarEx {
public static void main(String[] args) {
Car myCar = new Car();
// 한국타이어x4
myCar.run();
//frontTire 2개 kumhoTire로 교체
myCar.frontLeftTire = new KumhoTire();
myCar.frontRightTire = new KumhoTire();
// 앞 바퀴 금호 2개, 뒷 바퀴 한국타이어 유지
myCar.run();
}
}
<실행>
한국타이어가 굴러갑니다.
한국타이어가 굴러갑니다.
한국타이어가 굴러갑니다.
한국타이어가 굴러갑니다.
금호타이어가 굴러갑니다.
금호타이어가 굴러갑니다.
한국타이어가 굴러갑니다.
한국타이어가 굴러갑니다.
매개 변수의 다형성
자동 타입 변환은 필드의 값을 대입할 때에도 발생하지만, 주로 메소드를 호출할 때 많이 발생한다.
매개값을 다양화하기 위해서 상속에서는 매개 변수를 부모 타입으로 선언하고 호출할 때에는 자식 객체를
대입했습니다.
위에 이미지 처럼 만약 Bus가 구현 클래스라면 다음과 같이 Driver의 drive() 메소드를 호출할 때 Bus 객체를
생성해서 매개값으로 줄 수 있다. drive() 메소드는 Vehicle 타입을 매개 변수로 선언했지만, Vehicle을 구현한
Bus 객체가 매개값으로 사용되면 자동 타입 변환이 발생한다.
<= 자동 타입 변환
Vehicle vehicle = bus;
매개 변수의 타입이 인터페이스일 경우 어떠한 구현 객체도 매개값으로 사용할 수 있고, 어떤 구현객체가 제공
되느냐에 따라 메소드의 실행결과는 다양해질 수 있다. 이것이 인터페이스 매개변수의 다형성 이다.
인터페이스
package sec01.exam04_1;
//인터페이스
public interface Vehicle {
public void run();
}
매개 변수의 인터페이스화
package sec01.exam04_1;
public class Driver {
public void drive(Vehicle vehicle) {
vehicle.run();
}
}
구현 클래스 1
package sec01.exam04_1;
public class Bus implements Vehicle {
@Override
public void run() {
System.out.println("버스가 달립니다.");
}
}
구현 클래스 2
package sec01.exam04_1;
public class Taxi implements Vehicle {
@Override
public void run() {
System.out.println("택시가 달립니다.");
}
}
실행
package sec01.exam04_1;
public class DriverEX {
public static void main(String[] args) {
Driver driver = enw Driver();
Bus bus = new Bus();
Taxi taxi = new Taxi();
driver.drive(bus); // 자동 타입 변환
driver.drive(taxi);// 자동 타입 변환
}
}
<결과>
버스가 달립니다.
택시가 달립니다.
강제 타입 변환
구현 객체가 인터페이스 타입으로 자동 타입 변환하면, 인터페이스에 선언된 메소드만 사용 가능하다는 제약사항이
따른다. 예를 들어 인터페이스에는 3개의 메소드가 선언되어 있고 클래스에는 5개의 메소드가 선언되어 있다면,
인터페이스로 호출 가능한 메소드는 3개뿐 이다.
하지만 경우에 따라서는 구현 클래스에 선언된 필드와 메소드를 사용해야 할 경우도 발생하는데 이때 강제 타입
변환을 해서 다시 구현 클래스 타입으로 변환한 다음, 구현 클래스의 필드와 메소드를 사용할 수 있다.
인터페이스
package sec01.exam04_1;
//인터페이스
public interface Vehicle {
public void run();
}
매개 변수의 인터페이스화
package sec01.exam04_1;
public class Driver {
public void drive(Vehicle vehicle) {
vehicle.run();
}
}
구현 클래스 1
package sec01.exam04_1;
public class Bus implements Vehicle {
@Override
public void run() {
System.out.println("버스가 달립니다.");
}
public void checkFare() {
System.out.println("승차요금 체크 합니다.");
}
}
구현 클래스 2
package sec01.exam04_1;
public class Taxi implements Vehicle {
@Override
public void run() {
System.out.println("택시가 달립니다.");
}
}
실행
package sec01.exam04_1;
public class DriverEX {
public static void main(String[] args) {
// 익명의 객체생성
Vehicle vehicle1 = new Vehicle() {
@Override
public void run() {
System.out.println("새로운 차 달린다.");
}
};
Vehicle vehicle = new Bus(); // 필드 다형성
vehicle.run();
// Bus bus = vehicle;
// vehicle.chechFare(); //에러 밑에 처럼 강제 형변환 필요
// Bus bus = (Bus) vehicle;
// bus.checkFare();
// ((Bus) vehicle).checkFare(); // 위에 두줄과 동일
if(vehicle instanceof Bus) { // 강제 형변환 확인 유무
System.out.println("객체 변한 가능");
Bus bus = (Bus) vehicle;
bus.checkFare();
}
}
}
<결과>
버스가 달립니다.
객체 변한 가능
승차요금 체크 합니다.
객체 타입 확인
강제 타입 변환은 구현 객체가 인터페이스 타입으로 변환되어 있는 상태에서 가능하다. 그러나 어떤 구현 객체가
변환되어 있는지 알 수 없는 상태에서 무작정 강제 타입 변환할 경우 ClassCastException이 발생할 수도 있다.
예를 들어 다음과 같이 Taxi 객체가 인터페이스로 변환되어 있을 경우, Bus 타입으로 강제 타입 변환하면 구현
클래스 타입이 다르므로 ClassCastException이 발생한다.
Vehicle vehicle = new Taxi();
Bus bus = (Bus) vehicle;
메소드의 매개 변수가 인터페이스로 선언된 경우, 메소드를 호출할 때 다양한 구현 객체들을 매개값으로 지정할 수
있다.( 매개 변수의 다형성 ) 어떤 구현 객체가 지정될지 모르는 상황에서 다음과 같이 매개값을 Bus로 강제 타입 변환
하면 ClassCastException이 발생할 수 있다.
public void drive(Vehicle vehicle) {
Bus bus = (Bus) vehicle;
bus.checkFare();
}
예를 들어 Vehicle 인터페이스 타입으로 변환된 객체가 Bus 인지 확인하려면 다음과 같이 instanceof 연산자 사용
if(vehicle instanceof Bus) {
Bus bus = (Bus) vehicle;
}
인터페이스 타입으로 자동 타입 변환된 매개값을 메소드 내에서 다시 구현 클래스 타입으로 강제 타입 변환해야
한다면 반드시 매개값이 어떤 객체인지 instaceof 연산자로 확인하고 안전하게 강제 타입 변환을 해야 한다.
인터페이스 상속
인터페이스도 다른 인터페이스를 상속할 수 있다. 인터페이스는 클래스와는 달리 다중 상속을 허용 한다.
밑에와 같이 extends 키워드 뒤에 상속할 인터페이스들을 나열할 수 있다.
하위 인터페이스를 구현하는 클래스는 하위 인터페이스의 메소드뿐만 아니라 상위 인터페이스의 모든 추상
메소드에 대한 실체 메소드를 가지고 있어야 한다. 그렇기 때문에 구현 클래스로부터 객체를 생성한 후에
밑에와 같이 하위 및 상위 인터페이스 타입으로 변환이 가능하다.
하위 인터페이스로 타입 변환이 되면 상위 및 하위 인터페이스에 선언된 모든 메소드를 사용할 수 있으나,
상위 인터페이스로 타입 변환되면 상위 인터페이스에 선언된 메소드만 사용 가능하고 하위 인터페이스에
선언된 메소드는 사용할 수 없다. 예를 들어 아래와 같이 인터페이스가 상속 관계에 있다고 가정하면
InterfaceC 인터페이스 변수는 methodA(),mehodB(),methodC()를 모두 호출할 수 있지만,
InterfaceA와 InterfaceB 변수는 각각 methodA()와 mehodB()만 호출할 수 있다.
상위 인터페이스 1
package sec01.exam04_2;
// 상위 인터페이스
public interface InterA {
public void methodA();
}
상위 인터페이스 2
package sec01.exam04_2;
//상위 인터페이스
public interface InterB {
public void methodB();
}
하위 인터페이스
package sec01.exam04_2;
//하위 인터페이스
public interface InterC extends InterA, InterB {
public void methodC();
}
하위 인터페이스 구현
package sec01.exam04_2;
public class C implements InterC {
@Override
public void methodA() {
System.out.println("C-method_A 실행");
}
@Override
public void methodB() {
System.out.println("C-method_B 실행");
}
@Override
public void methodC() {
System.out.println("C-method_C 실행");
}
}
실행
package sec01.exam04_2;
public class Ex1 {
public static void main(String[] args) {
C c1 = new C();
InterA a1 = c1;
a1.methodA();
InterB a2 = c1;
a2.methodB();
InterC a3 = c1;
a3.methodA();
a3.methodB();
a3.methodC();
}
}
<결과>
C-method_A 실행
C-method_B 실행
C-method_A 실행
C-method_B 실행
C-method_C 실행
실습
인터페이스_구현 클래스 2개
인터페이스
package sec01.exam04_3;
public interface DataAccessObject {
public void select();
public void insert();
public void updata();
public void delete();
}
구현 클래스 1
package sec01.exam04_3;
public class OracleDao implements DataAccessObject {
@Override
public void select() {
System.out.println("Oracle DB에서 검색");
}
@Override
public void insert() {
System.out.println("Oracle DB에서 삽입");
}
@Override
public void updata() {
System.out.println("Oracle DB에서 수정");
}
@Override
public void delete() {
System.out.println("Oracle DB에서 삭제");
}
}
구현 클래스 2
package sec01.exam04_3;
public class Mysql implements DataAccessObject {
@Override
public void select() {
System.out.println("Mysql에서 검색");
}
@Override
public void insert() {
System.out.println("Mysql에서 삽입");
}
@Override
public void updata() {
System.out.println("Mysql에서 수정");
}
@Override
public void delete() {
System.out.println("Mysql에서 삭제");
}
}
실행
package sec01.exam04_3;
public class Ex1 {
// static이 붙은건 "." 호출, 안붙으면 생성자 생성 후 "." 호출
public static void dbWork(DataAccessObject dao) {
dao.select();
dao.insert();
dao.updata();
dao.delete();
}
public static void main(String[] args) {
dbWork(new OracleDao());
dbWork(new Mysql());
}
}
<결과>
Oracle DB에서 검색
Oracle DB에서 삽입
Oracle DB에서 수정
Oracle DB에서 삭제
Mysql에서 검색
Mysql에서 삽입
Mysql에서 수정
Mysql에서 삭제
Maria DB_JAVA파일 연동 후 (JDBC) 입력 값 DB에 저장
package jdbc0609;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Scanner;
public class TestForJDBC {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
Scanner sc = new Scanner(System.in);
Connection con = null;
String url = "jdbc:mariadb://localhost:3307/jspdb";// DB 연결 주소
String user = "root"; // DB 계정
String pass = "maria"; // DB PW
Class.forName("org.mariadb.jdbc.Driver");
System.out.println("드라이버 로딩!");
con =
DriverManager.getConnection(url, user, pass);
System.out.println("접속 성공!");
System.out.print("사번 입력: ");
int empno = sc.nextInt(); // 사용자로부터 사번 입력 받음
System.out.print("이름 입력: ");
String ename = sc.nextLine(); // 사용자로부터 이름 입력 받음
ename = sc.nextLine();
System.out.print("급여 입력: ");
int sal = sc.nextInt(); // 사용자로부터 가격 입력 받음
System.out.print("전화번호 입력: ");
String phone = sc.nextLine(); // 사용자로부터 전화번호 입력 받음
phone = sc.nextLine();
String sql = "insert into emp (empno,ename,sal,phone)"
+ "VALUES ("+ empno +", '"+ename+"', " + sal +", '"+phone+"' )";
Statement stmt = con.createStatement();
stmt.executeUpdate(sql);
System.out.println("query 성공");
}
}
