자바/스프링 개발 부트캠프 7일차 (생성자 , 상속)
오늘의 추천곡
- 아티스트
- 교이
- 앨범
- 그게맞아
- 발매일
- 2018.05.03
1. 메서드오버로딩 다시한번 살펴보기
| 2 ) 생성자 | |
2-1 |
생성자란? |
| 2-2 |
생성자 예시코드 |
| 2-3 |
생성자오버로딩 예제 |
| 2-4 |
생성자 예제 |
| 2-5 |
this |
| 2-6 |
this 예제 |
| 2-7 | 변수의 초기화 |
3) 용어정리
4) 상속
4-1) 상속 예제
4-2) super
5) 오늘의 예제 (클래스 내용)
1) 메서드 오버로딩 다시 한번 살펴보기
메서드 오버로딩이란?
자바에서는 한 클래스 내에 이미 사용하려는 이름과 같은 이름을 가진 메 서드가 있더라도 매개변수의 개수 또는 타입이 다르면, 같은 이름을 사 용해서 메서드를 정의할 수 있다.
한 클래스 내에 같은 이름의 메서드를 여러 개 정의하는 것을 메서드 오버로딩(Method Overloading) 또는
오버로딩(Overloading)이 라 한다.
오버로딩의 조건
메서드의 이름이 같아야 한다 매개변수의 개수 또는 타입이 달라야 한다 그외의 리턴타입이나, 접근제어자는 조건에 포함되지 않는다
오버로딩된 메서드의 호출 우선순서
1. 메서드 호출시 입력된 자료형과 선언부의 매개변수의 자료형이 동일 한 경우 호출된다
2. 1의 기준이 없는 경우는 최소 갯수로 자동형변환이 되는 매개변수를 가진 메서드를 선택한다.
* 주의 : 동일한 선택 기준이 되는 메서드가 여러개인 경우 오류 발생
@@ 2) 생성자(Constructor) @@
2 -1 ) 생성자란?
객체화시 호출되는 '인스턴스 초기화 메서드
주로 인스턴스변수의 초기화 작업에 주로 사용
생성자 역시 메서드처럼 클래스 내에 선언됨.
생성자없는 객체생성은 불가능
클래스 내부에 생성자를 구현하지않으면 기본생성자를 제공함
구조도 메서드와 유사하지만 리턴값이 없다(void 등 존재X)는 점이 다름.
생성자 오버로딩 가능!
생성자의 형태
class명 (타입 변수명, 타입 변수명, … )
{ /* 인스턴스 생성 시 수행될 코드, 주로 인스턴스멤버의 초기화 코드를 적는다. */ }
기본생성자의 형태
class명(){ };==> 의 형태
ex)
public class Coin
{
public Coin(int a){ }
public Coin(double a){}
}
생성자의 조건.
생성자의 이름은 클래스의 이름과 같아야 한다.
생성자는 리턴 값이 없다
2-2) 생성자 예시 코드
인스턴스를 생성할 때는 반드시 클래스 내에 정의된 생성자 중의 하나를 선택하여 호출 해야 한다.
package ex5_constructor;
public class Number1 { //생성자구현안함
//생성하지않아도 기본생성자 (매개변수가없는 생성자)제공
int num;
}package ex5_constructor;
public class Number2 {
int num;
public Number2(int num) { //생성자
this.num = num;
}
// public Number2() {
// System.out.println("기본생성자");
// }
//기본생성자를 호출하고싶다면 따로 만들어야함}package ex5_constructor;
public class ConstructorEx1 {
public static void main(String[] args) {
Number1 n1 = new Number1();
Number2 n2 = new Number2(10);
//생성자의매개변수에 int num존재 --> 필수로 int값을 전달해 생성해야함
System.out.println("n1Num : "+n1.num);
System.out.println("n2Num : "+n2.num);
}}n1Num : 0
n2Num : 10
2-3) 생성자오버로딩예제
클래스
package ex5_constructor;
public class Car {
String color;
int num;
static int width = 200;
static int height = 120;
Car(){}; //기본생성자 (생성자를 하나라도 구현했을 시
//기본생성자도 선언을 해야 사용할 수 있음)
Car(String c , int n){ //생성자1
color = c;
num = n;
}
Car(String c){//생성자2
color = c;
num= 1234;
}
Car (int n){//생성자3
color = "White";
num = n;
}
public String toString() {
return color+","+num+"("+width+","+height+")";
}
}메인코드
package ex5_constructor;
public class ConstructorEx2 {
public static void main(String[] args) {
Car c1 = new Car("Blue",1422);
Car c2 = new Car("Blue");
Car c3 = new Car(1982);
Car c4 = new Car();
System.out.println("c1 : "+c1);//생성자1
System.out.println("c2 : "+c2);//생성자2
System.out.println("c3 : "+c3);//생성자3
System.out.println("c4 : "+c4);//기본생성자
}}c1 : Blue,1422(200,120)
c2 : Blue,1234(200,120)
c3 : White,1982(200,120)
c4 : null,0(200,120)
2-4) 기본 예제
package ex5_constructor.exam;
public class Exam2 {
public static void main(String[] args) {
EastCard c1 = new EastCard(3,false);
EastCard c2 = new EastCard();
System.out.println(c1);//3
System.out.println(c2);//1K
}}다음과 같은 EastCard클래스를 완성해보자
1~10 까지 각 두장의 카드가있다.
1 3 8 만 K 가 존재함
package ex5_constructor.exam;
public class EastCard {
int num;
boolean isKwang;
public EastCard() {
num = 1;
isKwang = true;
}
public EastCard(int num , boolean isKwang) {
this.num = num;
if(num==1||num==3 || num==8) {
this.isKwang = isKwang;
}else {
this.isKwang = false;
}
}
public String toString() {
return num+""+(isKwang==true?"K":" ");
}
}1 3 8 만 k가 존재하므로 if문을 넣어서 처리를해줬고
기본생성자는 num = 1 isKwang=true 로 고정을해줬다
만약 밑에 public EastCard(int num , boolean isKwang) {} 만 구현을 했다면
메인코드에서 기본생성자는 사용할 수 없게 됨.
this.num = num 과 같은 코드를 작성했는데
this를 사용할 수 있는건 인스턴스멤버 즉 자기자신밖에없다
이름을 똑같이 해놓고 매개변수를 받아 this(자기자신) 으로 대입하는 방법임
2-5) this
this 생성자 (동일한 클래스에서 다른 생성자 호출 시 사용)
같은 클래스의 멤버들간에 서로 호출할 수 있는 것처럼 생성자 간 서로 호출이 가능
단, 다음의 두 조건을 만족시켜야 한다.
1.생성자의 이름으로 클래스이름 대신 this를 사용.
2.한 생성자에서 다른 생성자를 호출할 때는 반드시 첫 줄에서만 호출.
this 참조변수 ( 자기참조 변수)
this를 사용할 수 있는 것은 인스턴스멤버뿐이다. (인스턴스필드 or 인스턴스메서드)
static메서드(클래스메서드)에서는 인스턴스 멤버들을 사용할 수 없는 것처럼, this 역시 사용할 수 없다.
생성자를 포함한 모든 인스턴스메서드에는 자신이 관련된 인스턴스를 가리키는
참조변수 this를 지역변수로 숨겨진 상태로 존재
인스턴스 메서드에서 지역변수로 선언되고 , 객체 생성시 자기참조를 저장
지역변수와 멤버변수 구분 시 사용
지역변수의 이름과 멤버변수의 이름이 같은경우 < 지역변수
==> this 참조변수 이용해 멤버변수 호출가능
이름이 다른경우에는 this 생략가능
package ex6_this;
public class ThisEx1 {
public static void main(String[] args) {
Car car = new Car();
Car car2 = new Car("blue",523);
System.out.println("car : "+car);
System.out.println("car2 : "+car2);
}
}package ex6_this;
public class Car {
String color;
int number;
int seriaNo;
static int sno;
Car(String color , int number){
System.out.println("Car(String , int) 생성자");
this.color = color;
this.number = number;
this.seriaNo = ++sno;
}
Car(){
//매개변수 형이 (String , int)인 다른생성자 호출=> 9번라인으로이동
this("white",11441); //생성자는 무조건 상단에위치
System.out.println("Car() 생성자"); //this생성자종료 시 실행
// color = "White";
// number = 1141;
// this.seriaNo = ++sno;}
@Override
public String toString() {
return "Car [color=" + color + ", number=" + number + ", seriaNo=" + seriaNo + "]";
}
}Car(String , int) 생성자
Car() 생성자
Car(String , int) 생성자
car : Car [color=white, number=11441, seriaNo=1]
car2 : Car [color=blue, number=523, seriaNo=2]
조금 더 개선 (this생성자 응용)
package ex6_this;
public class ThisEx1 {
public static void main(String[] args) {
Car car = new Car();
System.out.println(car+"\n");
Car car2 = new Car("blue",523);
System.out.println(car2+"\n");
Car car3 = new Car("Red");
System.out.println(car3+"\n");//3번자동차 : Red , 111
Car car4 = new Car(1234);
System.out.println(car4+"\n");//4번자동차 White 1234
Car car5 = new Car(car);
System.out.println(car5+"\n"
);//5번자동차 blue 523
}
}
package ex6_this;
public class Car {
String color;
int number;
int seriaNo;
static int sno;
Car(String color , int number){
System.out.println("@Car(String , int) 생성자@");
this.color = color;
this.number = number;
this.seriaNo = ++sno;}
Car(){
//매개변수 형이 (String , int)인 다른생성자 호출
this("white",11441); //생성자는 무조건 상단에위치
System.out.println("Car() 생성자");}
public Car(String color) {
this(color,111);
System.out.println("Car(String) 생성자");}
public Car(int i) {
this("white",i);
System.out.println("car(int)생성자"); }
public Car(Car car) {
this(car.color,car.number); }
@Override
public String toString() {
return seriaNo+"번자동차 "+"[color=" + color + ", number=" + number + "]";
}
}
this() 생성자를 사용해
(String , int) 형의 생성자를 호출해서 사용하고있다.
2-6) 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);
}
}다음 코드가 정상작동 하도록
this생성자를 활용해 클래스완성하기
(this생성자는 코드첫줄에 써야하는것을 잊지말자)
package ex6_this.exam;
public class Rectangle {
int width, height, number;
static int no;
int area() {
return width*height;}
int length() {
return 2*(width+height);}
public Rectangle(int width, int height) {
System.out.println("@(int,int)생성자@");
this.width = width;
this.height = height;
number = ++no;}
public Rectangle() {
this(1,1);
System.out.println("기본생성자");
System.out.println();}
public Rectangle(int width) {
this(width,1);
System.out.println("(int)생성자");
System.out.println(); }
public Rectangle(Rectangle r) {
this(r.width,r.height);
System.out.println("(Rectangle)생성자");
System.out.println();}
public String toString() {
return number+"번 사각형 ("+width+","+height+")"+
"면적 : "+area()+" 둘레 : "+length()+" "
+(width==height?"[정사각형]":"[직사각형]");
}
}@(int,int)생성자@
@(int,int)생성자@
기본생성자
@(int,int)생성자@
(int)생성자
@(int,int)생성자@
(Rectangle)생성자
1번 사각형 (10,10)면적 : 100 둘레 : 40 [정사각형]
2번 사각형 (1,1)면적 : 1 둘레 : 4 [정사각형]
3번 사각형 (10,1)면적 : 10 둘레 : 22 [직사각형]
4번 사각형 (10,10)면적 : 100 둘레 : 40 [정사각형]
| 클래스영역 | 스택영역 | 힙영역 |
| Rectangle | r1 = new R(10,10) 1000 r2 = new R() 2000 r3 = new R(10) 3000 r4 = new R(r1) 4000 |
1000 width(10) height(10) sno(1) 생성자4 메서드3 |
| width , heigth , sno | ||
| cnt[ 1 ->2->3 ->4 ] | 2000 width(1) height(1) sno(2) 생성자4 메서드3 |
|
| 생성자 4개 | 3000 width(10) height(1) sno(3) 생성자4 메서드3 |
|
| area() , length() , toString() | 4000 width(10) height(10) sno(4) 생성자4 메서드3 |
|
| width [ ] height [ ] (this = 내 객체의참조값을 가지고있음) this[1000->2000->300->4000] (생성이끝났다면 사라짐) |
main 코드실행할때
메모리구조를 간단하게 나타내봤다.
2-7) 변수의 초기화
인스턴스 초기화 블록
인스턴스를 생성할 때 마다 수행. (객체화 되어야함)
인스턴스 변수의 초기화에 사용된다. 생성자와 기능이 겹침
생성자보다는 인스턴스 초기화 블럭이 먼저 수행된다
static 초기화 블록
클래스가 메모리에 처음 로딩될 때 한번 수행
클래스변수들이 메모리에 만들어지고, 바로 클래스 초기화블럭이 클래스 변수들을
초기화 클래스 변수의 초기화에 사용
초기화 블럭
예제코드
package ex7_init;
/*
* static 초기화블럭 : 클래스변수의 초기화 .
* 클래스 정보 로드 시 한번만 실행됨.
* main 메서드보다 먼저 실행
*
* 인스턴스 초기화블럭 : 인스턴스변수의 초기화담당 , 생성자와 기능이겹침
* 객체화 시 생성자 호출전에 실행됨
*/
public class InitEx1 {
static int cv;
int iv;
InitEx1(){//satic블록 > 인스턴스블록 > 생성자 순으로 실행됨
System.out.println("5.생성자호출\n");
}
//static 초기화블록
static { //클래스가 메모리에 처음 로딩 될 떄 한번만 수행 (가장먼저 로드 됨)
cv = (int)(Math.random()*100);
System.out.println("1.static 초기화블럭 실행 : cv="+cv);
}
//인스턴스 블록
{// 객체화될 떄(인스턴스 생성) 마다 실행 , 생성자보다 빨리 실행
iv = (int)(Math.random()*100);
System.out.println("4.인스턴스 초기화블럭 실행 : iv="+iv);
}
public static void main(String[] args) {
System.out.println("2.main메서드 시작");
System.out.println("3.main메서드 init1 객체 생성");
InitEx1 init1= new InitEx1();
System.out.println("3.main메서드 init2 객체 생성");
InitEx1 init2 = new InitEx1();
System.out.println("InitEx1.cv : "+InitEx1.cv);
System.out.println("init1.iv : "+init1.iv);
System.out.println("init2.iv : "+init2.iv);
}
}
1.static 초기화블럭 실행 : cv=65
2.main메서드 시작
3.main메서드 init1 객체 생성
4.인스턴스 초기화블럭 실행 : iv=66
5.생성자호출
3.main메서드 init2 객체 생성
4.인스턴스 초기화블럭 실행 : iv=74
5.생성자호출
InitEx1.cv : 65
init1.iv : 66
init2.iv : 74
@@ 3) 용어정리 @@
추상화 => 클래스생성의 과정 , 클래스는 사용자정의 자료형이다.
* 변수(속성, 명사적인 특징(이름 나이 등) :
클래스변수 (static) : 클래스 정보 로드 시 메모리할당 . 모든객체의 공유변수
인스턴스변수(멤버변수) : 객체화 시 메모리할당 , 객체별로 다른 메모리 할당
메서드(기능, 동사적인 특징(가다 , 먹다 등))
1.클래스 메서드(static):클래스정보 로드시 메서드 실행 준비완료
2.인스턴스 메서드 : 객체화 시 메서드 실행 준비완료
클래스 멤버 : (static)클래스 변수 + (static)클래스 메서드
인스턴스멤버 : 인스턴스 변수 + 인스턴스 메서드 + 생성자
주의 : 클래스멤버에서 인스턴스 멤버 호출 시 객체화 필요
생성자 : 객체화시 호출되는 메서드 , 인스턴스메서드
this : 자기 참조변수 , 인스턴스메서드에서만 사용가능(힙영역)
this() : 생성자. 같은클래스 내의 다른 생성자 호출 시 사용(꼭 코드 맨윗줄에 사용)
오버로딩 : 같은클래스 내에 이름은 같고 매개변수가 다른 메서드가 여러개 존재 가능
( 메서드의 다형성 )
@@ 4) 상속 @@
1. 상속은 extends로 표현한다.
class 자손클래스 extends 부모클래스 { .... }
2.단일 상속만 가능하다. 자손클래스의 부모클래스는 한개만 가능함.
3.자손클래스의 객체화시 부모클래스의 객체를 먼저 생성한다.
4.모든 클래스는 Object 클래스를 상속받는다. 모든클래스의 객체는 Object 클래스의 객체부터 생성한다.
Car(부모) ElectricCar(자식) 의 그림
예시코드
package ex1_is_a;
public class Phone {
private boolean power;
int number;
void power() {
power = !power;
}
void send() {
if(power) {
System.out.println("전화걸기");
}
else {
System.out.println("전원이 꺼져있어..");
}
}
void receive() {
if(power) {
System.out.println("전화받기");
}
else {
System.out.println("전원이 꺼져있어..");
}
}
}package ex1_is_a;
public class SmartPhone extends Phone{ //Phone을 상속받겠단 의미
void setApp(String name) {
System.out.println(name + "앱 설치");
}
}
사용코드
package ex1_is_a;
/*
*
* 1. 자손클래스의 객체생성은 부모클래스의 객체부터 생성함.
* 2. 클래스간의 상속은 단일상속만 가능 자식[클래스extend부모클래스1 , 부모클래스2 X]
* ex) 자식1 extends 부모 o
* 자식2 extends 부모 o
* 자식3 extneds 자식2 o
* 3. 모든 클래스의 부모클래스가 존재 (Object)
*/
public class PhoneEx1 /*extends Object*/{
public static void main(String[] args) {
SmartPhone sp = new SmartPhone();
sp.power();
sp.send();
sp.receive();
sp.setApp("카카오");
}
}전화걸기
전화받기
카카오앱 설치
smartPhone에는 저런 메서드들이 없는데 어떻게 한거지???
sp의 참조변수 == 1000;
1000 (힙영역 )
| boolean power | phone 객체 | smartPhone 객체 |
| int number | ||
| power() | ||
| send() | ||
| receive | ||
| setApp() | XXX |
smratPhone에 없는 기능이있다면
위로 올라가 Phone객체의 기능을 뒤지게 된다
(자식은 부모의기능을 물려받는다)
그 반대의경우는 할 수 없음 부모가 자식의기능을 사용할수없음!!
4-1) 상속 예제
* Studemt , Person 클래스 구현
*
* Student클래스 : Person을 상속
* 멤버메서드
* void study() : 공부한다 출력
*
* Person 클래스 :
* void eat() : 먹는다를 화면에출력
* void sleep() : 잔다를 출력
package ex1_is_a.exam;
public class Exam1 {
public static void main(String[] args) {
Student st = new Student();
System.out.println("Studnet");
st.eat();
st.sleep();
st.study();
System.out.println();
System.out.println("Person");
Person p = new Person();
p.eat();
p.sleep();
// p.study(); 부모는 자식의기능 사용X
}
}
Person(상위)
package ex1_is_a.exam;
public class Person {
void eat() {
System.out.println("먹는다");
}
void sleep() {
System.out.println("잔다");
}
}
Student(하위)
//Person을 상속받았으므로 Person의 기능을 다 물려받는다
package ex1_is_a.exam;
public class Student extends Person {
void study() {
System.out.println("공부한다");
}
}
Studnet
먹는다
잔다
공부한다
Person
먹는다
잔다
4-2) Super
super 레퍼런스
super 레퍼런스는 슈퍼클래스를 가리키는 레퍼런스이고
super()메소드
super()메소드는 슈퍼클래스의 생성자를 호출한다.
this 레퍼런스나 super 레퍼런스는 static이 붙은 메소드에서 는 사용 할 수 없다.
따라서 main()메소드에서도 이들을 사용할 수 없다.
부모타입에 생성자가 있다면
자식타입에도 생성자를 만든 후 super(매개변수 타입) 으로 꼭 호출해줘야함
부모타입에 생성자가없거나 생성자에 매개변수가 없다면.
매개변수가없는 생성자만 존재한다면 생략해도 자동출력 됨!
* super 예약어
* super() 생성자
* --부모클래스의 생성자 호출 . 코드 첫줄에 구현해야함(this와 같음)
* -- 부모클래스의 생성자 중 매개변수 없는 생성자가 있다면(기본생성자)
* super(); 생략가능
* -- 부모클래스의 생성자 중 매개변수 없는 생성자가 없으면 super(부모클래스의 매개변수타입)
* 으로 호출해야함 . @@생략불가!!
@@ 5) 오늘의 예제 @@
https://github.com/donggonyoo/javaStudyGudee/tree/main/chap07/src/test
예제1)
2. Coin 클래스 구현하기
Coin 클래스
멤버변수 : int side (앞면:0, 뒷면:1), serialNo(동전번호),
sno(동전번호 생성을위한 클래스변수)
생성자 : 구동 클래스에 맞도록 구현
멤버메서드 : void flip()
Math.random() 메서드를 사용하여 side를 결정.
[결과]
Coin 객체 생성 :1번 동전 : 앞면
flip() 실행 후 :1번 동전 : 뒷면
Coin 객체 생성 :2번 동전 : 뒷면
flip() 실행 후 :2번 동전 : 앞면
Coin 객체 생성 :3번 동전 : 뒷면
flip() 실행 후 :3번 동전 : 뒷면
Coin 객체 생성 :4번 동전 : 뒷면
flip() 실행 후 :4번 동전 : 앞면
Coin 객체 생성 :5번 동전 : 앞면
flip() 실행 후 :5번 동전 : 뒷면
Coin 객체 생성 :6번 동전 : 뒷면
flip() 실행 후 :6번 동전 : 앞면
Coin 객체 생성 :7번 동전 : 앞면
flip() 실행 후 :7번 동전 : 뒷면
Coin 객체 생성 :8번 동전 : 뒷면
flip() 실행 후 :8번 동전 : 뒷면
Coin 객체 생성 :9번 동전 : 뒷면
flip() 실행 후 :9번 동전 : 앞면
Coin 객체 생성 :10번 동전 : 뒷면
flip() 실행 후 :10번 동전 : 뒷면
생성 후 앞면 동전의 갯수 :3
생성 후 뒷면 동전의 갯수 :7
flip 후 앞면 동전의 갯수 :4
flip 후 뒷면 동전의 갯수 :6
public class Test2 {
public static void main(String[] args) {
Coin[] coinarr = new Coin[10];
int[] cnt1 = new int[2];
int[] cnt2 = new int[2];
for(int i=0;i<coinarr.length;i++) {
int side = (int)(Math.random() * 2); // 0 or 1
coinarr[i] = new Coin(side);
System.out.println("Coin 객체 생성 :" + coinarr[i]);
cnt1[coinarr[i].side]++;
coinarr[i].flip();
System.out.println("flip() 실행 후 :" + coinarr[i]);
cnt2[coinarr[i].side]++;
}
System.out.println("생성 후 앞면 동전의 갯수 :" + cnt1[0]);
System.out.println("생성 후 뒷면 동전의 갯수 :" + cnt1[1]);
System.out.println("flip 후 앞면 동전의 갯수 :" + cnt2[0]);
System.out.println("flip 후 뒷면 동전의 갯수 :" + cnt2[1]);
}
}위 구동클래스를 보고 Coin클래스를 만들어보아라..!!
구동클래스를 살짝 설명하자면
1. 10개의 Coin객체를 담을 수 있는 배열 ==> new Coin[10]
2. 생성 후 앞면 갯수 : cnt1[0] 생성 후 뒷면 갯수 : cnt1[1]
flip 후 앞면 갯수 :cnt2[0] flip 후 뒷면 갯수 : cnt2[1]
3. 배열의 크기만큼 루프돌리기 for(i=0 ; i < coinarr.length ; i++)
4. Math.random을 이용해 0 혹은 1 의 랜덤변수를 생성
5.Coin객체를 생성 해 랜덤변수를 집어넣음 coinarr[i] = new Coint(Side);
6. 앞면이면 cnt[0] 뒷면이면 cnt1[1] 의 숫자를 하나올림
7.Coin객체의 메서드인 flip을 사용해 다시 랜덤한 변수를 만듬
8 다시만든 랜덤한 변수가 앞면이면 cnt2[0] 아니면 cnt2[1]에 넣기
후 모든 갯수를 출력
class Coin{
static int sno;
int side,serialNO;
public Coin(int side) {
this.side =side;
++sno;
}
void flip() {
this.side = (int)(Math.random()*2);
}
String getSide() {
return this.side==0?"앞면":"뒷면";
}
public String toString() {
return sno+"번 동전 : "+getSide();
}
}일단 생성자를 통해
객체생성시 side(랜덤변수) 를 받은 후
sno(숫자카운트)를 증가시킨다
flip() : 0 or 1 의 랜덤변수를 side에 넣는다
getSide : side 가 0이면 "앞면" 1이면 "뒷면"반환
예제 2)
회사가 고용하는 여러 유형의 직원들이 있다.
직원은 정규직원과 비정규직원 으로 나뉜다.
모든 직원은 직원구분(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,기본입금=1000
이비정의 급여 : 1000
구동클래스
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, 1000);
System.out.println(ie);
System.out.println(ie.name + "의 급여 : " + ie.getPay());
}
}Date 클래스를 사용했는데
Date date = new Date();
date.getTime() ===> 현재날짜와 요일
하지만 더하는 과정이 너무 복잡하다
(2년을 밀리초로 환산해야함)
또한 윤년을 계산 안하기에 정확하지 않을 수 있음
난 LocalDateTime을 사용해 변경해보았다
Employee 클래스
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;
} }
FormalEmployee 클래스( Employee 상속)
부모클래스에 생성자의매개변수가있다면 호출은 필수임!!!!
class FormalEmployee extends Employee{
//정규직원은 직원번호(empNo), 직급(position), 연봉(salary)를 가진다.
String empNo , position;
int salary;
String type = "정규직";
public FormalEmployee(String name, String address, String dept, String empNo,int salary,String position) {
super(name, address, dept);
super.type = empNo;
this.empNo = empNo;
this.salary = salary;
this.position = position;
}
int getPay() {
return salary / 12;
}
public String toString() {
//정규직:이름=김정규, 주소=서울시 용산구,부서=총무부,직원번호=1,직급=과장,연봉=5000
return type+": 이름 = "+name+", 주소 = "+address+
",부서 : "+dept+" 직원번호 : "+empNo+", 직급 : "+position;
}
}
InformalEmployee 클래스 (Employee 상속)
class InformalEmployee extends Employee{
LocalDateTime date;
DayOfWeek week;
int primaryPay;
String type = "비정규직";
public InformalEmployee(String name, String address, String dept,DayOfWeek week,LocalDateTime date ,int primaryPay ) {
super(name, address, dept);
this.date = date;
this.primaryPay = primaryPay;
this.week = week;
}
int getPay() {
return primaryPay;
}
//비정규직:이름=이비정, 주소=서울시 구로구,부서=영업부,계약만료일=Sun Sep 01 15:58:50 KST 2024,기본입금=1000
public String toString() {
return type+": 이름 = "+name+", 주소 = "+address+
",부서 : "+dept+" 계약만료일 : "+week+","+date;}
}
출력:
정규직: 이름 = 김정규, 주소 = 서울시 용산구,부서 : 총무부 직원번호 : 1, 직급 : 과장
김정규의 급여 : 416
비정규직: 이름 = 이비정, 주소 = 서울시 구로구,부서 : 영업부 계약만료일 : WEDNESDAY,2027-02-10T17:41:09.422043300
이비정의 급여 : 1000