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

 

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

 

 

(자바(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

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

 

break문과 continue문은 반복문 등에서 분기를 하기 위해 사용한다.

 

■ break문

- for, while, do-while문과 같은 반복문의 루프를 실행하다가 break문을 만나면, 반복문의 루프를 빠져나간다.

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Main {
    public static void main(String[] args) {
        int i = 1;
        
        while(true) {
            System.out.println("i : " + i);
            if(i == 10break;
            ++i;
        }
        
        System.out.println("종료!");
    }
}
cs

Line 3 : 정수형 변수 i 선언 후 1로 초기화

Line 5 : 무한 루프

Line 6 : i값 출력

Line 7 : i가 10인 경우 while문을 빠져나와 Line 10으로 이동

Line 8 : i값 1 증가

 

■ continue문

- for, while, do-while문과 같은 반복문의 루프를 실행하다가 continue문을 만나면, 그 아래의 문장들을 실행하지 않고 루프의 조건 체크 부분으로 이동한다.

1
2
3
4
5
6
7
8
9
10
public class Main {
    public static void main(String[] args) {
        for(int i = 1; i <= 10++i) {
            if(i % 2 == 0continue;
            System.out.println("i : " + i);
        }
        
        System.out.println("종료!");
    }
}
cs

Line 3 : i가 1부터 1씩 증가하면서, 10보다 작거나 같을 때까지 반복

Line 4 : i를 2로 나눈 나머지가 0인경우(짝수인 경우) 조건 체크 부분으로 이동

Line 5 : i값 출력

'Java' 카테고리의 다른 글

자바(Java) 클래스(Class)와 인스턴스(Instance)  (0) 2020.06.30
자바(Java) 객체 지향 프로그래밍(OOP)  (0) 2020.06.30
자바(Java) for문  (0) 2020.06.26
자바(Java) do-while문  (0) 2020.06.26
자바(Java) while문  (0) 2020.06.26

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

 

초기식, 조건식, 증감식 모두를 기본적으로 포함하고 있고, 가장 많이 사용되는 반복문이다. 반복 과정은 while문과 같다.

 

(자바(Java) while문 : https://devmoomin.tistory.com/60)

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import java.util.Scanner;
 
public class Main {
    public static void main(String[] args) {
        Scanner keyboard = new Scanner(System.in);
        int total = 1, num;
        System.out.print("num의 값 입력 : ");
        num = keyboard.nextInt();
        
        for(int i = 1; i <= num; ++i) {
            total *= i;
        }
        
        System.out.println(num + "! = " + total);
    }
}
cs

Line 6 : 정수형 변수 total, num 선언 후 total을 1로 초기화

Line 8 : num에 값을 입력 받음

Line 10 : i가 1부터 1씩 증가하면서, num보다 작거나 같은 동안 반복 (num회 반복)

Line 11 : total에 i의 값을 누적해서 곱해줌

Line 14 : 결과값 출력

 

■ for문 무한루프

- for문은 조건을 만족하는 동안 계속해서 반복 실행되는데, 만약 조건문을 계속해서 만족하게 된다면 for문을 빠져나오지 못하고 계속 실행하는 무한 루프에 빠지게 된다.

1
2
3
4
5
6
7
public class Main {
    public static void main(String[] args) {
        for(int i = 1; i > 0++i) {
            System.out.println("i = " + i);
        }
    }
}
cs

Line 3 : i가 1부터 1씩 증가하면서, 0보다 큰 동안 반복

※ i의 값은 무조건 0보다 크므로 무한 루프에 빠지게 된다.

 

■ for문 중첩

- for문 안에 for문을 포함시킨 것으로, 반복 구조 내에서 또 다른 반복 구조가 형성된다.

1
2
3
4
5
6
7
8
9
10
11
public class Main {
    public static void main(String[] args) {
        for(int i = 1; i <= 3++i) {
            System.out.println("[i = " + i + "일 때]");
            
            for(int j = 1; j <= 2++j) {
                System.out.println("j = " + j);
            }
        }
    }
}
cs

Line 3 : i가 1부터 1씩 증가하면서, 3보다 작거나 같은 동안 반복

Line 4 : i의 값 출력

Line 6 : j가 1부터 1씩 증가하면서, 2보다 작거나 같은 동안 반복

Line 7 : j의 값 출력

i j
1 1
1 2
2 1
2 2
3 1
3 2

'Java' 카테고리의 다른 글

자바(Java) 객체 지향 프로그래밍(OOP)  (0) 2020.06.30
자바(Java) break, continue문  (0) 2020.06.26
자바(Java) do-while문  (0) 2020.06.26
자바(Java) while문  (0) 2020.06.26
자바(Java) switch-case문  (0) 2020.06.25

+ Recent posts