33일차 java 연산(2023-02-08)

[Eclipse 연습]

[계산]
class Fruit1 {
	public void print() {
		System.out.print("나는 ");
	}
}

class Grape1 extends Fruit1 {
	@Override
	public void print() {
		super.print();
		System.out.println("포도이다.");
	}
}

class Apple1 extends Fruit1 {
	@Override
	public void print() {
		super.print();
		System.out.println("사과이다.");
	}
}

class Pear1 extends Fruit1 {
	@Override
	public void print() {
		super.print();
		System.out.println("배이다.");
	}
}

public class Test47 {
	public static void main(String[] args) {
		Fruit1 fAry[] = { new Grape1(), new Apple1(), new Pear1() };
		for (Fruit1 f : fAry) {
			f.print();
		}
	}
}

[결과값]
나는 포도이다.
나는 사과이다.
나는 배이다.

---

[계산]
//4 x 4의 2차원 배열을 만들고 이곳에 1에서 10까지 범위의 정수를 
//랜덤하게 생성하여 정수 16개를 배열에 저장하고, 2차원 배열을 화면에 출력하라.
public class Test47 {
	public static void main(String[] args) {
		int[][] twoArr = new int[4][4];
		for (int i = 0; i < twoArr.length; i++) {
			for (int j = 0; j < twoArr[i].length; j++) {
				twoArr[i][j] = (int) (Math.random() * 10) + 1;
			}
		}
		for (int i = 0; i < twoArr.length; i++) {
			for (int j = 0; j < twoArr[i].length; j++) {
				System.out.print(twoArr[i][j] + "\t");
			}
			System.out.println("");
		}
	}
}

[결과값]
5	1	2	3	
2	9	4	5	
3	4	9	2	
6	6	3	5

---

[계산]
public class Test47 {
	public static void main(String[] args) {
		int[][] twoArr = new int[4][4];
		for (int i = 0; i < twoArr.length; i++) {
			for (int j = 0; j < twoArr[i].length; j++) {
				twoArr[i][j] = (int) (Math.random() * 10) + 1;
			}
		}
		for (int[] arr : twoArr) { // new int[4]행에 해당함.
			for (int num : arr) { // new int[][4]열에 해당함.
				System.out.print(num + "\t");
			}
			System.out.println();
		}
	}
}

[결과값]
1	2	8	4	
2	8	10	7	
6	3	8	7	
6	4	4	1

---

[자동형변환/명시적형변환]

자동 형변환 : 부모=자식일 때 자동 형변환 됨.

⇒A3 aa = new B3();
// (A3) new B3(); 앞에 A3가 생략된 것.

(강제)명시적 형변환 : 자식=부모일 때 강제 형변환 함.

⇒자식 = 부모가 될 수 있는 조건
aa가 B3로 객체 생성이 되어 있어야 함. ⇒ A3 aa = new B3();

[계산]
class A3 {
}
class B3 extends A3 {
}
public class PolymorphismCasting {
	public static void main(String[] args) {
		int a = 10;
		double d = a; // 자동형변환
		a = (int) d; // 강제형변환, 명시적 형변환

		B3 bb;
		A3 aa = new B3(); // (A3) new B3(); 컴파일러가 자동으로 형변환하여 앞에 A3가 생략된 것.
		bb = aa; // 자식 = 부모 에러!
		bb = (B3) aa; // 강제 형변환 시 | 자식 = 부모 가능
		// 자식 = 부모가 될 수 있는 조건
		// aa가 B3로 객체 생성이 되어 있어야 함. | A3 aa = new B3();

		aa = bb; // 부모 = 자식 가능
	}
}

---

[instanceof 연산자]

레퍼런스 변수(객체) instanceof 클래스명
형변환 가능하면 true 아니면 false를 리턴한다.
box의 주소를 찾아가서 PaperBox가 메모리에 올라와 있는지 찾는 것.

[계산]
class Box2 {
	public void simpleWrap() {
		System.out.println("Simple Wrapping");
	}
}

class PaperBox extends Box2 {
	public void paperWrap() {
		System.out.println("Paper Wrapping");
	}
}

class GoldPaperBox extends PaperBox {
	public void goldWrap() {
		System.out.println("Gold Wrapping");
	}
}

public class InstanceOf {
	public static void main(String[] args) {
		Box2 box1 = new Box2();
		PaperBox box2 = new PaperBox();
		GoldPaperBox box3 = new GoldPaperBox();

		wrapBox(box1);
		wrapBox(box2);
		wrapBox(box3);
	}

	// box의 주소를 찾아가서 PaperBox가 메모리에 올라와 있는지 찾는 것.
	// 올라와 있다면 true | 없다면 false
	public static void wrapBox(Box2 box) { // Box2 box는 부모 polymorphism 적용을 하지 않으면 데이터 타입별로 적어야 함.
		if (box instanceof GoldPaperBox) { // 부모 box(box1|box2|box3대입) = GoldPaperBox로 형변환 되나?
			((GoldPaperBox) box).goldWrap();
		} else if (box instanceof PaperBox) { // 부모 box = box2 | PaperBox로 형변환 되나?
			((PaperBox) box).paperWrap(); // box의 타입을 (PaperBox)로 형변환 후 .paperWrap(); 함수를 호출
			///////////////////////////////////////////////
			// ((PaperBox) box).paperWrap();하기는 해당 내용과 같은 의미
			// PaperBox p = (PaperBox)box;
			// p.paperWrap();
			///////////////////////////////////////////////
		} else {
			box.simpleWrap();
		}
	}
}

[결과값]
Simple Wrapping
Paper Wrapping
Gold Wrapping

---

[상속의 목적]

[계산]
class Friend {
	protected String name; // protected 패키지와 상관 없이 상속하는 것은 직접 값을 받아올 수 있다.
	protected String phone;

	public Friend(String name, String phone) {
		this.name = name;
		this.phone = phone;
	}

	public void showInfo() {
		System.out.println("이름: " + this.name);
		System.out.println("전화: " + this.phone);
	}
}

class UnivFriend extends Friend { // 대학 동창
	private String major; // 전공

	public UnivFriend(String name, String major, String phone) {
		super(name, phone);
		this.major = major;
	}

	@Override
	public void showInfo() {
		super.showInfo();
		System.out.println("전공: " + this.major);
	}
}

class CompFriend extends Friend { // 직장 동료
	private String department; // 부서

	public CompFriend(String name, String department, String phone) {
		super(name, phone);
		this.department = department;
	}

	@Override
	public void showInfo() {
		super.showInfo();
		System.out.println("부서: " + this.department);
	}
}

//대학 동창 : 이름, 전공, 전화번호 정보 저장 및 관리
//직장 동료 : 이름, 부서, 전화번호 정보 저장 및 관리
public class Test48 {
	public static void main(String[] args) {
		Friend[] frns = new Friend[10];
		int cnt = 0; // 인덱스

		frns[cnt++] = new UnivFriend("LEE", "Computer", "010-333-555");
		frns[cnt++] = new UnivFriend("SEO", "Electronics", "010-222-444");
		frns[cnt++] = new CompFriend("YOON", "R&D 1", "02-123-999");
		frns[cnt++] = new CompFriend("PARK", "R&D 2", "02-321-777");
		// 모든 동창 및 동료의 정보 전체 출력
		for (int i = 0; i < cnt; i++) {
			frns[i].showInfo();// 오버라이딩 한 메소드가 호출된다.
			System.out.println();
		} // 이러한 클래스 디자인 기반에서 관리 대상이 넷, 다섯으로 늘어난다면?
			// 인스턴스 관리와 관련해서 코드가 복잡해지지 않는다.
	}
}

[결과값]
이름: LEE
전화: 010-333-555
전공: Computer

이름: SEO
전화: 010-222-444
전공: Electronics

이름: YOON
전화: 02-123-999
부서: R&D 1

이름: PARK
전화: 02-321-777
부서: R&D 2

---

[Object 클래스]

모든 클래스는 Object 클래스를 상속한다.
class C extends Object {} ⇒ 컴파일러가 자동으로 입력해준다.

12개의 함수가 정의되어 있다.
5개는 스레드 관련

그 중 응용(활용)하는 것은 3가지
・hashCode
・equals
・toString