32일차 java 연산(2023-02-07)

[Eclipse 연습]

[계산]
public class Test44 {
	public static void main(String[] args) {
		int[][] arr = { { 11 }, { 22, 33 }, { 44, 55, 66 } };
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr[i].length; j++) {
				System.out.print(arr[i][j] + "\t");
			}
			System.out.println("");
		}
	}
}

[결과값]
11	
22	33	
44	55	66

---

[계산]
//[1번] 다음 main() 메소드와 실행 결과를 참고하여 
//			TV를 상속받은 ColorTV 클래스를 작성하라.
//			32인치 1024컬러
class TV1 {
	private int size;
	public TV1(int size) {
		this.size = size;
	}

	protected int getSize() {
		return size;
	}
}

class ColorTV1 extends TV1 {
	private int color;

	public ColorTV1(int size, int color) {
		super(size);
		this.color = color;
	}

	public void printProperty() {
		System.out.println(super.getSize() + "인치 " + this.color + "컬러");
	}
}

public class Test44 {
	public static void main(String[] args) {
		ColorTV1 myTV = new ColorTV1(32, 1024);
		myTV.printProperty();
	}
}

[결과값]
32인치 1024컬러

---

[계산]
class Circle11 {
	double r;

	public Circle11(double r) {
		this.r = r;
	}

	public double getArea() {
		return this.r * this.r * Math.PI;
	}

	public static double getArrArea(Circle11[] c) {
		double input = 0;
		for (int i = 0; i < c.length; i++) {
			input += c[i].getArea();
		}
		return input;
	}
}

public class Test44 {
	public static void main(String[] args) {
		Circle11[] circleArr = new Circle11[2];
		circleArr[0] = new Circle11(10);
		circleArr[1] = new Circle11(10);

		double areas = Circle11.getArrArea(circleArr);
		System.out.println(areas); // 628.2345234523
	}
}

[결과값]
628.3185307179587

---

[참조변수의 참조 가능성:배열 기반]

부모=자식
Cake cake = new CheeseCake(); 가능
CheeseCake[] cakes = new CheesCakip10] 가능
Cake[] cakes = new CheeseCaki[10] 가능

---

[메소드 오버라이딩1]

메소드 오버라이딩 : 상속 관계에 있는 부모 클래스에서
                 이미 정의된 메소드를 자식 클래스에서 다시 정의하는 것(덮어쓴다)

함수 오버라이딩 조건 : 함수오버라이딩은 자식꺼

하기 조건을 충족 시 함수 오버라이딩이 된다.
1.상속 관계에서(부모자식관계)
2.데이터타입, 함수명, 파라미터까지 동일
3.{}바디 안의 내용만 다르게 한다.

=자식의 함수가 부모의 함수를 덮어쓴다.

[계산]
class Cake {
	public void yummy() {
		System.out.println("Yummy Cake");
	}
}

class CheeseCake extends Cake {
	public void yummy() {
		System.out.println("Yummy Cheese Cake");
	}
}

//오버라이딩 관계
//CheeseCake의 yummy 메소드가
//Cake의 yummy 메소드를 오버라이딩!
public class MathodOverRiding {
	public static void main(String[] args) {
		Cake c1 = new CheeseCake();
		CheeseCake c2 = new CheeseCake();

		c1.yummy();
		c2.yummy();
	}
}

[결과값]
Yummy Cheese Cake
Yummy Cheese Cake

---

[오버라이딩 된 메소드 호출하는 방법]

[계산]
// 오버라이딩 된 메소드를 인스턴스 외부에서 호출하는 방법은 없다.
// 그러나 인스턴스 내부에서는 키워드 super를 이용해 호출 가능
class Cake1 {
	public void yummy() {
		System.out.println("Yummy Cake");
	}
}

class CheeseCake1 extends Cake {
	public void yummy() {
		super.yummy();
		System.out.println("Yummy Cheese Cake");
	}

	public void tasty() {
		super.yummy();
		System.out.println("Yummy Tasty Cake");
	}
}

//오버라이딩 관계
//CheeseCake의 yummy 메소드가
//Cake의 yummy 메소드를 오버라이딩!
public class MathodOverRiding2 {
	public static void main(String[] args) {
		CheeseCake1 c1 = new CheeseCake1();
		c1.yummy();
	}
}

[결과값]
Yummy Cake
Yummy Cheese Cake

---

[계산]
class Shape {
	public double getArea() {
		return 0;
	}
}

class Circle1 extends Shape {
	private double radius;

	public Circle1(double radius) {
		this.radius = radius;
	}

	@Override
	public double getArea() {
		return this.radius * this.radius * Math.PI;
	}
}

class Rectangle1 extends Shape {
	private double width, height;

	public Rectangle1(double width, double height) {
		this.width = width;
		this.height = height;
	}

	@Override
	public double getArea() {
		return this.width * this.height;
	}
}

class Triangle1 extends Shape {
	private double width, height;

	public Triangle1(double width, double height) {
		this.width = width;
		this.height = height;
	}

	@Override
	public double getArea() {
		return (this.width * this.height) / 2;
	}
}

public class InstanceOf {
	public static void main(String[] args) {
		// 변수 선언
		Shape[] shapeArr = { new Circle1(10), new Rectangle1(10, 20), new Triangle1(10, 20) };

		// 로직
		double sum = 0;
		for (Shape shape : shapeArr) {
			sum += shape.getArea(); // 함수 오버라이딩 | 부모것을 덮어쓰니까
		}
		System.out.println("총 면적은: " + sum); // 총 면적은: 614.1592653589794
		shapeAllArea(shapeArr); // 총 면적은: 614.1592653589794
	}

	public static void shapeAllArea(Shape[] shapeArr) {
		double sum = 0;
		for (Shape shape : shapeArr) {
			sum += shape.getArea();
		}
		System.out.println("총 면적은: " + sum);
	}
}
// ========================================================
//		Circle1 circle1 = new Circle1(10);
//		System.out.println(circle1.getArea()); // 오버라이딩과 상관 없이 Circle1의 함수를 호출한 것이다.

//		Shape shape = new Circle1(10);
//		System.out.println(shape.getArea()); // 오버라이딩 되어 값이 0이 아닌 Circle1의 getArea()값이 호출된다.

//		Rectangle1 rectangle = new Rectangle1(10, 20);
//		System.out.println(rectangle.getArea());// 오버라이딩과 상관 없이 Rectangle1의 함수를 호출한 것이다.
//
//		double area = circle1.getArea() + rectangle.getArea();
//		System.out.println("총 면적의 합" + area);

[결과값]
총 면적은: 614.1592653589794
총 면적은: 614.1592653589794

---