[TIL] 2022-11-17(14day)

👉 객체 지향 

 

코드 재사용성이 높다 : API 사용
코드 관리가 쉽다 : 상속, 다향성, 추상화. 캡슐화
신뢰성이 높은 프로그램 개발 가능

-1) 캡슐화 (encapsulation) : 자바가 지향하는 코드 스타일

     # 데이터와 관련 기능을 묶는다.

     # 객체가 어떻게 행동(기능)하는지 외부에 노출하지 않는다.

     # 정보 은닉

     # 객체 내부 행동(기능)이 변경 되더라도, 외부에 영향을 주지 않는다.

 

-2) 상속 (inheritance)

-3) 다형성 (polymorphism)

     # 다양한 모습을 갖는 것

     # 한 객체가 다양한 타입을 갖는 것

     # 한 객체가 여러 타입의 기능을 제공

     # 타입 상속으로 다형성 구현 (상속관계에서 성립)

     # 같은 이름의 기능이 클래스나 객체에 따라 다르게 동작하도록 구현되는 것.

---

👉 접근제어자 (access modifier)

private : 같은 클래스 내에서만 접근이 가능.

default(nothing) : 같은 패키지 내에서만 접근이 가능.
protected : 같은 패키지 내에서, 그리고 다른 패키지의 자손클래스에서 접근이 가능.
public : 접근 제한이 전혀 없음.

---

👉 클래스와 객체

-1) 클래스 (설계도) == 붕어빵 틀
객체를 정의해 놓은 것, 용도는 객체를 만들기 위한 것

-2) 객체(인스턴스) == 붕어빵
실제로 존재하는 것, 클래스 모양 (설계) 그대로 생성된 실체

-3) 객체 : 속성 + 기능
속성과 기능을 통틀어 맴버라고 부른다.
속성 : 맴버변수, 필드
기능 : 매서드 

-4) 객체를 생성과 사용

class Phone { //Phone 이라는 클래스
    String model; //변수(속성)와 메서드(기능)
    String color;
    int price;
}

public class Main {
    public static void main(String[] args) {
        Phone galaxy = new Phone(); //Phone의 속성을 가진 galaxy 인스턴스 생성
        galaxy.model = "Galaxy10";
        galaxy.color = "Black";
        galaxy.price = 100;
        
        Phone iphone =new Phone(); //Phone의 속성을 가진 iphone 인스턴스 생성
        iphone.model = "iPhoneX";
        iphone.color = "Black";
        iphone.price = 200;
        

        System.out.println("철수는 이번에 " + galaxy.model + galaxy.color + " + 색상을 " + galaxy.price + "만원에 샀다.");
        System.out.println("영희는 이번에 " + iphone.model + iphone.color + " + 색상을 " + iphone.price + "만원에 샀다.");
    }
}

#1. 클래스명은 첫글자 대문자, 숫자로 시작 X, 띄어쓰기 X, 특수기호 _ $ 만 허용
패키지내 클래스명은 한개만 존재해야함.

#2. 객체 생성
**선언**
클래명 참조변수명; : String str;

**생성**
참조변수명 = new 클래스 명 ()

**선언 + 생성 **
클래스명 참조 변수명 = new 클래스명 ();
Scanner sc = new Scanner();

참조 변수 (레퍼런스 변수) : 객체를 가르키는, 객체의 주소 (레퍼런스)
new : 클래스 모양의 메모리를 점유하는 문법적으로 중요한 키워드

 

#3. 객체 사용
참조변수명.변수 = 값;
참조변수명.메서드();


 ---> 정리
클래스 == 사용자 정의 데이터 타입
기본형 : 메모리 양이 정해진것
클래스 : 개발자가 필요한 만큼 메모리 크기를 직접 지정해서 만든것.
클래스 : 유사한 특징을 지닌 객체들의 속성과 기능을 묶어 놓은 집합

---

👉 변수의 종류

: 선언 위치(어디서 변수가 만들어졌느냐)에 따라 변수의 종류와 성질이 달라짐.

-1) 클래스 변수  (static 변수)
- 클래스 안에 생성 (메서드 밖)
- 이름앞에 static 키워드가 붙는다

- 종류 : 클래스 기본형 변수(int string) / 클래스 참조형 변수(tv.. /
- 특징 : 모든 객체들이 공유하는 변수
 프로그램시작하면 먼저 한번만 로딩하고,
 new로 객체생성하지 않아도 바로 사용가능.
- 접근방법 
클래스명.변수명
참조변수명.변수명

-2) 인스턴스 변수 
- 클래스 안 생성 (메서드 밖)
- 종류 : 인스턴스 기본형 변수 / 인스턴스 참조형 변수 
- 특징 : 각 객체(인스턴스)의 개별적인 저장 공간 갖는다.
new~ 로 객체생성한 후 메모리가 점유되면 사용가능.
가르키는 참조변수가 없을 경우 가비지 컬렉터가 수거 or 프로그램 종료시 소멸됨.
- 접근 방법
참조변수명. 변수명

-3) 지역 변수   
- 메서드 안 생성
- 종류 : 지역 기본형(int, char 소문자) 변수 / 지역 참조형(Scanner, String 대문자) 변수
- 특징 : 메서드 (,조건문 , 반목문) 내에서 선언된 변수를 가르키며, 메서드 종료시 소멸

# 메모리 로딩순서
클래스 영역-> static -> main 실행 -> (new~~) 인스턴스 생성 
:클래스 범위 만들고
| static 붙은 아이들 모두 로딩
|메인 있다면 실행
| new로 객체 생성된 아이들 실행

---

👉 메서드 method

-1) 메서드 : 함수
어떠한 작업을 수행하기 위한 명령문들의 집합. main()도 메서드
메서드 -> 연산을 처리하는 곳
변수 -> 그 결과를 저장하는 곳
메서드는 어떤 값을 입력 받아 처리하고, 그 결과(하나만)를 돌려준다. (입력값, 리턴값 유/무)

목적, 장점 : 재사용 : 반복적인 코드를 줄이고 코드 관리가 용이함.
ex) System.out.println(); 출력해주는 메소드

-2) 메서드의 정의와 사용
#1. 입력값 x , 리턴값 x
#정의
리턴타입 메서드명(){
실행할 코드들
}

#사용(호출)
메서드명();

#2. 입력값 o , 리턴값 o

int add(int x, int y) { //타입 파라미터명, 타입 파라미터명
    int result = x + y; //실행할 코드
    return result; //리턴값
}

#사용
메서드명(인자, 인자,....); 

-3) 용어 정리
리턴타입 : 메서드의 작성된 코드를 실행하고 리턴해주는 결과의 타입.
모든 타입이 될 수 있고, 리턴해줄것이 없다면 void 라고 작성.

메서드명 : 변수명명규칙 참고 (소문자) , 무슨 작업을 하는지 유추 가능한 이름으로 만들기
파라미터 : 매개변수, arguments
메서드를 실행할때(부를떄) 외부에서 던져주는 데이터를 받아주는 변수
메서드에 입력받을 값을 담아주는 변수
외부에서 던져주는 값이 없다면 괄호안 비워두기

return   : 함수를 호출한 곳으로 값을 돌려주는 키워드
1) 메서드를 종료시킴
2) 뒤에 작성한 값을 호출한 곳으로 
리턴타입이 void가 이 아닌 이상 반드시 return 값이 있어야한다.
리턴타입과 return 뒤에 기입할 데이터의 타입이 동일해야함.
void 타입에서도 어떤 조건에 의해 메서드가 중간에 강제종료하고 싶을때는 return; 값 없이 키워드만 사용가능
인자(파라미터) : 매개변수, 인수, 인자값, 인수값, 파라니처, arguments
메서드 호출시, 메서드에게 던져줄 데이터를 말함.

🔥 인자와 파라미터의 개수/순서/데이터타입은 반드시 일치해야함.

-4) 메서드의 종류
#1. 클래스 메서드 : static이 붙은 메서드 (객체 생성안하고❌ 바로 사용가능)

#2. 인스턴스 메서드 : 일반메서드 (객체 생성✔️ 후 사용가능)
(같은 클래스안에 있는 애들을 부를때는 메모리 생성 시기가 같아서 객체생성 안해도 됨.)

-5) main() 메서드
public static void main(String[] args){
}

 

👉 메서드 인자 전달 방식

자바의 인자 전달 방식은 "값의 의한 호출 : Call-by-value" 이다.
호출하는 곳에서의 인자값이 복사되어 파라미터에게 전달된다.

1) 기본형 값 전달 : read only : 값만 복사해줌. 원본 훼손 x
2) 참조형 값 전달 : read & write : 객체의 레퍼런스(주소값)이 전달된다.

---

👉 추상클래스

• 기본적으로 클래스이다. 상속, 확장하여 사용하기 위한 것
• 여러 하위 클래스가 동일한 구현으로 로직을 수행 + 일부 로직이 다를 때 추상클래스 사용 고민 (Template Method 패턴)

# 클래스를 상속받아 이용 및 확장을 위함

   (부모의 기능을 확장하는 개념)

#다중 상속 불가능 , 단일 상속

# extends를 이용하여 구현

# 추상메소드에 대한 구현 가능

# 생성자와 일반변수 모두 가질 수 있다.

-1) 설계와 구현을 분리한다면, 설계부분에 해당
-2) 키워드 : abstract
-3) 추상메서드 : abstract 키워드를 붙혀 메서드의 선언분(원형)만 있고
구현은 되어있지 않은 형태 (중괄호 부분 없음) 
  public String getNAme(){} 이지만 
->로 표현 public abstract String getName();


-4) 추상클래스 : 일반 맴버 (변수, 메서드)들과 함께 추상 메서드를 포함하는 클래스
추상 메서드가 하나라도 있으면 무조건 추상 클래스
추상 클래스가에는  abstract 키워드를 붙혀야 한다.

abstract class Sharpe{ // 추상클래스
int a ;
abstract void draw(); //추상 메서드
}

-5) 추상 클래스로는 객체 생성 불가!! 불완전한 / 미완성인 클래스이므로 메모리에 올릴 수 없다
Shape s = new Shape ();   -----> (X)
Shape s;  ----> (O) 변수 선언만은 괜찮다.

-6) 상속에서 수퍼클래스로 사용된다. 부모 클래스 될 수 있음. extends 키워드로 상속시킬수 있다.

-7) 추상클래스를 물려받은 자식클래스를 완성시키려면 추상메서드를 오버라이딩(내용물 구현)해야한다.
추상클래스를 단순히 상속만 받은 자식클래스는 그 또한 추상클래스가 된다.

# 추상 클래스 단순 상속  : 상속받은 추상 메서드 구현 안하면,
abstract class Rect extends Shape {
int width
}

# 추상 클래스를 상속 + 구현 
class Rect extends Shape {
int width;
@override
void draw(){....
}
}

8) 추상클래스를 상속받은 자식클래스는 개발자들이 추상메서드를 모두 구현해야함.
-> 추상 클래스를 가이드라인,
자식 클래스는 가이드를 따른 구현된 사용가능한 실제 클래스

 

abstract class Bird {
    private int x, y, z;

    void fly(int x, int y, int z) {
        printLocation();
        System.out.println("이동합니다.");
        this.x = x;
        this.y = y;
        if (flyable(z)) {
            this.z = z;
        } else {
            System.out.println("그 높이로는 날 수 없습니다");
        }
        printLocation();
    }

    abstract boolean flyable(int z);

    public void printLocation() {
        System.out.println("현재 위치 (" + x + ", " + y + ", " + z + ")");
    }
}

class Pigeon extends Bird {
    @Override
    boolean flyable(int z) {
        return z < 10000;
    }
}

class Peacock extends Bird {
    @Override
    boolean flyable(int z) {
        return false;
    }
}

public class Main {
    public static void main(String[] args) {
        Bird pigeon = new Pigeon();
        Bird peacock = new Peacock();
        System.out.println("-- 비둘기 --");
        pigeon.fly(1, 1, 3);
        System.out.println("-- 공작새 --");
        peacock.fly(1, 1, 3);
        System.out.println("-- 비둘기 --");
        pigeon.fly(3, 3, 30000);
    }
}

---

👉 인터페이스 interface : 규격   / 골격제작

• 인터페이스를 구현한 객체들에 대한 동일한 동작을 보장하기 위해 사용

# 구현하려는 객체의 동작의 명세

# 다중 상속 가능

# implements를 이용하여 구현

# 메소드 시그니처(이름, 파라미터, 리턴 타입)에 대한 선언만 가능

# 생성자와 일반변수 모두 가질 수 없다.

-1) 키워드 : interface  //클래스 대신 사용
키워드 사용해서 클래스를 선언하듯이 인터페이스를 선언
-2) 인터페이스 멤버는 추상메서드와 상수만으로 구성된다.

interface Phone {
public static final 타입 변수명;      //상수
public abstract 리턴타입 메서드명();  //추상 메서드

}

interface Phone {
public static final int BUTTONS = 20;   int BUTTONS = 20;
public abstract void sendCall(); void senCall();
public abstrcat void receiveCall(); receiveCall();
}

* 인터페이스 멤버는 어디서라도 접근 가능하게 모두 public으로 만듬

-3) 모든 메서드는 public abstract 이며 생략 가능하다. 

-4) 상수는 public static final 타입이며 생략 가능하다.

-5) 인터페이스는 객체 생성 불가!
메서드는 모두 구현안된 추상메서드이므로 미완성/불완전해 객체 생성 불가능

Phone p = new Phone(); ----> X

-6) 인터페이스 타입의 변수 선안만은 가능 

Phone p; ---> O

-7) 인터페이스 상속
인터페이스는 다른 인터페이스를 상속 받을 수 있다.
인터페이스는 규격과 같은 것으로, 상속을 통해
기존 인터페이스에 새로운 규격을 추가한 새로운 인터페이스를 만들 수 있다.
extends 키워드 사용

interface Mobile extends Phone {
void sendSMS();    // 상수, 추상메서드
void receiveSMS();     규격추가 
}

### 인터페이스는 다중 상속 허용 ###  (구현이 안되니 충돌날일이 없으니깐)
interface DualcameraPhone extends Mobile, Camera {
void makeVideo();
}

-8) 인터페이스 구현
인터페이스의 추상 메서드를 모두 구현한 클래스를 작성하는 것
키워드 : implements

class Iphone Implementes Mobile{
// 추상메서드 모두 구현
public void senCall(){.....}
public void receiveCall(){.....}
public void sendSMS(){...}
public voiud receiveSMS(){...}
//추가적으로 일반 메서드 , 변수선언
public int doubleFingerTouch(){...}

} 

* 추상메서드중 하나라도 구현안하면 에러!!
  키워드 implements는 객체생성가능
                   Mobile m = new Iphone();

-9) 인터페이스의 목적
-10) 인터페이스의 다중 구현
클래스는 하나 이상의 인터페이스 구현 가능.,
class Iphone Implementes Mobile, Camera,

 

interface Bird {
    void fly(int x, int y, int z);
}

class Pigeon implements Bird{
    private int x,y,z;

    @Override
    public void fly(int x, int y, int z) {
        printLocation();
        System.out.println("날아갑니다.");
        this.x = x;
        this.y = y;
        this.z = z;
        printLocation();
    }
    public void printLocation() {
        System.out.println("현재 위치 (" + x + ", " + y + ", " + z + ")");
    }
}

public class Main {

    public static void main(String[] args) {
        Bird bird = new Pigeon();
        bird.fly(1, 2, 3);
//        bird.printLocation(); // compile error
    }
}

---

🙋‍♂️ 소감 : 

객체지향 개념을 처음 들었을때는 너무 어려웠는데, 확실히 처음 들었을때보다는 확실히 더 와닿는 부분이 많았다.앞으로 3일동안 오전 라이브강의 내용에 집중해서,다음 프로젝트에는 모르고 쓰는것이 아닌 개념적인 부분을 확실히 이해하고 사용해야겠다.

😈 아는 내용이라고 그냥 넘어가지 않기! 😈