1. 객체지향 언어

• '80년 초 소프트웨어 위기' -> 빠른 변화를 못쫓아감
• 해결책으로 객체지향 언어를 도입(절차적 -> 객체지향, 1960 simula)
• 코드의 재사용성이 높고 유지보수가 용이, 중복 코드 제거
• 객체지향 언어 = 프로그래밍 언어 + 객체지향 개념(규칙)
• 하드웨어 -> 소프트웨어화

1. 객체지향의 핵심 4가지(Object Oriented Programming)

• 캡슐화
• 상속
• 추상화
• 다형성

2. 클래스와 객체

• 클래스의 정의 : 클래스란 객체를 정의해 놓은 것
• 클래스의 용도 : 클래스는 객체를 생성하는데 사용
• 객체의 정의 : 실제로 존재하는 것, 사물 또는 개념
• 객체의 용도 : 객체가 가지고 있는 기능과 속성에 따라 다름

클래스		객체
제품 설계도	제품
TV 설계도	TV
붕어빵 기계	붕어빵

3. 속성과 기능

• 객체 = 속성(변수) + 기능(메서드)

TV
속성 :	크기, 길이, 높이, 색상, 볼륨, 채널 등
기능 :	켜기, 끄기, 볼륨 높이기, 볼륨 낮추기, 채널 변경하기 등

class TV {
	String color;
    boolean power;
    int channel;
    
    void power() { power = !power; }
    void channelUp() { channel++; }
    void channelDown() { channel--; }
}

4. 객체와 인스턴스

• 객체 : 모든 인스턴스를 대표하는 일반적 용어
• 인스턴스 : 특정 클래스로부터 생성된 객체(예: TV인스턴스)
• 클래스 -인스턴스화-> 인스턴스(객체)

번외

• 클래스가 왜 필요한가?
  • 객체를 생성하기 위해
• 객체가 왜 필요한가?
  • 객체를 사용하기 위해
• 객체를 사용한다는 것은?
  • 객체가 가진 속성과 기능을 사용하려고

5. 하나의 소스파일에 여러 클래스 작성

올바른 작성 예		설명

Hello2.java
public class Hello2 {}	public class가 있는 경우, 
       class Hello3 {}	소프파일의 이름은 반드시 public class의 이름과 일치해야 한다

Hello2.java
class Hello2 {}		publick class가 하나도 없는 경우,
class Hello3 {}		소스파일의 이름은 'Hello2.java', 'Hello3.java'둘 다 가능하다

잘못된 작성 예		설명

Hello2.java		하나의 소스파일에 둘 이상의 public class가 존재하면 안된다
public class Hello2 {}	각 클래스를 별도의 소스파일에 나눠서 저장하던가
public class Hello3 {}	아니면 둘 중의 한 클래스에 public을 붙이지 않아야 한다

Hello3.java
public class Hello2 {}	소스파일의 이름이 public class의 이름과 일치하지 않는다
       class Hello3 {}	소스파일의 이름을 'Hello2.java'로 변경해야 맞다
       
hello2.java		소스파일의 이름과 public class의 이름이 일치하지 않는다
public class Hello2 {}	대소문자를 구분하므로 대소문까지 일치해야 한다
       class Hello3 {}	그래서, 소스파일의 이름에서 'h'를 'H'로 바꿔야 한다

6. 객체의 생성과 사용

• 객체의 생성

클래스명 변수명;		// 클래스의 객체를 참조하기 위한 참조변수를 선언
변수명 = new 클래스명(); 	//클래스의 객체를 생성 후, 객체의 주소를 참조변수에 저장

Tv t;		// Tv클래스 타입의 참조변수 t를 선언
t = new Tv();	// Tv인스턴스를 생성한 후, 생성된 Tv인스턴스의 주소를 t에 저장

• 객체의 사용

t.channel = 7;		// Tv인스턴스의 멤버변수 channel의 값을 7로 한다
t.channelDown();	// Tv인스턴스의 메서드 channelDown()을 호출한다
System.out.println("현재 체널은"+t.channel+" 입니다");

• 객체의 생성과 사용 예제
  

7. 선언위치에 따른 변수의 종류

class Variables { // 1. 클래스 영역
	int iv; // 인스턴스 변수
    	static int cv; // 클래스 변수(static변수, 공유변수)
        
        void method() { // 2. 메서드 영역
        	int lv = 0; // 지역변수
        }
}

• 영역
  • 클래스 영역 : iv(intance variable), cv(class value, iv + static)
  • 메소드 영역 : lv(local variable)
    
    

8. 클래스 변수와 인스턴스 변수

9. 메서드란?

• 문장들을 작업단위로 묶어놓은 것
• 값(입력)을 받아서 처리하고, 결과를 반환(출력)
• 메서드의 장점
  • 코드의 중복을 줄일 수 있다
  • 코드의 관리가 쉽다
  • 코드를 재사용할 수 있다
  • 코드가 간결해서 이해하기 쉬워진다
• 메서드의 작성
  • 반복적으로 수행되는 여러 문장을 메서드로 작성
  • 하나의 메서드는 한 가지 기능만 수행하도록 작성

// 코드중복이 발생
public static void main(String args[]) {
	...
	for(int i = 0; i < 10; i++) {
    		numArr[i] = (int)(Math.random()*10);
    	}
    	// *
	for(int i = 0; i < 10; i++) {
    		System.out.printf("%d", numArr[i]);
    	}
    	System.out.printnl();
    	...
    	// *
    	for(int i = 0; i < 10; i++) {
    		System.out.printf("%d", numArr[i]);
    	}
	System.out.printnl();
}

// 코드 중복된 부분을 메소드로 만들기!
static void printArr(int[] numArr) {
	for(int i = 0; i < 10; i++) {
    		System.out.printf("%d", numArr[i]);
    	}
        System.out.printnl();
}
public static void main(String args[]) {
	...
	for(int i = 0; i < 10; i++) {
    		numArr[i] = (int)(Math.random()*10);
	}
    	printArr(numArr); // 배열을 출력, 메소드 호출
    	...
    	printArr(numArr); // 배열을 출력, 메소드 호출
}

• 메서드 = 선언부 + 구현부

반환타입 메서드이름 (타입 변수명, 타입 변수명, ...) {  // 선언부
	// 메서드 호출시 수행될 코드 		// 구현부
}

int add (int a, int b) { 	// 선언부
	int result = a + b; 	// 구현부
    return result;		// 구현부
}

• 지역변수(lv, Local Variable) : 메서드 내에 선언된 변수

int add(int x, int y) { 	// 매개변수, 지역변수 x, y
	int result = x + y; 	// 지역변수 result
    return result;
}

10. 메서드의 호출

• 메서드이름(값1, 값2, ...); // 메서드 호출하는 방법
• print99danAll(); // void print99danAll()을 호출
• int result = add(3, 5); // int add(int x, int y)를 호출하고, 결과를 result에 저장

11. 메서드의 실행흐름

• main메서드에서 메서드 add를 호출한다, 인수 1L과 2L이 메서드 add의 매개변수 a, b에 가각 복사(대입) 된다
• 메서드 add의 괄호{}안에 있는 문장들이 순서대로 수행된다
• 메서드 add의 모든 뭄ㄴ장이 실행되거나 return문을 만나면, 호출한 메서드(main메서드)로 되돌아와서 이후의 문장들을 실행 한다

MyMath mm = new MyMath(); // 먼저 인스턴스를 생성한다

long value = mm.add(1L, 2L); // 메서드를 호출한다

long add(long a, long b) {
	long result = a + b;
    return result;
}

12. return 문

• 실행 중인 메서드를 종료하고 호출한 곳으로 되돌아간다

void printGugudan(int dan) {
	if(!(2 <= dan && dan <= 9))
    	return; // dan의 값이 2 ~ 9가 아닌 경우, 호출한 곳으로 그냥 되돌아간다
        
    for(int i = 1; i <= 9; i++) {
    	System.out.printf("%d * %d = %d%n", dan, i, dan * i);
    }
    return; // 반환 타입이 void이므로 생략가능, 컴파일러가 자동 추가
}

• 반환타입이 void가 아닌 경우, 반드시 return문이 필요

int multiply(int x, int y) {
	int result = x * y;
    	return result;
}
// error return문이 없다
int max(int a, int b) {
	if(a > b)
    		return a; // 참일 때만 return이 있기에 오류가 발생한다
}

// 수정
int max(int a, int b) {
	if(a > b)
    		return a;
    	else 
        	return b;
}

13. 반환 값

• 반환 타입이 void가 아닐때 반드시 필요하다
• 반환 값의 타입은 반환 타입과 일치해야 된다(자동형 변환 가능한 값 return)
• return 값을 받는 변수도 타입을 맞춰줘야 한다

14. 호출 스택(call stack)

• 스택(stack) : 밑이 막힌 상자, 위에 차곡 차곡 쌓인다
  
  
  
• 메서드 수행에 필요한 메모리가 제공되는 공간
• 메서드가 호출되면 호출스택에 메모리 할당, 종료되면 해제
  

class EX {
	public static void main(String[] args) {
    		System.out.println("Hello");
    	}
}

15. 기본형 매개변수

• 기본형 매개변수 : 변수의 값을 읽기만 할 수 있다.(read only)
  

16. 참조형 매개변수

• 참조형 매개변수 : 변수의 값을 읽고 변경할 수 있다.(read & write)
  

17. 참조형 반환타입

• 참조형 매개변수를 활용하여 새로운 객체를 만들어 반환한다
  
• static메소드를 활용한 참조형 변수타입
  

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

class test {
	long a, b;
    
    	long add() { // 인스턴스 메서드, static이 안붙음 클래스메서드
        	return a+b;
        }
        
        static long add(long a, long b) { // 클래스메서드(static 메서드)
        	return a+b;
        }
}

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

19. static을 언제 붙여야 할까?

• 속서(멤버 변수)중에서 공통 속성에 static을 붙인다
  
• 인스턴스 멤버(iv, im)을 사용하지 않는 메서드에 static을 붙인다
  

20. 메서드 간의 호출과 참조

• static 메서드는 인스턴스 변수(iv)를 사용할 수 없다(객체가 있을지 없을지 모르기 때문에 불가)
  

• static 메서드는 인스턴스 메서드(im)를 호출할 수 없다
  

번외

• static 메서드는 static 메서드 호출 가능?
  • 네, static은 언제나 호출이 가능하다
• static 메서드는 인스턴스 변수 사용가능?
  • 아니요, 인스턴스 변수는 객체를 생성 후에야 사용가능한데 static이 호출이 되었을 때 객체의 생성 여부판단이 어려움
• static 메서드는 인스턴스 메서드 호출 가능?
  • 아니요, 위에 답과 같이 객체 생성 여부판단이 어려움
• 왜? static 메서드는 인스턴스 멤버(iv, im)를 쓸 수 없나요?
  • static메서드 호출시 객체(iv묶음)가 없을 수도 있어서

21. 오버로딩(overloading)

• 한 클래스 안에 같은 이름의 메서드 여러개 정의하는 것

void println()
void println(boolean x)
void println(char x)
void println(char[] x)
void println(double x)
void println(float x)
void println(int x)
void println(long x)
void println(Object x)
void println(String x)

• 오버로딩이 성립하기 위한 조건
  • 메서드 이름이 같아야 한다
  • 매개변수의 개수 또는 타입이 달라야 한다
  • 반환 타입은 영향없다

// 오버로딩X, 메서드 중복 정의
int add(int a, int b) {return a+b;}
int add(int x, int y) {return x+y;}
long add(int a, int b) {return a+b;}

// 오버로딩 O, 하지만 호출시에 인수값이 모호하여 에러가 발생할 수 있음
int add(int a, int b) {return a+b;}
int add(long a, int b) {return a+b;}

• 오버로딩의 올바른 예 : 매개변수는 다르지만 같은 의미의 기능수행

int add(int a, int b) {
	System.out.println("int add(int a, int b) - ");
    	return a+b;
}

long add(long a, long b) {
	System.out.println("long add(long a, long b) - ");
    	return a+b;
}

int add(int[] a) {
	System.out.println("int add(int[] a) - ");
    	int result = 0;
    	for(int i = 0; i < a.length; i++)
        	result += a[i];
    	return result;
}

22. 생성자(constructor)

• 인스턴스가 생성될 때마다 호출되는 '인스턴스 초기화 메서드'
• 인스턴스 생성시 수행할 작업(iv 초기화)에 사용
  
• 생성자 규칙
  • 생성자 이름이 클래스 이름과 같아야 한다

    클래스이름 (타입 변수명, 타입 변수명, ...) {
    	// 인스턴스 생성 시 수행될 코드,
     	// 주로 인스턴스 변수의 초기화 코드를적는다
    }

  • 리턴값이 없다.(void 안붙임)
  • 모든 클래스는 반드시 생성자를 가져야 한다(최소 1개)

23. 기본 생성자(default constructor)

• 매개 변수가 없는 생성자
• 생성자가 하나도 없을 때만, 컴파일러가 자동 추가

클래스이름(){}	// 기본 생성자
Point(){}	// Point클래스의 기본 생성자

24. 매개변수가 있는 생성자

class Car{
	String color;
    	String gearType;
        int door;
        
        Car() {};
        Car(String color, String gearType, int door) {
        	this.color = color;
            	this.gearType = gearType;
                this.door = door;
        }
}

25. 생성자 this()

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

class Car{
	String color;
    	String gearType;
        int door;
        
        Car() {
        	this("white", "auto", 4)
        };
        Car(String color) {
        	this(color, "auto", 4)
        }
        Car(String color, String gearType, int door) { // 참조가 되는 생성자 함수
        	this.color = color;
            	this.gearType = gearType;
                this.door = door;
        }
}

26. 참조변수 this

• 인스턴스 자신을 가리키는 참조변수
• 인스턴스 메서드(생성자 포함)에서 사용가능
• 지역변수(lv)와 인스턴스 변수(iv)를 구별할 때 사용

class Car{
	String color;
    	String gearType;
        int door;
        
        Car(String color, String gearType, int door) {
        	//  this.변수명 iv, 변수명 lv
        	this.color = color;
            	this.gearType = gearType;
                this.door = door;
        }
}

27. 참조변수 this와 생성자 this()

this : 인스턴스 자신을 가리키는 참조변수, 인스턴스의 주소가 저장되어 있다
       모든 인스턴스메서드에 지역변수로 숨겨진 채로 존재
this(), this(매개변수) : 생성자, 같은 클래스의 다른 생성자를 호출할 때 사용

• this와 this()는 비슷하게 생겼을 뿐 완전히 다른 것이다
• this는 '참조변수'이고 this()는 '생성자'이다

28. 변수의 초기화

• 지역변수(lv)는 수동 초기화 해야함(사용전 꼭!!!)
• 멤버변수(iv, cv)는 자동 초기화된다.

class IntiTest {
	int x;
    	int y = x;
        
        // 지역변수는 메소드 호출시에만 잠시 생성이 되기 때문에 수동 초기화를 해주어야 한다
        void methid1() {
        	int i;
            	int j = i; //Error, 지역변수를 초기화하지 않고 사용
        }
}

• 명시적 초기화(=)

class Car{
	int door = 4; // 기본형(primitive type) 변수의 초기화
    	Engine e = new Engine(); // 참조형(reference type) 변수의 초기화
}

• 초기화 블록 (복잡한 초기화, 여러문장 넣기)
  • 인스턴스 초기화 블럭 : {}
  • 클래스 초기화 블럭 : static {}
• 생성자 (iv 초기화, 복잡한 초기화)

Car(String color, String geartype, int door) {
	this.color = color;
    	this.gearType = gearType;
    	this.door = door;
}

• cv, iv 초기화 3가지
  • 자동초기화 : default
  • 간단초기화 : =
  • 복잡초기화 : {}
    - cv : static
    - iv : 생성자
    

29. 멤버변수의 초기화

• 클래스 변수 초기화 시점 : 클래스가 처음 로딩될 때 단 한번
• 인스턴스 변수 초기화 시점 : 인스턴스가 생성될 때 마다