day31

📖추상클래스

부모클래스 역할을 추상클래스로 활용!

abstract class 클래스명 : 몸통이 없는 클래스
-> 변수, 생성자, 메소드 다 가능
-> 추상메소드 : 선언만 있고 정의(실행코드)가 없음
자식 클래스에서 부모 클래스의 추상메소드는 필수로 구현을 해야한다.

//추상클래스
public interface Abstract002 {
	
	public static void main(String[] args) {
		
//	Car c = new Car();
	//추상클래스는 인스턴스 객체 생성X
	Car c = new Bus();
	//타입으로는 쓸 수 있다!
		
	Bus b = new Bus();	
	Truck t = new Truck();

	b.stop(); //상속관계는 되있는 상태! 그냥 Car클래스의 객체를 생성하지 못하는것~! 
	t.stop(); //상속관계는 되있는 상태! 그냥 Car클래스의 객체를 생성하지 못하는것~! 
	
//	b.run();
//	t.run();
	
	Car[] carArr = {b, t};
	
	for (int i=0; i<carArr.length; i++) {
		carArr[i].run();
		
		//아예 abstract run(); 이 없을때 Car에 run()메소드가 없으니까 밑에처럼 형변환해서 불러줘야함!
//		((Bus)carArr[i]).run();
//		((Truck)carArr[i]).run();
	}
	
	
	
	}
}

abstract class Car { //추상클래스 -> Car라는 설계도가 반만 완성된 상태 
	//최소한의 기본 공통점만 모아놓는곳으로 굳이 객체생성하지 않아도 되는 클래스 만들고싶을때!
	//최소한의 기본 공통점만 가지고 객체태어나면 안되는 상황일때
	
	//차 -> 대범주 분류상으로 그냥 차!
	
	//필드
	String type; //타입
	
	//생성자
	public Car() {}
	
	//메소드
	void stop() {
		System.out.println("Car stop()");
	}
	
	 abstract public void run();
	//추상메소드는 선언 부분만 작성! 정의{}부분은 작성X
}

class Bus extends Car {
	//차의 한 종류인 실체가 버스
	
	//부모클래스에 추상메소드가 있으면 무조건 자식클래스에서 구현해줘야한다
	//자동으로 import하듯이 하면 생김
	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("Bus run()");
	} 
	
	void stop() {
		System.out.println("Bus stop()");
	}
	
}

class Truck extends Car {
	// 차의 한 종류인 실체가 트럭
	
	//부모클래스에 추상메소드가 있으면 무조건 자식클래스에서 구현해줘야한다
	//자동으로 import하듯이 하면 생김
	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("Truck run()");
	} 
	
	
}

💻

🖐추상클래스는 객체생성을 할 수 없다!
하지만 타입으로는 쓸 수 있다!

🖐하지만 자식클래스에서 상속관계와 똑같이 부모클래스의 변수, 메소드를 이용할 수 있다

🖐추상클래스는 필드변수, 메소드 선언+구현까지 다 할 수 있어 상속과 똑같다고 생각하면 되고 메인클래스에서 추상클래스 객체를 생성하지 못한다는 차이점만 있는거고
추상메소드 abstract public void run(); 는 선언만 가능하고 구현{}은 못한다!

🖐그래서 추상클래스 Car를 상속받는 Bus와 Truck은 추상클래스 Car에 추상메소드가 있으면 무조건 구현해줘야 한다!
부모클래스에 추상메소드가 있으면 자식클래스에서 무조건 구현해줘야한다

📖인터페이스

연결통신, 서로 소통하는 기준!
ex)220V 꽂는 곳: interface / 어댑터들: class

public class Interface002 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
//		Callable c1 = new Callable(); //인터페이스는 객체 생성X
		GalaxyPhone1 gp1 = new GalaxyPhone1();
		gp1.callState = Callable.CALL_ON;
		
		GalaxyPhone1 gp2 = new GalaxyPhone1();
		gp2.callState = Callable.CALL_OFF;
				
		//상속과 동일한 부분 -> 객체생성은 못하지만 타입으로는 O
		Callable gp3 = new GalaxyPhone1();
		//인터페이스 타입 = 구현클래스
		Callable gp4 = new IPhone1();
		
		IPhone1 gp5 = new IPhone1();
		
		Callable[] arr = {gp3, gp4};
		arr[0].call();
		arr[1].call();
		
		GalaxyTab1 gt1 = new GalaxyTab1();
		gt1.call();
		gt1.connect();
		
		Callable gt2 = new GalaxyTab1(); //구현 하고있으니까 담을 수 있어
		gt2.call();
//		gt2.connect(); //Callable에 들어가있는 메소드만 가능~!
		
		Callable[] arr2 = {gp3, gp4, gt1}; //다 담을 수 있지~! 상속이랑 동일한 부분!
		for (Callable ca : arr2) {
			ca.call();
		}
	
		//인터페이스 타입 = 구현클래스
		BluetoothConnectable bc1 = new GalaxyPhone1();
		BluetoothConnectable bc2 = new GalaxyTab1();
		bc2.connect();
//		bc2.call(); //BluetoothConnectable에 들어가있는 메소드만 가능!

		//BluetoothConnectable bc3 = new IPhone1(); //구현안했으니까 X
		
		GalaxyTab1 gt3 = new GalaxyTab1();
		Callable ca = gt3;
		BluetoothConnectable bc = gt3;
		
		BluetoothConnectable[] bcArr = {gt1, gp1};
		//gp3 -> Callable에 담겨있어! 상관없는관계니까 안담기지
		//gp4 -> Callable에 담겨있어! 상관없는관계니까 안담기지
		//gp5 -> IPhone1에 담겨있어! IPhone1은 BluetoothConnectable을 구현X
		//gt1 -> GalaxyTab1에 담겨있으니까 BluetoothConnectable에 들어가있으니까 담기지
		//gp1 -> GalaxyPhone1에 담겨있으니까 BluetoothConnectable에 들어가있으니까 담기지
		
		
		//타입변환
		Callable ca2 = gt3; //gt3는 GalaxyTab1에 담겨져있음
		if (ca2 instanceof GalaxyTab1) { //ca2를 GalaxyTab1로 바꿀수 있냐
			
		}
		GalaxyTab1 gt33 = (GalaxyTab1)ca2; //ca2는 Callable에 담겨져있으니까 부모가 자식에 담길수없으니 강제형변환!
		gt33.call();
		gt33.connect();
		
		BluetoothConnectable bt2 = gt3; 
		//gt3는 GalaxyTab1에 담겨져있음? 위에서 Callable에 담겨져있는 상태로 변한거 아닌가..X
		//ca2,bt2는 Q167에 담겨있는 gt3를 가리키고 있는것 -> gt3는 그냥 지 타입이 있는거지
		if (bt2 instanceof GalaxyTab1) { //bt2를 GalaxyTab1로 바꿀수 있냐
			
		}
		GalaxyTab1 gt34 = (GalaxyTab1)bt2;
		gt34.call();
		gt34.connect();
		
		/*
		  GalaxyTab1 gt3 = new GalaxyTab1();
		  
		  Callable ca2 = gt3; //O //gt3는 GalaxyTab1에 담겨져있음 
		  BluetoothConnectable bt2 = gt3; //O //gt3는 GalaxyTab1에 담겨져있음
		  //ca2,bt2는 Q167에 담겨있는 gt3를 가리키고 있는것 -> gt3는 그냥 지 타입이 있는거지
		  
		  
		  BluetoothConnectable bt2 = ca2; //X //ca2는 Callable에 담겨져있음 
		 
		 */
		
		
	}

}

//인터페이스
//has-a : Callable (전화를 걸 수 있다) / 기능을 중점으로 ~할수있냐?
//		  갤럭시폰은 전화가능. 아이폰 전화가능
//		  샤오미폰 전화가능. 아이패드 전화가능
//		  애플워치 전화가능.

interface Callable {
	//상수형 변수 사용 O
	public static final int CALL_ON = 1;	
	//필드변수 같이 보여도 상수형 변수로 인식한다! (static final 생략)
	public int CALL_OFF = 5; 
	
	//필드변수 X
//	int callState; //인터페이스에서는 필드 인스턴스 변수 X
	
	public void call(); //선언만 가능 구현{}은 X == 추상메소드
}

interface BluetoothConnectable { //블루투스연결가능?
	public void connect(); //선언만 가능 구현{}은 X == 추상메소드
}

class Phone1 {}

class GalaxyPhone1 implements Callable, BluetoothConnectable { //구현하겠다
	//필드변수 -> interface에서 필드변수를 못가지니까 여기서 만들어
	int callState;
	
	//자식이 꼭 구현해야한다 (import하듯이) == 추상메소드
	@Override
	public void call() { //자체적인 메소드
		// TODO Auto-generated method stub
		System.out.println("갤럭시 전화걸기");
	}
	
	//자식이 꼭 구현해야한다 (import하듯이) == 추상메소드
	@Override
	public void connect() { //자체적인 메소드
		// TODO Auto-generated method stub
		System.out.println("갤럭시 블루투스 연결");
	} 
	
}

class IPhone1 implements Callable { //블루투스연결기능X
	//필드변수 -> interface에서 필드변수를 못가지니까 여기서 만들어
	int callState;

	//자식이 꼭 구현해야한다 (import하듯이) == 추상메소드
	@Override
	public void call() { //자체적인 메소드
		// TODO Auto-generated method stub
		System.out.println("아이폰 전화걸기");
	}
	
}

//갤럭시탭 태블릿
class GalaxyTab1 implements Callable, BluetoothConnectable { //다중인터페이스 O
	//필드변수 -> interface에서 필드변수를 못가지니까 여기서 만들어
	int callState;
		
	//자식이 꼭 구현해야한다 (import하듯이) == 추상메소드
	@Override
	public void call() { //자체적인 메소드
		// TODO Auto-generated method stub
		System.out.println("갤럭시탭 전화걸기");
	}

	//자식이 꼭 구현해야한다 (import하듯이) == 추상메소드
	@Override
	public void connect() { //자체적인 메소드
		// TODO Auto-generated method stub
		System.out.println("갤럭시탭 블루투스 연결");
	}
	
}

class MarshallSpeaker implements BluetoothConnectable {
	
	//자식이 꼭 구현해야한다 (import하듯이) == 추상메소드
	@Override
	public void connect() {
		// TODO Auto-generated method stub
		
	}
	
}

🖐interface Callable {} => 필드변수X, 생성자X, 메소드는 선언만! {}X, 인터페이스 객체 생성X // 필드변수처럼 써도 상수형 변수로 인식!

🖐interface Callable {} => 상수형 변수O, 다중 인터페이스 구현O

🖐

GalaxyTab1 gt3 = new GalaxyTab1();
		  
Callable ca2 = gt3; //O //gt3는 GalaxyTab1에 담겨져있음 
BluetoothConnectable bt2 = gt3; //O 
	//gt3는 GalaxyTab1에 담겨져있음
	//ca2,bt2는 Q167에 담겨있는 gt3를 가리키고 있는것 -> gt3는 그냥 지 타입이 있는거지
		  
BluetoothConnectable bt2 = ca2; //X //ca2는 Callable에 담겨져있음 

gt3는 그냥 지 타입이 따로 있는것! ca2에 담겼다고 해서 Callable에 담겨서 BluetoothConnectable bt2에 못들어가는게 아니라! 걍 gt3는 GalaxyTab1에 들어가있는 변수인거여~!

💻