6월5일 - Abstract class + Interface

[자체교안] chapter 17 - Abstract class /chapter 18 - Interface
[교학사] 6장 - 객체지향 프로그래밍 2 /추상클래스, 인터페이스

Abstract Class - 추상클래스

추상클래스는 객체를 생성할 수 없다.

- 직접 new연산자를 사용할 수 없다.

- 불완전한 클래스

추상클래스=일반메소드+추상메소드

=일반메소드와 추상메소드가 같이 선언 가능하다

추상메소드

- 메소드의 body{}가 없음 불완전한 함수

- 메소드의 머리말만 존재

- 형식 : 리턴형 함수명();

1) 추상클래스는 추상메소드가 1개라도 있으면 추상클래스가 된다.

abstract class Animal {  //추상클래스
	                //추상메소드가 1개라도 있으면 추상클래스가 된다.
	String name;
	void view(){} //일반메소드 
	abstract void disp();  //추상메소드 리턴값가질수있음
}//class end

2) 추상클래스는 누군가의 부모역할만 한다(extends만 한다는 뜻)

- 추상클래스는 자신의 클래스 이름으로 객체생성 불가능
- 추상클래스를 상속받은 자식클래스는 반드시 추상메소드를 완성해야한다(override)

- 추상클래스는 불완전클래스이므로, 자식이 물려받는다면 자식이 완전하게 override해서 완성시켜줘야한다.

class Elephant extends Animal {
	@Override
	void disp() {
		System.out.println("점보...");
	}
}//class end

class Tuna extends Animal {
	@Override
	void disp() {
		System.out.println("니모...");
	}
}//class end

public class Test01_Abstract {

	public static void main(String[] args) {
		// 추상클래스 abstract class
		
		//추상클래스는 new연산자로 객체생성할 수 없다.
		//Animal ani=new Animal(); 에러
		
		Elephant jumbo=new Elephant();
		jumbo.disp(); //점보...
		
		Tuna nemo=new Tuna();
		nemo.disp();  //니모...

3) 추상클래스의 다형성

- 자식클래스는 부모클래스에 들어갈 수 있다.

- 다형성은 부모님 모습과 내모습이 비슷해야함.
- 내모습을 비슷하게 부모님꺼에서 수정해서 다시 부모님집으로 들어가야하는것

Animal ani=new Elephant();
ani.disp(); //점보...
		
ani=new Tuna();
ani.disp(); //니모...

abstract class Travel {  //추상클래스
	public void view(){}                //일반메소드
	abstract String travelWhere(); //추상메소드
}//class end

class TypeA extends Travel {
	@Override
	String travelWhere() {
		return "제주도 올레길";
	}
}//class end

class TypeB extends Travel {
	@Override
	String travelWhere() {
		return "여의도 불꽃축제";
	}
}//class end

class TypeC extends Travel {
	@Override
	String travelWhere() {
		return "서울 둘레길";
	}
}//class end


public class Test02_Abstract {

	public static void main(String[] args) {
		// 추상클래스
		
		//추상클래스는 자신의 클래스 이름으로 객체생성 불가능
		//Travel tour=new Travel();
		
		Travel tour=new TypeA();
		System.out.println(tour.travelWhere()); //제주도 올레길
		
		tour=new TypeB();
		System.out.println(tour.travelWhere()); //여의도 불꽃축제
		
		tour=new TypeC();
		System.out.println(tour.travelWhere()); //서울 둘레길

Interface 인터페이스

- 추상메소드로만 구성되어있다
- 추상클래스보다 더 추상화되어져 있다.

- 인터페이스=추상메소드

=추상메소드만 선언 가능하다

- 추상클래스보다 인터페이스의 활용도가 더 높다.

1) 인터페이스는 추상메소드로만 구성되어져있다.

2) 인터페이스 자신으로 직접 객체 생성 불가능

3) 클래스 입장에서 부모가 클래스 : extends 확장
부모가 인터페이스 : implements 구현

package oop0605;

interface Parent{
	//void disp(){} 에러; 일반메소드 사용불가
	abstract void kind(); //추상메소드
	void breathe();        //abstract 생략가능
}//interface end

class Son implements Parent { //구현 
	@Override
	public void kind() {
		System.out.println("아들");
	}
	@Override
	public void breathe() {
		System.out.println("허파 숨쉬기 1");
	}
}//class end

class Daugther implements Parent {
	@Override
	public void kind() {
		System.out.println("딸");
	}
	@Override
	public void breathe() {
		System.out.println("허파 숨쉬기 2");
	}	
}//class end

public class Test03_Interface {

	public static void main(String[] args) {
		// Interface 인터페이스
		
		Son son=new Son();
		son.kind(); //아들
		son.breathe(); //허파 숨쉬기 1
		
		Daugther daugh=new Daugther();
		daugh.kind(); //딸
		daugh.breathe(); //허파 숨쉬기 2
        
	}//main() end
}//class end

4) 인터페이스 다형성

- 부모들이 물려준거에 자식들은 오버라이드를 무조건 하기때문에 인터페이스에서의 다형성은 더 최적화되어있다

Parent parent=new Son();
parent.kind(); //아들
parent.breathe(); //허파 숨쉬기 1
		
parent=new Daugther();
parent.kind(); //딸
parent.breathe(); //허파 숨쉬기 2

5)인터페이스를 활용해서 개발 프로젝트에서 발생하는 여러 페이지들을 표준화, 구조화할 수도 있다.

package oop0605;

interface ICalc {      //산술연산 + - * / %
	public int add();
	public int sub();
	public int mul();
	public int div();
	public int mod();
}//interface end

class Calclmp implements ICalc {
	private int x, y;
	
	public Calclmp() {}
	public Calclmp(int x, int y) {
		this.x=x;
		this.y=y;
	}
	
	@Override
	public int add() {
		return x+y;
	}
	@Override
	public int sub() {
		return x-y;
	}
	@Override
	public int mul() {
		return x*y;
	}
	@Override
	public int div() {
		return x/y;
	}
	@Override
	public int mod() {
		return x%y;
	}	
}//class end

public class Test04_Interface {

	public static void main(String[] args) {
		
		//다형성
		ICalc calc=new Calclmp(5,3);
		System.out.println(calc.add()); //8
		System.out.println(calc.sub()); //2
		System.out.println(calc.mul()); //15
		System.out.println(calc.div()); //1
		System.out.println(calc.mod()); //2
		
	}//main() end
}//class end

6) 클래스와 인터페이스간의 상속 및 구현

- 클래스에서 클래스 extends

- 인터페이스에서 인터페이스 extends

- 클래스에서 인터페이스 implements

- 인터페이스간에는 다중상속이 가능하다. ( , 로 구분해서 표기)

- 클래스간에는 단일상속만 가능하다.

package oop0605;

class Unit {
	int currentHP; //유닛의 체력
	int x, y;          //유닛의 x,y 좌표
}//class end

interface Movable {
	void move(int x, int y);
}//interface end

interface Attackable {
	void attack(Unit u);
}//interface end

interface Fightable extends Movable, Attackable {
	//인터페이스는 다중상속이 가능하다
}//interface end

class Fight extends Unit implements Fightable{

	@Override
	public void move(int x, int y) {
		// TODO Auto-generated method stub		
	}

	@Override
	public void attack(Unit u) {
		// TODO Auto-generated method stub		
	}
	
}//class end

public class Test05_Interface {

	public static void main(String[] args) {
		// 클래스와 인터페이스간의 상속 및 구현

fomat 클래스

- superclass 부모 클래스는 하나만 가능

- interfaces implement는 여러개 가능

Anonymous class 익명 내부 클래스

- 필요한 곳에서 일시적으로 실행
- 이벤트(클릭)가 발생할 때만 실행
- 안드로이드 자바, JavaScript, jQuery에서 많이 활용한다.

package oop0605;

interface IMessage {
	public void msgPrint();
}//interface end

class Message implements IMessage {
	@Override
	public void msgPrint() {
		System.out.println("Message 클래스");
	}
}//class end

public class Test06_Anonymous {

	public static void main(String[] args) {
		// 익명 내부 클래스 Anonymous class 이름없는 클래스를 통칭하는 말, 클래스 이름은 아님
		
		//인터페이스는 객체생성할 수 없다.
		//IMessage msg=new IMessage(); 에러
		
		//1) 구현클래스
		Message msg = new Message();
		msg.msgPrint(); //Message 클래스
		
		//2) 다형성
		IMessage imess=new Message();
		imess.msgPrint(); //Message 클래스

		//3) 익명클래스
		//필요한 곳에서 일시적으로 실행
		//이벤트(클릭)가 발생할 때만 실행 
		IMessage mess=new IMessage(){
			@Override
			public void msgPrint() {
				System.out.println("Anonymous 익명 내부 클래스"); 
			}
		};
		
		mess.msgPrint(); //Anonymous 익명 내부 클래스
	}//main() end
}//class end

Inner class 내부클래스

클래스안에 클래스가 또 있는 것 .

클래스 내부에서 선언된 클래스

안드로이드OS 안에서 중요함 , R클래스를 통해 id로 접근 가능,

1) Inner 클래스 예제

class WebProgram {
	String title="Java Program";
	
	class Language{ //inner class
		String basic="JAVA, HTML, CSS, JavaScript";
		void display(){
			System.out.println("기초수업:"+basic);
		}
	}//class end
	
	class Smart{ //inner class
		String basic="Objectiv-C, Java OOP, C#";
		void display(){
			System.out.println("기초수업:"+basic);
		}
	}//class end
	
	void print(){
		Language lang=new Language();
		lang.display();
		
		Smart sm=new Smart();
		sm.display();
	}
	
}//class end


public class Test07_Inner {

	public static void main(String[] args) {
		// 내부 클래스 inner class
		
		WebProgram web=new WebProgram();
		web.print(); //기초수업:JAVA, HTML, CSS, JavaScript
                             //기초수업:Objectiv-C, Java OOP, C#

2) 내부클래스는 직접 접근할 수 없다. (단, 외부에서 단계적으로 접근할 수는 있다.)

/*에러남
Language lang=new Language();
Smart sm=new Smart();
*/

- 내부클래스는 외부에서 단계적으로 접근할 수는 있다. import자동 설정됨

Language lang=new WebProgram().new Language();
Smart sm       =new WebProgram().new Smart();
		
lang.display(); //기초수업:JAVA, HTML, CSS, JavaScript
sm.display();   //기초수업:Objectiv-C, Java OOP, C#

3) 안드로이드 기반 자바

class R {
	static class id {
		static String btn="버튼";
	}
}//class end

public class Test07_Inner {

	public static void main(String[] args) {
		// 내부 클래스 inner class
        
        System.out.println(R.id.btn); //버튼

저작자표시

'공부 > 자바 OOP' 카테고리의 다른 글

6월11일 - 파일입출력 (0)	2019.06.11
6월10일 - Java Collection Framework (0)	2019.06.10
6월4일 - 상속 + 객체지향(다향성, object) + exception (0)	2019.06.04
6월3일 - 상속 (0)	2019.06.03
5월31일 - Wrapper 클래스 (0)	2019.05.31

3XL

6월5일 - Abstract class + Interface

'공부 > 자바 OOP' 카테고리의 다른 글

티스토리툴바

6월5일 - Abstract class + Interface

'공부 > 자바 OOP' 카테고리의 다른 글

'공부/자바 OOP' Related Articles

티스토리툴바