11/22 수업 (17일차) _ 접근 제어자 / 다형성

개미의 베짱이 2023. 11. 22. 17:28

2023. 11. 22. 17:28

** 문법 **

trim() : 문자열의 맨앞과 맨 뒤 공백만 제거
replace(" ","") : 문자열에서 첫번째 인수를 찾아 두번쨰 인수로 변경
replaceAll(" ", "") : 문자열에서 첫번째인수를 찾아 두번째 인수로 변경

public class MyProject1121_7 {

	public static void main(String[] args) {
		
		//접근제어자
		
		//******************************************************************************
		/* 문법
		 trim() : 문자열의 맨앞과 맨 뒤 공백만 제거
		 replace(" ","") : 문자열에서 첫번째 인수를 찾아 두번쨰 인수로 변경
		 replaceAll(" ", "") : 문자열에서 첫번째인수를 찾아 두번째 인수로 변경
		 */
		
		String tmp = "  홍 길동   ";
		System.out.println("trim() : [" + tmp.trim() + "]");
		System.out.println("replace() : [" + tmp.replace(" ", "") + "]");
		System.out.println("replace() : [" + tmp.replaceAll(" ", "홍") + "]");
		
		//******************************************************************************
        
	}
}

** 실습 1122 (접근제어자 + 오버라이딩)**

/* 접근제어자, 오버라이딩
*출력예)좋은 아침입니다. 오전에는 맑음 입니다.
* 즐거운 점심입니다. 점심에는 흐림입니다.
* 행복한 오후되세요. 오후에는 비가 내리겠습니다.
*단, greeting메서드를 이용함
*/

class Today{	//extends Object 생략
	private String weather;
	
	public String getWeather() {
		return this.weather;
	}
	public void setWeather(String weather) {
		this.weather = weather;
	}
	
	void greeting() {
		System.out.println("즐거운 하루 되세요.");
	}
	
//	//자식클래스 생성자에 super(weather); 사용할 경우
//	Today(String weather){
//		setWeather(weather);
//	}
}


class Morning extends Today{
		
	Morning(String weather){
		//super();		//생략되어있다.
		setWeather(weather);	//super. 생략됨 (Morning 클래스에 setWeather 메서드가 없기때문)
//		//super(weather);
	}
	
	void greeting() {
		System.out.println("좋은 아침입니다. 오전에는 " + super.getWeather() + "입니다.");
		//super. 생략가능 (Morning 클래스에 setWeather 메서드가 없기때문)
	}
}


class Lunch extends Today{
	
	Lunch(String weather){
		setWeather(weather);
	}
	
	void greeting() {
		System.out.println("즐거운 점심 입니다. 점심에는 " + getWeather() + "입니다.");
	}
}


class Dinner extends Today{
	
	Dinner(String weather){
		super.setWeather(weather);
	}
	
	void greeting() {
		System.out.println("행복한 오후되세요. 오후에는 " + getWeather() + "가 내리겠습니다.");
	}
}

public class MySample1122 {

	public static void main(String[] args) {
		
		//상속 + 오버라이딩
		
		Morning m = new Morning("맑음");
		Lunch l = new Lunch("흐림");
		Dinner d = new Dinner("비");
		
		m.greeting();
		l.greeting();
		d.greeting();
	}
}

** 실습 1122_2 (오버라이딩 + 접근제어자) **

class Car3{
	private int door;
	private String gearType;
	private String color;
	
	Car3(String color){
		//setColor(color);
		//setGearType("auto");
		//setDoor(4);
		this(color, "auto", 4);		//this. 같은 클래스 내에있는 타입갯수와 종류에 맞는 생성자 불러옴
	}
	Car3(String color, String gearType){
		//setColor(color);
		//setGearType(gearType);
		//setDoor(4);
		this(color, gearType, 4);
	}
	Car3(String color, String gearType, int door){
		setColor(color);
		setGearType(gearType);
		setDoor(door);
	}
	
	
	public int getDoor() {
		return this.door;
	}
	public void setDoor(int door) {
		this.door = door;
	}
	
	public String getGearType() {
		return this.gearType;
	}
	public void setGearType(String gearType) {
		this.gearType = gearType;
	}
	
	public String getColor() {
		return this.color;
	}
	public void setColor(String color) {
		this.color = color;
	}

}


class SportsCar extends Car3{
	int speedLimit;			//제한속도

	SportsCar(String color){
		super(color);		
		//setColor(color);	//super(); 생략되어있어서 오류남
		this.speedLimit = 200;
	}
	
	SportsCar(String color, int speedLimit){
		super(color);		
		this.speedLimit = speedLimit;
	}
	
	SportsCar(String color, String gearType){
		super(color, gearType);		
		this.speedLimit = 200;
	}
	
	SportsCar(String color, String gearType, int speedLimit){
		super(color, gearType);		
		this.speedLimit = speedLimit;
	}
	
	SportsCar(String color, String gearType, int door, int speedLimit){
		super(color, gearType, door);
		this.speedLimit = speedLimit;
	}
	
	public String toString() {
		
		return "차량의 색은 "+ getColor() +"이고, " + getGearType() + "이며, 문의 개수는 "  + getDoor() + "개이며," + " 제한 속도는 " + speedLimit + " 입니다.";
	}
	
}

public class MySample1122_2 {

	public static void main(String[] args) {
		
		/*
		 실행결과)차량의 색은 red이고, auto이며, 문의 개수는 4개이며,
		 		 제한 속도는 330 입니다.
		 (단, 차량 색은 반드시 입력받고, 제한속도가 없을 경우 200, 기어타입이 없을 경우 auto로 정의함)
		 	  문 개수가 없을 경우 기본 4개로 정의함.
		 클래스와 변수는 세팅되있는것만 사용한다.
		 단 정수가 하나만들어온 경우 speedLimit으로 여긴다.
		 */
		
		SportsCar cs = new SportsCar("red", 330);
		
		System.out.println(cs.toString());		//.toString 생략되어있음
		
	}

}

다형성(polymorphism)

하나의 객체가 여러가지 타입을 가질 수 있는 것을 의미.

부모 클래스 타입의 참조 변수로 자식클래스 타입의 인스턴스를 참조 할 수 있도록 구현.

참조 변수의 다형성

class Parent{...}

class Chlid extends Parent{...}

...

Parent pa = new Parent(); // 허용

chlid ch = new Child(); // 허용

Parent pc = new Chlid(); // 허용

Child cp = new Parent(); // 오류 발생

//상속을 통해 확장된 수 있으나 축소될수는 없음. 자식클래스에서 사용할 수 있는 멤버(인스턴스변수, 인스턴스 메소드...)의 개수가 언제나 부모 클래스와 같거나 많게됨

instanceof : 연산자 / 참조변수가 참조하고 있는 인스턴스 실제 타입 확인

문법)참조변수 instanceof 클래스이름 -> true, false 리턴

다형성에서 어떠한 변수와 메소드를 사용할 것인가?

* 인스턴스 변수
// 부모에게 있고 자식에도 있으면 -> 부모꺼 실행
// 부모에게 있고 자식에게 없으면 -> 부모꺼 실행
// 부모에는 없고 자식에게 있으면 -> 오류2

* 메소드
// 부모에게 있고 자식에도 있으면 -> 자식꺼 실행 (메소드 오버라이딩)
// 부모에게 있고 자식에게 없으면 -> 부모꺼 실행
// 부모에는 없고 자식에게 있으면 -> 오류2

** 1122_3 예제 (다형성) **

class A{
	void methodA() {
		System.out.println("methodA()...");
	}
}

class B extends A{
	void methodB() {
		System.out.println("methodB()...");
	}
}

public class MySample1122_3 {

	public static void main(String[] args) {
		
		A obj = new B();
		obj.methodA();		//가능
//		obj.methodB();		//불가능
		
		B obj2 = new B();
		obj.methodA();		//가능
		obj2.methodB();		//가능
		
	}

}

** 예제 1122_4 (다형성) **

class Car4{
	String color;
	int door;
	
	void drive() {
		System.out.println("drive()...Car4");
	}
	
	void stop() {
		System.out.println("stop()...Car4");
	}
}

class FireEngine extends Car4{
	void water() {
		System.out.println("water()...FireEngine");
	}
}


public class MySample1122_4 {

	public static void main(String[] args) {
		
		// 다형성
		
		
//		Car4 c = null;
//		FireEngine f = new FireEngine();
//		FireEngine f2 = null;
//		
//		f.water();
//		c = f;			//다형성 => Car4 c = new FireEngine(); 과 같다.
//						//내부적으로 형변환이 발생했음.(up-casting)
//		
//		//c.water();		//불가능(부모형 참조변수로 자식객체를 바라볼수 있으나 자식객체에 메서드는 사용할 수 없음)
//		
//		f2 = (FireEngine)c;		//안되지만 (FireEngine)으로 강제 형변환해서 사용가능
//								//down-casting이므로 강제 형변환 꼭해야함.
//		f2.water();
		
		
		//불가능한예제
		
		Car4 c = new Car4();		//= new FireEngine();로 변경하면 1.싫애시에도오류안남
//		Car4 c = new FireEngine();
		Car4 c2 = null;
		FireEngine f = null;
		Car4 c3 = new FireEngine();
		
		c.drive();
		//f = (FireEngine)c;			//f = c; 는 불가능 하나 형변환을 통해서 가능
									//컴파일은 가능하나 시행시 오류 발생
		
		f.drive();					// 실행시오류 
		
		c2 = f;						//up-casting
		//c2.water();				//불가능 : c2 참조변수는 클래스 타입이 Sard4이고 water()a메서드는 			
		c2.drive();
		c2.stop();					// 		  FireEngine클래스의 메서드이기 떄문에 호출불가
		
	}

}

** 예제 1122_6 (다형성) **

class Animal3{
	void breath() {
		System.out.println("숨쉬기");
	}
	
	public String toString() {
		return "몰라";
	}
}

class Lion3 extends Animal3{
	public String toString() {
		return "사자";
	}
}

class Rabbit extends Animal3{
	public String toString() {
		return "토끼";
	}
}

class Monkey extends Animal3{
	public String toString() {
		return "원숭이";
	}
	public void printA() {
		System.out.println("printA()...");
	}
}

class ZooKeeper{
	
//	void feed(Lion3 lion) {
//		System.out.println(lion + "에게 먹이주기...");
//	}
//	
//	void feed(Rabbit rabbit) {
//		System.out.println(rabbit + "에게 먹이주기...");
//	}
//	
//	void feed(Monkey monkey) {
//		System.out.println(monkey + "에게 먹이주기...");
//	}
	
	void feed(Animal3 animal) {
		System.out.println(animal + "에게 먹이주기...");
	}
	
}


public class MySample1122_5 {

	public static void main(String[] args) {
		
		// 다형성
		
		ZooKeeper j = new ZooKeeper();
//		
//		Lion3 lion1 = new Lion3();
//		j.feed(lion1);
//		
//		Rabbit rabbit = new Rabbit();
//		j.feed(rabbit);
//		
//		Monkey monkey = new Monkey();
//		j.feed(monkey);
		
		Animal3 lion1 = new Lion3();	//객체생성은 Lion3, 바라보는관점은 Animal3 -> Animal3에 있는 것들을 사용할 수 있음
		j.feed(lion1);
		
		Animal3 rabbit = new Rabbit();
		j.feed(rabbit);
		
		Animal3 monkey = new Monkey();
		j.feed(monkey);
		
		j.feed(new Animal3());		// Animal3 animal = new Monkey(); //다시보기!!!!
		
		monkey.printA();			// 오류 : monkey참조변수는 Animal3클래스의 참조변수이므로
									//		 Monkey() 클래스에 있는 printA()메서드 접근 불가능
	}
}

** 예제 1122_6 (다형성_ 연산자 instanceof) **

class Parent3{
}

class Child3 extends Parent3{
}

class Brother extends Parent3{
}

public class MySample1122_6 {

	public static void main(String[] args) {
		
		// 다형성 (instanceof 연산자)
		
		Parent3 p = new Parent3();
		
		System.out.println(p instanceof Object);	// true
		System.out.println(p instanceof Parent3);	// true
		System.out.println(p instanceof Child3);	// false
		
		Parent3 p2 = new Child3();
		
		System.out.println(p2 instanceof Object);	// true
		System.out.println(p2 instanceof Parent3);	// true
		System.out.println(p2 instanceof Child3);	// true
		
		//부모에게 있고 자식에도 있으면 -> 자식꺼 실행
		//부모에게 있고 자식에게 없으면 -> 부모꺼 실행
		//부모에는 없고 자식에게 있으면 -> 오류

	}
}

'수업끄적끄적_7MONTH > Java' 카테고리의 다른 글

11/28 수업 (19회차) _ 인터페이스 (0)	2023.11.28
11/23 수업 (18회차) _ 다형성 예제 / Vector 클래스 / 추상 클래스 (1)	2023.11.23
11/21 수업 (16일차) _ 오버라이딩 / 접근 제어자 (3)	2023.11.21
11/17 수업 (15회차) _ 상속 (1)	2023.11.17
11/16 수업 (14회차) _ 메소드 오버로딩 / 생성자 (0)	2023.11.16

sist