첫 번째 목표 - 잃지 않는 투자

너바나님께서 재테크 레벨에 대해 말씀해주셨다. 나는 현재 월급쟁이 전세입자인 "사원" 레벨에 해당한다. 주기적으로 오르는 이자와 좀처럼 줄어들지 않는 원금때문에 스트레스를 받고 있지만, 월부에 오기 전까지는 다들 이렇게 사는 줄만 알았다. 월부에서 좋은 분들과 오랫동안 함께 하면서 잃지 않는 투자자인 "팀장" 레벨을 목표로 열심히 달려나가야겠다.

 

좋은 투자란?

1) 잃지 않는 것

2) 원하는 수익률을 내는 것

남의 말만 듣고 섣불리 투자를 했다가 크게 손해를 본 경험이 있다. 오랫동안 투자를 하기 위해서는 무엇보다도 잃지 않는 투자가 가장 중요한 것 같고, 너바나님께서도 잃지 않는 투자의 중요성에 대해 강조해주셨다. 잃지 않을 뿐만 아니라 원하는 수익률을 내는 좋은 투자자가 되도록 고수들의 투자원칙을 벤치마킹 해 나가야겠다.

 

투기꾼 vs 투자자

투기꾼은 투자 기준 없이 타인에게만 의지하는 사람, 결과만 중요시하게 생각하는 사람, 투자리스크와 성과를 모르는 사람을 말한다. 투자꾼은 투자 기준이 있고, 타인에게 의지하지 않는 사람, 과정과 결과를 모두 중요시하게 생각하는 사람, 투자리스크와 성과를 알고 투자하는 사람을 말한다. 지금까지는 투기꾼에 가까웠다면 앞으로는 투자자가 될 수 있도록 독서와 강의를 꾸준히 들어야겠다.

 

너바나 레시피 - 저환수원리

저평가, 환금성, 수익률, 원금보존, 리스크 관리 이 다섯가지가 너바나님께서 말씀하신 잃지 않는 투자를 위한 필수 요건이다. 카페를 통해 저환수원리라고 많이 듣기는 했지만, 이번 강의를 통해 저환수원리가 무엇인지, 그리고 얼마나 중요한지 자세하게 설명을 들을 수 있었다. 나만의 투자 기준을 세우고, 저환수원리를 모두 충족시킬 수 있는 물건을 찾아 투자를 시작해야겠다.

 

 

1주차 때는 어떠한 마음가짐으로 투자에 임해야되는지 중점적으로 말씀해주셨다면, 2주차 강의에서는 본격적으로 잃지 않는 투자를 하기 위한 기준잡는 법에 대해 자세하게 설명해주셨다. 확실히 책으로만 공부했을 때 보다 강의를 통해 공부하는게 이해하기 쉬운 것 같다. 벌써부터 다음 3주차 강의가 기다려진다.

'투자' 카테고리의 다른 글

월부 실준 1주차 강의후기  (1) 2023.01.09
월부 열기 5주차 후기  (0) 2022.12.27
월부 열기 4주차 후기  (0) 2022.12.19
월부 열기 3주차 후기  (0) 2022.12.13
월부 열기 1주차 후기  (1) 2022.11.28

 

드디어 기다리던 1주차 강의가 시작되었다.

많은 기대를 했지만, 기대 이상으로 많은 것을 배우고 느낄 수 있었다.

"Not A But B"

세상이 A인줄 알았는데 B였다. 나도 처음의 너바나님 처럼, 그리고 주변의 다른 회사원들 처럼 아무생각 없이 회사일만 열심히하고, 나중에 퇴직금을 받으면 당연히 노후 대비가 되는 줄 알고있었다. 하지만 주변의 은퇴하시는 분들을 보면 그렇지 않은 것 같았다. 너바나님도 통계 자료를 통해 월 100만원 이상 버는 65세 이상이 몇 프로인지 말씀해주셨고, 객관적인 수치를 확인하니 가슴이 두근거렸다. 그동안 잘못 생각했구나, 그동안 잘못 행동해왔구나를 느낄 수 있었다.


"전세금은 전세계에서 유일한 0%짜리 대출이다."

 

사회 초년생 때 부터 전셋집에 들어가느라 제법 많은 전세대출을 받고있다. 처음에는 1-2%의 낮은 이자였지만, 금리가 계속해서 올라가는 지금, 이자는 어느새 6%에 육박하게 되었다. 육아휴직중인 아내로 인해 외벌이 중인 요즘, 높은 금리가 점점 부담으로 다가오고 있다. 하지만 너바나님께서 말씀하신 "전세금은 전세계에서 유일한 0%짜리 대출이다"라는 말씀을 듣고 많은 생각이 들었다. 주변에 부동산 투자를 하시고, 수익을 올리신 분들이 제법 계셨지만, 한 번도 그분들께 투자에 대해 여쭤보지 않았다. 그저 대출이나 착실히 갚다보면 언젠가는 내집을 마련할 것이라는 막연한 생각만 하고 있었다. 갈수록 떨어지는 화폐가치에 맞서 내 자산을 방어하기 위해서는 투자는 필수라는 점을 다시 한 번 깨달을 수 있었다.


"위기란 현재가 위기인 줄 모르는 것.

진짜 위기란 현재가 위기인 줄 알면서도 아무것도 하지 않는 것."

 

집값은 갈수록 오르고 있고, 더 오르면 월급만 받아서는 도저히 집을 살 수가 없을 것이라는 생각이 들었다. 한 번 씩 '어차피 집을 사지 못할 거, 포기하고 좋은 차나 사볼까?' 이런 생각이 머리를 스쳐지나갔다. 앞으로 집을 못살 것이라는 위기 상황은 인지했지만, 어떻게 이 상황을 벗어날 것 인지에 대한 방법은 생각해보지 못한 것 같다. '나 뿐만 아니라 다른 사람도 집을 못살거고 그러면 언젠가는 다시 내려가겠지' 라는 생각도 들었다. 너바나님께서 말씀하신 진짜 위기의 상황에 처해있다는 것을 이번 강의를 통해 깨달을 수 있었다. 차근차근 종잣돈을 모아서 자식들에게 지금의 돈 없는 상황을 물려주고 싶지 않았다.


"Long Work, Early Start, Double Income - LED 전략"

막연히 경제적 자유를 이루고, 이른 은퇴를 하고 싶다는 생각은 하고 있었다. 비전보드 작성을 통해 지금 상황에서 내 목표금액을 달성하기 위해, 몇 살때까지 얼마의 수익률을 가져야 하는지를 알게 되었고, 계산 결과 생각보다 늦은 은퇴시기와, 많은 종잣돈이 필요하다는 것을 알게 되어 한숨이 나왔다. 너바나님께서는 월급쟁이 노후 해법으로 LED 전략을 말씀하셨다.

 

· L(Long Work) : 은퇴 시기를 늦추자

- 은퇴시기를 늦추면 필요한 노후자금이 줄어들고, 노후 자금을 더 많이 마련할 수 있다.

 

· E(Early Start) : 일찍 시작하자. 오늘이 우리 인생의 가장 젊은날!

- 어차피 50년이 걸리는 일이라면 조금이라도 일찍 시작해야 일찍 목표를 달성할 수 있다.

 

· D(Double Income) : 맞벌이

- 투자를 하기 위해서는 종잣돈 마련이 중요하다. 많은 종잣돈을 마련하기 위해서는 맞벌이는 필수이다.

 

위 LED 전략을 통해 미래에 대한 큰 그림을 그려볼 수 있었다.


생각보다 긴 강의였지만 알찬 내용으로 구성되어있어 시간가는 줄 모르고 들을 수 있었던 것 같다. 1주차 강의는 구체적인 방법 보다는 어떤 마음가짐, 어떤 습관으로 생활하고 투자에 임해야 하는지의 뼈대를 만들어준 강의라는 생각이 들었다. 너바나님께서 강의 초반에 강의를 통해 단 한 가지만이라도 변화해보라고 말씀하셨다. 이번 1주차 강의에 수많은 내용이 있었지만, 앞으로의 투자 생활을 위해 아래 두 가지만이라도 꼭 실천 해 봐야겠다고 마음먹었다.

 

1. 생각의 변화 뿐만 아니라 행동도 변화하기

2. 꾸준히 노력해서 행동을 습관으로 만들기

 

'투자' 카테고리의 다른 글

월부 실준 1주차 강의후기  (1) 2023.01.09
월부 열기 5주차 후기  (0) 2022.12.27
월부 열기 4주차 후기  (0) 2022.12.19
월부 열기 3주차 후기  (0) 2022.12.13
월부 열기 2주차 후기  (0) 2022.12.05

(공감과 댓글 하나는 글쓴이에게 큰 힘이 됩니다.)

 

이차원 이상의 배열을 다차원 배열이라고 한다. 다차원 배열에서는 이차원 배열을 가장 많이 사용하는데, 이차원 배열은 행과 열로 구성되어 있다.

 

 

(자바(Java) 배열(Array) : https://devmoomin.tistory.com/81)

 

■ 이차원 배열의 선언과 초기화

- 자료형[][] 배열명 = new 자료형[행개수][열개수]; 와 같은 형식으로 선언이 가능하다.

- int[][] arr = {{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}}; 과 같은 형식으로 배열을 초기화 할 수 있다.

 

■ 이차원 배열의 접근

- 2중 for문을 통해 배열을 순회하면서 각각의 인덱스에 접근할 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Main {
    public static void main(String[] args) {
        int[][] arr = new int[][] {{12345}, {678910}};
        
        for(int i = 0; i < 2++i) {
            for(int j = 0; j < 5++j) {
                System.out.println("arr[" + i + "][" + j + "] = " + arr[i][j]);
            }
        }
        
        // arr[0][0] = 1
        // arr[0][1] = 2
        // arr[0][2] = 3
        // arr[0][3] = 4
        // arr[0][4] = 5
        // arr[1][0] = 6
        // arr[1][1] = 7
        // arr[1][2] = 8
        // arr[1][3] = 9
        // arr[1][4] = 10
    }
}
cs

Line 3 : 행의 크기 2, 열의크기 5인 정수형 배열 arr 선언 및 초기화

Line 5 : 행을 순회하기 위한 for문

Line 6 : 열을 순회하기 위한 for문

Line 7 : 배열의 값 출력

(공감과 댓글 하나는 글쓴이에게 큰 힘이 됩니다.)

 

동일한 자료형의 변수를 여러 개 선언하여 사용해야 되는 경우가 있다. 예를 들어 학생의 수학 점수를 관리해야 되는 상황이라면 학생의 수만큼 정수형 변수를 선언해야 하는데, 배열을 통해 변수의 묶음으로 한 번에 선언하여 관리할 수 있다. 연속된 자료형이므로 반복문을 통해 각각의 변수에 접근이 가능하여 코드의 중복을 최소화 할 수 있다.

(자바(Java) 다차원 배열 : https://devmoomin.tistory.com/82)

 

■ 배열의 선언과 초기화

1) 배열의 선언

- 자료형[] 배열명 = new 자료형[개수]; 또는 자료형 배열명[] = new 자료형[개수]; 와 같은 형식으로 선언이 가능하다.

- 배열을 선언하면 자료형에 해당하는 변수가 지정한 개수만큼 생성되는데, int형 배열 5개를 선언하면 int형 4바이트 * 5가 되어 총 20바이트가 메모리에 할당된다.

- 자료형에는 int, char와 같은 기본 자료형 뿐만 아니라 사용자가 직접 정의한 참조 자료형도 사용할 수 있다.

1
2
3
4
5
6
public class Main {
    public static void main(String[] args) {
        int[] arr1 = new int[5];
        String[] arr2 = new String[5];
    }
}
cs

Line 3 : 크기가 5인 int형 배열 선언

Line 4 : 크기가 5인 String형 배열 선언

 

2) 배열의 초기화

- int[] arr = new int[] {1, 2, 3, 4, 5}; 또는 int[] arr = {1, 2, 3, 4, 5}; 와 같은 형식으로 초기화가 가능하다.

- 중괄호 안의 개수만큼 자동으로 배열이 선언되며, 선언과 동시에 초기화 할 때에는 []안에 개수를 생략해 주어야 한다.

1
2
3
4
5
6
public class Main {
    public static void main(String[] args) {
        int[] arr1 = new int[] {12345};
        int[] arr2 = {12345};
    }
}
cs

Line 3 : 크기가 5인 int형 배열 선언 후 초기화

Line 4 : 크기가 5인 int형 배열 선언 후 초기화

 

- 선언과 초기화를 따로 할 때에는 new 자료형[]을 생략할 수 없다.

1
2
3
4
5
6
public class Main {
    public static void main(String[] args) {
        int[] arr;
        arr = new int[] {12345};
    }
}
cs

Line 3 : 정수형 배열 arr 선언

Line 4 : 정수형 배열 arr 초기화

 

■ 배열의 접근

- 배열은 인덱스라는 고유의 번호를 통해 접근이 가능한데, 인덱스는 0부터 시작한다. 따라서 크기가 5인 배열을 선언한 경우 0 ~ 4의 인덱스를 사용할 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Main {
    public static void main(String[] args) {
        String[] arr = new String[5];
        
        for(int i = 0; i < 5++i) {
            arr[i] = new String("arr" + (i + 1));
        }
        
        for(int i = 0; i < 5++i) {
            System.out.println("arr[" + i + "] = " + arr[i]);
        }
        
        // arr[0] = arr1
        // arr[1] = arr2
        // arr[2] = arr3
        // arr[3] = arr4
        // arr[4] = arr5
    }
}
cs

Line 3 : 크기가 5인 String형 배열 arr 선언

Line 5 ~ Line 7 : [0] ~ [4] 인덱스의 배열에 각각 값을 대입

Line 9 ~ Line 11 : 배열에 들어있는 값 출력

 

■ 배열의 복사

- 배열을 사용하다보면 배열의 값을 다른 배열의 값으로 복사해야하는 경우가 종종 있다. 값을 복사하는 방식에 따라 크게 얕은 복사와 깊은 복사로 나누어 진다.

 

1) 얕은 복사

- 값을 복사하는 것이 아니라 인스턴스의 주소 자체를 복사하는 경우를 말한다.

- 두 개의 배열이 하나의 인스턴스를 참조하고 있으므로, 해당 인스턴스의 값이 바뀌면 해당 인스턴스를 바라보는 배열 모두 영향을 받는다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class Main {
    public static void main(String[] args) {
        String[] arr1 = new String[5];
        arr1[0= "apple";
        arr1[1= "book";
        arr1[2= "coffee";
        arr1[3= "dog";
        arr1[4= "easy";
        
        String[] arr2 = arr1;
        
        for(int i = 0; i < 5++i) {
            System.out.println("[" + i + "] = " + arr1[i]);
        }
        
        // [0] = apple
        // [1] = book
        // [2] = coffee
        // [3] = dog
        // [4] = easy
        
        arr1[0= "airport";
        
        for(int i = 0; i < 5++i) {
            System.out.println("[" + i + "] = " + arr2[i]);
        }
        
        // [0] = airport
        // [1] = book
        // [2] = coffee
        // [3] = dog
        // [4] = easy
    }
}
cs

Line 3 ~ Line 8 : 크기가 5인 String형 배열 arr1 선언 후 초기화

Line 10 : arr2 배열 선언 후 arr1의 인스턴스 주소를 대입하여 초기화

Line 12 ~ Line 14 : arr1 배열의 값 출력

Line 22 : arr1 배열의 [0]번 인덱스의 값을 airport로 변경

Line 24 ~ Line 26 : arr2 배열의 값 출력 (arr2[0]의 값이 airport로 바뀐 것 확인)

 

2) 깊은 복사

- 인스턴스의 주소가 아닌 값을 직접 복사하여 서로 영향을 받지 않도록 복사하는 경우를 말한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public class Main {
    public static void main(String[] args) {
        String[] arr1 = new String[5];
        arr1[0= "apple";
        arr1[1= "book";
        arr1[2= "coffee";
        arr1[3= "dog";
        arr1[4= "easy";
        
        String[] arr2 = new String[5];
        for(int i = 0; i < 5++i) {
            arr2[i] = arr1[i];
        }
        
        for(int i = 0; i < 5++i) {
            System.out.println("[" + i + "] = " + arr1[i]);
        }
        
        // [0] = apple
        // [1] = book
        // [2] = coffee
        // [3] = dog
        // [4] = easy
        
        arr1[0= "airport";
        
        for(int i = 0; i < 5++i) {
            System.out.println("[" + i + "] = " + arr2[i]);
        }
        
        // [0] = apple
        // [1] = book
        // [2] = coffee
        // [3] = dog
        // [4] = easy
    }
}
cs

Line 3 ~ Line 8 : 크기가 5인 String형 배열 arr1 선언 후 초기화

Line 10 : 크기가 5인 String형 배열 arr2 선언

Line 11 ~ Line 13 : arr1 배열의 값을 각각 arr2 배열에 복사

Line 15 ~ Line 17 : arr1 배열의 값 출력

Line 25 : arr1의 [0]번 인덱스의 값을 airport로 변경

Line 27 ~ Line 29 : arr2 배열의 값 출력 (arr2[0]의 값에 영향 없는 것 확인)

(공감과 댓글 하나는 글쓴이에게 큰 힘이 됩니다.)

 

변수나 메소드에 static이라는 예약어가 붙으면 각각 클래스 변수와 클래스 메소드가 된다. 인스턴스가 생성될 때만 사용 가능한 인스턴스 변수, 인스턴스 메소드와는 다르게 클래스가 정의만 되어도 접근해서 사용이 가능하다.

 

 

■ static 변수(클래스 변수)

- 딱 한번만 정의되어 모든 인스턴스에서 공유되는 변수이다. 프로그램이 실행될 때 생성돼서 프로그램이 종료될 때 GC(Garbage Collector)에 의해 소멸된다. 인스턴스의 생성 여부에 상관없이 메모리에 올라가므로 클래스 변수라고도 하며, 클래스의 이름으로 접근할 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Employee {
    public static int employeeCount;
        
    public Employee() {
        ++employeeCount;
    }
}
 
public class Main {
    public static void main(String[] args) {
        Employee e1 = new Employee();
        System.out.println(e1.employeeCount); // 1
        System.out.println(Employee.employeeCount); // 1
        
        Employee e2 = new Employee();
        System.out.println(e1.employeeCount); // 2
        System.out.println(Employee.employeeCount); // 2
    }
}
cs

Line 2 : static 변수 employeeCount 선언

Line 4 ~ Line 6 : 디폴트 생성자 (static 변수 employeeCount의 값을 1 증가)

Line 11 : 인스턴스 생성

Line 12 : 참조 변수를 이용한 employeeCount 출력

Line 13 : 클래스를 이용한 employeeCount 출력

Line 16 : 참조 변수를 이용한 employeeCount 출력

Line 17 : 클래스를 이용한 employeeCount 출력

 

■ static 메소드(클래스 메소드)

- static 변수와 동일한 방식으로 호출하게 되며, static 메소드가 삽입된 클래스의 모든 인스턴스로부터 접근이 가능하다. static 메소드 안에서는 인스턴스 변수의 사용이 불가능하다. (static 메소드는 프로그램의 시작과 동시에 메모리에 올라가는데, 인스턴스 변수는 인스턴스가 생성됐을 때 메모리에 올라가므로 참조가 불가능)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Employee {
    private static int employeeCount;
    private int temp;
 
    public static int getEmployeeCount() {
        return employeeCount;
    }
 
    public static void setEmployeeCount() {
        // temp = 1;
        ++employeeCount;
    }
}
 
public class Main {
    public static void main(String[] args) {
        System.out.println(Employee.getEmployeeCount()); // 0
        Employee.setEmployeeCount();
        System.out.println(Employee.getEmployeeCount()); // 1
    }
}
cs

Line 2 : static 변수 employeeCount를 private으로 선언 (getter, setter를 통한 접근만 가능)

Line 3 : 멤버 변수 temp 선언

Line 5 : static 변수 employeeCount의 값을 얻어오기 위한 get 메소드

Line 9 : static 변수 employeeCount의 값을 설정하기 위한 set 메소드

Line 10 : static 변수와 static 메소드는 인스턴스의 생성에 상관없이 메모리에 올라가는데, 인스턴스 변수인 temp는 인스턴스가 생성되는 경우에 메모리에 올라간다. static 메소드를 메모리에 올리기 전에 인스턴스의 생성이 불가능하기 때문에 해당 부분은 에러가 발생한다.

Line 17 : static 메소드를 호출 employeeCount의 값 출력

Line 18 : static 메소드를 호출하여 employeeCount의 값 1 증가

Line 17 : static 메소드를 호출 employeeCount의 값 출력

'Java' 카테고리의 다른 글

자바(Java) 다차원 배열  (0) 2020.07.04
자바(Java) 배열(Array)  (0) 2020.07.04
자바(Java) this 예약어  (0) 2020.07.03
자바(Java) 접근 제어자  (0) 2020.06.30
자바(Java) 생성자(Constructor)  (0) 2020.06.30

(공감과 댓글 하나는 글쓴이에게 큰 힘이 됩니다.)

 

자바에서 this는 생성된 인스턴스 스스로를 가리키는 예약어이다.

 

■ this를 통한 멤버 변수 참조

- this 예약어를 통해 멤버 변수임을 명시할 수 있다. this를 사용하지 않더라도 IDE에서 자동으로 구분을 해주지만, this를 사용하여 명시해주면 개발자가 해당 변수를 더 쉽게 파악할 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Calculator {
    private int num1;
    private int num2;
    
    public Calculator(int num1, int num2) {
        this.num1 = num1;
        this.num2 = num2;
    }
}
 
public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator(1020);
    }
}
cs

Line 2 : 멤버 변수 num1 선언

Line 3 : 멤버 변수 num2 선언

Line 5 : num1과 num2를 받아오는 생성자

Line 6 : 멤버 변수 num1을 생성자 선언 시 넘겨준 num1의 값으로 초기화

Line 7 : 멤버 변수 num2를 생성자 선언 시 넘겨준 num2의 값으로 초기화

 

■ this를 통한 다른 생성자 호출

- this를 통해 생성자에서 다른 생성자를 호출할 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class Calculator {
    private int num1;
    private int num2;
    private char ch;
    
    public Calculator(int num1, int num2) {
        this.num1 = num1;
        this.num2 = num2;
        System.out.println("Calculator(int num1, int num2)");
    }
    
    public Calculator(int num1, int num2, char ch) {
        this(num1, num2);
        this.ch = ch;
        System.out.println("Calculator(int num1, int num2, char ch)");
    }
}
 
public class Main {
    public static void main(String[] args) {
        System.out.println("------------ calc1 ------------");
        Calculator calc1 = new Calculator(1020); // Calculator(int num1, int num2)
        
        System.out.println("------------ calc2 ------------");
        Calculator calc2 = new Calculator(1020'+'); // Calculator(int num1, int num2)
                                                        // Calculator(int num1, int num2, char ch)
    }
}
cs

Line 6 : num1과 num2를 받아오는 생성자

Line 12 : num1, num2, ch를 받아오는 생성자

Line 13 : Line 6의 생성자를 호출하여 num1과 num2를 초기화

Line 14 : 멤버 변수 ch 초기화

Line 22 : num1, num2를 매개변수로 전달하는 Line 6의 생성자 호출

Line 25 : num1, num2, ch를 매개변수로 전달하는 Line 12의 생성자 호출

 

■ this를 통한 자신의 주소 반환

- this를 통해 자기 자신의 주소 값을 반환할 수 있다. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Calculator {
    private int num1;
    private int num2;
    
    public Calculator(int num1, int num2) {
        this.num1 = num1;
        this.num2 = num2;
    }
    
    public Calculator printAddress() {
        return this;
    }
}
 
public class Main {
    public static void main(String[] args) {
        Calculator calc1 = new Calculator(1020);
        System.out.println(calc1.printAddress()); // Calculator@15db9742
    }
}
cs

Line 10 : 자기 자신의 주소 값을 반환하는 메소드 (반환형을 클래스형으로 만들어야 함)

Line 18 : 생성한 calc1 인스턴스의 주소 값 출력

(공감과 댓글 하나는 글쓴이에게 큰 힘이 됩니다.)

 

지시자 클래스 내부 동일 패키지 상속받은 클래스 이외의 영역
private O X X X
default O O X X
protected O O O X
public O O O O

 

■ 정보 은닉

- 변수를 private으로 선언하는 경우 다른 클래스에서 이를 직접 참조할 수 없다. 따라서 getter, setter라고 불리는 get(), set() 메소드를 통해 private 변수의 값을 설정하거나 가져와야 하는데, 이렇게 직접 접근하지 못하고 getter, setter로 접근하도록 숨겨 놓는 것을 정보 은닉이라고 한다. 단순히 변수에 직접 대입하여 사용하는 경우 양수만 사용해야 되는 상황에서 음수를 사용했을 때 컴파일러가 에러를 인지하지 못해 문제 상황을 인지하지 못할 수도 있다. 하지만 setter 메소드에서 변수 값을 대입하는 경우 조건문을 통해 판단하여 에러 상황을 처리해 줄 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Calendar {
    private int month;
 
    public int getMonth() {
        return month;
    }
 
    public void setMonth(int month) {
        if(month >= 1 && month <= 12) {
            this.month = month;
        } else {
            System.out.println("잘못된 값을 입력하셨습니다!");
            return;
        }
    }
}
 
public class Main {
    public static void main(String[] args) {
        Calendar calendar1 = new Calendar();
        calendar1.setMonth(1);
        
        Calendar calendar2 = new Calendar();
        calendar2.setMonth(13); // 잘못된 값을 입력하셨습니다!
    }
}
cs

Line 2 : 정수형 변수 month를 private으로 선언

Line 4 ~ 6 : month의 값을 얻어오기 위한 get 메소드

Line 8 ~ Line 15 : month의 값을 설정하기 위한 set 메소드 (month 값에 따른 조건 분기)

Line 20 : 인스턴스 생성

Line 21 : 참조 변수 calendar1의 month를 1로 설정

Line 23 : 인스턴스 생성

Line 24 : 참조 변수 calendar2의 month를 2로 설정 (범위에 벗어난 값을 입력하여 메시지 출력 후 종료)

(공감과 댓글 하나는 글쓴이에게 큰 힘이 됩니다.)

 

생성자(Constructor)란 딱 한 번만 호출되어 멤버 변수의 초기화를 목적으로 사용되는 메소드이다. 생성자의 이름은 클래스 이름과 같고, 반환형이 없다. 또한 클래스에는 반드시 하나 이상의 생성자가 필요하다.

 

■ 디폴트 생성자

- 아무런 생성자도 만들지 않으면 컴파일러에서 컴파일 시 자동으로 생성자를 만들어주는데, 이를 디폴트 생성자라고 한다. 디폴트 생성자는 아무런 매개변수도 갖지 않고, 안에 어떠한 코드도 존재하지 않는다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Customer {
    String name;
    int money;
    
    //public Customer() {}
}
 
public class Main {
    public static void main(String[] args) {
        Customer c1 = new Customer(); // 디폴트 생성자를 통한 인스턴스 생성
        c1.name = "무민";
        c1.money = 2000;
    }
}
cs

Line 5 : 어떠한 생성자도 만들어주지 않으면, 디폴드 생성자가 컴파일 시 자동으로 만들어진다.

 

■ 생성자 만들기

- 인스턴스를 초기화하기 위해 사용자가 직접 생성자를 만들 수 있다. 사용자가 아무런 생성자도 만들지 않는 경우에 디폴트 생성자가 만들어졌지만, 사용자가 생성자를 만드는 순간 디폴트 생성자는 자동으로 생성되지 않는다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Customer {
    String name;
    int money;
    
    //public Customer() {}
    public Customer(String n, int m) {
        this.name = n;
        this.money = m;
    }
}
 
public class Main {
    public static void main(String[] args) {
        Customer c1 = new Customer("무민"2000);
        Customer c2 = new Customer(); // 에러 발생
    }
}
cs

Line 6 ~ 9 : name과 money를 초기화시켜주는 생성자

Line 14 : 사용자가 만든 생성자를 통한 인스턴스 생성

Line 15 : 생성자를 만든 경우 디폴트 생성자가 자동으로 생기지 않으므로 에러 발생

            (이 경우 Line 5의 주석을 해제하여 디폴트 생성자를 직접 만들어줘야 한다.)

 

■ 오버로딩(Overloading)

- 생성자처럼 동일한 이름의 메소드를 여러 개 생성하는 것을 오버로딩이라고 한다. 매개변수의 개수를 다르게 하거나, 매개변수의 타입을 다르게 하여 동일한 이름의 메소드를 여러 개 생성하여 사용할 수 있다. 호출 시 매개변수를 비교하여 매개변수와 일치하는 메소드가 호출된다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Customer {
    String name;
    int money;
    
    public Customer() {
        System.out.println("constructor 1");
    }
    public Customer(String n) {
        System.out.println("constructor 2");
        this.name = n;
    }
    public Customer(String n, int m) {
        System.out.println("constructor 3");
        this.name = n;
        this.money = m;
    }
}
 
public class Main {
    public static void main(String[] args) {
        Customer c1 = new Customer("무민"); // constructor 2
    }
}
cs

Line 5 ~ 7 : 디폴트 생성자

Line 8 ~ 11 : name을 초기화 시키는 생성자

Line 12 ~ 16 : name, money를 초기화 시키는 생성자

Line 21 : 파라미터로 name만 전달하여 constructor 2에 해당하는 생성자 실행

(공감과 댓글 하나는 글쓴이에게 큰 힘이 됩니다.)

 

객체란 물건 또는 대상을 의미하며, 이를 코드로 구현한 것이 클래스이다. 그리고 클래스를 메모리 공간에 생성한 상태를 인스턴스라고 한다. 쉽게 말해 클래스가 붕어빵 틀이라면 인스턴스는 붕어빵 틀을 통해 찍어내는 붕어빵이라고 할 수 있다.

 

■ 인스턴스(Instance) 생성

- 인스턴스는 new 예약어를 이용하여 생성할 수 있다. 하나의 클래스 타입으로 여러개의 인스턴스를 생성 가능하다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Customer {
    String name;
    int money;
        
    public void customerInfo() {
        System.out.println("이름 : " + name + ", 가진돈 : " + money);
    }
}
 
public class Main {
    public static void main(String[] args) {
        Customer c1 = new Customer();
        c1.name = "무민";
        c1.money = 2000;
        
        Customer c2 = new Customer();
        c2.name = "마루코";
        c2.money = 3000;
        
        c1.customerInfo(); // 이름 : 무민, 가진돈 : 2000
        c2.customerInfo(); // 이름 : 마루코, 가진돈 : 3000
    }
}
cs

Line 1 ~ 8 : Customer라는 객체를 구현한 클래스

Line 12 : Customer 인스턴스 c1 생성

Line 13 ~ Line 14 : c1 인스턴스의 값 설정

Line 16 : Customer 인스턴스 c2 생성

Line 17 ~ Line 18 : c2 인스턴스의 값 설정

Line 20 ~ 21 : 인스턴스의 값 출력

 

■ 참조 변수와 참조 값

- Customer c1 = new Customer()에서 c1을 Customer 인스턴스를 가리키는 참조 변수라고 한고, 참조 변수는 참조 값을 갖는다. 참조 값을 통해 인스턴스의 메모리 위치에 접근할 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Customer {
    String name;
    int money;
}
 
public class Main {
    public static void main(String[] args) {
        Customer c1 = new Customer();
        c1.name = "무민";
        c1.money = 2000;
        
        System.out.println("참조 변수의 참조 값 : " + c1); // 참조 변수의 참조 값 : test.Customer@15db9742
    }
}
cs

Line 12 : 참조 변수의 참조 값을 출력한다.

'Java' 카테고리의 다른 글

자바(Java) 접근 제어자  (0) 2020.06.30
자바(Java) 생성자(Constructor)  (0) 2020.06.30
자바(Java) 객체 지향 프로그래밍(OOP)  (0) 2020.06.30
자바(Java) break, continue문  (0) 2020.06.26
자바(Java) for문  (0) 2020.06.26

(공감과 댓글 하나는 글쓴이에게 큰 힘이 됩니다.)

 

■ 객체 지향 프로그래밍(OOP)

1) 객체(Object)

- 객체는 영어로 Object이고, 사전적 의미로는 물건 또는 대상을 의미한다. 객체는 우리 주변에 존재하는 물건이나 대상 전부를 의미한다고 생각하면 된다. 내가 카페에서 아메리카노를 주문하는 상황을 예로 들면, '나', '카페', '아메리카노'를 객체라고 할 수 있다.

 

2) 객체 지향 프로그래밍(OOP)

- 객체 지향 프로그래밍은 영어로 Object-Oriented Programming, 줄여서 OOP라고 표현하며, C언어처럼 프로그램을 작성한 순서대로 실행하는 절차 지향 프로그램과는 다르게 객체끼리 상호작용을 통해 기능을 구현하는 것을 말한다. 앞서 내가 카페에서 아메리카노를 주문하는 예를 보면, 내가 커피를 구매하기 위해 3000원을 지불하는 행위, 카페로부터 아메리카노를 전달받는 행위 자체를 구현할 수 있다. 객체 지향 프로그래밍은 클래스를 기반으로 프로그래밍한다.

 

■ 클래스(Class)

클래스는 객체의 속성과 기능을 코드로 구현한 것이다. 내가 카페에서 아이스 아메리카노를 구매했다면, '나', '카페', '아메리카노'가 속성이 되는데 이를 멤버 변수라고 하고, 내가 커피를 구매하기 위해 3000원을 지불하는 행위, 카페로부터 아메리카노를 전달받는 행위가 기능이 되며 이를 메소드(Method)라고 한다. 클래스의 이름은 대문자로 시작하고, 멤버 변수와 메소드는 첫 글자는 소문자로 시작해서 중간에 새로운 단어가 나올 때마다 대문자를 사용한다.

 

1) 멤버 변수(Member Variable)

- 멤버 변수는 접근 제어자, 자료형, 변수명으로 구성된다. 접근 제어자는 private, default, protected, public 네 가지가 있으며, 아무것도 사용하지 않는 경우를 default라고 한다. 자료형은 int, long, double 등 기본 자료형과 String, Customer 등 JDK에서 제공하거나 사용자가 직접 만든 클래스를 자료형으로 사용할 수 있다.

 

2) 메소드(Method)

- 메소드(Method)는 객체의 기능을 구현한 것을 말하며, 접근 제어자, 반환형, 메소드명으로 구성된다.  

 

 

■ 메소드(Method)

메소드(Method)는 함수의 한 종류로, 입력 값과 그에 따른 결과 값을 갖는다. 메소드(Method)를 사용하면 반복적으로 사용하는 코드를 묶어서 정의해 놓고, 필요할 때마다 가져다 쓸 수 있으므로 코드의 양을 줄일 수 있다. 또한 기능별로 나눠서 효율적으로 개발할 수 있고, 수정이 필요하면 해당 기능 부분만 수정하면 되기 때문에 유지보수가 쉽다.

 

1) 반환형(Return Type)

- 반환형(Return Type)은 메소드를 종료하면서 반환할 값의 타입을 의미한다. 메소드를 종료할 때 반드시 반환형에 해당하는 타입의 값을 반환하고 종료해야 한다. 만약 해당 메소드가 값을 반환할 필요가 없는 메소드라면 반환형으로 void를 사용하면 된다.

 

2) 매개변수(Parameter)

- 메소드는 입력 값과 그에 따른 결과 값을 갖는 것을 말한다. 입력 값에 따라 결과 값이 달라지게 되는데, 매개변수란 메소드에서의 입력 값을 말한다. 위의 add 메소드에서 num1과 num2가 매개변수이고, 메소드에 따라 매개변수가 존재하지 않을 수도 있다.

 

3) return

- return은 값의 반환 또는 프로그램의 종료 두 가지 기능을 수행할 수 있다. 만약 반환형이 void가 아니라면, return을 통해 해당 반환형의 값을 반환할 수 있고, 반환형이 void인 경우 return을 통해 프로그램을 강제로 종료시킬 수 있다.

 

 

 

 

 

 

 

 

'Java' 카테고리의 다른 글

자바(Java) 생성자(Constructor)  (0) 2020.06.30
자바(Java) 클래스(Class)와 인스턴스(Instance)  (0) 2020.06.30
자바(Java) break, continue문  (0) 2020.06.26
자바(Java) for문  (0) 2020.06.26
자바(Java) do-while문  (0) 2020.06.26

+ Recent posts