[TIL]이노베이션 캠프 10일차

1. 개발 진행 상황

2. 개발 중 발생한 이슈와 해결

3. 새로 배운 것

메서드의 호출

메서드명(값1, 값2,...); //메서드를 호출하는 방법

print99danAll(); / void print99danAll()을 호출
int result = add(3,5); // int add(int x, int y)를 호출하고 결과를 result로 저장

return문: 실행 중인 메서드를 종료하고 호출한 곳으로 되돌아감

void printGugudan(int dan) {
	if(!(2 <= dan && dan <= 9))
    	return; //dan의 값이 2~의가 아닌경우, 호출한 곳으로 되돌아감
        
        for(int i = 1; i <= 9; i++) {
        	System.out.printf(%d * %d = %d%m, dan , i, dan * i);
            }
            return; // 반환타입이 void이므로 생략가능. 컴파일러가 자동추가
    }
    
    int multiply(int x, in y) {
    	int result = x * y;
        return result; // 반환타입이 void가 아니므로 생략 불가
    }
    int max(int a, int b) {
    	if(a > b)
        	return a; // 조건식이 참일때만 실행 됨 -> 에러발생
    }
    
   int max(int a, int b) {
    	if(a > b)
        	return a; //조건식이 참일 때 실행
        else
        	return b;//조건식이 거짓일 때 실행 
    }

호출 스택 (call stack): 메서드 수행에 필요한 메모리가 제공되는 공간으로 메서드가 호출되면 호출스택에 메모리 할당하고 종료되면 해제

스택(stack): 밑이 막힌 상자로 위에 차곡 차곡 쌓임, 하나의 스택에서는 하나의 메서드가 실행 됨(나머지는 대기중)

 

기본형 매개변수: 변수의 값을 읽기만 할 수 있음, 값을 넘기는거

class Data { int x; }

class Ex6_6 {
	public static void main(String[] args) {
		Data d = new Data(); //객체 생성
		d.x = 10;
		System.out.println("main() : x = " + d.x); // 출력1 main() : x = 10

		change(d.x);
		System.out.println("After change(d.x)"); // 출력3 After change(d.x)
		System.out.println("main() : x = " + d.x); // 출력4 main(0 : x = 10
	}

	static void change(int x) {  // 기본형 매개변수
		x = 1000;
		System.out.println("change() : x = " + x); // 출력2 chage() : x = 1000
	}
}

결과
main() : x = 10
chage() : x = 1000
After change(d.x)
main(0 : x = 10

참조형 매개변수: 변수의 값을 읽고 변경 할 수 있음, 주소를 넘기는거

class Data2 { int x; }

class Ex6_7 {
	public static void main(String[] args) {
		Data2 d = new Data2();
		d.x = 10;
		System.out.println("main() : x = " + d.x); // 출력1 main() : x = 10

		change(d);
		System.out.println("After change(d)"); // 출력3 After change(d)
		System.out.println("main() : x = " + d.x); // 출력4 main() : x = 1000
	}

	static void change(Data2 d) { // 참조형 매개변수
		d.x = 1000;
		System.out.println("change() : x = " + d.x); // 출력2 change() : x = 1000
	}
    
    결과
    main() : x = 10
    change() : x = 1000
    After change(d)
    main() : x = 1000

참조형 반환타입

class Data3 { int x; }

class Ex6_8 { //객체 생성 한다면 Ex6_8 e = new Ex6_8(); 호출은 e.copy();이런식으로 해야지만 static메서드라 객체 생성 안하고 참조변수 없이 호출 
	public static void main(String[] args) {
		Data3 d = new Data3();
		d.x = 10;

		Data3 d2 = copy(d); //참조변수 없는 이유: 1. 같은 클래스 안에 있어서 2. static 메서드라서
		System.out.println("d.x ="+d.x); // 출력1 d.x = 10
		System.out.println("d2.x="+d2.x); // 출력2 d2.x = 10
	}

	static Data3 copy(Data3 d) { // 참조형 반환타입은 개체의 주소를 반환한다, static 메서드는 객체 생성 없이 호출 가능
		Data3 tmp = new Data3();    // 새로운 객체 tmp 생성

		tmp.x = d.x;  // d.x의 값을 tmp.x에 복사

		return tmp;   // 복사한 객체 주소 반환
	}
}

static 메서드와 인스턴스 메서드

인스턴스 메서드	static 메서드(클래스 메서드)
객체 생성 후 사용되는 인스턴스 변수 사용 '참조변수.메서드명()'으로 호출	객체 생성 없이 사용(언제나 사용 가능) '클래스이름.메서드명()'으로 호출
인스턴스 멤버(iv, im)와 관련된 작업을 하는 메서드	인스턴스 멤버(iv, im)와 관련없는 작업을 하는 메서드
메서드 내에서 인스턴스 변수(iv) 사용 가능	메서드 내에서 인스턴스 변수(iv)사용 불가

class MyMath2 {
	long a, b; // 인스턴스 변수(iv)
    
	// 인스턴스 메서드
	long add()	{ return a + b; }  
	long subtract() { return a - b; }
	long multiply() { return a * b; }
	double divide() { return a / b; }

	// 클래스 메서드(static 메서드)
	static long   add(long a, long b)	{ return a + b; }  // a, b는 지역변수(lv), 인스턴스 변수(iv)를 사용하면 static 붙일 수 없음
	static long   subtract(long a, long b)	{ return a - b; }
	static long   multiply(long a, long b)	{ return a * b; }
	static double divide(long a, long b)	{ return a / (double)b; }
	
}

class Ex6_9 {
	public static void main(String args[]) {
		// 클래스 메서드 호출 형식: 클래스명.메서드명();  // 객체 생성없이 호출 가능
		System.out.println(MyMath2.add(200L, 100L));
		System.out.println(MyMath2.subtract(200L, 100L));
		System.out.println(MyMath2.multiply(200L, 100L));
		System.out.println(MyMath2.divide(200L, 100L));

		MyMath2 mm = new MyMath2(); // 인스턴스 생성 // 객체 생성하고 메서드 호출
		mm.a = 200L;
		mm.b = 100L;
		// 인스턴스 메서드 호출 형식: 참조변수명.메서드명();
		System.out.println(mm.add());
		System.out.println(mm.subtract());
		System.out.println(mm.multiply());
		System.out.println(mm.divide());
   }
}

static을 언제 붙여야 할까?

속성(멤버 변수) 중에서 공통 속성에 static을 붙임

class Card {
	String kind; //인스턴스 변수(개별 속성) 
	int number
    
	static int width = 100; //클래스 변수(공통 속성)
	static int height = 250;
}

인스턴스 멤버(iv, im)을 사용하지 않는 메서드에 static을 붙임

Class MyMath2 {
	long a, b;
    
    	long add() {return a + b;} // a, b는 인스턴스 변수
 static long add(long a, long b) {return a + b;} // a, b는 지역 변수
 }

메서드 간의 호출과 참조

static메서드는 인스턴스 변수(iv)를 사용할 수 없음

static 메서드는 인스턴스 메서드(im)를 호출할 수 없음  // 인스턴스 메서드는 인스턴스 변수를 사용하는 메서드

-

생성자(cnstructor)

인스턴스가 생성될 때마다 호출되는 '인스턴스 초기화 메서드'

인스턴스 생성 시 수행할 작업(iv 초기화)에 사용

생성자의 이름은 클래스 이름과 같아야 함

리턴값이 없음(void 안붙임)

모든 클래스는 반드시 1개 이상의 생성자를 가져야 함(생성자 필수)

 

기본 생성자(default constructor)

매개변수가 없는 생성자

생성자가 하나도 없을 때만 컴파일러가 자동 추가 함

class Data_1 {
	int value; // 생성자가 하나도 없어서 컴파일러가 기본 생성자Data_1() {} 자동 추가
}

class Data_2 {
	int value;

	Data_2(int x) {   // 매개변수가 있는 생성자, 기본 생성자 Data_2() {}추가 필요
		value = x;
	}
}

class Ex6_11 {
	public static void main(String[] args) {
		Data_1 d1 = new Data_1(); // Data1클래스에서 자동으로 생성된 기본 생성자로인해 error발생하지 않음
		Data_2 d2 = new Data_2(); // 기본 생성자 호출 compile error발생
	}
}

매개변수가 있는 생성자

class Car {
	String color;		// 색상
	String gearType;	// 변속기 종류 - auto(자동), manual(수동)
	int door;			// 문의 개수

	Car() {} // 기본 생성자

	Car(String c, String g, int d) { // 매개변수가 있는 생성자
		color = c;
		gearType = g;
		door = d;
	}
}

class Ex6_12 {
	public static void main(String[] args) {
		Car c1 = new Car();
		c1.color    = "white";
		c1.gearType = "auto";
		c1.door = 4;

		Car c2 = new Car("white", "auto", 4);

		System.out.println("c1�� color=" + c1.color + ", gearType=" + c1.gearType+ ", door="+c1.door);
		System.out.println("c2�� color=" + c2.color + ", gearType=" + c2.gearType+ ", door="+c2.door);
	}
}

생성자 this(), this(매개변수)

같은 클래스 생성자에서 다른 생성자 호출할 때 사용

다른 생성자 호출 시 첫줄에서만 사용 가능

class Car2 {
	String color;		// 색상
	String gearType;	// 변속기 종류 - auto(자동), manual(수동)
	int door;			// 문의 개수

	Car2() {
		this("white", "auto", 4); //Car2(String color, String gearType, int door)를 호출
	}

	Car2(String color) {
		this(color, "auto", 4);
	}

	Car2(String color, String gearType, int door) {
		this.color = color;
		this.gearType = gearType;
		this.door = door;
	}
}
class Ex6_13 {
	public static void main(String[] args) {
		Car2 c1 = new Car2();	
		Car2 c2 = new Car2("blue");

		System.out.println("c1�� color=" + c1.color + ", gearType=" + c1.gearType+ ", door="+c1.door);
		System.out.println("c2�� color=" + c2.color + ", gearType=" + c2.gearType+ ", door="+c2.door);
	}
}

참조변수 this

인스턴스 자신을 가리키는 참조변수로 인스턴스의 주소가 저장되어 있음

인스턴스 메서드(생성자 포함)에서 사용 가능(모든 인스턴스 메서드에 지역변수로 숨겨진 채로 존재)

지역변수(lv)와 인스턴스 변수(iv)구별할 때 사용

Car(String c, String g, int d) { // 매개변수가 있는 생성자
		color = c; //color는 인스턴스 변수(iv), c는 지역변수(lv), 같은 클래스 내에서는 this 생략 가능
		gearType = g;
		door = d;
}

Car(String color, String gearType, int door) {
		this.color = color; // this.color는 인스턴스 변수(iv), color는 지역변수(lv)
		this.gearType = gearType;
		this.door = door;
}

 

class MyMath2 {
	long a, b; // 인스턴스 변수(iv)의 진짜 이름은 this.a, this.b
    
    MyMath2(int a, int b) { // 생성자
    	this.a = a; // this.a는 인스턴스 변수, a는 지역변수(lv) // 이름이 같아서 iv와 lv 구분 안가서 this 붙임
        this.b = b;
    }
    
	long add() { // 인스턴스 메서드
    	return a + b; // return this.a + this.b; this는 생략 가능
	

	// 클래스 메서드(static 메서드)
	static long   add(long a, long b)	{ return a + b; }  // a, b는 지역변수(lv), 인스턴스 변수(iv)라서 this가 오는 경우x , 인스턴스 변수는 static 붙일 수 없음
	static long   subtract(long a, long b)	{ return a - b; }
	static long   multiply(long a, long b)	{ return a * b; }
	static double divide(long a, long b)	{ return a / (double)b; }
	
}

-

변수의 초기화

지역변수(lv)는 수동 초기화 해야함

-

상속(Inheritance)

기존의 클래스로 새로운 클래스를 작성하는 것 -> 코드의 재사용

두 클래스를 부모와 자식으로 관계 맺어주는 것

class 자식클래스 extends 부모클래스 {
//...
}

자손은 조상의 모든 멤버를 상속받음(생성자, 초기화 블럭 제외)

자손의 멤버 개수는 조상보다 적을 수 없음(같거나 많다)

자손의 변경은 조상에 영향을 미치지 않음

class Tv {
	boolean power; // 전원상태(on/off)
	int channel;	// 채널

	void power()       {   power = !power; }
	void channelUp()   {   ++channel;      }
	void channelDown() {   --channel;      }
}

class SmartTv extends Tv {  // smartTv는 Tv에 Caption)자막)을 보여주는 기능
	boolean caption;     // 캡션 상태(on/off)
	void displayCaption(String text) {
		if (caption) {   // 캡션 상태가 on(true)일 때만 text를 보여줌
			System.out.println(text);
		}
	}
}

class Ex7_1 {
	public static void main(String args[]) {
		SmartTv stv = new SmartTv();
		stv.channel = 10;			// 조상 클래스로부터 상속받은 멤버
		stv.channelUp();			// 조상 클래스로부터 상속받은 멤버
		System.out.println(stv.channel);
		stv.displayCaption("Hello, World");
		stv.caption = true;	// 캡션(자막)기능을 켠다       
		stv.displayCaption("Hello, World");
	}
}

포함 관계

포함(composit)

클래스의 멤버로 참조변수를 선언하는 것

작은 단위의 클래스를 만들고 이 들을 조합해서 클래스를 만듦

 

클래스 간의 관계 결정하기

상속관계: A는 B이다.(is-a) Circle is a Point 

포함관계: A는 B를 가지고있다.(has-a) Circle has a Point // 보통 포함 관계가 많이 쓰임

 

4. 참고 레퍼런스

 

5. 오늘 한 일 / 회고

6. TO-DO LIST

7. 특이사항