주말 복습 2 ( 클래스와 생성자, 상속)
1) 클래스
2) 생성자
3) 상속
@@ 1) 클래스 @@
객체지향 언어
특징 : 코드재사용성이 높으며 , 유지보수가 용이함
클래스 ( 사용자 정의 자료형)의 특징
1)추상화
2)상속 - 재사용(extends)
3) 캡슐화 - 접근제어자
4) 다형성 : 참조변수의 형 변환
클래스의 구조와 정의
긴말 하지않고 구동클래스를 하나 만들어서
calc클래스를 완성해보자
public static void main(String[] args) {
Calc c = new Calc();
c.num1 = 10;
c.num2 = 15;
c.minus(); // -5
c.plus(); // 25
System.out.println(c);//toString사용해서 입력값들을 뽑아보자
}
}여기서는 필드를 직접 접근을 했지만
실제로는 필드는 private로 설정을하고 생성자로 한번만 설정이 가능하게 하던지
해야한다
Calc 클래스
class Calc{
int num1;
int num2;//필드(속성)
void minus() {
System.out.println("num1-num2 : "+(num1-num2));
}
void plus() { //메서드(기능)
System.out.println("num1+num2 : "+(num1+num2));
}
public String toString() {
return "num1 : "+num1+", num2 : "+num2;
}
}
출력결과
num1-num2 : -5
num1+num2 : 25
num1 : 10, num2 : 15
| 선언위치에따른 변수의 종류 |
*선언위치 | 선언 방식 | 메모리 할당시점 | 메모리할당 위치 |
| 클래스변수 (필드) |
클래스 내부에 선언 객체화와 관련X 모든 객체의공통변수로 사용 클래스명.변수명 으로 호출 기본값으로 자동초기화 |
static int iv ; | 클래스 정보 로드 | 클래스영역 static |
| 인스턴스 변수 (필드) |
클래스 내부에 선언 객체화과 되어야 값을 저장 반드시 객체화필요 참조변수명.변수명 호출 기본값으로 초기화 |
int iv; | 객체 생성 시 | 힙 영역 |
| 지역 변수 | 메서드 내에 실행( 블록 내 ) 선언한 { } 블록 내에서만 사용 for(int i=0;..){} : i변수는 for문 내에서만 사용 사용전에 반드시 초기화 매개변수는 지역변수 |
int iv = 0; | 선언문 실행 시 | 스택 영역 |
응용 예제)
public class Exam1 {
public static void main(String[] args) {
System.out.println("Rectangle.cnt : "+Rectangle.cnt);
Rectangle r1 = new Rectangle();
r1.width = 10;
r1.height = 20;
r1.sno = ++Rectangle.cnt;
System.out.println("++Rectangle.cnt : "+Rectangle.cnt);
System.out.println(r1);
Rectangle r2 = new Rectangle();
r2.width = 10;
r2.height = 20;
r2.sno = ++Rectangle.cnt;
System.out.println("++Rectangle.cnt : "+Rectangle.cnt);
System.out.println(r2);
}
}Rectangle.cnt : 0
++Rectangle.cnt : 1
1번 사각형 : 가로(10), 세로(20),현재까지 생성된 사각형 (1)
++Rectangle.cnt : 2
2번 사각형 : 가로(10), 세로(20),현재까지 생성된 사각형 (2)
다음과같은 출력이나오게 클래스를 작성해보시오!!!
class Rectangle {
public int width;
int height;
int sno; ///인스턴스변수 , 0으로 초기화 (참조로접근)
static int cnt; //클래스변수 . 0으로초기화 (클래스로접근)
public String toString() {
return sno+"번 사각형 : 가로("+width+"), 세로("+height+"),"
+ "현재까지 생성된 사각형 ("+cnt+")";
}
}
위 클래스를 배열의 요소로 사용해보자!!!!
Rectangle[] rArr = new Rectangle[3];
for (Rectangle rectangle : rArr) {
System.out.print(rectangle+",");
}//지금 배열에는 모두 null값이 들어 있을거다
System.out.println();
rArr[0] = r1;
rArr[1] = r2;
for (Rectangle r : rArr) {
System.out.print("["+r+"] ,");
}
**rArr배열 초기요소**
null,null,null,
** r1 ,r2 를 요소로 사용**
[1번 사각형 : 가로(10), 세로(20),현재까지 생성된 사각형 (2)] ,
[2번 사각형 : 가로(10), 세로(20),현재까지 생성된 사각형 (2)] ,
[null] ,
클래스(객체)를 배열로 선언을하면
그 클래스(객체)들이 들어갈수있는 방을 만드는거다.
(객체를 생성하는게 아님)
클래스 멤버와 인스턴스멤버 관계와 특징
호출 예시
(클래스멤버에서 인스턴스멤버를 호출하기위해서는
객체화가 필수!!! 인스턴스멤버의 참조를 알아야 사용할 수 있음)
package ex3_method;
public class MemberCallEx1 {
static int cv1 = 10;
static int cv2 = cv1; //클래스멤버간 호출
int iv1 = 100;
int iv2 = iv1;
int iv3 = cv1; //인스턴스멤버에서 클래스멤버 값 호출한것.(가능)
static int cv3 = new MemberCallEx1().iv1;
void method1() {
System.out.println("method1(instanceMember)");
System.out.println("cv1 +cv2 : "+(cv1+cv2));//클래스멤버
System.out.println("iv1 +iv2 : "+(iv1+iv2));//클래스멤버
}
static void method2() {
System.out.println("method2(classMember)");
MemberCallEx1 a = new MemberCallEx1();//객체화
System.out.println("cv1 +cv2 : "+(cv1+cv2));//클래스멤버간 호출
System.out.println("iv1 +iv2 : "+(a.iv1+a.iv2));
// System.out.println("iv1 +iv2 : "+(iv1+iv2)); 객체화가 되어야 호출가능
}
void method3() {
System.out.println("@@method3(InstanceMember@@)");
method1();method2();
}
static void method4() {
System.out.println("@@method4(ClassMemeber@@)");
new MemberCallEx1().method1(); //객체화
method2();
}
public static void main(String[] args) {
MemberCallEx1 m = new MemberCallEx1();
m.method1();
/* MemberCallEx1. */method2();
//main함수와 같은 멤버(static)이므로 생략가능
m.method3();
MemberCallEx1.method4();
}
}method1(instanceMember)
cv1 +cv2 : 20
iv1 +iv2 : 200
method2(classMember)
cv1 +cv2 : 20
iv1 +iv2 : 200
@@method3(InstanceMember@@)
method1(instanceMember)
cv1 +cv2 : 20
iv1 +iv2 : 200
method2(classMember)
cv1 +cv2 : 20
iv1 +iv2 : 200
@@method4(ClassMemeber@@)
method1(instanceMember)
cv1 +cv2 : 20
iv1 +iv2 : 200
method2(classMember)
cv1 +cv2 : 20
iv1 +iv2 : 200
메서드 오버로딩
같은이름을 사용해 메서드를 정의 하는 것
조건
1) 매개변수의 타입 or 갯수 or 순서가 달라야함
2)메서드의 이름이 같아야함
3) 리턴타입 , 접근제어자는 조건에 포함X
* 오버로딩 메서드의 선택기준
* 1.호출되는 인자값의 자료형 == 메서드에선언된 매개변수의 자료형
* 2. 1의조건이없는경우
* 최소갯수로 자동형변환이 가능한 메서드 선택.
* (주의사항)=> 동일조건 메서드가 여러개인경우는 오류발생
package ex4_Overloading;
class Adder2{
int add(int a, int b) {
System.out.print("1 : ");
return a+b;
}
// int add(int x, int y) {
// System.out.print("1 : ");
// return x+y;
// } 매개변수이름만 바꾸면 성립X
// double add(int a , int b) {
// return a+b;
// }타입은 상관이없음 매개변수가 바뀌어야함
long add(long a, int b) {
System.out.print("2 : ");
return a+b;
}
long add(int a, long b) {
System.out.print("3 : ");
return a+b;
}//매개변수의 위치를 바꾸면 성립 O
long add(long a, long b) {
System.out.print("4 : ");
return a+b;
}
}
public class OverloadingEx2 {
public static void main(String[] args) {
Adder2 adder2 = new Adder2();
System.out.println(adder2.add(10, 10));
//int int (1) 만약에int int매개변수를 가진 메서드가없다면
//만들거나 자동형변환이 되더라도 앞에 타입을 붙여주자
System.out.println(adder2.add(10, 10L));
//int long (2)
System.out.println(adder2.add(10L, 10));
//long int (3)
System.out.println(adder2.add(10L, 10L));
// long long (4)
System.out.println(adder2.add('A', '0'));
//int가 가장 가까움
}
}
클래스활용 예제)
class Coin{
int side;
void flip() {
side = (int)(Math.random()*2);
// 0<= Matn.random() < 1
// 0<= Math.random()*2 < 2 -----> int로 바꾸면 0 or 1 라는 뜻
// new Random().nextInt(1);이거와 같은 뜻
}
boolean isSquare() {
return side==0?true : false; //side가 0이면 true
}
String getSide() {
return side==0?"앞":"뒤"; //앞 뒤 반환
}
}
두개의 Coin 객체를 생성하기
myCoin, youCoin 객체 생성하기
앞면이 연속해서 3번 나오면 승리가 출력되도록 구동 클래스 구현하기
[결과예시] => 결과는 다를 수 있습니다.
myCoin youCoin
앞면 뒷면
뒷면 앞면
앞면 앞면
앞면 앞면
youCoin 승리
public class Test6_B {
public static void main(String[] args) {
Coin c1 = new Coin();
Coin c2 = new Coin(); //코인객체 2개생성
System.out.println("myCoin \t YouCoin");
int c1Count=0;
int c2Count=0;
while(true) {
c1.flip();//side에 0or1 저장
c2.flip();
System.out.printf("%3s",c1.getSide()+"\t");
System.out.printf("%3s",c2.getSide());
System.out.println();
//앞면이라면 true가반환된다
//true면 c1Count에 1을 누적하고 아니라면 c1Count를 0으로설정
c1Count = (c1.isSquare()==true ? c1Count+=1 : 0);
c2Count = (c2.isSquare()==true ? c2Count+=1 : 0);
if (c1Count==3) {
System.out.println("나 승리");
break;
}
else if(c2Count==3) {
System.out.println("시스템 승리");
break;
}
}
}
}myCoin YouCoin
뒤 앞
뒤 앞
앞 앞
시스템 승리
@@ 2) 생성자 @@@
객체화시 호출되는 '인스턴스 초기화 메서드
주로 인스턴스변수의 초기화 작업에 주로 사용
생성자 역시 메서드처럼 클래스 내에 선언됨.
생성자없는 객체생성은 불가능
클래스 내부에 생성자를 구현하지않으면 기본생성자를 제공함
구조도 메서드와 유사하지만 리턴값이 없다(void 등 존재X)는 점이 다름.
생성자 오버로딩 가능!
생성자의 형태
class명 (타입 변수명, 타입 변수명, … )
{ /* 인스턴스 생성 시 수행될 코드, 주로 인스턴스멤버의 초기화 코드를 적는다. */ }
기본생성자의 형태
class명(){ };==> 의 형태
ex)
public class Coin
{
public Coin(int a){ }
public Coin(double a){}
}
생성자도 오버로딩이 가능함!
생성자의 조건.
생성자의 이름은 클래스의 이름과 같아야 한다.
생성자는 리턴 값이 없다
인스턴스 생성시 생성자는 무조건 호출해야함
기본예제 )
package ex5_constructor.exam;
public class Rectangle {
int width;
int height;
public Rectangle(int w, int h) {
this.width = w;
this.height = h;
}
public Rectangle(int w) {
this.width = w;
this.height = 1;
}
int length() {
return 2*(width+height);
}
int area() {
return width*height;}
public String toString() {
return "("+width+","+height+")"+
"면적 : "+area()+", 둘레"+length();
}
}다음과같이 생성자오버로딩까지해서 두개를 구현했다
둘 중 하나는 무조건 구현해야함
매개변수값이 하나인 생성자를 사용하게된다면 높이가 1로초기화 됨.
public class Exam1 {
public static void main(String[] args) {
Rectangle r = new Rectangle(10,20);//길이가 10 높이가20인 사각형
System.out.println("r : "+r);
Rectangle r2 = new Rectangle(10); //길이가10 높이가1 인사각형
System.out.println("r2 : "+r2);
}
}r : (10,20)면적 : 200, 둘레60
r2 : (10,1)면적 : 10, 둘레22
this
this 생성자 (동일한 클래스에서 다른 생성자 호출 시 사용)
같은 클래스의 멤버들간에 서로 호출할 수 있는 것처럼 생성자 간 서로 호출이 가능
단, 다음의 두 조건을 만족시켜야 한다.
1.생성자의 이름으로 클래스이름 대신 this를 사용 .ex) this(x,y)
2.한 생성자에서 다른 생성자를 호출할 때는 반드시 첫 줄에서만 호출.
this 참조변수 ( 자기참조 변수)
this를 사용할 수 있는 것은 인스턴스멤버뿐이다. (인스턴스필드 or 인스턴스메서드)
static메서드(클래스메서드)에서는 인스턴스 멤버들을 사용할 수 없는 것처럼, this 역시 사용할 수 없다.
생성자를 포함한 모든 인스턴스메서드에는 자신이 관련된 인스턴스를 가리키는
참조변수 this를 지역변수로 숨겨진 상태로 존재
인스턴스 메서드에서 지역변수로 선언되고 , 객체 생성시 자기참조를 저장
지역변수와 멤버변수 구분 시 사용
지역변수의 이름과 멤버변수의 이름이 같은경우 < 지역변수
==> this 참조변수 이용해 멤버변수 호출가능
이름이 다른경우에는 this 생략가능
응용예제)
구동클래스를 보고 클래스를 만들어보자
package ex6_this.exam;
public class Exam1 {
public static void main(String[] args) {
//1번생성자호출
Rectangle r1 = new Rectangle(10,10);//1번사각형 (10,10) 면적둘레 정사각형
System.out.println();
//2번생성자호출 -> this(1,1) 1번생성자호출
Rectangle r2 = new Rectangle();//2번사각형 (1,1)면적둘레정사각형
//3번생성자호출 -> this(width , 1) 1번생성자호출
Rectangle r3 = new Rectangle(10);//3번사각형(10,1)....
//4번생성자호출 -> this(r.width , r.height) 1번생성자호출
Rectangle r4 = new Rectangle(r1);//4번사각형 (10,10) .....
System.out.println(r1);
System.out.println(r2);
System.out.println(r3);
System.out.println(r4);
}
}
class Rectangle1{
private int w;// 필드를 외부에서 직접 접근할수없게 막음
private int h;// 오직 생성자로만 접근
static int count;
int sno;
public Rectangle1(int w, int h) {
this.w =w;
this.h = h;
sno=++count; //인스턴스멤버는 클래스멤버 호출가능
}
public Rectangle1() {
this(1,1);
}
public Rectangle1(int w) {
this(w,1);
}
public Rectangle1(Rectangle1 r) {
this(r.w , r.h);
}
private int area() {
return this.w * this.h;
}
private int length() {
return 2*(this.w +this.h);
}
public String toString() {
return sno+"번 사각형 ("+w+","+h+") 면적 :"+area()+
"둘레 : "+length()+" "+(w==h?"정사각형":"직사각형");
}
}1번 사각형 (10,10) 면적 :100둘레 : 40 정사각형
2번 사각형 (1,1) 면적 :1둘레 : 4 정사각형
3번 사각형 (10,1) 면적 :10둘레 : 22 직사각형
4번 사각형 (10,10) 면적 :100둘레 : 40 정사각형
@@@ 3) 상속 @@@
1. 상속은 extends로 표현한다.
class 자손클래스 extends 부모클래스 { .... }
2.단일 상속만 가능하다. 자손클래스의 부모클래스는 한개만 가능함.
3.자손클래스의 객체화시 부모클래스의 객체를 먼저 생성한다.
//super();
4.모든 클래스는 Object 클래스를 상속받는다. 모든클래스의 객체는 Object 클래스의 객체부터 생성한다.
부모생성시 자식객체은 생성되지않음
상속의 예제 )
Car 클래스와 Electric Car 구현해보자
Car 클래스
void start() : 출발
void brake() : 브레이크밟는다
void charge() : 연료를넣는다
Electirc Car : Car를 상속
void charge() : 전기를 충전하다
package ex1_is_a.exam;
class Car{
public Car(String name){
System.out.println(name);
}
void charge() {
System.out.println("연료를 채운다");
}
void start() {
System.out.println("출발");
}
void brake() {
System.out.println("시동을 건다");
}
}
class ElectricCar extends Car{
public ElectricCar(String name) {
super(name);
}
@Override
void charge() {
System.out.println("전기를 충전한다");
}
}
public class Exam2 {
public static void main(String[] args) {
Car car = new Car("K5");
car.start();
car.brake();
car.charge();
ElectricCar eCar = new ElectricCar("EV6");
eCar.start();
eCar.brake();
eCar.charge();
}
}부모가 생성자가 있다면
자식은 무조건 부모의 생성자를 호출하게 되어있다.
super(String name); //자식생성자의첫줄에 작성
but
기본생성자 (매개변수가없는생성자)라면
자동으로호출이된다.(적을필요없음)
K5
출발
시동을 건다
연료를 채운다
EV6
출발 //상속받은 기능
시동을 건다 //상속받은 기능
전기를 충전한다 //오버라이딩
super 예약어
super() 생성자( 인스턴스멤버에서만 사용이가능함)
--부모클래스의 생성자 호출 . 코드 첫줄에 구현해야함(this와 같음)
-- 부모클래스의 생성자 중 매개변수 없는 생성자가 있다면(기본생성자)
super(); 생략가능
-- 부모클래스의 생성자 중 매개변수 없는 생성자가 없으면 super(부모클래스의 매개변수타입)
*으로 호출해야함 . @@생략불가!!
예제
회사가 고용하는 여러 유형의 직원들이 있다.
직원은 정규직원과 비정규직원 으로 나뉜다.
모든 직원은 직원구분(type), 이름(name), 주소(address),소속부서(dept)정보를 가진다.
정규직원은 직원번호(empNo), 직급(position), 연봉(salary)를 가진다.
비정규직원은 계약만료일(expireDate), 기본임금(primaryPay)를 가진다.
직원클래스(Employee)
정규직원 클래스(FormalEmployee)
비정규직원클래스(InformalEmployee)
또한 모든 직원은 급여를 받는다.
정규직원은 급여로 연봉 / 12 로
비정규직원은 기본임금
FormalEmployee,InformalEmployee클래스에 getPay() 메서드를 구현하기
구동클래스 실행시 다음의 결과가 나오도록 클래스 생성하기
[결과]
정규직:이름=김정규, 주소=서울시 용산구,부서=총무부,직원번호=1,직급=과장,연봉=5000
김정규의 급여 : 416
비정규직:이름=이비정, 주소=서울시 구로구,부서=영업부,계약만료일=Sun Sep 01 15:58:50 KST 2024,기본입금=200
이비정의 급여 : 200
구동클래스
public class Test5 {
public static void main(String[] args) {
//정규직원 객체 생성
FormalEmployee fe = new FormalEmployee
("김정규", "서울시 용산구","총무부", "1", 5000, "과장");
System.out.println(fe);
System.out.println(fe.name + "의 급여 : " + fe.getPay());
// Date expireDate = new Date(); //현재날짜 시간.
// expireDate.setTime(expireDate.getTime() +
// (1000L * 60 * 60 * 24 * 365 * 2)); 밑에방법이 더 정확하고 간단
LocalDateTime now = LocalDateTime.now();
LocalDateTime ldt= now.plusYears(2);
DayOfWeek week = ldt.getDayOfWeek();
InformalEmployee ie = new InformalEmployee
("이비정", "서울시 구로구", "영업부", week,ldt, 200);
System.out.println(ie);
System.out.println(ie.name + "의 급여 : " + ie.getPay());
}
}
Employee , (FormalEmployee), (InformalEmployee)
구현
class Employee{
String address,dept,name;
String type;
public Employee(String name , String address , String dept ) {
this.name = name;
this.address = address;
this.dept = dept;
}
public String toString() {
return type+": 이름 = "+name+", 주소 = "+address;
}
}
//--------------------------------------------------------------------------------------
class FormalEmployee extends Employee{
String no;
int salary;
String position;
//부모의 생성자가 매개변수가있다면 필수로 호출
public FormalEmployee(String name, String address, String dept,String no,int salary , String position) {
super(name, address, dept);
type = "정규직";//필드를구현하지않앗지만 부모에 type필드가존재
this.no = no;
this.salary = salary;
this.position = position;
}
public int getPay() {
return salary/12;
}
public String toString(){//super.toString()부모의 toString 호출
return super.toString()+",직원번호 : "+no+",직책 : "+position;
}
}
//------------------------------------------------------------------------------
class InformalEmployee extends Employee{
int primaryPay;
DayOfWeek week;
LocalDateTime date;
public InformalEmployee(String name, String address, String dept,DayOfWeek week,LocalDateTime date ,int primaryPay) {
super(name, address, dept);
super.type = "비정규직"; //type으로 접근해도되지만 super.type으로 접근했음
this.primaryPay = primaryPay;
this.week= week;
this.date = date;
}
public int getPay() {
return primaryPay;
}
public String toString() {
return super.toString()+", 계약 만료일 : "+week+date;
}
}
출력
정규직: 이름 = 김정규, 주소 = 서울시 용산구,직원번호 : 1,직책 : 과장
김정규의 급여 : 416
비정규직: 이름 = 이비정, 주소 = 서울시 구로구, 계약 만료일 : MONDAY2027-02-15T16:41:53.855164600
이비정의 급여 : 200
다형성)
1 . 자손타입의 객체를 부모타입의 참조변수로 참조가 가능 : 다형성 (반대는 성립X)
Parent p = new Child(); OOO
Child c = new Parent(); XXX
2 . 부모타입의 참조변수로 자손타입의 객체를 참조하는경우
같은 멤버인경우
변수 : 참조변수 타입을 따라감
메서드 : 객체의 최종 오버라이딩 된 메서드
3. 모든클래스의 객체는 Object 의 참조변수로 형변환 가능함!!
Object o = xx;
Parent p =new Parent();
Child c = (Child)p;
오류발생
Parent p = new Child();
Child c = (Child)p;
이거는 자식객체참조했으니 형변환이가능
4. 모든클래스의 객체는 Object 참조변수로 참조가 가능.
부모와 자식의 멤버변수가 같은 경우
class Parent{
int x = 10;
void method() {
System.out.println("Parent 쿨래스의 method");
}
}
class Child extends Parent{
int x = 20;
@Override
void method() {
super.method();
System.out.println("Child클래스의 method");
System.out.println("x = "+x);
System.out.println("this.x : "+this.x);
System.out.println("super.x : "+super.x);
}
}
public class BindingEx1 {
public static void main(String[] args) {
Parent p = new Child(); // 부모는 자식객체 참조가 가능(부모는 자식을 담을 수 있음)
System.out.println(p.x);//참조변수 타입을 따라감 p == Parent 참조변수
p.method(); //객체의 오버라이딩 된 메서드를 호출함
System.out.println();
Child c = (Child)p;//자식 <- 부모 (강제형변환 필요)
System.out.println(c.x);// c == child
c.method();
Object o = p;//부모 <- 자식 : 자동형변환
}
}10
Parent 쿨래스의 method
Child클래스의 method
x = 20
this.x : 20
super.x : 10
20
Parent 쿨래스의 method
Child클래스의 method
x = 20
this.x : 20
super.x : 10