기록
day 0520 상속_메소드 오버라이딩_객체의 배열 본문
클래스 변수
: 일반적으로 클래스의 멤버변수들을
객체를 생성해야지만 메모리가 확보되고 반드시 객체를 통해서 사용할 수 있는데
만약에 객체와 무관하게 사용할 메모리 공간이 필요하거나 또 모든 객체가 공동으로
사용할 메모리 공간이 필요하다면 멤버변수명 앞에 static 키워드를 붙여서
클래스 변수로 만들어서 사용합니다.
객체없이 접근하여야 하기 때문에 클래스 이름으로 접근합니다
클래스 메소드
: 일반적으로 멤버메소드들은 반드시 객체를 생성하고 그 객체를 통해서 사용할 수 있어요.
그런데 만약, 객체와 무관하게 동작시키고자 하는 기능이 있다면
메소드 이름 앞에 static 키워드를 붙여서 클래스 메소드로 만들어서 사용합니다
객체없이도 접근해야 하기 때문에 클래스 이름으로 접근합니다
클래스변수와 클래스메소드는 객체 없이 클래스이름으로 접근 할 수 있고
만약에 객체가 있다면 객체를 통해서도 접근할 수 있어요.
클래스 메소드 에서는 반드시 클래스 맴버에만 접근할 수 있어요
객체를 생성해야만 사용할 수 있는 일반 맴버에는 접근할 수 없어요
** 생성자 중복(Constructor Overloading)
생성자는 클래스 이름과 같은 이름의 특수한 메소드를 말하며 객체생성시에 자동수행되어
멤버변수들을 초기화 할 목적으로 사용하는데 이러한 생성자를 여러개 중복하여 만들 수 있어요
중복하기 위해서는 매개변수의 개수가 다르거나 자료형이 달라야합니다
** 메소드 중복(Method Overloading)
같은 이름의 메소드를 중복하여 정의하는 것을 말하며
매개변수의 개수가 다르거나 자료형이 달라야 합니다
package com.kosta.exam;
public class MyUtil {
// 두개의 정수를 매개변수로 전달받아 그 중에 큰 수를 찾아서 반환하는 메소드 정의
public int getMax(int a, int b){
int max;
if(a > b) {
max = a;
}else {
max = b;
}
return max;
/*
if(b > a){
a = b;
}
return a;
*/
}
// 두개의 실수를 매개변수로 전달받아..
public double getMax(double a, double b) {
if(b > a) {
a = b;
}
return a;
}
// 실수형 배열을 매개변수로 전달받아 그 중에 가장 큰 수를 찾아서 반환하는 메소드 정의
public double getMax(double[] arr) {
double max = arr[0];
for(int i = 1; i < arr.length; i++) {
if(arr[i] > max) {
max = arr[i];
}
}
return max;
}
}package com.kosta.exam;
// MyUtil의 3개의 getMax를 각각 호출하는 실험을 해 보세요.
public class MyUtilTest {
public static void main(String[] args) {
MyUtil m = new MyUtil();
// int는 double에 포함되기 때문에 double 매개변수로 갖는 메소드가 동작한다
System.out.println(m.getMax(1, 2));
System.out.println(m.getMax(1.1, 1.2));
double[] data1 = {1.1, 1.2, 1.3};
System.out.println(m.getMax(data1));
// int형으로 getMax에 전달해보기 : error
// 기본자료형 변수 double은 int를 포함하지만 배열은 오류가 발생한다
int[] data2 = {1, 2, 3};
// System.out.println(m.getMax(data2));
}
}
객체지향 프로그래밍의 특징
1) 은닉성(Encapsulation)
외부로부터 데이터(멤버변수)를 보호하는 것
접근명시자 : private, public, protected, default
default 접근명시자(접근명시자를 생략한 상태, 동일한 패키지에 있는 접근명시자를 허용)
다른 패키지에 있을경우 :
접근명시자를 생략하면 default 접근명시자로써 동일한 패키지에 있는 클래스에게만 접근을 허용합니다
아무리 상속받은 자식이라도 동일한 패키지에 있지 않으면 접근 할 수 없어요
상속받은 자식클래스에게 접근을 허용하려면 protected에 두어야 합니다
2) 상속성(Inheritance)
이미 정의되어있는 클래스를 확장하여(상속하여) 새로운 클래스를 만들 수 있어요
코드의 재사용성을 높일 수 있어요
==> 상속을 해 준 클래스 "부모클래스", "상위클래스"
==> 상속을 받은 클래스 "자식클래스", "하위클래스"
class 부모클래스 {
}
// 확장하겠습니다~
class 자식클래스 extends 부모클래스 {
부모 : 동물
자식 : 개, 소, 양, 쥐
--------------------
동물은 쥐이다 x
쥐는 동물이다 o
}
이렇게 함으로써 자식클래스는 부모클래스의 모든 속성과 동작을 물려받게 됩니다
부모클래스의 코드양이 몇백줄이 된다고 할 때에 extends 부모클래스 하는 순간
자식클래스에서 그 코드를 모두 작성한것과 같다
==> 상속을 함으로 해서 코드의 재사용성을 높일 수 있어요
또, 우리 현실에서
"동물"이라는 단어보다는 "개, 소, 양, 쥐.." 라는 단어를 먼저 사용했을겁니다
공통으로 가지는 속성과 동작을 뽑아서 일반화하여 "동물"이라고 하자 했을 겁니다
이와 같이 우리가 미래에 만들어질 클래스들의
공통적인 속성과 동작을 뽑아서 "일반화(부모클래스)" 하는것도 "상속"이라고 할 수 있습니다
그리고 "쥐"는 "동물"이다, "뱀"은 "동물"이다 라고 표현할 수 있듯이
상속관계는 is a 관계에 있다고 합니다
즉, 자식클래스의 자료형은 부모클래스의 자료형에 포함될 수 있고
그 반대는 될 수 없습니다
package com.kosta.exam;
class A{
String title;
int year;
}
// B는 A의 모든것을 물려받는다
class B extends A{
String data;
// 메소드 추가
public void info() {
System.out.println(title + ", " + year + ", " + data);
}
}
public class D02Inheritance {
public static void main(String[] args) {
// title, year
A a = new A();
// title, year, data 만큼 메모리가 잡힌다
B b = new B();
b.title = "hello";
b.year = 2024;
b.data = "java";
// 갖고있는 속성 모두 출력, private 아니기에 가능
b.info();
System.out.println(b.title + ", " + b.year + ", " + b.data);
}
}
부모가 동일한 패키지가 아닌 다른 패키지에 있어도 상속 가능하다
Superclass에서 부모클래스 선택 할 수 있다
package com.kosta.exam02;
public class A {
// private로 인한 오류
// private String title;
// private int year;
protected String title;
protected int year;
}package com.kosta.exam03;
import com.kosta.exam02.A;
public class B extends A {
private String data;
public void info() {
/*
아무리 상속받은 자식클래스라 할지라도
부모클래스의 private 영역에는 접근할 수 없어요
만약에 외부의 다른클래스로부터는 보호하고
자식클래스에게는 접근을 허용할면 protected에 둔다
*/
System.out.println(title + ", " + year + ", " + data); // error
}
}
값을 넣고 출력하기위해 setter, getter
package com.kosta.exam02;
public class A {
protected String title;
protected int year;
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
}package com.kosta.exam03;
import com.kosta.exam02.A;
public class B extends A {
private String data;
public String getData() {
return data;
}
public void setData(String data) {
this.data = data;
}
public void info() {
System.out.println(title + ", " + year + ", " + data);
}
}package com.kosta.exam04;
import com.kosta.exam03.B;
public class D03ProtectedTest {
public static void main(String[] args) {
B b = new B();
b.setTitle("hello");
b.setYear(2024);
b.setData("java");
b.info();
}
}
접근명시자
private : 클래스 자신만 접근할 수 있고 외부의 모든 클래스로부터 접근을 허용하지 않아요
public : 외부의 어떤 클래스라도 접근할 수 있어요
protected : 외부의 다른 클래스로부터는 보호하되 상속된 자식클래스들에게는 접근을 허용해요
default : 외부의 다른 클래스로부터는 보호하되 동일한 패키지에 있는 클래스들에게는 접근을 허용해요
/상속.pdf/
/*
PROGRAMMING 2.
Person 클래스를 설계하라. Person 클래스는 이름, 주소, 전화 번호를 필드로 가진다.
하나 이상의 생성자를 정의하고 각 필드에 대하여 접근자와 설정자 메소드를 작성하라.
이어서 Person을 상속받아서 Customer를 작성하여 보자.
Customer는 고객 번호와 마일리지를 필드로 가지고 있다.
한 개 이상의 생성자를 작성하고 적절한 접근자 메소드와 설정자 메소드를 작성하라.
*/package com.kosta.exam05;
public class Person {
protected String name;
protected String addr;
protected String phone;
public Person(String name, String addr, String phone) {
super();
this.name = name;
this.addr = addr;
this.phone = phone;
}
public Person() {
super();
// TODO Auto-generated constructor stub
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddr() {
return addr;
}
public void setAddr(String addr) {
this.addr = addr;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
}package com.kosta.exam05;
public class Customer extends Person {
private int num;// 고객번호
private int mileage; // 마일리지
// 부모의 생성자가 동작해야 자식 생성자가 동작한다
public Customer(String name, String addr, String phone, int num, int mileage) {
// super(); 부모 생성자 요구하는 명령은 첫번째 문장에 와야한다
super(name, addr, phone);
this.num = num;
this.mileage = mileage;
}
public Customer() {
super();
// TODO Auto-generated constructor stub
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public int getMileage() {
return mileage;
}
public void setMileage(int mileage) {
this.mileage = mileage;
}
}package com.kosta.exam05;
public class PersonTest {
public static void main(String[] args) {
Person p = new Person("무도사", "서울시 종로구", "01011111111");
Customer c = new Customer("배추도사", "서울시 종로구", "01022222222", 1000, 10000);
System.out.println("** Person의 정보 **");
System.out.println("이름 : " + p.getName() );
System.out.println("전화 : " + p.getPhone() );
System.out.println("주소 : " + p.getAddr() );
System.out.println("** Customer의 정보**");
System.out.println("이름 : " + c.getName() );
System.out.println("전화 : " + c.getPhone() );
System.out.println("주소 : " + c.getAddr() );
System.out.println("고객번호 : " + c.getNum() );
System.out.println("마일리지 : " + c.getMileage() );
}
}
/toString() 으로 문자열 반환하기/
public class Person {
protected String name;
protected String addr;
protected String phone;
public String toString() {
String data = "";
data += "이름 : " + name;
data += ", 주소 : " + addr;
data += ", 번호 : " + phone;
return data;
} // 부모클래스 toString() 재정의하기
public String toString() {
String data = "";
data += "이름 : " + name;
data += ", 주소 : " + addr;
data += ", 번호 : " + phone;
data += ", 고객번호 : " + num;
data += ", 마일리지 : " + mileage;
return data;
}package com.kosta.exam05;
public class PersonTest {
public static void main(String[] args) {
// ctrl + class명 누르면 해당 class로 이동
Person p = new Person("무도사", "서울시 종로구", "01011111111");
Customer c = new Customer("배추도사", "서울시 종로구", "01022222222", 1000, 10000);
System.out.println("** Person의 정보 **");
System.out.println(p);
System.out.println("** Customer의 정보**");
System.out.println(c);
}
}
메소드 오버로딩(method overloading)
: 같은 이름의 메소드를 중복하여 정의하는 것을 말하며 매개변수의 개수가 다르거나 자료형이 달라야 합니다
메소드 오버라이딩(method overriding) / super.toString();
: 상속관계에 있을때에 부모의 동일한 이름의 메소드를 자식클래스에 맞도록 다시정의(재정의)하는 것을 말하며
메소드 이름뿐 아니라 매개변수의 개수와 자료형까지 일치되게 재정의 해야 합니다
public String toString() {
String data = "";
// 부모 클래스의 toString() 호출한다
data += super.toString();
data += ", 고객번호 : " + num;
data += ", 마일리지 : " + mileage;
return data;
}
super() / 부모 생성자 요구하기
: 상속관계에 있을 때 부모클래스의 생성자를 동작시키는 명령입니다.
이 명령은 반드시 생성자의 첫번째 문장에 와야합니다
super.멤버변수
super.멤버메소드()
: 상속관계에 있을 때 부모클랫스의 멤버와 동일한 이름의 멤버를 자식클래스에 만들면
부모에 있는 동일한 멤버는 가려지게되어 자식에서 만든 멤버가 우선순위가 높아요
그런데 만약 부모클래스에 있는 동일한 이름에 멤버에 접근하려면 super 키워드를 통해서 접근 할 수 있어요
이클립스가 자동으로 toString() 해준다
상속과 생성자
==> 상속관계 있을 때 자식의 객체를 생성하면 별다른 문장이 없어도
부모의 생성자가 먼저 동작하고 자식의 생성자가 동작합니다.
만약 부모의 매개변수를 갖는 생성자를 동작시키려면 super(값);를 사용합니다.
class A{
}
class B extends A{
}
위의 경우에 B b = new B(); 처럼 객체를 생성하면
부모클래스인 A의 기본 생성자가 먼저 동작하고 B의 기본 생성자가 동작합니다
자바는 따로 생성자를 만들지 않으면 기본 생성자를 제공합니다
class A{
public A(int data){
}
}
class B extends A{
}
위와 같은 경우에는 B b = new B(); 라고 하면 오류가 발생합니다
A 클래스에서 매개변수를 갖는 생성자를 사용자가 만들었기 때문에 기본 생성자가 제공되지 않아요
그런데 B b = new B(); 의 경우는 부모의 기본 생성자를 요구하기 때문에 오류가 발생합니다
/상속.pdf/
/*
PROGRAMMING 3.
일반적인 책을 나타내는 Book 클래스를 상속받아서 잡지를 나타내는 Magazine 클래스를 작성하여 보자.
Book 클래스는 제목, 페이지수, 저자 등의 정보를 가진다.
Magazine 클래스는 추가로 발매일 정보를 가진다.
*/package com.kosta.exam06;
public class Book {
protected String title;
protected int pages;
protected String writer;
@Override
public String toString() {
return "Book [title=" + title + ", pages=" + pages + ", writer=" + writer + "]";
}
// 기본 생성자는 제공하지만
public Book() {
super();
// TODO Auto-generated constructor stub
}
// 생성자를 만들기 시작하면 기본생성자를 만들어줘야한다
public Book(String title, int pages, String writer) {
super();
this.title = title;
this.pages = pages;
this.writer = writer;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public int getPages() {
return pages;
}
public void setPage(int page) {
this.pages = pages;
}
public String getWriter() {
return writer;
}
public void setWriter(String writer) {
this.writer = writer;
}
}package com.kosta.exam06;
public class Magazine extends Book {
private String date;
@Override
public String toString() {
return "Magazine [date=" + date + ", title=" + title + ", pages=" + pages + ", writer=" + writer + "]";
}
public Magazine(String title, int pages, String writer, String date) {
super(title, pages, writer);
this.date = date;
}
public Magazine() {
super();
}
public String getDate() {
return date;
}
public void setDate(String date) {
this.date = date;
}
}
package com.kosta.exam06;
public class BookTest {
public static void main(String[] args) {
Book b1 = new Book("재미있는 자바", 231, "KOSTA");
Magazine m1 = new Magazine("신나는 자바", 322, "KOSTA", "24/05/20");
System.out.println(b1);
System.out.println(m1);
Book b2 = new Book();
System.out.println(b2);
Magazine m2 = new Magazine();
System.out.println(m2);
}
}
14:00 ~
내 기억에 없ㄴ,, exam07,,, 숙면이슈,,,,,
/*
PROGRAMMING 1.
회사에서 근무하는 직원들을 나타내는 클래스들을 상속을 이용하여 작성하여 보자.
1) Employee 클래스를 설계하라. Employee 클래스는 이름, 사번 등의 정보를 필드로 가져야 한다.
생성자를 정의하고 접근자와 설정자 메소드도 작성하라.
월급을 계산하는 메소드 computeSalary()를 구현하라.
2) Employee 클래스에서 상속받아서 SalariedEmployee라는 클래스를 정의하여 보자.
이 클래스는 월급이라는 필드를 추가로 가진다.
역시 생성자를 정의하고 접근자와 설정자 메소드도 작성하라.
수퍼 클래스의 computeSalary()를 재정의하라.
3) Employee 클래스에서 상속받아서 시간제 직원을 나타내는 HourlyEmployee 클래스를 정의하라.
시간당 임금과 일한 시간을 필드로 추가하라.
역시 생성자를 정의하고 접근자와 설정자 메소드도 작성하라.
수퍼 클래스의 comute-Salary()를 재정의하라.
*/package com.kosta.exam07;
public class Employee {
protected String name; //이름
protected String no; //사번
public Employee(String name, String no) {
super();
this.name = name;
this.no = no;
}
public Employee() {
super();
// TODO Auto-generated constructor stub
}
public void computeSalary() { //급여를 계산하는 메소드
//월급제사원과 시간제 사원의 급여계산방식이 다르기 때문에
//부모클래스를 만드는 시점에서 메소드의 body를 구체화 할 수 없어요.
//그래 비워둡니다.
}
}package com.kosta.exam07;
public class SalariedEmployee extends Employee {
private int salary; //월급
private int level; //호봉
private int base; //기본금
private int allowances; //수당
@Override
public void computeSalary() {
switch(level) {
case 1: base = 4000000;allowances=400000;break;
case 2: base = 5000000;allowances=500000;break;
case 3: base = 6000000;allowances=600000;break;
}
salary = base+allowances;
}
@Override
public String toString() {
return "SalariedEmployee [salary=" + salary + ", level=" + level + ", base=" + base + ", allowances="
+ allowances + ", name=" + name + ", no=" + no + "]";
}
public SalariedEmployee() {
super();
// TODO Auto-generated constructor stub
}
public SalariedEmployee(String name, String no, int level) {
super(name, no);
this.level = level;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
public int getLevel() {
return level;
}
public void setLevel(int level) {
this.level = level;
}
public int getBase() {
return base;
}
public void setBase(int base) {
this.base = base;
}
public int getAllowances() {
return allowances;
}
public void setAllowances(int allowances) {
this.allowances = allowances;
}
}package com.kosta.exam07;
public class HourlyEmployee extends Employee {
private int base; //시간당 임금
private int hours; //일한 시간
private int salary; //실수령액
@Override
public void computeSalary() {
salary = base * hours;
}
@Override
public String toString() {
return "HourlyEmployee [base=" + base + ", hours=" + hours + ", salary=" + salary + ", name=" + name + ", no="
+ no + "]";
}
public HourlyEmployee() {
super();
// TODO Auto-generated constructor stub
}
public HourlyEmployee(String name, String no, int base, int hours) {
super(name, no);
this.base = base;
this.hours = hours;
}
public int getBase() {
return base;
}
public void setBase(int base) {
this.base = base;
}
public int getHours() {
return hours;
}
public void setHours(int hours) {
this.hours = hours;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
}package com.kosta.exam07;
public class EmployeeTest {
public static void main(String[] args) {
SalariedEmployee e1 = new SalariedEmployee("이름1", "A1000", 1);
SalariedEmployee e2 = new SalariedEmployee("이름2", "A1001", 2);
HourlyEmployee h1 = new HourlyEmployee("이름3", "H0001", 100000, 20);
e1.computeSalary();
e2.computeSalary();
h1.computeSalary();
System.out.println(e1);
System.out.println(e2);
System.out.println(h1);
}
}
객체지향 프로그래밍의 특징
1) 은닉성
2) 상속성
3) 다형성(polymorphism)
객체마다 받은 메세지는 동일한데 객체마다 동작하는 방식이 달라요.
상속관계에 있을 때 부모로부터 물려받은 메소드를 자신에게 맞도록 재정의 한 경우에
자식클래스의 객체마다 동작하는 방식이 달라요. 이것을 "다형성"이라고 합니다.
SalariedEmployee e1 = new SalariedEmployee("이름1, "A1000", 1);
HourlyEmployee h1 = new HourlyEmployee("이름2", "H0001", 100000, 20);
e1.computeSalary(); // A
h1.computeSalary(); // B
위의 실습코드에서 A, B 모두 동일한 메세지 computeSalary();를 주었는데
e1 : 호봉에 따라 기본금, 수당을 결정하고 기본금과 수당을 더해서 급여를 계산합니다
h1 : 시간당 임금과 일한 시간을 곱하기하여 실수령액을 계산합니다
이와 같이 두개의 객체가 동일한 메세지를 받았는데 동작하는 방식이 즉, 응답이 달라요
이것을 "다형성"이라고 합니다
/부모의 메소드 Override 하기/
/*
PROGRAMMING 6.
2차원 도형들을 나타내는 클래스들을 작성하여 보자.
수퍼 클래스인 Shape에는 도형의 위치, 크기 등의 정보가 들어 간다.
각각의 필드에 대하여 접근자와 설정자 메소드를 정의하라.
추가로 도형의 둘레, 면적을 계산하는 메소드도 제공한다.
각 도형은 Shape에서 상속받아서 특정 도형에 맞도록 둘레와 면적을 계산하는 메소드를 수정한다.
테스트 클래스를 작성하여서 여러 도형들을 생성하고 테스트한다.
*/package com.kosta.exam08;
public class Shape {
protected int x;
protected int y;
protected double area;
protected double round;
public void calcArea() {}
public void calcRound() {}
@Override
public String toString() {
return "Shape [x=" + x + ", y=" + y + ", area=" + area + ", round=" + round + "]";
}
public Shape() {
super();
// TODO Auto-generated constructor stub
}
public Shape(int x, int y) {
super();
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
public double getArea() {
return area;
}
public void setArea(double area) {
this.area = area;
}
public double getRound() {
return round;
}
public void setRound(double round) {
this.round = round;
}
}package com.kosta.exam08;
public class Rectangle extends Shape {
private double width;
private double height;
@Override
public void calcArea() {
area = width * height;
}
@Override
public void calcRound() {
round = (width + height) * 2;
}
@Override
public String toString() {
return "Rectangle [width=" + width + ", height=" + height + ", x=" + x + ", y=" + y + ", area=" + area
+ ", round=" + round + "]";
}
public Rectangle() {
super();
// TODO Auto-generated constructor stub
}
public Rectangle(int x, int y, double width, double height) {
// 부모의 생성자 요청
super(x, y);
this.width = width;
this.height = height;
}
public double getWidth() {
return width;
}
public void setWidth(double width) {
this.width = width;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
}package com.kosta.exam08;
public class Circle extends Shape {
// 원의 면적, 원이 넓이구하기
private double radius; // 반지름
private final static double PI = 3.141592; // final : 상수, 고정된 값
@Override
public void calcArea() {
area = PI * radius * radius;
}
@Override
public void calcRound() {
round = 2 * PI * radius;
}
public Circle(int x, int y, double radius) {
super(x, y);
this.radius = radius;
}
public Circle() {
super();
// TODO Auto-generated constructor stub
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
}package com.kosta.exam08;
public class ShapeTest {
public static void main(String[] args) {
// 부모의 참조변수는 자식의 객체를 참조 할 수 있다
// Shape s = new Rectangle(10, 10, 100, 100);
Rectangle r = new Rectangle(10, 10, 100, 100);
Circle c = new Circle(10, 200, 50);
r.calcArea();
r.calcRound();
c.calcArea();
c.calcRound();
System.out.println(r);
System.out.println(c);
}
}
// Rectangle r = new Rectangle(10, 10, 100, 100);
// Circle c = new Circle(10, 200, 50);
Shape r = new Rectangle(10, 10, 100, 100);
Shape c = new Circle(10, 200, 50);
위의 코드에서 Shape은 Rectangle과 Circle의 부모클래스입니다.
부모클래스의 참조변수는 자식 클래스의 객체를 참조할 수 있어요
예를 들어, 우리는 2차원 도형이 많이 필요하다고 상상해 봅시다.
그러면 기억장소가 많이 필요할 때에는 "배열"을 이용합니다.
그런데 2차원 도형에는 원도 있고 사각형도 있는데
배열의 자료형은 무엇으로 해야 할까요?
이럴때에 원과 사각형을 모두 담을 수 있는 Shape으로 배열을 만들면 됩니다.
package com.kosta.exam09;
public class ShapeTest {
public static void main(String[] args) {
// Circle 밖에 못 담는다
Circle[] data1 = new Circle[100];
Rectangle[] data2 = new Rectangle[100];
// 2차원 도형(Circle, Rectangle) 어떤 것이라도 담을 수 있는 배열을 만들어요
// 2차원 도형의 부모클래스인 Shape으로 배열을 만들어요
Shape[] data = new Shape[3]; // 객체 참조변수 3개
// data의 자료형 Shape(부모)으로 자식 객체 참조
data[0] = new Circle(10, 10, 50);
data[1] = new Rectangle(10, 200, 100, 100);
data[2] = new Circle(10, 30, 25);
// 다형성
for(Shape s : data) {
s.calcArea();
s.calcRound();
System.out.println(s);
}
}
}
- 오늘 학습내용에 대하여 요약 및 정리하고 궁금한 점 질문합니다.
- pdf "상속"의 LAB의 1번을 프로그래밍 해 봅니다.
/*
LAB 1.
*/'📖' 카테고리의 다른 글
| day 0522 인터페이스 (0) | 2024.05.22 |
|---|---|
| day 0521 추상클래스_추상메소드 (0) | 2024.05.21 |
| day 0517 객체와 클래스_생성자_this (0) | 2024.05.17 |
| day 0516 정렬_객체와 클래스 (0) | 2024.05.16 |
| day 0514 배열_메소드 (0) | 2024.05.14 |
