[2022년 청년친화형 기업 ESG지원 사업 - 15]

일시 : 2022.09.24

시간 : 9:00 ~ 18:00

---

오전/오후 : Java

---

• 상속
  • 개념 
    • 기존 클래스의 변수(데이터)와 메소드(로직, 코드)를 상속받아 새로운 클래스를 구성하는 것
      • 기존 클래스 
        • 부모클래스
        • 수퍼클래스
      • 새로운 클래스 : 부모클래스를 상속을 받기 때문에 재사용 + 추가기능
        • 자식 클래스
        • 서브 클래스
  • 장점
    • 기존 클래스의 변수와 코드를 재사용
      • 코드의 중복 감소 => 클래스 간결화
    • 먼저 작성된 검증된 프로그램을 재사용
      • 신뢰성 있는 프로그램 손쉽게 개발
    • 클래스 간 계층적 분류 및 관리
      • 유지보수 용이
  • 특징
    • 다중상속을 지원하지 않음 => 하나의 수퍼 클래스만 가질 수 있음
    • 상속의 횟수에 제한을 두지 않음
    • 모든 클래스는 java.lang.Object를 상속받음
  • 구조
    • class 서브클래스 extends 수퍼클래스
• 오버라이딩(overriding)
  • 개념
    • 자식 클래스에서 부모 클래스와 동일한 메소드를 재정의 하는것
  • 조건
    • 메소드의 이름이 같아야 함
    • 메소드 매개변수의 개수와 데이터 타입이 같아야 함
    • 메소드의 리턴 타입이 같아야 함
• Casting(캐스팅)
  • 개념 
    • 기존 데이터 타입을 다른 데이터타입으로 변환하는 것
  • Primitive Type
    • 데이터 공간의 크기
  • Object Type
    • 객체 내 필드, 메소드의 접근 권한
      • Upcasting(업캐스팅)
        • 하위 클래스가 상위클래스 타입으로 자동 타입 변환하는 것(다형성)
        • 객체 내 모든 변수, 메소드에 접근할 수없고 상위클래스의 변수, 메소드에만 접근 가능
        • 단, 하위 클래스가 상위 클래스의 메소드를 오버라이딩한 경우 하위 클래스의 메소드를 호출
      • Downcasting
        • upcasting된 객체를 강제(명시적)타입 변환으로 다시 되돌리는 것
• 추상화
  • 개념
    • 클래스 간의 공통점을 찾아내서 공통의 조상을 만드는 작업
    • 상속 계층도를 따라 올라갈수록 클래스의 추상화는 더욱 심화됨
• 구체화
  • 개념
    • 상속을 통해 클래스를 구현, 확장하는 작업
• 추상메소드(abstract method)
  • 개념
    • 선언되어 있으나 구현되어 있지 않은 메소드
    • 추상메소드 선언
      • abstract 키워드로 선언
      • ex) public abstract int getValue();
    • 추상 메소드는 서브 클래스에서 오버라이딩하여 구현
• 추상 클래스(abstract class)
  • 개념
    • 추상 메소드를 하나라도 가진 클래스
      • 클래스 앞에 반드시 abstract라고 선언해야함
  • 특성
    • 추상 클래스의 객체는 생성 할 수 없음
    • 추상 클래스 필요성
      • 상속관계에서 서브클래스가 반드시 구현해야함을 알릴 때(강제성)
      • 설계와 구현 분리
        • 슈퍼클래스에서 개념적 특징 정의
        • 서브 클래스에서 구현 

실습 예제1

package ex01;

public class PhoneTest {

	public static void main(String[] args) {
		Telephone tp = new Telephone();
		tp.call();
		tp.answerCall();
		
		SmartPhone sp = new SmartPhone();
		sp.call();
		sp.answerCall();
		sp.PlayMusic();
		sp.Internet();
	}
	
	

}

package ex01;

public class SmartPhone extends Telephone{
	public void PlayMusic() {
		System.out.println("음악 재생하기");
	}
	
	public void Internet() {
		System.out.println("인터넷 하기");
	}
}

package ex01;

public class Telephone {
	public void call() {
		System.out.println("전화걸기");
	}
	
	public void answerCall() {
		System.out.println("전화받기");
	}
}

---

실습예제2

package ex02;

public class Animal {
	String name;
	
	public void eat() {
		System.out.println("먹다.");
	}
	
	public void move() {
		System.out.println("걷다.");
	}
}

package ex02;

public class Cat extends Animal{

	@Override
	public void eat() {
		System.out.println("야금야금 먹다.");
	}
	
}

package ex02;

public class Dog extends Animal {
	
	// 재정의
	public void eat() {
		System.out.println("와구와구 먹기");
	}
	@Override 
	public void move() {
		System.out.println("총총총총 달리기");
	}
	
	// 추가 메소드 정의 
	public void run() {
		System.out.println("꼬리를 흔들며 달려옴");
	}
}

package ex02;

public class Main {

	public static void main(String[] args) {
//		Animal ani = new Animal();
//		ani.name = "코코";
//		ani.eat();
//		ani.move();
//		System.out.println(ani.name);
//		
//		Dog d = new Dog();
//		d.name = "멍멍이";
//		d.eat();	// 오버라이딩 된 메소드 호출
//		d.move();	// 오버라이딩 된 메소드 호출
//		d.run();
//		
//		Cat c = new Cat();
//		c.eat();
		
		// Upcasting
		// 하위 클래스가 상위 클래스의 타입으로 자동 타입 변환 하는 것(다형성)
		// A가 B의 부모클래스일 경우 아래 코드 성립
		// A a = new B();
		
		Animal dog = new Dog();
		
		// 부모 클래스의 변수, 메소드에만 접근 가능
		dog.name = "멍멍이";
		dog.move();
		// 단, 자식 클래스가 부모클래스의 메소드를 오버라이딩한 경우
		// 자식 클래스의 메소드가 호출
		dog.eat();
//		dog.run();
		
		// downcasting
		// upcasting된 객체를 강제(명시적)타입 변환으로 다시 되돌리는 것
		
		Dog d1 = (Dog)dog;
		System.out.println(d1.name);
		d1.run();
		
		Animal cat = new Cat();
		
		int num =1;
		Animal ani;
		if(num==1) {
			ani = new Dog();
		}
		else {
			ani=new Cat();
		}
		ani.eat();
		
	}

}

---

실습예제 3

 

package ex03;

public abstract class WildAnimal {
	
	public abstract void hunt();	//추상클래스
	public void eat() {
		System.out.println("사냥한 먹이를 먹다.");
	}
//	public void hunt() {
//		System.out.println("사냥하다.");
//	}

}

package ex03;

public class Lion extends WildAnimal{

	@Override
	public void hunt() {
		System.out.println("단독사냥");
	}
	
}

package ex03;

public class Eagle extends WildAnimal {

	@Override
	public void hunt() {
		System.out.println("날아서 사냥");
	}

}

package ex03;

public class Wolf extends WildAnimal {

	@Override
	public void hunt() {
		System.out.println("무리 사냥");
	}
	
}

package ex03;

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		// 각각의 동물의 사냥 방법 출력하기
		Scanner sc = new Scanner(System.in);
		WildAnimal wa = null;

		System.out.print("[1] 사자 [2]독수리 [3]늑대 >> ");
		int choice = sc.nextInt();

//		if (choice == 1) {
//			wa = new Lion();
//			wa.hunt();
//		} else if (choice == 2) {
//			wa = new Eagle();
//			wa.hunt();
//		} else if (choice == 3) {
//			wa = new Wolf();
//			wa.hunt();
//		}
		
		WildAnimal[] ani = new WildAnimal[3];
		ani[0] = new Lion();
		ani[1] = new Eagle();
		ani[2] = new Wolf();
		ani[choice-1].hunt();
		ani[choice-1].hunt();
	}

}

---

실습예제4

package ex04;

import java.util.Scanner;

public class VendingMachine  {
	
	private Scanner sc;
	// 필드 구성
	private int money;
	private int itemMoney;
	private Language lang;

	public VendingMachine(Language l){					//Scanner 객체 생성
	      sc = new Scanner(System.in);
	      lang = l;
	   }

	public void showTitle() {					//타이틀 출력
		System.out.println(lang.getTitle());
	}

	public void inputMoney() {					//돈 입력하고 money에 저장
		System.out.print(lang.getInputMoneyMsg());
		money = sc.nextInt();
	}

	public void choiceMenu() {					//메뉴 선택, choice에 따라 가격 
		System.out.println(lang.getChoiceMenuTitleMsg());
		System.out.print(lang.getChoiceMenuMsg());
		int choice = sc.nextInt();
		if (choice == 1) {
			itemMoney = 700;
		} else if (choice == 2) {
			itemMoney = 1000;
		} else if (choice == 3) {
			itemMoney = 500;
		}
	}

	public void changeMoney() {					// 잔돈 계산
		if (money - itemMoney < 0) {
			System.out.println(lang.getNoMoneyMsg());
		} else {
			money -= itemMoney;
			System.out.println(money + lang.getChangeMoney());
		}
	}
}

package ex04;

public abstract class Language {
	// 자판기 객체와 호환이 되기위해 규약을 정의
	
	public abstract String getTitle();
	public abstract String getInputMoneyMsg();
	public abstract String getChoiceMenuTitleMsg();
	public abstract String getChoiceMenuMsg();
	public abstract String getNoMoneyMsg();
	public abstract String getChangeMoney();
}

package ex04;

public class English extends Language {

	@Override
	public String getTitle() {
		return "=== Vending Program===";
	}

	@Override
	public String getInputMoneyMsg() {
		return "Insert Money >> ";
	}

	@Override
	public String getChoiceMenuTitleMsg() {
		return "Menu Choice";
	}

	@Override
	public String getChoiceMenuMsg() {
		return "1.water(700) 2.coke(1000) 3.coffee(500) ";
	}

	@Override
	public String getNoMoneyMsg() {
		return "No money";
	}

	@Override
	public String getChangeMoney() {
		return "won left";
	}

}

package ex04;

public class Korea extends Language{

	@Override
	public String getTitle() {
		return "=== 자판기 프로그램===";
	}

	@Override
	public String getInputMoneyMsg() {
		return "돈을 넣으세요. >> ";
	}

	@Override
	public String getChoiceMenuTitleMsg() {
		return "메뉴를 선택하세요.";
	}

	@Override
	public String getChoiceMenuMsg() {
		return "1.물(700) 2.콜라(1000) 3.커피(500) >> ";
	}

	@Override
	public String getNoMoneyMsg() {
		return "돈이 부족합니다.";
	}

	@Override
	public String getChangeMoney() {
		return "원이 남았습니다.";
	}

}

---

점심시간

---

복습 예제1

package 오후;

public abstract class Animal {	// 추상클래스
	//접근제한자 : public
	//타입 : String
	//변수명 kind로 필드 작성
	
	public String kind;
	
	//breathe() 라는 메소드 작성
	//접근제한자 : public 리턴 타입 : void
	//실행문장 : "야! 숨셔 숨"
	
	public void breathe() {
		System.out.println("야! 숨셔 숨");
	}
	
	//추상 메소드도 만들어주세요.
	//메소드 이름 : sound
	//리턴 타입 : void 
	public abstract void sound();
		
}

package 오후;

public class AnimalMain {

	public static void main(String[] args) {

		// Dog 생성자 호출
		Dog dog = new Dog();

		// Cat 생성자
		Cat cat = new Cat();

		dog.sound();
		cat.sound();

		Animal animal = null;

		animal = new Dog(); // 자동으로 타입 변환
		animal.sound(); // Dog에 구현된 sound() 메소드 실행

		animal = new Cat(); // 자동으로 타입 변환
		animal.sound(); // Cat에 구현된 sound() 메소드 실행

		animalSound(new Dog());	//매개변수도 자동으로 타입변환 O
		animalSound(new Cat());	//매개변수도 자동으로 타입변환 O
		
		//sound() 추상메소드는 Cat,Dog 클래스에 맞게끔 구현
		// 그런데 여기에서 재정의(오버라이딩) 하게 된다면, 다형성 발생
		// 다형성 : 상위 클래스가 동일한 메시지로 하위 클래스들을 서로 다르게 동작.
		// 규격에 맞게끔 필드명/메소드명 통일

	}

	private static void animalSound(Animal animal) {
		animal.sound();
	}

}

package 오후;

public class Dog extends Animal{
	// 상위 클래스인 Animal로부터 상속 받도록 키워드를 작성해주세요.
	
	//Dog 생성자 만드는데 kind는 포유류로
	public Dog() {
		this.kind = "포유류";
	}
	
	
	@Override
	public void sound() {
		System.out.println("왈왈");
	}
}

package 오후;

public class Cat extends Animal {
	//상위 클래스인 Animal로 부터 상속받도록 키워드를 작성


	//Cat생성자
	//kind - 포유류
	
	public Cat() {
		this.kind = "포유류";
	}
	
	//sound 메소드 재정의, 야옹이라고 실행문장 만들기
	@Override
	public void sound() {
		System.out.println("야옹");
	}

}

---

복습예제2

package 오후;

public abstract class Car {
	// 추상클래스 : abstract 키워드 사용
	// 추상클래스의 특징 : 반드시 하나 이상의 추상메소드를 포함
	
	public abstract void runner();	//구현부 x
	
	int tire = 4;
	String color;
	
	public int getTire() {
		return tire;
	}
}

package 오후;

public class CarMain {

	public static void main(String[] args) {
		
		// 추상화 : 여러 객체에서 공통적으로 사용되는 기능(필드, 메소드)등을 뽑아내는 것
		Porche po = new Porche();
		Sonta so = new Sonta();
		
		po.runner();
		po.wet();
		po.color = "파랑";
		
		System.out.println(po.getTire());
		
		so.runner();
		so.pilot();
		
//		Car c = new Car();	//생성차 호출, 추상클래스는 객체화X
		
		// 왜 추상화를 사용할까?
		// 상속을 통해서 무언가 기능 구체화 --> 추상화 사용
	}

}

package 오후;

public class Porche extends Car{
	
	// 일반 클래스에서 부모클래스를 물려받았을때(상속받았을때)
	// 부모의 기능을 사용하거나 / 사용하지 않거나 결정할수가 있음
	
	// 물려받는 추상메소드에 대해서
	// 메소드니까 구체적인 기능 구현
	// 추상클래스를 물려받는 경우에는
	// 부모로부터 지정되어있는 메소드를 반드시 오버라이딩 해줘야함
	
	@Override
	public void runner() {
		System.out.println("코너링이 좋아요");
	}
	public void wet() {
		System.out.println("도로가 안젖었어요");
	}

}

package 오후;

public class Sonta extends Car {

	// 부모클래스 자식 클래스 상속받을때
	// 오버라이딩을 해줘야함

	@Override
	public void runner() {
		System.out.println("기어 잘 돌아감");
	}

	public void pilot() {
		System.out.println("자율주행");
	}

}

---

• Interface(인터페이스)
  • 개념 
    • 클래스들이 구현해야하는 공통되는 기능들을 미리 지정
    • 작업명세서 or 프로젝트 설계도
    • 기능만 정의함으로써 구현 객체의 같은 동작 보장[구현강제]
  • 특징
    • 1. 상수 : 변하지 않은 수
      • 구조 :  final 변수타입 변수명 = 값;
      • 인터페이스에서 값을 정해줄테니까 함부로 바꾸지 말고 이 값만 참조해라 
    • 2. 추상 메소드
      • 구조 : 타입 메소드명(매개변수);
      • 가이드를 해줄테니 추상메소드를 재정의(오버라이딩)해서 구현을 다시해라
    • 3. 디폴트 메소드
      • 구조 :default 타입 메소드명(매개변수){  }
      • 인터페이스에서 기본적으로 제공해줌. 만약에 사용자가 맘에 안들면 알아서 구현
    • 4. 정적(static) 메소드
      • 구조 : static 타입 메소드명(매개변수){  }
      • 인터페이스에서 제공해주는것으로 무조건 사용

---

package 오후;

public interface practice {
	// 인터페이스 = 작업 명세서
	
	// 인터페이스의 특징 : 딱 4가지만 정의하거나 구현
	
//	 1. 상수 : 변하지 않은 수
//	 final 변수타입 변수명 = 값;
//	 인터페이스에서 값을 정해줄테니까 함부로 바꾸지 말고 이 값만 참조해라
//	
//	 2. 추상 메소드
//	 타입 메소드명(매개변수);
//	 가이드를 해줄테니 추상메소드를 재정의(오버라이딩)해서 구현을 다시해라
//	
//	 3. 디폴트 메소드
//	 default 타입 메소드명(매개변수){
//	 }
//	 인터페이스에서 기본적으로 제공해줌. 만약에 사용자가 맘에 안들면 알아서 구현
//	
//	 4. 정적(static) 메소드
//	 static 타입 메소드명(매개변수){
//	 }
//	 인터페이스에서 제공해주는것으로 무조건 사용
	
	
	
}

package 오후;

public class Main {

	public static void main(String[] args) {
		
		Archor a = new Archor();
		a.attack();
		a.run();
		
		System.out.println();
		
		Warrior w = new Warrior();
		System.out.println("이 녀석의 캐릭터 서버 : " + w.server);
		w.attack();
		w.run();
		w.skin();
	}

}

package 오후;

public interface Skill {
	// Interface는 클래스 x
	// new 키워드를 사용해서 객체를 생성할 수 없음
	// 인터페이스 안에 변수 선언 : 상수로 지정
	// final 키워드를 생략할 수 있음
	
	public final String server = "스카니아";
	public void attack();
	
	//abstract 키워드가 생략되어도 자동으로 추상메소드로 인지
	
	// 추상화 - 인터페이스(공통점)
	// 1. 구현부가 없다. 단, 선언부는 존재
	// 2. new라는 키워드를 사용해서 객체를 생성 X
	// 3. 상속을 받았거나, 구현이 다 된 자식클래스 한해서 객체 생성
	
	
	// 추상화 - 인터페이스(차이점)
	// 1. 추상클래스 : 동일한 부모클래스를 가진 클래스를 묶어서 상속 받고 기능 확장
	// 2. 인터페이스 : 구현된 객체가 같은 동작을 한다는 것을 보완해주기 위한 목적
	// 3. 추상클래스 - "단일 상속" 가능, 인터페이스 = "다중 구현" 가능
	
	public abstract void run();
		
	
	
}

package 오후;

public interface Skin {
	public abstract void skin();
}

package 오후;

public class Archor implements Skill {
	
	@Override
	public void attack() {
		System.out.println("폭풍의 시");
	}

	@Override
	public void run() {
		System.out.println("화살 쏘고 달리기");
	}
	
	// 상속을 물려 받았을 때 : extends
	// 인터페이스를 물려 받고자(구현) 할 때 : implements
}

package 오후;

public class Warrior implements Skill, Skin {
	public void attack() {
		System.out.println("검 휘두르기");
	}

	public void run() {
		System.out.println("뛰어");
	}

	@Override
	public void skin() {
		System.out.println("피부가 어두움");
	}
}