[Java] 자바의 객체지향 프로그래밍(Object-Oriented Programming)

[Java] 자바의 객체지향 프로그래밍(Object-Oriented Programming)

2021. 2. 28. 20:53ㆍ개념 정리 작업실/Java

728x90

안녕하세요? 주니하랑 입니다.

현재 주니하랑은 국비지원으로 자바를 배우고 있고, 그 공부 내용을 다시 복습할겸 또한, 자바 공부를 하시는 분들께 보다 쉽게 이해할 수 있는 자료를 만들고 싶다는 점에서 블로그에 글을 올리고 있는 것이에요.

일단, 자바의 객체지향은 C언어를 가볍게 배웠던 분들이라면 객체지향에서 많이 어려움을 느끼실거라고 생각하는 것이에요. 저도 그랬고, 같이 공부하는 몇몇 분들도 그러한 어려움을 겪고 있습니다.

일단, 주니하랑은 객체지향에 대해 이해가 되었다고 판단되는 바 제가 이해했던 방법을 여러분들께 소개 하면서 많은 분들이 저보다는 좀 더 쉽게 객체지향을 이해하시길 바라는 것이에요.

이 글은 개념 위주로 작성한 글 입니다. 인터넷 강의 등을 통해 자바의 객체지향을 공부 했는데, 잘 이해가 안 가신다면 도움이 될 것이지만, 완전 내용을 모르는 상태에서는 다소 어려울 수 있으니 참고 바랍니다.

그럼 바로 시작 해 보겠습니다!

📌 Java Code에서 객체(객체지향)

📍설명하기에 전

본격적인 설명에 앞 써서 각각의 명칭에 제가 이해하기 쉬웠던 방법에 대해서 소개를 해 드리고자 합니다. 많은 예시들이 있는데, 제가 교육 받으면서 예시로 들었던 것과 제가 이해하기 쉬웠던 예시를 두가지로 설명 드리도록 하겠습니다.

👉 첫번째. Class(객체) 혹은 인스턴스

교육의 예시: 제품 설계도

주니하랑의 예시: 회사 (Main이 있는 또한, 파일 제목명과 동일한 Class명을 가진 Class를 우리 회사라고 생각

👉 두번째. 함수 (Method)

교육에서의 예시: 函數. 즉, 물건을 담는 상자에 입력(매개변수)값을 넣어 출력(Return)값을 얻는 상자.주니하랑의 예시: 1) 계산기. 입력(매개변수)값을 입력을 받아 그 결과인 출력(Return)을 보여주는 계산기. 이 계산기는 문자도 계산이 가능한데, 컴퓨터라는 계산기는 문자도 사실 0과 1로 처리하고 있기 때문이다.

2) 그 회사의 각 팀. 회사라는 Class(객체)에는 팀이 있고, 그 팀에는 팀원이 존재. Main이라는 Method는 우리회사이고, 이 일을 하청을 주어 다른 회사(Class)에게 외주를 주는데, 그 외주 업체 안에는 팀이 있고, 팀원이 존재.

👉 세번째. 변수

교육에서의 예시: 물건을 담는 하나의 그릇

주니하랑의 예시: 어떤 회사의 회사원 1명. 이 회사원은 하루에 하나의 일만 처리 가능.

👉 객체지향 언어란?

기존의 프로그래밍 언어(절차지향 언어)에 몇 가지 새로운 규칙 추가

장점: 코드 재사용성 - 새로운 코드를 작성할 때 기존의 코드를 이용할 수 있다.

코드 관리 용이 - 코드간의 관계를 이용 적은 노력으로 쉽게 코드 변경 가능

신뢰성이 높은 프로그래밍 - 제어자와 Method를 이용 데이터를 보호하고, 코드의 중복 제거로 코드의 불일치로 인한 오동작 방지

👉객체 생성 순서

1) Class 정의

2)객체 생성 (new)

3) 객체와 객체 간의 상호 작용( 서로 호출, 응답)

- 객체 안에는 필드와 메서드가 있다. ('메서드를 호출하여 전달과 반환을 통해 값을 주고 받는다'를 상호 작용이라 칭함.)

4) 객체간의 관계 (상속과 구현) => 메서드 중심 => 함수형 언어의 대두

- 데이터는 변수에만 넣을 수 있고, 기능은 함수로 이용.

- 상속이란? 기존에 함수가 있는데, 필요에 의해 함수를 추가로 만들겠다. 라는 의미

- 구현(Implements)이란? 아직 만들지 않은 함수를 만들겠다는 의미.

5) Class에서 객체를 정의 할 때, 전화번호와 같이 각각 다른 값을 가진다면 Static을 붙이지 않는다. 즉, 모든 객체가 같은 값을 갖는다면 Static을 붙혀주어야 한다.

6) 필드는 가지고 있다라는 의미이고, 메서드는 어떤 기능을 할 수 있다라는 의미

- 필드는 인스턴스 변수이며, 지역 변수가 아닌 전역 변수이다. 주니하랑은 그 클래스의 직원으로 이해.

- 메서드는 그 클래스의 팀이다. 팀은 팀원 각각이 자기의 역할을 하여 결과를 도출한다.

- 결국 실행은 함수로 한다.

7) 은닉화(캡슐화)

- Main에서 의도하지 않은 Class의 값을 변경하면 데이터의 일관성을 잃는다. 개발시에 이것을 막아야 한다.

- 객체명에 점(.)을 찍었을 때, 나오는 변수명들이나, 기능들이 안 나오게 하겠다는 것.

- Member 중 외부로 노출되지 않아야 하는 것에 접근권한, 접근 지정을 할 수 있는 것.

=> Public: 공개(Method에 사용)

=> Private: 비공개(Field에 사용)

=> Protected: 제한적 공개

=> (defualt): 제한적 공개

위의 대한 내용은 아래 접근 제어자에서 자세히 설명하도록 할 것이에요!

8) Class형 객체를 생성하고, 그 Class안에 필드를 구성하면 그 Class는 필드를 의존. 의존성이란 없으면 안되는 Class(객체)등이 있다라는 의미.

📍 객체와 인스턴스

클래스로부터 객체를 만드는 과정을 클래스의 인스턴스화라고 하며, 어떤 클래스로부터 만들어진 객체를 클래스의 인스턴스라고 합니다.

객체: 모든 인스턴스를 대표하는 용어

인스턴스: 특정 클래스로 부터 생성된 객체

👉 객체의 구성요소 - 속성과 기능

속성(Property): 멤버변수, 특성, 필드(인스턴스 변수), 상태

기능(Function): Method, 함수, 행위

/**
* 출처: 자바의 정석
*/

class Tv {	// Tv라는 외부 업체

// 변수 = Tv회사의 직원들의 특성과 직원명. (Data Type = 직원 특성, 변수 = 직원명)
	
    String color;	// 색깔
    boolean power;  // 전원상태
    int channel;	// 채널
    
    // Method = Tv라는 회사의 각 팀.
    
   	void power() {
    	power = !power; 
    }
    
    void chanelUp() {
    	channel ++; 
    }
    
    void channelDonw() {
    	channel --;
    }

속성은 크기, 길이, 높이, 색상, 볼륨, 채널 등이 될 수 있고, 기능은 켜기, 끄기, 볼륨 높이기 / 줄이기, 채널 변경하기 등이 있습니다.

👉 인스턴스의 생성과 사용

앞 써 주니하랑은 클래스를 회사라고 생각을 했고, 교육에서는 설계도라고 했습니다.

여기서도 동일하게 설명을 해 보겠습니다.

/**
* 출처: 자바의 정석
*/

// [클래스명] [변수명]				// 클래스의 객체를 참조하기 위한 참조변수를 선언
                                  // 외주 업체를 관리할 직원 채용
                                  
// [변수명] = new [클래스명]		// 클래스의 객체를 생성 뒤, 객체의 주소를 참조 변수에 저장
								  // 어느 업체(클래스)에 외주 하청 계약서를 작성한 뒤 변수가 그 회사 연락처 보관

Tv t;							  // Tv 클래스 타입의 참조변수 t를 선언
								  // Tv 특성을 가진 t라는 직원을 외주 업체 관리를 위해 채용
                                  
t = new Tv();					  // Tv인스턴스를 생성. 생성된 Tv 인스턴스의 주소 t에 저장
								  // t라는 직원이 Tv회사와 외주 하청 계약을 맺어 Tv 업체의 연락처를 보관

TvTest.java

/**
*출처: 자바의 정석
*/

Class Tv {
	// Tv의 속성(멤버변수)
   	String color;				// 색상
    boolean power;				// 전원상태(on/off)
    int channel;				// 채널
    
        // Tv의 기능(메서드)
        void power() {				// TV를 켜거나, 끄는 기능 메서드
            power = !power;
      }

        void chaanelUP() {			// TV의 채널을 높이는 기능 메서드
            ++channel;
      }

        void channelDown() {		// TV의 채널을 낮추는 기능 메서드
            --channel;
      }
  }
  
  /* ########################### Main ############################### */
  
  class TvTest {
  	public static void main(String[] args) {
    	Tv t;								// Tv객체(인스턴스)를 참조하기 위한 변수 t 선언
        t = new Tv();						// Tv객체(인스턴스) 생성.
        t.channel = 7;						// Tv객체(인스턴스)내에 channel 변수에 7 값 입력.
        t.channelDown();					// Tv객체(인스턴스)내에 channelDown(); 메서드 호출하여 그 메서드의 기능 동작
       
        System.out.println("현재 채널은 " + t.channel + "입니다.");
        
        }
 }
 
 
 
/* ############################ 실행 결과  ############################	*/
 
 // 현재 채널은 6 입니다.

📍Class 정의

Class라는 예약어로 정의된 뒤 {} 중괄호가 있는 것이며, 앞글자가 대문자 자료형의 하나이나, 기본형은 아니고, 복합형으로 불리는 것입니다. 요청을 하는 쪽에서 객체를 생성하게 됩니다.

예를 들어 Main Method에서 어떤 객체(Class)를 만들고 싶다면 Main이 호출하는 쪽이 됩니다.

결국 클래스의 정의는 객체를 정의 해 놓은 것이고, 그 용도는 객체를 생성하는데, 사용이 됩니다.그렇다면 객체의 정의는 무엇일까요? 객체는 실제로 존재하는 것. 사물 또는 개념이며, 그 용도는 객체가 가지고 있는 기능과 속성에 따라 다릅니다.

사용자 Type: 원하는 Type을 만들 수 있습니다.

클래스는 설계도 혹은 회사로 비유할 수 있습니다. 또한, 데이터와 함수를 가지고 있구요. 사용자 정의 Data Type 입니다.

✏️ 예시

int hour: 

int min; 

int sec;

// 세 개의 시간을 저장하려면 3개 변수가 필요한 것이에요. 
// 만약 배열로 만든다면 시간 따로 분 따로 각각의 배열이 필요하겠지요? 
// Class를 만들면 하나의 Class로 시, 분, 초를 다룰 수 있는 것이에요.



################## Time Class 생성 ########################

class Time {
	int hour;
    int min;
    int sec;
} // Time Class End

################## Test Class 생성 ########################

class Test {
	public static void main(String[] args) {
    	Time t = new Time();
   } // Main End
} // Test Class End

1. 변수: 하나의 데이터를 저장할 수 있는 공간
2. 배열: 같은 종류의 여러 데이터 저장할 수 있는 공간
3. 구조체: 서로 관련된 여러 데이터 종류 관계 없이 저장할 수 있는 공간
4. 클래스: 데이터와 함수의 결합(구조체 + 함수)

참고형 배열을 통해 객체를 생성할 때, 참조형 배열명 앞에 자료형 타입은 적지 않아야 합니다!

안 그러면 자료형 안 맞는다고, 예외가 발생하게 될 것이에요!

📍 변수와 메서드

변수는 자료형이 정해져야 하며, 기본형(Primitive Type)인 경우 '값이 얼마가 있다'라는 의미이고, Class형(참조형 - Reference Type)인 경우 변수안에 값이 아니고, 주소값이 들어가 있게 됩니다. 자료형이 다르면 당연히 처리가 다르겠지요?

즉, 기본형 변수는 값 하나를 저장하는 변수이고, int num = 10;이라고 한다면 num은 10이다라고 표현할 수 있는 것이에요.

즉, 기본형 변수는 그 자체가 값이라고 생각할 수 있답니다.

참조형 변수는 값의 위치(주소)를 저장하는 변수에요. String과 같이 첫글자가 대문자인 것을 Class형(참조형) 변수라고 한답니다.

string obj = [주소를 저장]

위의 뜻은 obj에 가면 String이 있다라고 표현할 수 있겠네요.

점(.) 연산은 Class(참조)형 변수에만 사용할 수 있습니다. 이 점 역시 연산자 입니다. 점을 기준으로 왼쪽으로 가서 오른쪽에 있는 것을 보아라! 라고 표현할 수 있으며, 참조형 변수명에 점을 찍고 나오는 것들 중 이클립스 상에서 보이는 초록색 동그라미 표시는 Method를 나타 냅니다.

println(); 에서 참조형 변수명을 출력하라고 했을 때, 나오는 것은 .toStirng();의 결과가 나오게 됩니다. 기본형 변수는 그 변수가 가지고 있는 값을 직접 찍지만, 참조형 변수는 주소값을 가지고 있기 때문에 다르다는 점 기억 해 주세요!

Class는 개발자하는 사람이 만든 자료형이기 때문에 다른 사람이나, 컴퓨터는 그 위치를 알 수가 없습니다. 이 때문에 Class Method를 호출할 때 (.) 점을 찍는 표현이 들어가게 됩니다. 이 점이라는 것을 적어주면 그 주소로 가면 그 안에 어떤 자료형이 있는지 보게 됩니다.

[Class Type] [변수명] = new [Class Type (객체명 혹은 생성자명이라고도함)] 이럴 때 ' Class Type에 해당하는 객체를 새로 만들어 변수에 넣겠다'라는 의미로 이해 하시면 편하겠네요!

✏️ 예시

Car go = new Car();

'Car Type을 갖는 변수 go에 Car 객체를 생성하여 넣는다'라는 의미 입니다.

💬 비유

교육용 예시: Car Type을 갖는 한 개의 값을 저장하는 상자인 go에 Car()라는 제품 설계도를 만들어 넣겠다.

주니하랑의 예시: Car Type을 갖는 우리 회사 직원 go가 외주 업체인 Car()와 하청 계약을 맺어 그 업체 연락처를 가지고 있다.

Class Variables {
// 클래스 영역 (선언만 가능하며, 초기화 불가)
	int iv;			// 인스턴스 변수 (필드)
    static int cv;	// 클래스 변수, static변수, 공유변수 (인스턴스 변수 앞에 static을 붙히면 클래스 변수)
    
// 메서드 영역
	void method() {
    	int lv = 0;	// 지역 변수
    }	// Method End
}	// Class End

👉 인스턴스 변수(필드) - Instance Variable (Filed)

클래스 영역에 선언되며, 클래스의 인스턴스를 생성 시 만들어 집니다. 인스턴스 변수의 값을 읽어 오거나, 저장하기 위해 인스턴스를 생성합니다.

필드는 독립적인 저장공간을 갖고, 서로 다른 값을 가질 수 있습니다. 인스턴스마다 고유한 상태를 유지해야 하는 속성은 인스턴스 변수로 선언해야 합니다.

👉 클래스 변수(Class Variable)

인스턴스 변수(필드)명 앞에 static을 붙히기만 하면 클래스 변수가 됩니다. 모든 인스턴스가 공통된 저장공간(변수)를 공유하게 됩니다.

한 클래스의 모든 인스턴스들이 공통 값을 유지해야 하는 경우 클래스변수로 선언 합니다.

클래스 변수는 인스턴스(객체)를 생성하지 않고, (new [객체명])을 하지 않고도, 바로 사용할 수 있고, '클래스명.클래스변수' 형식으로 사용 됩니다.

같은 프로그램 내 어디서나 접근이 가능한 전연변수(Global Variable)의 성격을 갖습니다.

👉 지역변수(Local Variable)

메서드 내에 선언하고, 메서드 내에서만 사용가능하며, 메서드가 종료되면 같이 Memory에서 소멸되어 버립니다.

class Card {
// 인스턴스 변수(필드)
	String kind;	// 무늬
    int number;		// 숫자
    
// 클래스(공통) 변수
    static int width = 100;	 // 폭
    static int height = 250; // 높이
    


class Test {
	static void main(Stirng[] args) {
    	Card c = new Card();
        
        // 인스턴스 변수에 값 넣기
        
        c.kind = "HEART";
        c.number = 5;
        
        // 클래스 변수에 값 넣기
        Card.width = 200;
        Card.height = 300;
        
        // 클래스 변수는 클래스명.~~로 호출
        // 인스턴스(필드) 변수는 참조변수.필드명이지만, 클래스는 클래스명. 이다.

👉 return문

return문은 현재 실행중인 메서드 종료 뒤 호출한 메서드로 되돌아 갑니다. 반환 타입이 void인 경우 반환값이 없다는 의미이기에 return을 명시하지 않아도 아무런 문제가 없는데, 그 이유는 컴파일러가 자동으로 return ; 을 추가 해주었기 때문 입니다.

void printGugudan(int dan) {
	for(int i = 1; <= 0 ; ++i) {
    	Sysstem.out.printf("%d * %d = %d%n", dan, i, dan * i);
    } // for End
    return;				// 	메서드의 반환타입이 void임으로 생략 가능 합니다.
} // printGugudan End


###################### 반환 타입이 void가 아닌 경우 #############################

int multplay (int x, int y) {
	int result = x * y;
	return result;			// 반환 타입이 void가 아니므로, 생략 불가
} // multplay Mthod End

👉반환값(return value)

return문의 반환값으로 주로 변수가 오긴 하는데, 항상 그런것은 아닌 것이에요.

int add (int x, int y) {
	int result = x + y;
    return result;
}



#############################

int add (int x, int y) {
	return x + y;
}


// 위와 같이 수식의 결과를 담은 변수가 아닌 바로 계산식을 넣어 반환할 수도 있는 것이에요!

반환 타입 (return Type)이 있는 메서드는 종료 시 결과값을 자신을 호출한 메서드 등에게 반환 하는 것이에요.

main()이 firstMehotd()를 호출하고, firstMethod()가 secondMethod를 호출하고 있네요. 객체를 생성하지 않고도, 메서드를 호출할 수 있으려면 메서드 앞에 static 붙이면 된다는 것 잊지 않으셨죠?

👉매개변수 유효성 검사

메서드 구현부(Body) { } 중괄호 안의 내용을 작성 시 매개 변수 값이 적절한 것인지 확인하는 것이 좋은 것이에요.

메서드를 작성 시 호출 쪽에서 적절한 값을 넘겨 주겠지?라는 착각은 절대로 하면 안되는 것이에요. Type만 맞으면 어떤 값도 매개변수를 통해 넘어올 수 있기 때문에 메서드 작성 시 매개변수 유효성 검사 코드 작성은 필수 랍니다!

👉기본형 매개변수와 참조형 매개변수

자바에서는 메서드 호출 시 매개변수로 지정한 값을 메서드의 매개변수에 복사해서 넘겨 주는 것이에요.

매개변수의 타입이 기본형(primitive) 일 땐 기본형 값이 복사되겠지만, 참조형(reference)이면 객체의 주소가 복사 된답니다.

기본형 매개변수: 변수의 값 읽기만 가능.
참조형 매개변수: 변수의 값 읽고 변경 가능.

📍 Class 선언

하나의 프로그램(프로젝트)에 여러 개의 Class(객체)가 사용되게 됩니다. 이런 이유로 각각의 Class에 선언된 Member 간에 서로 얽힘이 발생하게 되는데요. 이 때, 요청(Class - 전달)과 응답 (return - 반환)이 발생되게 되는데, 요청은 객체의 'Method를 호출하여 ()소괄호에 인자(매개변수)값을 전달하겠다는 의미입니다. 객체는 서로 상호작용을 하며, '메시지를 주고 받는다'라고 표현합니다.

👉 접근 지정자 혹은 접근 제한자(Access Modifier)

필드(Class 변수) 입장에서 봤을 때, 요청하는 쪽에서 나에게 함부러 접근하지 못하도록 권한을 지정할 수 있습니다. 이렇게 하는 이유를 비유로 들자면 필드 입장에서 내가 가지고 있는 물건을 아무나 와서 가져가고, 바꾸고 하면 기분이 나쁘겠지요? 그래서 이것을 못하도록 내 물건을 숨기기 위해 Class(객체)에서 선언한 변수(필드)를 은닉화를 하여 변수 자료형 앞에 Private를 작성하게 됩니다. 단, 모든 Methodsms public으로 선언하는게 좋답니다. (초보자만!)

접근 제어자는 public과 private외에도 두가지가 더 있습니다. protected와 default가 그것입니다. protected는 상속 관계에 있다면 서로 다른 패키지에 있는 클래스의 접근도 허용합니다. default는 접근 제어 지시자가 없는 경우를 의미하는데, 접근 제어자가 없는 메소드는 같은 패키지에 있고, 상속 관계에 있는 메서드에 대해서만 접근을 허용 합니다. 아래 그림은 접근 제어자 별로 접근 허용 범위를 그림으로 나타낸 것이에요. 안쪽에 있을수록 접근 통제가 삼엄하고, 밖에 있을수록 접근이 자유롭습니다.

접근 제어자는 Member 또는 Class에 사용 된답니다!

접근 제어자가 사용될 수 있는 곳 - Class, Member 변수, Method, 생성자
- private : 같은 클래스 내 접근 가능
- defulat : 같은 패키지 내만 접근 가능
- protected : 같은 패키지 내와 다른 패키지의 자손 Class에서만 접근 가능
- public : 어떤 곳에서든 접근 가능

	public	protected	default	private
같은 패키지, 같은 클래스	허용	허용	허용	허용
같은 패키지, 상속 관계	허용	허용	허용	불용
같은 패키지, 상속 관계 아님	허용	허용	허용	불용
다른 패키지, 상속 관계	허용	허용	불용	불용
다른 패키지, 상속 관계 아님	허용	불용	불용	불용

public > protected > (default) > private

💻 예시 코드

Main Method

package oopconcept;

// Phone Class에 인스턴스(객체)를 생성하세요.

// new: 지정된 Class의 객체를 생성하고, 그 참조값(주소)를 반환 받아야 한다.

// 받는다라는 의미는 변수를 선언하고, 대입연산을 통해서 저장해라 (자료형 결정)

 

       Phone01 phone = new Phone01(); //참조형 변수: phone

 

// 처음 객체를 정의하면 예외가 발생하는데, 이유는 아래와 같다.

// 1. Phone Class를 정의 해야 한다.

// 2. 패키지에 따라 import를 했는가?

 

        phone.setMeta(10);       // 여기서 . 앞에는 Main이 setMeta Method를 호출하려 할 때 phone안에 있으니 이렇게 작성한다.

                                 // 만약 setMeta();가 Main이나, 같은 Class안에 있다면 . 앞에를 작성할 필요가 없다. 

                                 // 결국 10이라는 정수를 setMeta에 저장해라. 

                                 // Set하고 뒤에 나오는 이름은 위에 필드로 정의되어 있다라고 생각해라.   

 

     } // Main End

} Class End

Phone Class

package oopconcept.vo;

// 하나의 프로그램(프로젝트)에 여러 개의 Class(객체)가 사용된다.

// 위의 이유로 각각의 Class에 선언된 Member들이 얽힘이 생긴다.

// 이 때, 요청(Call 전달)과 응답(return - 반환)이 발생되는데, 요청은 객체의 Method를 호출한다라고 표현한다.

// 객체간 상호작용한다. 메시지를 주고 받는다라고 표현한다.


public class Phone {

    // Class 중괄호 안에 선언된 것들을 Member라고 한다.

    // Class 중괄호 안에 정의된 변수를 Member 변수라고 한다.

            int meta;          // Member 변수 혹은 필드라고 부른다.

 

      public int setMeta(int param) {    // Method는 무조건 public으로 선언

        this.meta = param   // 위에 있는 필드(Class형 변수)에 param인자로 받은 값을 저장한다.

        return meta;

        // Method 중괄호 안에 내용을 Body라고 한다.

   } // setMeta Method End

} // Main End

📍Getter와 Setter

✏️Getter는 필요에 의해 만들어진 Class에 필드가 생성되면 무조건 해당 필드명 앞에 get을 붙혀 만들어야 합니다.

✏️Getter: 필드의 값을 반환하는 Method.

✏️ Seteer: 필드의 값을 저장하는 Method. 외부에서 받은 값을 위의 필드(인스턴스 변수)에 저장하는 함수입니다.

✏️ 예시set[필드명](); : set을 제외한 첫글자는 대문자로 만들어주어야 합니다. 이것은 데이터 은닉화를 위해 필드를 privated로 설정 시에 main함수에서 직접 필드를 사용할 수 없기 때문에 사용합니다.필드명과 매개변수(지역 변수)명이 같은 경우1) 매개변수명(지역 변수명)을 바꾼다.2) 필드명(인스턴스 변수명)을 바꾼다.3) this 예약어로 변수명을 작성하면 필드를 나타낸다.

💻 예시 코드

Public class Test {

	private String name;
    
    
    public String getName() {
    	return name;
        
    }

위와 같이 필드가 private로 선언이 되어 있다면 자기 자신외에 사용할 수가 없습니다. 이 때문에 getter를 만들어 필드 내용을 받아 읽을 수 있게 해주는 것이지요!

Setter는 필요에 의해 만들어진 Class에 필드가 생성되면 무조건 해당 필드명 앞에 set을 붙혀 만들어야 합니다.

💻 예시 코드

Public class Test {

	public void setName (String name) {
    	this.name = name;
    
    }

사용 이유는 getter와 같습니다. 이 때문에 setter를 만들어 Class 필드를 호출한 대상이 준 입력값을 통해 필드에 수정을 한 뒤 반환하여 줍니다. 반환 형식이 void가 아니면 return 문은 꼭 써줘야 합니다!

📍객체 배열

배열도 Class이며, Array라는 Class(참조)형 객체 입니다. 그렇기 때문에 생성 시 new가 들어가게 되는 것이에요. 즉, 자료형을 기본형 요소로 하는 배열이 되겠지요?

int[] nums = new int[5];

대괄호가 붙은 것은 기본형이 아니고, 배열형 입니다. 여기서 int가 있다는 것은 배열형에 갔더니 int가 있네!라고 이해 하시면 됩니다.

이 의미는 int형 nums의 변수를 5개 나열해라 입니다. int형 배열은 자동 초기화로 0이 들어가니 참고 바랍니다.

nums[0] = 10;

nums[1] = 40;

위의 뜻은 0번 배열에 10을 넣고, 1번 배열에 40이라는 정수값을 넣으라는 의미이죠? 배열명으로 오는 것은 대입 연산자 왼쪽에 오기 때문에 이 또한 변수 입니다.

class CDdata {
	int data;
}

#################################################

public class Review {
	public static void main(String[] args) {
    
    CData[] ref = new CData[5];			// 여기서 REF는 참조형 변수이면서 배열명 입니다.
    
    ref[0] = new CData[5];				// 참조형이기 때문에 CData(Class)의 주소가 들어가야 합니다. 
    									// 자료형이 맞아야 대입이 되기 때문에 오른쪽과 왼쪽의 자료형이 맞아야 겠죠?
   	ref[0] = new CData();				// CData라는 객체를 하나 생성하여 ref[0]배열에 넣는다.
    ref[0].data = 10;					// ref 요소번호 0번 안에 data가 있고, 그 곳에 10을 넣어라.
    ref[1] = new CDdata();
    ref[1].data = 20;
    
    
    // ref [0]과 [1]은 가르키는 곳이 다르기 때문에 전혀 다른 것임을 잊지 마세요!

객체 배열안에는 객체가 저장되는 것이 아니고, 객체의 주소가 저장되는 것이에요. 꼭! 기억하시기 바랍니다.

위의 그림에서 볼 수 있듯이 객체 배열을 생성하는 것은, 그저 객체를 다루기 위한 참조 변수들이 모인 여러 방이 만들어진 것일 뿐, 아직 객체가 생성된 것은 아닙니다. 이 부분을 잘 이해하셔야 합니다. 안 그럼 정말 혼란 스러운 것이에요! 객체를 생성해서 객체 배열의 각 요소에 저장을 꼭 해줘야 합니다. 객체 배열에서 초보자들이 가장 어려워 하는 부분이 객체 배열만 생성해 놓고, "분명히 객체를 생성했는데, 에러가 발생해요!"라는 것 입니다.

Product p1 = new Tv();
Product p2 = new Computer();
Product p3 = new Audio();

위의 코드를 그림으로 나타내면 위와 같은 것이에요. 각 p1, p2, p3 변수는 각각의 객체의 주소값을 저장하는 것을 잊지 마세요!

Product[] p = new Product[3];

p[0] = new Tv();
p[1] = new Computer();
p[2] = new Audio();

위의 코드를 그림으로 나타내면 아래와 같은 것이에요. 위의 내용과 다른점은 배열을 사용 했다는 점 인 것이에요.

위 그림에서 보듯이 같은 배열에 new를 통해 객체를 생성하게 되면 새로운 객체가 생성되고, 다른 주소값을 갖게 되어 그 주소값을 참조형 배열이 갖게 됩니다. 기존에 생성되었던 객체와는 전혀 다른 객체라는 점 잊지 마세요!

💻 예시 코드

Tv[] tvArr = new Tv[3]; 		// 참조변수 배열(객체 배열)을 생성.
// 배열만 생성한 것입니다. 아직 객체를 생성한 것은 아니에요!!

//객체를 생성해서 배열의 각 요소에 저장
	tvArr[0] = new Tv();
    tvArr[1] = new Tv();
    tvArr[2] = new Tv();
    
// 위의 배열의 초기화를 한 줄로 정리하면 아래와 같습니다.

	Tv[] tvArr = { new Tv(), new Tv(), new Tv() };
    
// 다뤄야 할 객체가 많다면 우리의 for문을 사용하면 되는 것이에요.

	Tv[] tvArr = new Tv[100]
    
    for(int i = 0; i < tvArr.length; ++i) {
    	tvArr[i] = new Tv();
	}

💬 참고사항

RAM은 우리가 주인이 아니고, OS가 주인이라고 합니다. 그렇기 때문에 OS에게 사용을 요청하여 사용할 수 있으며, Memory 주소를 직접 정할 수 없습니다. 그렇기 때문에 OS에게 요청을 해서 Memory 공간을 할당 받아야 해서 new라는 것을 써서 객체를 생성하게 되는 것 입니다.

CData[] a = ref.clone();
System.out.println ( ref );
System.out.println ( a );


########출력 결과#############

[LReview_210226.CData;@2f0e140b

[LReview_210226.CData;@7440e464

// @ 오른쪽은 Memory의 주소값이고, 이 주소에 가면  LRevew_210226.CData라는 배열([)이 있다라는 의미.
// 두 개의 주소값이 다르기 때문에 배열이 두 개라는 것.

// 배열을 반환 받을 때 사용하는 함수

.clone();			// 배열 전체를 다 떠서 다른 배열을 만들 때 사용.

📍생성자

필드는 무조건 선언만 해야 합니다. 예를 들어 meta라는 필드에 10을 넣고 싶다면 아래와 같이 추가하면 안됩니다.

public class test() {
	private int meta = 10;     // 이렇게 필드에서 초기화까지 하면 안됨.
}

초기화는 Method나, 생성자에서만 해줘야 합니다. 즉, 내가 어떤 필드에 값을 초기화 하고 싶을 때, 생성자를 쓴다고 이해 하면 좋습니다. 생성자는 반드시 필요한 것은 아니고, 필드를 초기화할 필요가 있을 때 사용하면 되는 것 입니다.

결국 생성자는 인스턴스가 생서오딜 때 호출되는 '인스턴스 초기화 메서드'라고 할 수 있습니다. 생성자는 오버로딩(같은 이름을 가진 여러 메소드 사용)이 가능 합니다.

👉 생성자 생성 규칙

✏️ 반환 (return)은 명시하지 않습니다.

✏️ 반드시 생성자명은 Class명과 일치해야 합니다.

✏️ 모든 객체는 1개 이상의 생성자가 무조건 있어야 합니다.

👉 기본 생성자(Defulat Constructor)

사실 모든 클래스에는 반드시 하나 이상의 생성자가 정의 되어 있어야 하는 것이에요. 그런데, 생성자를 정의하지 않고, 사용할 수 있었던 이유는 역시 컴파일러가 자동으로 '기본 생성자'를 생성 해 주었기 때문인 것이에요.

컴파일러가 자동적으로 추가해주는 기본 생성자는 매개 변수도 없고, 아무런 내용도 없는 아주 간단한 것이에요.

특별히 인스턴스 초기화 작업이 요구되어지지 않는다면 생성자를 정의하지 않고, 컴파일러가 제공하는 기본 생성자를 사용하는 것도 좋은 것이지만! 기본 생성자는 반드시 만들어 주는 습관을 드리는 것이 좋다고 하네요.

class Data2 {

	int value;
    
    Data2(int x) { 	// 매개변수가 있는 생성자
    	value = x;
    } // 생성자 End
} // Data2 Class End

######################### Main Method ####################################

class ConstructorTest {
	public static void main(Stirng[] args) {
    	Data1 d1 = new Data1();				// 여기서 new는 객체 생성을 의미합니다.
        									// Data1();은 그 객체의 생성자를 호출하는 것이에요.
       	Data1 d2 = new Data2();				// 생성자가 하나도 없으면 기본 생성자를 컴파일러가 넣어줘서 예외가 발생하지 않는 것이에요.
        									// 생성자가 하나라도 선언했다면 기본 생성자도 반드시 정의 해줘야 하는 것이에요.
    }	// Main End
} // ConstructorTest Class End

👉 매개변수가 있는 생성자

생성자도 메서드처럼 매개변수를 선언하여 호출 시 값을 넘겨 받아 인스턴스의 초기화 작업에 사용할 수 있는 것이에요.

인스턴스마다 각기 다른 값으로 초기화 되어야 하는 경우가 많기에 매개변수를 사용한 초기화는 매우 좋은 것이에요.

👉 생성자에서 다른 생성자 호출하기 - this() 와 this의 차이

같은 클래스의 맴버들 간 서로 호출할 수 있 듯 생성자 간에도 서로 호출이 가능한 것이에요.

1. 생성자의 이름으로 클래스 이름 대신 this를 사용
2. 한 생성자에서 다른 생성자를 호출 시 반드시 첫 줄에서만 호출 가능

1. 참조변수(필드)의 this
- 인스턴스 변수(필드)를 가르키는 참조 변수, 인스턴스의 주소가 저장.
- 클래스 메서드 (static 붙은 메서드)에서 사용 불가.

2. 생성자의 this()
- this, this(인자 혹은 매개변수)
- 같은 클래스 안에 다른 생성자 호출 시 사용.

💬 참고사항

생성자도 메서드이기 때문에 리턴값이 없다는 의미의 void를 붙혀야 하지만, 모든 생성자가 리턴값이 없으므로, void를 생략할 수 있습니다!

클래스의 '접근 제어자'가 public인 경우 기본 생성자로 'public 클래스이름() { }이 추가 되는 것이에요.

💻 예시 코드

public class testMain {
	public static void main(String[] args) {
    
    Test test = new Test();			// Test 자료형 객체를 생성하여 test 참조형 변수에 Test 주소값을 넣는다.
    
    test.setNumber(10, 20);			// 10정수를 인자값으로 전달하여 Test객체의 setNumber Method에 호출하면서 전달한다.
    	}
    }
    
    
    
    ======================================================================================================
    
   
   
   
   public class Test {
    
    	// Class안에 선언된 변수를 필드라고 한다.
        // 필드는 선언만 해야 하며, 초기화나 연산을 하면 안된다.
        
        private int meta;			// 정수형 meta 필드 선언
        pirvate int[] arr;			// 정수형 arr 배열 선언.
        
        
        
        // 생성자 생성 (생성자는 Class명과 동일해야 하고, ()소괄호 안 즉, 인자값을 넣지 않으며, 반환값도 명시하지 않는다.)
        public Test() {
        	
            meta = 0;				// 정수형 meta 필드 0으로 초기화
            arr = new int[10]		// 정수형 배열 arr 10의 길이로 초기화.
        
        }
        
        
        // meta 필드 Setter 생성
        
        public int setMeta (int a, int b) {
        
        	this.meta = a + b;
            
            // 반환값이 void가 아니면 무조건 return을 선언해야 한다.
            
            return meta;
            
            }
 }

📍상속

Main Method에서 새로운 Class를 생성할 때 자료형 타입명을 다르게 하고, Class 변수명을 동일하게 하여 생성하게 되면

Class명을 정의하는 부분에서 extend가 나오는데, 이걸 '상속 받는다'라고 합니다.

부모 객체와 자식 객체는 엄연히 다른 코드입니다. 다른 Method에서 자식 객체를 호출할 때는 바로 사용이 가능하지만,

부모 객체를 사용하려면 Super를 거쳐서 가야 합니다.

부모 필드가 Private이면 자신만 접근이 가능하다는 의미이기 때문에 자식도 접근할 수 없습니다. 부모 필드가 Protected이면

제한적 접근이 가능하다는 의미인데, 자식 객체는 접근이 가능합니다. 상속은 결국 어떤 Class 객체를 생성하고, 기능을 넣어 쓰다가 추가적으로 기능을 더 넣고 싶을 때, 자식 Class 객체를 생성해서 사용하는 것입니다.

부모는 하나밖에 가질 수 없기 때문에 한 부모에게만 상속 받을 수 있습니다.

결국 기존 Class를 확장해서 새로운 Class를 만드는 것입니다. 기존 Class를 Base 또는 Parent(부모)라 하고, 새로 만든 Class를 파생 또는 Child Class라고 합니다.

public class AdvanceWhell extends Wheel {

	public void back() {
    	System.out.println("뒤로 굴러간다.");
        
    } // back End
} // Class End

위의 코드에서 Class명 적는 곳에 extends 왼쪽은 자식 Class명이 오고, 오른쪽은 부모 Class명이 옵니다.

부모 Class는 하나만 사용할 수 있고, 상속을 사용하면 코드량을 많이 줄일 수 있게 됩니다.

👉클래스간의 관계 - 포함 관계

클래스 간의 관계
1. 상속: 여러 제약이 많아 꼭 필요한 경우 아니면 사용하지 않음.
- '~은 ~이다. (is-a)' 라고 표현
2. 포함: 대부분 클래스 간 포함 관계 사용.
- '~은 ~을 가지고 있다. (has-a)'라고 표현

Main Method에서 객체를 만들고, 그 객체에서 다른 객체를 만들면 포함 관계라고 하는 것이에요.

💻 예시 코드

public class TestPhone01 {

 

public static void main(String[] args) {

	// phone Class의 인스턴스(객체)를 생성하세요.
    // new: 지정된 Class의 객체를 생성하고, 그 참조값(주소)를 반환 받아야 한다.
    // '받는다'라는 의미는 변수를 선언하고, 대입연산을 통해서 저장해라 라는 의미 (자료형 결정)
    
    
    	Phone phone = new Phone();		// 참조형 변수명은 phone
        
  		phone.setMeta(10);				
        
        /** 위의 내용 중 (.) 점 앞에는 Main이 Phone Class의 setMeata Method를 호출하려 할 때,
          * 'phone안에 있으니 저기로 가라'라는 의미.
          * 만약 setMeta(); 가 Main이나, 같은 Class안에 있다면 (.) 점 앞에를 작성할 필요가 없다.
		  * 결국 10이라는 정수를 setMeta에 저장하라는 의미.
        /*  set하고, 뒤에 나오는 이름은 ' 해당 Class 위에 필드로 정의되어 있다'라는 의미로 생각.
        
        
  } // Main End
  
  
  =====================================================================================
  
  


// 하나의 프로그램(프로젝트)에 여러 개의 Class(객체)가 사용된다.
// 위의 이유로 각각의 Class에 선언된 Member들의 얽힘이 발생된다.
// 이때, 요청(Call - 전달)과 응답(retrun - 반환)이 발생되는데, 요청은 객체의 Method를 호출한다라는 표현이다.
// 객체끼리는 서로 사용 작용을 하는데, '서로 메시지를 주고 받는다'라고 표현한다.

public class Phone {

	// Class 중괄호 안에 선언된 것들을 Member라고 한다.
    // Class 중괄호 안에 정의된 변수를 Member 변수 혹은 필드라고 부른다.
    
    	int meta;		// Member 변수 혹은 필드라고 부른다.
        
        // 초보자는 Method를 무조건 public으로 선언.
        
    public int setMeta(int param) {	
    
    // 필드로 선언된 meta에 Method 인자로 전달 받은 param 값을 넣는다.
    
    	this.meta = param				
        
        return meta;
        
        // Method {} 중괄호 안에 내용을 Body라고 한다.
        
        }
        
  }

새 기능을 추가하기 위해 자식 객체 생성

public static void main (String[] args) {

   // 기존에 사용하던 phone 이라는 Class에서 새 기능 추가
   SmsPhone phone = new SmsPhone();
   
   phone.setMeta(10);    // 부모 Class(phone)에게 정수 10을 전달하여 호출
   phone.send("메시지를 보내주라");		// 자식 Class(send)에게 "메시지를 보내주라"라는 문자열 전달하여 호출





=======================================================================================

// phone Class

	public Class phone {
    
    int meta;
    
    
    public int setMeta(int param) {
    
    this.meta = param;
    
    return meta;
   
    }
    
}






=======================================================================================


// Phone Class를 상속받는 send Class

// [자식 Class명] extends [부모 Class명] = 읽을 때(오른쪽 부터)부모 Class에게 자식이 상속 받는다.
public class SmsPhone extends Phone {	

	public void send (String msg) {
    
    System.out.println("SMS: " + msg);
    
    }
}

💬 참고사항

처음 객체를 정의하면 예외(에러)가 발생하는데, 이유는 아래와 같습니다.

첫째. Class를 정의 했는지 여부

둘째. 패키지에 따라 import 했는지 여부

📍다형성 (Polymorphism)

조상 Type 참조 변수로 자손 Type 객체를 다루는 것이에요.

즉, 조상 Type 변수로 자손 객체를 생성하는 것인데, 자손의 모든 기능 중 조상의 기능만 사용 가능한 것이에요.

다형성은 상속과 매우 깊은 관계가 있답니다. 객체 지향 개념에서 다형성은 '여러 가지 형태를 가질 수 있는 능력'을 의미하고, 자바에서는 한 Type의 참조변수로 여러 Type의 참조변수로 여러 Type 객체를 참조할 수 있도록 구현한 것이에요.

다형성의 장점은 무엇이 있을까요? 다형적 매개변수를 가질 수 있고, 하나의 배열에 여러 객체를 저장할 수 있는 것이에요.

조상 Class Type의 참조변수로 자손 Class의 인스턴스를 참조!

Tv Class와 CaptionTv Class가 이와 같이 정의 되었을 때, 두 Class 간의 관계를 그림으로 하면 아래와 같은 것이에요.

Tv Class와 CaptionTv는 서로 상속 관계에 있으며, 이 두 Class의 인스턴스를 생성하고, 사용하기 위해 다음과 같이 할 수 있는 것이에요.

Tv t = new Tv();
CaptionTv c = new CaptionTv();

###############################

Tv t = new CaptionTv();			// 조상 Type의 변수 t에 자손 Type 객체를 생성하여 넣는다.

부모 Type으로 자손 Type의 객체를 생성하는 것은 가능하나, 반대로 자손 Type으로 부모 Type의 객체를 생성할 수는 없는 것이에요.

그 이유는 자손이 부모보다 Member가 많은데, 자손 Type변수로 조상 Type 객체를 생성하면 없는 기능을 호출할 수 없기 때문에 사용 불가한 것이에요.

자손 Type의 참조변수로 조상 Type의 인스턴스 참조는 불가능!

👉 참조변수의 형 변환

사용할 수 있는 Member의 개수만을 조절하는 것. (주소값, 객체는 변화 없음)
기본형 형 변환은 값이 달라지지만, 참조형 형 변환은 값이 달라지지 않는다.

기본형 변수와 같이 참조변수도 형 변환이 가능하답니다! 단, 서로 상속관계의 Class사이에서만 가능하기 때문에 자손 Type의 참조변수를 조상 Type의 참조변수로 조상 Type의 참조변수를 자손 Type의 참조변수로 형 변환만 가능 하답니다!

위의 코드와 같이 세 Class Car, FireEngine, Ambulance가 정의 되었을 때, 그림으로 나타내면 위와 같은 것이에요.

💬 참고사항

바로 윗 조상이나, 자손이 아닌 조상의 조상으로도 형 변환이 가능하답니다! 모든 참조변수는 모든 Class의 조상인 Object Class Type으로 형 변환이 가능한 것이에요!

📍오버라이딩 (재 정의)

메서드의 재정의 혹은 덮어쓰기로 이해하면 쉽답니다!

public static void main(String[] args) {
	toStirng();		// toStirng 메서드 호출
}


##########################################

puglic String toStirng() {

	// 오버라이딩 내용 입력
}

// oject Class의 toStirng을 오버라이딩 시

오버라이딩은 메서드의 내용만을 새로 작성하는 것이에요. 메서드의 선언부는 조상의 것과 완전히 일치해야 한답니다.

자손 클래스에서 오버라이딩하는 메서드는 조상 클래스의 메서와
- 이름이 같아야 한다.
- 매개변수가 같아야 한다.
- 반환타입이 같아야 한다.

1. 접근 제어자는 조상 클래스의 메서드보다 좁은 범위로 변경할 수 없다.

만일 조상 클래스에 정의된 메서드의 접근 제어자가 protected라면, 이를 오버라이딩하는 자손 클래스의 메서드는 접근 제어자가 protected나, public이어야 하는 것이에요.

2. 조상 클래스의 메서드보다 많은 수의 예외(에러)를 선언할 수 없다.

👉오버로딩과 오버라이딩의 차이

오버로딩(Overloding) 기존에 없는 새로운 이름이 같은 메서드를 정의 (new) (상속과 무관)
오버라이딩(Overriding) 상속받은 메서드의 내용을 변경 (Changer, modify)

📍제어자(Modifier)

영어로 치면 형용사(명사를 꾸며줌)과 같은 것이에요. 클래스와 클래스 Member에게 부가적인 의미를 부여하죠!

접근 제어자: public, protected, defulat, private ( 4개 중 하나만 사용 가능)
그 외: static, final, abstract, native, transient, synchronized, volatile, strictfp

제어자는 클래스나 멤버변수와 메서드에 주로 사용되며, 하나의 대상에 여러 제어자를 조합하여 사용하는 거시에요.

접근 제어자는 한 번에 네가지 중 하나만 사용 가능 하답니다!

👉static - 클래스의, 공통적인

static은 '클래스의' 또는 '공통적인'의 의미를 갖습니다.

인스턴스 변수(필드)는 하나의 클래스로부터 생성되었더라도 각기 다른 값을 유지하나, 클래스변수(static Member 변수)는 인스턴스에 관계 없이 같은 값을 갖습니다. 이유는 하나의 변수를 모든 인스턴스가 공유하기 때문인 것이에요.

static이 붙은 Member 변수와 메서드, 초기화 블럭은 인스턴스가 아닌 클래스에 관계 되었기에 인스턴스를 생성하지 않고 사용 가능하답니다! (new를 사용하지 않는다.)

인스턴스 메서드와 static메서드의 근본적 차이는 메서드 내에 인스턴스 Member(필드)를 사용할 수 있느냐 없느냐 인 것이에요.

👉final - 마지막의, 변경될 수 없는

final은 '마지막의' 또는 '변경될 수 없는' 이라는 의미를 갖은 것이에요! 또한, 거의 모든 대상에 사용 가능하답니다.

💬 참고사항

제어자들 간의 순서는 상관없지만, 주로 제어자를 맨 왼쪽에 명시 한답니다!

📍추상화(Abstract - 추상의, 미완성의)

abstract는 '미완성'의 의미를 갖으며, 메서드의 선언부만 작성하고, 실제 수행내용은 구현하지 않은 추상 메서드를 선언하는데 사용합니다.

Abstract가 사용될 수 있는 곳 - Class, Method

추상 클래스는 아직 완성되지 않은 매서드가 존재하는 '미완성 설계도' 혹은 '미완성 회사'이기에 인스턴스를 생성할 수 없는 것이에요.

미완성 회사이기에 업무가 당연히 불가하겠지요? 그래서 다른 회사(인스턴스 - 객체)와 계약(생성)이 불가한 것이에요.

추상 클래스에서 객체를 만들고 싶다면 이 클래스를 상속 받아 완성해야 하고, 완성된 클래스에서 객체 생성이 가능하답니다!

abstract class AbstractTest {		//	추상 클래스(추상 메서드를 포함한 클래스)
	abstract void move();			// 추상 메서드 (구현부 혹은 Body가 없는 메서드)
}

이 클래스 자체로는 쓸데가 없어 보이는데, 왜 만들어 놨을까요? 그것은 이 클래스를 상속 받아서 일부의 원하는 메서드만 오버라이딩(재 정의) 해도 된다는 장점이 있기 때문인 것이에요. 만일 이 클래스가 없다면 아무런 내용도 없는 메서드를 잔뜩 오버라이딩 할 수도 있다네요!

👉 추상화에는 완성되지 않은 Method가 있는 것을 나타냅니다.

✏️ 프로젝트를 설계할 때 많이 사용하는 것으로, 필요한 기능(Method)가 있는데, 현재(당장) 구현할 내용을 모를 때 사용 합니다.

✏️ Method 중 교체될 여지가 높고, 상황, 사람, 회사 등에 변경을 시킬 때 사용됩니다.

✏️ 구현된게 있거나, 구현되지 않은 것들이 있을 수 있고, 구현되지 않은 것들을 만들 때 사용합니다.

✏️ 추상 Class를 선언할 때, new를 붙히지 않습니다. 즉, 추상 Class는 객체를 생성할 수 없기 때문에 new를 붙히지 않습니다.

✏️ extends(상속)을 이용해서 아직 완성되지 않은 Class 혹은 Method를 정의합니다.

👉 추상 Mhothd는 {} 중괄호가 없습니다.

✏️ Method명과 전달값(인자 혹은 매개변수라고도 함)이 필요한데, 그 Method가 처리하는 방법이 다를 때 사용됩니다. 예를 들어 emaile을 보낼 때, 네이버와 다음 메일이 방식이 다르다면 email이라는 공통점은 있지만, 그 방법이 다르게 사용될 것입니다. 이럴 때 추상화를 사용하게 됩니다.

✏️ abstract가 붙어 있는 Method가 추상 Method인데, 이건 '지금 구현 안하고, 나중에 할 것이다'로 이해하면 된다고 합니다.

✏️ 다양성이 있으니 그 다양성에 맞게 사용할 때 사용 합니다.

👉 추상 Class는 추상 Method가 있는 Class를 말합니다.

✏️ 추상 Class는 객체를 생성할 수 없습니다. 그래서 생성 시에 new를 사용할 수 없습니다.

✏️ 추상 Method ( Abstract )를 가지고 있는 Class는 public abstract class [Class명] { }으로 만들어 줘야 합니다.

✏️ 추상 Class는 수정하면 안되고, 만약 수정 사항이 생기게 된다면 추상 Class를 상속 받아 구현한 자식 Class(구현체)를 만들어 사용해야 합니다. 즉, 부모 Class에 있는 추상 Method를 자식 Class가 구현하게 됩니다.

✏️ 업무 시에 앞으로 계속 사용할 Class 종류에 대해 기준을 잡는 거라고 생각하면 좋다고 하네요!

📍추상 클래스 (Abstract Class)

추상 클래스도 생성자는 꼭 구현 되어야 한다!

클래스를 회사로 비유했다면 추상 클래스는 미완성의 회사라고 할 수 있겠습니다. 아직 업무가 시작되지 않은 회사인 것이에요.

클래스가 미완성이라는 것은 Member의 개수에 관계가 아니라, 미완성 Method(추상 Method)가 안에 포함 되어 있다는 의미 입니다.

위에서 주니하랑은 Method를 회사의 팀이라고 했던 것이에요. 팀이 미완성이 되어 있으니 회사가 제대로 업무를 할 수 없는 것이겠지요?

추상 클래스는 새로운 클래스를 작성하는데, 바탕이 되는 조상 클래스로 중요한 역할을 하는 것이에요.

아것도 없는 상태에서 어떤 작업을 시작하는 것보단, 완전하지는 못하더라도 틀이라도 갖추어져 있다면 훨씬 작업이 수월할 것이에요.

추상 클래스는 공통 부분만을 그린 미완성 회사를 만들어 놓고, 이 회사를 이용해서 각각의 하청 업체들을 완성하는 것이에요.

교육에서 처럼 설계도로 비유를 하자면 추상 클래스는 미완성의 설계도인 것이고, 공통 부분만을 그린 미완성 설계도를 만들어 놓고, 이 미완성 설계도를 이용하여 각각의 설계도를 완성한다고 할 수 있는 것이에요.

추상 클래스는 키워드 'abstract'를 붙이기만 하면 된답니다.

abstract class [ClassName] {
     // 클래스 Body
}

추상 클래스 역시 생성자가 있으며, Member 변수와 Method도 가질 수 있답니다.

👉 추상 메서드(Abstract Method)

꼭 정의가 필요하지만, 자손마다 다르게 구현될 것으로 예상될 때 사용

추상 메서드는 선언부만 작성하고, 구현부(Body)는 작성하지 않는 채로 남겨 둔 것이에요.

추상화: 클래스간의 공통점을 찾아 공통의 조상을 만드는 작업
구체화: 상속을 통해 클래스를 구현, 확장하는 작업

추상 메서드를 호출하여 사용하려면 반드시 추상 클래스의 자손 클래스를 만들어 그 곳에서 메서드를 구현하여야만 객체로 생성을 하고, 호출을 할 수 있는 것이에요.

💬 참고사항

추상 Method를 포함하고 있지 않은 클래스도 키워드 'abstract'를 붙혀 추상 클래스로 지정할 수 있습니다. 단, 주의할 것은 추상 클래스로 지정되면 이 클래스를 객체로 생성할 수 없다는 것이에요.

📍Interface (인터페이스)

프로그래밍 관점에서 보면 추상 메서드의 집합!
모든 Member가 public으로 선언.

인터페이스는 일종의 추상 클래스인 것이에요. 인터페이스는 추상 클래스처럼 추상 메서드를 갖지만, 추상 클래스보다 추상화 정도가 높아 추상 클래스와 달리 몸통을 갖춘 일반 메서드, Member 변수를 구성원으로 가질 수 없는 것이에요.

추상 클래스와 인터페이스의 차이는 무엇일까요? 먼저, 추상 클래스는 추상 메서드, 인스턴스 변수, 생성자를 보유하고 있는 것이에요. (일부 미완성이라고 표현)

인터페이스는 추상 메서드만 보유하고 있고, 인스턴스 변수, 생성자를 가질 수 없는 것이에요. 단, final로 정의 된 변수는 가질 수 있답니다. (완전 미완성이라고 표현)

👉 인터페이스는 구현된 것이 아무것도 없이 만들어야 하는 상황에서 Method 목록만 있을 때 사용하게 됩니다.

👉 인터페이스는 Class가 아닙니다! 그렇기 때문에 객체를 생성할 수 없습니다.

👉 인터페이스라는 것은 연결점 혹은 규칙을 표현하는 것입니다. '서로 다른 사람, 컴퓨터 등을 어떤 규칙으로 연결한다'라는 의미와 같고, 네트워크에 프로토콜과 비슷하다고 보면 되겠네요!

👉 인터페이스를 사용할 땐 Method 이름과 자료형(전달, 반환)과 같은 내용을 정의 해야 합니다.

👉 API (Application Programing Interface)가 결국 지금 이야기는 Interface와 같은 개념입니다.

👉처음 인터페이스 생성 시 Class를 생성하는 것과 같이 생성한 뒤에 public class [ class명 ]이 아니라, public interface [ interface명] 으로 만들어 줘야 합니다.

👉인터페이스 필드는 Final 필드만 사용 가능한데, Final 필드는 수정이 불가하고, 초기값을 반드시 주어야 하며, 그 인터페이스 이름 모두를 대문자로 작성해야 합니다.

👉인터페이스를 구현한 Class를 구현체라고 합니다.

✏️ 인터페이스 이름 오는 곳에 implements 왼쪽에 오는 내용은 구현체의 이름이 오고, 그 오른쪽에는 자료형 Type이 오게 됩니다.

// Person이라는 인터페이스를 구현해서 PersonImpl Class를 만들 때 

Public class PersonImpl[인터페이스명] implements Person[자료형 Type명] {

	@Override
    public void todo() {
    
    }
    
    @Override
    public void run() {
    
    }
    
    @Override
    public void walk() {
    
    }

✏️ 구현체는 인터페이스를 여러가지 구현할 수 있습니다. 즉, implements 오른쪽에 쉼표를 구분자로 하여 여러개가 올 수 있습니다.

👉 인터페이스의 작성

인터페이스를 작성하는 것은 클래스를 작성하는 것과 같습니다.

interface [InterfaceName] {
	public static final	[자료형 타입] [변수명] = 값;	  // final이 붙으면 변수라 하지 않고, 상수(변하지 않는 값)이라고 표현
    public abstract [Method 명](매개변수);			// 추상 메서드

모든 Member 변수는 public static(제어자) final로 정의 되어야 하며, 인터페이스 내에서 모두 적혀야 되기에 생략 가능.
모든 메서드는 public abstract여야 하며, 생략이 가능. (단, static 메서드와 defulat 메서드는 예외 JDK 1.8 부터

인터페이스에 정의된 모든 Member에 예외없이 적용되는 사항이기에 제어자를 생략할 수 있는 것이에요.

👉인터페이스의 상속

인터페이스는 인터페이스로부터만 사용 가능한 것이에요.

클래스의 상속과 마찬가지로 자손 인터페이스(Fightable)는 조상 인터페이스(Movable, Attackable)에 정의된 member를 모두 상속 받습니다.

정의된 Member가 하나도 없지만, 조상 인터페이스로부터 상속 받은 두 개의 추상 메서드를 멤버로 갖게 된답니다.

👉인터페이스의 구현

인터페이스 역시 인터페이스를 상대로 인스턴스를 생성할 수 없으며, 자신에 정의된 추상메서드의 몸통을 만들어주는 클래스를 작성해야 합니다.

단, 클래스를 확장한다는 의미의 키워드 'extends'를 사용하는 것이 아닌 인터페이스를 구현 한다는 의미의 키워드 'implements'를 사용 합니다.

위와 같이 코드를 작성한다는 것은 'Fighter 클래스는 Fightable 인터페이스를 구현한다.' 라고 표현 합니다.

만일 구현 인터페이스 메서드 중 일부만 구현 시 abstract를 붙혀 추상클래스로 선언해야 한답니다.

인터페이스란? 추상 메서드의 집합인터페이스 구현체란? 인터페이스의 추상 메서드 몸통 만들기

abstract class Fighter implements Fightable {
	public void move (int x, int y) {	/* 내용 생략	*/ }
} // Fighter 구현체 End


// 그리고 다음과 같이 상속과 구현을 동시에 할 수도 있답니다.

class Fighter extends Unit implements Fightable {
	public void move(int x, int y) {	/* 내용 생략	*/ }
    public void attack(Unit u)	   {	/* 내용 생략	*/ }
} // Fighter 구현체 End

💬 참고사항

모든 Class에는 [Class명] extends object가 생략되어 있습니다.

인터페이스는 클래스와 달리 Object클래스와 같은 최고 조상이 없습니다.

💬 전체 참고사항

처음 코딩하시는 분들이 참고하면 좋으실 만한 내용 입니다.

- 코드 내용 부터 알아야 코드의 결과를 알 수 있습니다.

- 개념, 이론을 조금씩 현재 알고 있는 지식에 보태는 것이 좋습니다. 그러면 경험과 참조할 나만의 자료가 생기게 될 것 입니다.

- 인터페이스를 보고, 추상화를 구현하고, 그 추상화를 상속받는 Class들을 만들어야 합니다.

- 검색하는 방법 (Contains();는 부분 문자열을 검색하여 비교 대상과 비교하여 그 내용이 포함되어 있다면 true를 반환합니다. 이 함수는 검색 엔진 Logic에 사용 됩니다. equals는 아예 전부 모두 일치할 때 true를 반환하며, Login과 같은 Logic에 사용 됩니다.

- @Override : @표시 된 것을 Annotation이라 하며, 어떤 특성이 있음을 나타내는 예약어 입니다.

- @Deprecated : 우리가 어떤 부분을 맡아 코딩할 때 함수에 이것저것 만들어서 사람들에게 공유했는데, 뒤늦께 수정 사항이 생각났을 때, 다시 공유을 해서 사람들에게 줘야 하기 때문에 기존에 줬떤 함수 말고, 수정한 함수를 주기 전에 이 표시를 하여 다른 사람들에게 사용하지 말라고, 표시하는 것 입니다.

- System.exit(); 이 함수는 프로그램을 현 시점에서 종료하고 싶을 때 사용

package console_210223;



public class ExInstance01 {



	publicstaticvoidmain(String[] args) {

// 클래스형 변수명;를 인스턴스명 혹은 객체명이라고 한다.

Car car1 = new Car();    // 생성하는 것이라는 의미로 생성자(Constructor)라고 한다.

System.out.println( car1 );
System.out.println( car1.carNumber ); 
// 여기서 car1은 객체명 혹은 인스턴스명으로 부르고, carNumber는 그 객체의 Member변수이다.

(개념적인 내용) 우리가 Member라고 하는 것은 일반적으로 사람에 대한 정보이다. 모든 사람들이 공통적으로 갖는 것은 무엇일까? 그런 것들은 필드에 만든다. 즉, 어떤 것들이 공통적으로 갖는 값은 필드로 뺀다.

예를 들어 사람은 이름이 있다.

그리고, 필드에 선언한 것들을 처리하기 위한 함수(Method)를 정의한다. 어디에? 필드에!

또한 필드값에는 'Class가 어떤 행동을 할 수 있다'를 Method로 정의해야 한다.

결국 객체란 속성과 행위로 표현되는 것이다.

null이라는 의미는 없다라는 뜻인데, Memory상에 아예 공간 자체가 생성되지 않았음을 의미합니다. (예: 강의장 자체가 없다)

empty라는 의미는 없다라는 뜻인데, Memory상에 공간은 있지만, 값이 없다라는 의미 이다.

(예: 강의장에 사람이 없다)

Memory

Stack은 함수, 변수가 저장되고, 변수명으로 저장

Heap은 전역적(지역에 경계가 없다.)이며, 이름이 아니고, 주소(위치)를 참조한다. new(새로 생성한 Method의 주소를 변수에 넣는다.)라고 생성한 것은 다 여기로 저장.

main함수는 stack에 저장이되고, Member m = new Member();를 생성했을 시

main와 m변수가 stack에 저장되고, m변수값에 Memeber의 Memory(Heap)상의 위치를 저장한다. 즉, m변수 안에는 Member의 주소가 있다라고 표현할 수 있다이고, m 변수를 쓰면 Member 함수의 위치로 가라가 된다.

만약 todo(m);을 main에 선언하면 statc에 todo(Member p);가 Memory 주소값을 저장하는데, m변수를 인자로 줬기 때문에 Member 위치값을 가져가게 된다.

결국 p.name = " "; 이라고 하면 p가 Member의 주소값이 있기 때문에 거기에 name안에 공백을 저장하게 된다.

Class형이라는 걸을 다른말로 참조형이라고 한다.결국 기본형이 아니면 다 참조형이다. 얘는 무조건 앞글자가 대문자이다.

(.)은 안에 들어가라는 건데, 안에 들어가면 자료형이 바뀐다.

Class를 만들었다는 것은 자료형을 새로 만들었다고 생각해라. 그 이유는 여러가지의 자료형을 하나의 공간에 넣으려고 하니 자바는 배열에 여러가지 자료형을 넣을 수 없기 때문에 이렇게 한다.

배열은 Index 번호로 각 방을 판단하지만, Class는 이름으로 판단한다. Class형을 사용하려면 int나 기타 변수에 값을 자료형에 맞게 넣어야 하듯이 Class형을 사용하려니 Class의 객체를 만들어 넣어야 한다.

객체를 처음 생성하면 null로 초기화 되어 있다. null로 되어 있을 때, (.) 점을 찍으면 예외가 발생한다. NPE(Null Point Error) null에 점 찍으면 이런 예외가 발생한다.

IllegalFormatConversionException

이 예외는 format string 사용 시 format이 안 맞는다는 의미

주니하랑의 글이 마음에 드셨나요? 구독과 공감! 그리고, 댓글은 주니하랑에게 많은 힘이 됩니다!

728x90

저작자표시 비영리 변경금지

'개념 정리 작업실 > Java' 카테고리의 다른 글

[Java] 자바의 객체지향 프로그래밍(Object-Oriented Programming) + ArrayList - 예시 코드 풀이 (0)	2021.03.03
[Java] 자바의 객체지향 프로그래밍(Object-Oriented Programming) - 예시 코드 풀이 (0)	2021.03.01
[Java] 배열의 기초 (0)	2021.02.23
[Java] 자바 기초 (0)	2021.02.23
[Java] Memory, Driver개념, 해석기와 번역기, SDK, JDK 개념 (0)	2021.02.22

Juny's ITLog

태그

최근글

댓글

공지사항

아카이브

📌 Java Code에서 객체(객체지향)

📍설명하기에 전

👉 첫번째. Class(객체) 혹은 인스턴스

👉 두번째. 함수 (Method)

👉 세번째. 변수

👉 객체지향 언어란?

👉객체 생성 순서

7) 은닉화(캡슐화)

📍 객체와 인스턴스

👉 인스턴스의 생성과 사용

📍Class 정의

📍 변수와 메서드

✏️ 예시

📍 Class 선언

💻 예시 코드

📍Getter와 Setter

💻 예시 코드

💻 예시 코드

📍객체 배열

💻 예시 코드

💬 참고사항

📍생성자

💬 참고사항

💻 예시 코드

📍상속

💻 예시 코드

💬 참고사항

📍다형성 (Polymorphism)

💬 참고사항

📍오버라이딩 (재 정의)

👉오버로딩과 오버라이딩의 차이

📍제어자(Modifier)

👉static - 클래스의, 공통적인

👉final - 마지막의, 변경될 수 없는

💬 참고사항

📍추상화(Abstract - 추상의, 미완성의)

👉 추상화에는 완성되지 않은 Method가 있는 것을 나타냅니다.

👉 추상 Mhothd는 {} 중괄호가 없습니다.

👉 추상 Class는 추상 Method가 있는 Class를 말합니다.

📍추상 클래스 (Abstract Class)

👉 추상 메서드(Abstract Method)

💬 참고사항

📍Interface (인터페이스)

👉 인터페이스의 작성

👉인터페이스의 상속

👉인터페이스의 구현

💬 참고사항

💬 전체 참고사항

Memory

'개념 정리 작업실 > Java' 카테고리의 다른 글

관련글

티스토리툴바