머니로그(MoneyLog)

삽입정렬(InsertionSort)

SunnyCool — Mon, 11 May 2020 15:01:23 +0900

최악의 경우 버블정렬과 같이 n^2 의 시간복잡도를 가진다.

최선의 경우 정렬되어 있는 경우 n의 시간복잡도를 가진다.

평균 버블정렬보다 절반정도의 빠름을 보여준다.

특정위치에(인덱스)있는 요소를 적절한 위치에 들어갈 수 있도록 되어있다. 해당 인덱스는 버블정렬과 다르게, 선택되어진 특정 값이 자신의 위치를 찾는순간 더 이상 앞의 데이터와 비교할 필요(정확히 스위칭)가 없어지기 때문에 효과적이다.

예 제

Ex) 5 3 6 4

1) 2번째 3이 선택되어 진 값

ㅁ 5 6 4 <-- 선택된 3이 5보다 작으므로 5의 값을 오른쪽으로 한칸 스위치

3 5 6 4 <-- 더 이상 비교 할 값이 없으므로 3은 맨 앞에 위치한다.

2) 3번째 6이 선택되어 진 값

3 5 6 4 <-- 선택된 6이 5보다 크기때문에 변동없음.

3 5 6 4 <-- 선택된 6이 3보다 크기때문에 변동없음.

3) 4번째 4가 선택되어 진 값

3 5 ㅁ 6 <-- 선택된 4가 6보다 작으므로 6을 오른쪽으로 한칸 스위치

3 ㅁ 5 6 <-- 선택된 4가 5보다 작으므로 5를 오른쪽으로 한칸 스위치

3 4 5 6 <-- 선택된 4가 3보다 크기때문에 4를 2번째에 위치시킨다.

결과 : 3 4 5 6

소 스

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public class InsertionSort {
 
    public static void main(String[] args) {
        int[] targetArr = {3,9,6,5,2,7,4,1,8}; 
        
        int length = targetArr.length;
        
        int temp=0;
        for(int i=1; i < length; i++) {
            for(int j=i; j > 0; j--) {
                if(targetArr[j-1] > targetArr[j]) {
                    temp = targetArr[j];
                    targetArr[j] = targetArr[j-1];
                    targetArr[j-1] = temp;
                }
            }
        }
        
        for(int result : targetArr) {
            System.out.print(result);
        }
 
    }
}
 

 

 
결  과
 

버블정렬(BubbleSort)

SunnyCool — Mon, 11 May 2020 11:30:49 +0900

(N-1)+(N-2)……2+1 = n^2

최악, 최선, 평균에 상관없이 항상 n^2 만큼의 시간복잡도를 가진다.

가장 왼쪽수 부터, 바로 옆에 있는 값과 비교하여 정렬을 한다.

예 제

Ex)  4 1 3 2

1) 가장 좌측에 있는 4부터 값을 비교 한다.
1 4 3 2 <-- 4, 1 값 비교하여 4의 값이 더 크므로 값을 스위치
1 3 4 2 <-- 4, 3 값 비교하여 4의 값이 더 크므로 값을 스위치
1 3 2 4 <-- 4, 2 값 비교하여 4의 값이 더 크므로 값을 스위치

  2) 1)에서 가장 큰수인 4를 확정 지었으므로 -1개수만큼만 비교한다.
       1 2 3 <-- 2, 3 값 비교하여 3의 값이 더크므로 값을 스위치

  3) 2)에서 가장큰수인 3을 확정 지었으므로 -1개수만큼만 비교한다.
       1 2 <-- 1, 2 값 비교하여 1이 2보다 작으므로 그대로 둔다.

  결과 : 1 2 3 4

소스

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public class BubbleSort {
 
    public static void main(String[] args) {
        int[] targetArr = {3,9,6,5,2,7,4,1,8}; 
 
        int length = targetArr.length;
        for(int i=length-1; i > 0; i--) {
            for(int j=0; j < i; j++) {
                if(targetArr[j] > targetArr[j+1]) {
                    int temp = targetArr[j];
                    targetArr[j] = targetArr[j+1];
                    targetArr[j+1] = temp;
                }
            }
        }
        
        for(int result : targetArr) {
            System.out.print(result);
        }
    }
}
 

 

 
결과

파이코인 가이드(Pi coin) - 파이 네트워크(Pi Network)

SunnyCool — Mon, 13 Apr 2020 18:07:23 +0900

추천인 : suncool

가입할 때 추천인을 기입하셔야 가입이 되요~ 가입하면 서로 친구가 한명이 늘어서 채굴속도가 빨라집니다.

설치 : 구글, app store에서 pi network 혹은 pi coin 검색 후 설치

파이코인이란??

파이코인(Pi coin)은 휴대폰 리소스를 사용하지 않는 모바일 채굴이 가능한 코인이다.

해외 소식에 따르면 올해 말, 혹은 내년 초에 상장을 할것으로 보이며 그때 코인당 화폐의 가치가 적용될 것으로 보인다.

(장비의 리소스-cpu, ram등 을 사용하지 않고 채굴할 수 있는 것이 가장 큰 메리트 인거 같다. )

휴대폰의 배터리나, Cpu를 사용하는게 아니기 때문에 계속 켜놓고 있기만 해도 채굴이 된다.

다만 사용자가 100만명이 늘어남에 따라 채굴되는 속도가 절반으로 줄어드니, 늦더라도 최대한 빨리 시작하는게 좋다.

특징

핸드폰 수명에 영향을 주지 않음
추천인 코드로 친구를 추가하여, 추가한 친구 수 만큼 채굴속도 빨라짐(추천받은사람, 추천한사람 모두 추가됨)
- 추천인 : suncool 부탁드려요~ 그래야 가입됩니다.
24시간이 지난 후 번개모양의 버튼을 클릭해야 그날 채굴한 코인이 적립이 된다.(24시간이 지나면 알림 메세지가 뜸)
추가한 친구수마다 채굴 속도가 빨라진다

파이코인 설치하기

구글스토어, App store에서 pi network 혹은 pi coin으로 검색한 후 다운로드.
검색 귀찮으면 https://minepi.com/blue7128#download 클릭하여 어플을 다운로드 한다.

설치과정

facebook id 혹은 휴대폰 전화번호로 계정을 생성한다.

FirstName : 이름 LastName : 성 을 입력하고 맘에드는 username을 입력한다.

추천인 코드(초대한사람)를 넣는다. (suncool 추천부탁드려요)

추천인 코드를 안넣으면 가입이 안된다.

자바(Java) 가위바위보 게임

SunnyCool — Mon, 13 Apr 2020 16:00:43 +0900

궁금한 사항은 댓글로 남겨주세요. 소스마다 주석을 남겼으니 참고하시면 됩니다.

10판을 컴퓨터와 가위바위보 하여 이긴수, 비긴수, 패배수 를 카운트하여 결과를 보여준다.
컴퓨터가 낸 수는 Math.random 메소드를 이용하여 임의의 값을 받도록 한다.

소스

Rock_Paper_Scissors.java

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

import java.util.Scanner;
 
public class Rock_Paper_Scissors {
 
    //가위, 바위, 보를 정수형과 맵핑하기 위하여 final 변수 설정
    private static final int SCISSORS = 1; //가위
    private static final int ROCK = 2; //바위
    private static final int PAPER = 3; //보
 
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
 
        while(true) {
            System.out.println("경기 시작 : 1, 종료 : 2");
            
            if(scanner.nextInt() > 1) break;
 
            int win =0;    //이긴 수
            int compare = 0; //비긴 수
            int fail = 0; //패배 수
            
            int random = 0; //컴퓨터가 낸 값
            int user = 0; //유저가 낸 값
 
            for(int idx=0; idx < 10; idx++) {
                int ret = 0; //가위바위보 결과 
                
                //컴퓨터 가위/바위/보 중에 랜덤으로 생성
                //Math.random은 double형으로 random값을 생성하므로 10을 곱한뒤 3으로 나눈값에서 1을 더해준다.(1,2,3)
                random = (int) (Math.random() * 10) % 3 + 1;
                
                System.out.println("가위 바위 보중에 한가지를 선택하세요. (가위 : 1, 바위 : 2, 보 : 3)");
                //유저각 낸 값 저장
                user = scanner.nextInt();
                
                //가위바위보 결과를 저장한다.
                ret = result(user, random);
 
                if(ret == 0) {
                    win++;
                }else if(ret == 1) {
                    fail++;
                }else if(ret == 2) {
                    compare++;
                }
            }
            System.out.println("총 " + win + "승, " + fail + "패, " + compare + "무 입니다.");
        }
    }
    
    /**
     * 
     * @param user 사용자가 낸 값
     * @param computer 컴퓨터가 낸 값
     * @return int 유저가 이겼는지(0. 승리, 1. 패배, 2. 비김)
     */
    public static int result(int user, int computer) {
        int ret = 0;
 
        //비겼을 경우를 최우선으로 비교한다
        if(user == computer ) {
            System.out.println("비겼습니다.");
            ret = 2;
            return ret; 
        }
        
        //유저가 가위를 냈다면
        //컴퓨터가 낸 값이 바위와 보 둘중에 하나이므로 비교하여 승리, 패배결정
        if(user == SCISSORS) {
                System.out.print("유저 : 가위 ,");
            if(computer == ROCK) { 
                System.out.println("컴퓨터 : 바위 >>> 결과 : 패배");
                ret = 1;
            }else {
                System.out.println("컴퓨터 : 보 >>> 결과 : 승리");
                ret = 0;
            }
        }
        
        //유저가 바위를 냈다면
        //컴퓨터가 낸 값이 가위와 보 둘중에 하나이므로 비교하여 승리, 패배결정
        if(user == ROCK) {
                System.out.print("유저 : 바위 ,");
            if(computer == PAPER) { 
                System.out.println("컴퓨터 : 보 >>> 결과 : 패배");
                ret = 1;
            }else {
                System.out.println("컴퓨터 : 가위 >>> 결과 : 승리");
                ret = 0;
            }
        }
        
        //유저가 보를 냈다면
        //컴퓨터가 낸 값이 가위와 바위 둘중에 하나이므로 비교하여 승리, 패배결정
        if(user == PAPER) {
                System.out.print("유저 : 보, ");
            if(computer == SCISSORS) { 
                System.out.println("컴퓨터 : 가위 >>> 결과 : 패배");
                ret = 1;
            }else {
                System.out.println("컴퓨터 : 바위 >>> 결과 : 승리");
                ret = 0;
            }
        }
        
        //결과 리턴
        return ret;
    }
}
 

 

결 과

자바(Java) 주소록 관리-파일(File) 입출력 통한 저장 및 불러오기 기능 추가

SunnyCool — Sun, 12 Apr 2020 22:03:19 +0900

궁금한 사항은 댓글로 남겨주세요. 소스마다 주석을 남겼으니 참고하시면 됩니다.

개인정보를 입력을 통해 받는다(고유번호, 이름, 폰/집 전화번호, 성별, 나이, 메일)
리스트화 하는 출력기능
고유번호를 통해 수정/삭제 기능 추가
저장된 개인정보를 파일에 저장하는 기능 추가
저장된 파일을 불러오는 기능 추가

개발 요점

- 개인정보를 저장하는 PersonInfo 객체

- 입력, 수정, 삭제 역할을 담당하는 객체 생성

- 고정배열 보다는 그때그때 추가를 위하여 List 객체로 관리한다.

- 파일 저장 및 불러오기를 담당하는 객체 생성

FileUtil.java(파일 입출력 객체)

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

package kr.co.practice.util;
 
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStream;
import java.io.Reader;
import java.util.ArrayList;
import java.util.List;
 
import kr.co.practice.PersonInfo;
 
public class FileUtil {
 
     /**
     * @param file 개인정보가 저장된 파일
     * @return List<PersonInfo>
     */
    public static List<PersonInfo> readFile(File file) throws IOException {
        FileReader filereader = null;
        List<PersonInfo> InfoList = new ArrayList<PersonInfo>();
 
        try {
            filereader = new FileReader(file);
            //파일에서 읽어온 정보를 List에 저장한다.
            InfoList = readReader(filereader);
        } finally {
            if (filereader != null)
                filereader.close();
        }
        return InfoList;
    }
    
    /**
     * 
     * @param dir 저장할 디렉토리
     * @param name 파일명
     * @param InfoList 개인정보가 저장된 List
     * @throws IOException
     * 
     */
    public static void writeFile(String dir, String name, List<PersonInfo> InfoList ) throws IOException {
        OutputStream out = null;
        try {
            File dirent = new File(dir);
            
            //저장할 디렉토리가 존재하지 않으면 생성
            if(!dirent.exists()) {
                dirent.mkdir();
            }
 
            File outFile = new File(dir, name);
 
            //파일이 존재한다면 삭제한다.
            if(outFile.exists()) {
                outFile.delete();
            }
 
            //파일에 String값을 입력할 BufferedOutputStream 생성
            out = new BufferedOutputStream(new FileOutputStream(outFile));
            for(int idx=0; idx < InfoList.size(); idx++) {
                //List에서 개인정보를 가져온다.
                String writeStr = InfoList.get(idx).getPN() + "," + InfoList.get(idx).getName() + "," + InfoList.get(idx).getAge() + ","
                                + InfoList.get(idx).getSex() + ","+ InfoList.get(idx).getNumber() + "," + InfoList.get(idx).getPhonenumber()+"\n";
 
                //저장한 string값을 Byte 배열로 변경
                byte[] b = writeStr.getBytes();
                
                //파일에 해당 내용을 쓴다.
                out.write(b);
            }
        } catch (IOException ioe) {
            //입출력에서 예외발생시 예외 내용 출력
            ioe.printStackTrace();
            throw ioe;
        } finally {
            try {
                //BufferdOutputStream 객체를 close해준다.
                if (out != null) out.close();
            } catch (Exception e) {
            }
        }
    } 
    
    /**
     * 
     * @param input
     * @return
     * @throws IOException
     */
    public static List<PersonInfo> readReader(Reader input) throws IOException {
        try {
            //파일의 내용을 읽어들일 BufferReader 객체 생성
            BufferedReader in = new BufferedReader(input);
            String line;
            
            List<PersonInfo> InfoList = new ArrayList<PersonInfo>();
 
            //파일을 한줄씩 읽어간다. 
            while((line=in.readLine()) != null) {
                // ","로 split하여 배열에 저장
                String[] writeStr = line.split(",");
                
                // 모든 정보가 저장되어 있지 않다면 skip한다.
                if(writeStr.length != 6) continue;
                
                PersonInfo personInfo = new PersonInfo();
                
                //각 개인정보를 저장한다.
                personInfo.setPN(Integer.parseInt(writeStr[0]));
                personInfo.setName(writeStr[1]);
                personInfo.setAge(Integer.parseInt(writeStr[2]));
                personInfo.setSex(writeStr[3]);
                personInfo.setNumber(writeStr[4]);
                personInfo.setPhonenumber(writeStr[5]);
                
                //리스트에 객체 추가.
                InfoList.add(personInfo);
            }
            
            return InfoList;
        } finally {
            input.close();
        }
    }
}
 
 

 

PersonInfo.java(개인정보 객체)

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

package kr.co.practice; 
 
public class PersonInfo {
    //고유번호
    private int PN;
    //이름
    private String name;
    
    //나이
    private int age;
    
    //성별
    private String sex;
    
    //집전화
    private String number;
    
    //휴대폰번호
    private String phonenumber;
 
    /*
     * 각 멤버 변수 별 SET/GET Method
     */
    public int getPN() {
        return PN;
    }
 
    public void setPN(int pn) {
        this.PN = pn;
    }
    
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public String getSex() {
        return sex;
    }
 
    public void setSex(String sex) {
        this.sex = sex;
    }
 
    public String getNumber() {
        return number;
    }
 
    public void setNumber(String number) {
        this.number = number;
    }
 
    public String getPhonenumber() {
        return phonenumber;
    }
 
    public void setPhonenumber(String phonenumber) {
        this.phonenumber = phonenumber;
    }
    
    public void showInfo() {
        System.out.println("이름 : " + this.name);
        System.out.println("나이 : " + this.age);
        System.out.println("성별 : " + this.sex);
        System.out.println("전화번호 : " + this.number);
        System.out.println("휴대폰번호 : " + this.phonenumber);
    }
}
 

 

PersonManager.java(개인정보 저장/삭제/수정)

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

package kr.co.practice;
 
import java.util.ArrayList;
import java.util.List;
 
public class PersonManager {
    //개인정보 저장할 List
    private List<PersonInfo> InfoList = new ArrayList<PersonInfo>(); 
    //개인별 고유번호 
    private int PN = 0;
 
    /**
     * 
     * @return
     */
    public List<PersonInfo> getInfoList(){
        return this.InfoList;
    }
    
    /**
     * 
     * @param InfoList
     */
    public void setInfoList(List<PersonInfo> InfoList) {
        this.InfoList = InfoList;
    }
 
    /**
     * @param personInfo
     * @return
     */
    public int addInfo(PersonInfo personInfo) {
        //성공여부 return 변수
        int ret = 0;
 
        try {
            //교유번호 지정
            personInfo.setPN(++this.PN);
            
            //List에 객체를 추가 해 준다.
            this.InfoList.add(personInfo);
            
        }catch(Exception e) {
            System.out.println("정보 추가 중 에러가 발생하였습니다." + "\n" + e.getMessage());
            //return값 변경(0 : 정상, 1 : 에러) 
            ret = 1;
        }
        
        return ret;
    }
    
    /**
     * @param PN
     * @return
     */
    public int removeInfo(int PN) {
        //성공여부 return 변수
        int ret = 0;
        
        try {
            //List개수만큼 for문
            for(int idx=0; idx < this.InfoList.size(); idx++) {
                PersonInfo tempPersonInfo = this.InfoList.get(idx);
 
                if(PN == tempPersonInfo.getPN()) {
                    //고유번호를 비교하여 같은 번호의 정보를 삭제한다.
                    this.InfoList.remove(idx);
                    break;
                }
                
                if(idx == this.InfoList.size()-1) {
                    ret = 2;
                }
            }
        }catch(Exception e) {
            System.out.println("정보 삭제 중 에러가 발생하였습니다." + "\n" + e.getMessage());
            //return값 변경(0 : 정상, 1 : 에러, 2 : 해당정보없음) 
            ret = 1;
        }
        
        return ret;
    }
    
    /**
     * @param PN
     * @param personInfo
     * @return
     */
    public int updateInfo(PersonInfo personInfo, int PN) {
        //성공여부 return 변수
        int ret = 0;
        
        try {
            //List개수만큼 for문
            for(int idx=0; idx < this.InfoList.size(); idx++) {
                PersonInfo tempPersonInfo = this.InfoList.get(idx);
 
                if(PN == tempPersonInfo.getPN()) {
                    personInfo.setPN(PN);
 
                    //고유번호를 비교하여 같은 번호의 정보를 수정한다.
                    this.InfoList.remove(idx);
                    this.InfoList.add(idx, personInfo);
                    break;
                }
                
                if(idx == this.InfoList.size()-1) {
                    ret = 2;
                }
            }
        }catch(Exception e) {
            System.out.println("정보 수정 중 에러가 발생하였습니다." + "\n" + e.getMessage());
            //return값 변경(0 : 정상, 1 : 에러, 2 : 해당정보없음) 
            ret = 1;
        }
        
        return ret;
    }
    
    
    public void showInfo() {
        for(int idx=0; idx < this.InfoList.size(); idx++) {
            System.out.println("##########################");
            System.out.println("고유번호 : " + this.InfoList.get(idx).getPN()
                                +"\n이름 : " + this.InfoList.get(idx).getName()
                                +"\n나이 : " + this.InfoList.get(idx).getAge()
                                +"\n성별 : " + this.InfoList.get(idx).getSex()
                                +"\n전화번호 : " + this.InfoList.get(idx).getNumber()
                                +"\n휴대폰번호 : " + this.InfoList.get(idx).getPhonenumber()
                                );
            System.out.println("##########################");
        }
    }
}
 

 

PersonDesk.java(메인클래스)

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

package kr.co.practice;
 
import java.io.File;
import java.io.IOException;
import java.util.Scanner;
 
import kr.co.practice.util.FileUtil;
 
public class PersonDesk {
    private static Scanner scan = new Scanner(System.in);
    public static void main(String[] args) throws IOException {
        //추가, 삭제, 수정을 위한 객체 생성
        PersonManager pm = new PersonManager();
        
        //저장할 위치 및 파일
        String filepath = "c:\\test\\";
        String filename = "person.txt";
 
        boolean power = true;
        
        while(power) {
            scan.reset();
            System.out.println("1. 출력, 2. 추가, 3. 수정, 4. 삭제, 5. 파일저장, 6. 파일에서불러오기, 7. 종료, 8. 처음으로");
            
            String menuNum = scan.next();
 
            if("1".equals(menuNum)) {
                pm.showInfo();
            }else if("2".equals(menuNum)) {
                pm.addInfo(makeInfo());
            }else if("3".equals(menuNum)) {
                System.out.println("수정할 정보의 고유번호를 입력해 주세요.");
                int PN = scan.nextInt();
                pm.updateInfo(makeInfo(), PN);
            }else if("4".equals(menuNum)) {
                System.out.println("삭제할 정보의 고유번호를 입력해 주세요.");
                pm.removeInfo(scan.nextInt());
            }else if("5".equals(menuNum)) {
                FileUtil.writeFile(filepath, filename, pm.getInfoList());
            }else if("6".equals(menuNum)) {
                pm.setInfoList(FileUtil.readFile(new File(filepath, filename)));
            }else if("7".equals(menuNum)) {
                power = false;
            }else if("8".equals(menuNum)) {
                continue;
            }else {
                System.out.println("해당 메뉴는 없는 메뉴입니다. 다시 선택 바랍니다.");
                continue;    
            }
        }
        scan.close();
    }
    
    public static PersonInfo makeInfo() {
        scan.reset();
        PersonInfo person = new PersonInfo();
        
        System.out.print("이름 : ");
        person.setName(scan.next());
        
        System.out.println();
 
        System.out.print("나이 : ");
        person.setAge(scan.nextInt());
 
        System.out.println();
 
        System.out.print("성별  : ");
        person.setSex(scan.next());
 
        System.out.println();
 
        System.out.print("전화번호  : ");
        person.setNumber(scan.next());
 
        System.out.println();
 
        System.out.print("휴대폰번호  : ");
        person.setPhonenumber(scan.next());
        
        System.out.println();    
        
        return person;
    }
}
 

 

결 과

자바(Java) 주소록 관리-입출력

SunnyCool — Sun, 12 Apr 2020 21:39:56 +0900

궁금한 사항은 댓글로 남겨주세요. 소스마다 주석을 남겼으니 참고하시면 됩니다.

개인정보를 입력을 통해 받는다(고유번호, 이름, 폰/집 전화번호, 성별, 나이, 메일)
리스트화 하는 출력기능
고유번호를 통해 수정/삭제 기능 추가

개발 요점

- 개인정보를 저장하는 PersonInfo 객체

- 입력, 수정, 삭제 역할을 담당하는 객체 생성

- 고정배열 보다는 그때그때 추가를 위하여 List 객체로 관리한다.

PersonInfo.java(개인정보 객체)

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

public class PersonInfo {
    //고유번호
    private int PN;
    //이름
    private String name;
    
    //나이
    private int age;
    
    //성별
    private String sex;
    
    //집전화
    private String number;
    
    //휴대폰번호
    private String phonenumber;
 
    /*
     * 각 멤버 변수 별 SET/GET Method
     */
    public int getPN() {
        return PN;
    }
 
    public void setPN(int pn) {
        this.PN = pn;
    }
    
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public String getSex() {
        return sex;
    }
 
    public void setSex(String sex) {
        this.sex = sex;
    }
 
    public String getNumber() {
        return number;
    }
 
    public void setNumber(String number) {
        this.number = number;
    }
 
    public String getPhonenumber() {
        return phonenumber;
    }
 
    public void setPhonenumber(String phonenumber) {
        this.phonenumber = phonenumber;
    }
    
    public void showInfo() {
        System.out.println("이름 : " + this.name);
        System.out.println("나이 : " + this.age);
        System.out.println("성별 : " + this.sex);
        System.out.println("전화번호 : " + this.number);
        System.out.println("휴대폰번호 : " + this.phonenumber);
    }
}
 

 

PersonManager.java(개인정보 저장/삭제/수정)

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

package kr.co.practice;
 
import java.util.ArrayList;
import java.util.List;
 
public class PersonManager {
    //개인정보 저장할 List
    private List<PersonInfo> InfoList = new ArrayList<PersonInfo>(); 
    //개인별 고유번호 
    private int PN = 0;
 
    /**
     * @param personInfo
     * @return
     */
    public int addInfo(PersonInfo personInfo) {
        //성공여부 return 변수
        int ret = 0;
 
        try {
            //교유번호 지정
            personInfo.setPN(++this.PN);
            
            //List에 객체를 추가 해 준다.
            this.InfoList.add(personInfo);
            
        }catch(Exception e) {
            System.out.println("정보 추가 중 에러가 발생하였습니다." + "\n" + e.getMessage());
            //return값 변경(0 : 정상, 1 : 에러) 
            ret = 1;
        }
        
        return ret;
    }
    
    /**
     * @param PN
     * @return
     */
    public int removeInfo(int PN) {
        //성공여부 return 변수
        int ret = 0;
        
        try {
            //List개수만큼 for문
            for(int idx=0; idx < this.InfoList.size(); idx++) {
                PersonInfo tempPersonInfo = this.InfoList.get(idx);
 
                if(PN == tempPersonInfo.getPN()) {
                    //고유번호를 비교하여 같은 번호의 정보를 삭제한다.
                    this.InfoList.remove(idx);
                    break;
                }
                
                if(idx == this.InfoList.size()-1) {
                    ret = 2;
                }
            }
        }catch(Exception e) {
            System.out.println("정보 삭제 중 에러가 발생하였습니다." + "\n" + e.getMessage());
            //return값 변경(0 : 정상, 1 : 에러, 2 : 해당정보없음) 
            ret = 1;
        }
        
        return ret;
    }
    
    /**
     * @param PN
     * @param personInfo
     * @return
     */
    public int updateInfo(PersonInfo personInfo, int PN) {
        //성공여부 return 변수
        int ret = 0;
        
        try {
            //List개수만큼 for문
            for(int idx=0; idx < this.InfoList.size(); idx++) {
                PersonInfo tempPersonInfo = this.InfoList.get(idx);
 
                if(PN == tempPersonInfo.getPN()) {
                    personInfo.setPN(PN);
 
                    //고유번호를 비교하여 같은 번호의 정보를 수정한다.
                    this.InfoList.remove(idx);
                    this.InfoList.add(idx, personInfo);
                    break;
                }
                
                if(idx == this.InfoList.size()-1) {
                    ret = 2;
                }
            }
        }catch(Exception e) {
            System.out.println("정보 수정 중 에러가 발생하였습니다." + "\n" + e.getMessage());
            //return값 변경(0 : 정상, 1 : 에러, 2 : 해당정보없음) 
            ret = 1;
        }
        
        return ret;
    }
    
    
    public void showInfo() {
        for(int idx=0; idx < this.InfoList.size(); idx++) {
            System.out.println("##########################");
            System.out.println("고유번호 : " + this.InfoList.get(idx).getPN()
                                +"\n이름 : " + this.InfoList.get(idx).getName()
                                +"\n나이 : " + this.InfoList.get(idx).getAge()
                                +"\n성별 : " + this.InfoList.get(idx).getSex()
                                +"\n전화번호 : " + this.InfoList.get(idx).getNumber()
                                +"\n휴대폰번호 : " + this.InfoList.get(idx).getPhonenumber()
                                );
            System.out.println("##########################");
        }
    }
}
 

 

PersonDesk.java(메인클래스)

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

package kr.co.practice;
 
import java.util.Scanner;
 
public class PersonDesk {
    private static Scanner scan = new Scanner(System.in);
    public static void main(String[] args) {
        //추가, 삭제, 수정을 위한 객체 생성
        PersonManager pm = new PersonManager();
        
 
        boolean power = true;
        
        while(power) {
            scan.reset();
            System.out.println("1. 출력, 2. 추가, 3. 수정, 4. 삭제, 5. 종료, 6. 처음으로");
            
            String menuNum = scan.next();
 
            if("1".equals(menuNum)) {
                pm.showInfo();
            }else if("2".equals(menuNum)) {
                pm.addInfo(makeInfo());
            }else if("3".equals(menuNum)) {
                System.out.println("수정할 정보의 고유번호를 입력해 주세요.");
                int PN = scan.nextInt();
                pm.updateInfo(makeInfo(), PN);
            }else if("4".equals(menuNum)) {
                System.out.println("삭제할 정보의 고유번호를 입력해 주세요.");
                pm.removeInfo(scan.nextInt());
            }else if("5".equals(menuNum)) {
                power = false;
            }else if("6".equals(menuNum)) {
                continue;
            }else {
                System.out.println("해당 메뉴는 없는 메뉴입니다. 다시 선택 바랍니다.");
                continue;    
            }
        }
        scan.close();
    }
    
    public static PersonInfo makeInfo() {
        scan.reset();
        PersonInfo person = new PersonInfo();
        
        System.out.print("이름 : ");
        person.setName(scan.next());
        
        System.out.println();
 
        System.out.print("나이 : ");
        person.setAge(scan.nextInt());
 
        System.out.println();
 
        System.out.print("성별  : ");
        person.setSex(scan.next());
 
        System.out.println();
 
        System.out.print("전화번호  : ");
        person.setNumber(scan.next());
 
        System.out.println();
 
        System.out.print("휴대폰번호  : ");
        person.setPhonenumber(scan.next());
        
        System.out.println();    
        
        return person;
    }
}
 
 

 

결 과

자바 상속(Inheritance)과 다형성(polymorphism) - final, abstract, Interface

SunnyCool — Sun, 8 Sep 2019 22:28:14 +0900

1. 상속(inheritance) 이란?

부모클래스의 모든 자원을 자식클래스에게 물려주는 것을 상속이라 한다. 자식클래스는 상속받은 부모클래스의 모든 자원을 사용할 수 있다. (접근제어자 특징에 따라 달라 질 수 있다.)

상속은 다음과 같은 특징이 있다.

부모, 자식클래스는 예약어 extends 키워드로 정의된다.
하나의 부모클래스는 여러개의 자식클래스를 가질 수 있지만, 자식클래스는 다수의 부모클래스를 가질 수 없다.
자식클래스는 다른 클래스의 부모 클래스가 될 수 있다.
부모클래스의 자원은 오버라이딩 하여 재정의를 통해 사용할 수 있다.
부모클래스가 상속받은 자원은 자식 클래스에서도 사용가능 하다.
private을 제외한 상위클래스의 자원은 상속된다.
동일한 이름의 변수가 사용된다면 부모클래스의 변수는 숨겨진다.

위 특징과 같이 상속은 궁극적으로 소스의 중복을 제거하고, 확장하여 유지보수 및 재사용성에서 이익을 보기위함이다.

상속받은 클래스를 객체로 생성하여 사용하는 것이 효율적이라 할 수 있다. 다음 소스를 통해 확인해 보도록 하자.

galaxy.java

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

package Inheritance;
 
public class galaxy {
    protected int width;
    protected int height;
 
    public galaxy() {
        this.width = 7;
        this.height = 13;
    }
    
    public galaxy(int width, int heigth) {
        this.width = width;
        this.height = heigth;
    }
 
    public void display() {
        System.out.println("가로 : " + width + ", 세로 : " + height);
    }
    
    public void call() {
        System.out.println("전화 기능");
    }
    
    public void message() {
        System.out.println("문자 기능");
    }
}
 

 

galaxyNote.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

package Inheritance;
 
public class galaxyNote extends galaxy{
    private String display = "";
    
    public galaxyNote(int width, int height, String edge) {
        super(width, height);
        this.display = edge;
    }
    
    public void plusDisplayFunction() {
        System.out.println(this.display + " 기능 추가됨");
    }
    
    public void addPen() {
        System.out.println("펜 기능 추가");
    }
}
 

 

samsung.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

package Inheritance;
 
public class samsung {
 
    public static void main(String[] args) {
        galaxyNote note = new galaxyNote(10, 15, "엣지 디스플레이");
        
        //부모클래스에게서 상속받은 메소드
        note.display();
        note.call();
        note.message();
        
        System.out.println();
 
        //자식클래스에서 추가된 메소드
        note.plusDisplayFunction();
        note.addPen();
    }
}
 

 

결과)

    가로 : 10, 세로 : 15
    전화 기능
    문자 기능

    엣지 디스플레이 기능 추가됨
    펜 기능 추가

위소스의 클래스 다이어그램은 다음과 같다.

부모클래스인 galaxy와 galaxy클래스를 상속받아 추가 기능을 구현한 galaxyNote 자식클래스로 구분된다.

galaxyNote의 기본적인 전화걸기와 문자보내기, 디스플레이의 가로세로 셋팅은 galaxy클래스에 정의가 되어 있으니 해당 자원을 모두 상속받고 galaxyNote에서 추가되는 기능만 구현을 하였다. galaxyNote에는 pen기능과 edge디스플레이가 추가되었음을 확인 할 수 있다.

만약 galaxyNote클래스가 상속을 받지 않고 구현되었다면 galaxy에 있는 모든 자원들이 galaxyNote클래스에 구현이 되었어야 한다. 하지만 이는 중복된 코드가 다시 들어가게 되며, 공통된 기능이 수정된다면 galaxy, galaxNote클래스에서 모두 수정이 이루어져야 한다. 하지만 상속을 이용한다면 수정, 중복코드를 최소화 할 수 있다.

2. super

위 소스 중 galaxyNote클래스 생성자에서 super(int width, int height)를 사용하였다. 이는 부모클래스의 생성자를 호출 하는것으로 super는 다음과 같은 특징이 있다.

this가 객제 자신을 가리키는 포인터라면, super는 부모클래스의 객체를 가리키는 포인터 이다.
super.멤버변수, super.메소드(매개변수) 로 부모클래스의 자원에 접근 할 수 있다.
부모클래스 생성자에 접근하는 방법은 super(매개변수) 이다.

3. 추상클래스(Abstract class)

상속에서 빠지지 않는 개념이 추상클래스인데, 다음과 같은 특징이 있다.

클래스 및 메소드 앞에 abstract 예약어를 사용한다.
추상메소드는 선언만 되어있고 구현부분이 없다.
자식클래스는 반드시 추상클래스에 선언된 모든메소드를 재정의 하여 사용하여야 한다.
추상클래스 자체는 객체로 선언할 수 없으며, 상속의 기능으로만 사용하여야 한다.

그렇다면 추상 클래스는 왜 사용할까?? 이 부분은 추후에 별도 글을 통해 확인하도록 한다. 우선 다음 예제소스를 통해 기본적인 골격을 확인하도록 하자.

nation.java

1
2
3
4
5

package abstraction;
 
public abstract class nation {
    public abstract void show();
}

 

korea.java

1
2
3
4
5
6
7

package abstraction;
 
public class korea extends nation {
    public void show() {
        System.out.println("한국");
    }
}
 

 

 

america.java

1
2
3
4
5
6
7

package abstraction;
 
public class america extends nation{
    public void show() {
        System.out.println("미국");
    }
}
 

 

unitedkingdom.java

1
2
3
4
5
6
7

package abstraction;
 
public class unitedkingdom extends nation {
    public void show() {
        System.out.println("영국");
    }
}
 

 

main.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14

package abstraction;
 
public class main {
 
    public static void main(String[] args) {
        nation korea = new korea();
        nation america = new america();
        nation uk = new unitedkingdom();
        
        korea.show();
        america.show();
        uk.show();
    }
}
 

 

nation추상클래스를 상속받은 korea, america, uk는 모두 show메소드를 재정의 하여 사용한 것을 확인 할 수 있다. 특이점은 추상클래스인 nation타입으로 변수를 지정하고 자식클래스 중 어느 클래스를 객체로 생성해도 사용할 수 있다는 점이다.

결과)

    한국
    미국
    영국

4. final

final은 다음과 같은 특징이 있다.

final은 최초 초기화된 값으로만 사용할 수 있도록 정의된 예약어 이다.
final이 붙은 클래스는 상속할 수 없다.
final이 붙은 메소드는 오버라이딩(재정의) 할 수 없다.
final이 붙은 변수는 값을 변경할 수 없다.

일반적으로 최초 속성 값 이후에 절대 변경하지 말아야 하는 자원들은 final을 붙인다.

5. 인터페이스(Interface)

추상클래스와 의미가 비슷하지만 다중상속을 하기 위하여 나온 개념으로서 자세한 설명은 추후 별도 글에서 다루기로 한다.

implements 키워드를 사용하여 상속받는다.
인터페이스에서 정의된 모든 메소드는 상속받은 클래스에서 재정의 해야 한다.
static final 변수와 추상메소드 만을 사용한다.

자바 생성자(Java Constructor)

SunnyCool — Sun, 8 Sep 2019 17:33:15 +0900

1. 생성자 정의

객체를 생성할 때 초기화 기능을 제공하는데 이를 생성자(Constructor)라고 한다. 특징은 다음과 같다.

생성자는 return(반환) 값이 없다.
생성자명은 클래스명과 동일해야 한다.
개발자가 생성자를 구현하지 않아도 객체 생성 시 디폴트 생성자(Default Contructor)가 생성된다. - 빈껍데기

생성자가 호출되는 시점은 객체를 생성하기 위하여 new 연산자를 사용할 때 이다.

- new 클래스명(매개변수, 매개변수…...)

다음 소스를 통해 확인해 보도록 하자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public class calculator {
    private int leftNum;
    private int rightNum;
 
    //생성자를 통해 인스턴스 변수를 초기화 해준다.
    public calculator(int leftNum, int rightNum) {
        this.leftNum = leftNum;
        this.rightNum = rightNum;
    }
    
    public int sum() {
        return this.leftNum + this.rightNum;
    }
    public static void main(String[] args) {
        calculator cacl = new calculator(3, 5);
        
        System.out.println(cacl.sum());
    }
}
 

 

결과)

calculator cacl = new calculator(3, 5) 에서 객체를 생성함과 동시에 3과 5값을 생성자에 매개변수로 전달하여 인스턴스 변수를 해당 값으로 초기화 해주었다. 만약 생성자에서 초기화하는 역할을 수행하지 않았다면, 별도 인스턴스 변수를 초기화해야하는 메소드가 필요했을 것이다.

2. 생성자 오버로딩

생성자는 오버로딩하여 사용할 수 있다.

(오버로딩의 정의에 대해서는 https://codehouse.tistory.com/25 내용을 통해 숙지하도록 하자.)

생성자의 매개변수 개수, 타입으로 다수의 생성자를 만들 수 있다.

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

public class user {
 
    private String name = "";
 
    public user() {
        this.name = "할당된 이름 없음";
    }
    
    public user(String name) {
        this.name = name;
    }
 
    public user(String firstName, String lastName) {
        this.name = firstName + lastName;
    }
 
    public static void main(String[] args) {
        user test = new user();
        user test2 = new user("철수");
        user test3 = new user("김","철수");
        
        System.out.println(test.name);
        System.out.println(test2.name);
        System.out.println(test3.name);
    }
}
 

 

결과)

    할당된 이름 없음
    철수
    김철수

객체를 생성할 때 어떠한 매개변수를 지정하느냐에 따라 서로다른 값이 출력됨을 확인 할 수 있다.

자바 오버로딩, 오버라이딩(java overloading, overriding)

SunnyCool — Sun, 8 Sep 2019 17:27:34 +0900

자바 객체지향(OOP)의 특징 중 하나인 다형성을 지원하는 방법으로 메소드 오버로딩, 오버라이딩이 있다.

오버로딩과, 오버라이딩을 간단히 정의하자면 다음과 같다.

오버로딩 : 동일한 이름을 가지는 메소드를 매개변수의 타입과 갯수로 구분짓도록 하는것을 오버로딩 이라고 한다.
오버라이딩 : 부모(상위) 클래스의 메소드를 재정의 하여 사용하는 것을 오버라이딩 이라고 한다.

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
35
36
37
38
39
40

public class exOverloading {
    public String strTest;
 
    //기본생성자 - 매개변수 없는 타입의 생성자
    public exOverloading() {
        this.strTest = "기본생성자";
    }
    
    //매개변수가 있는 생성자 - new 클래스명(파라미터)로 객체를 생성하면 해당 생성자가 실행된다.
    public exOverloading(String msg) {
        this.strTest = msg;
    }
    
    //매개변수가 없는 메소드 - 인스턴스변수를 출력
    public void print() {
        System.out.println(this.strTest);
    }
    
    //매개변수가 있는 메소드 - 매개변수를 출력해 준다.
    public void print(String msg) {
        System.out.println(msg);
    }
    
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        exOverloading overloading = new exOverloading();
        exOverloading overloading2 = new exOverloading("생성자 오버로딩 테스트");
        
        //생성자 오버로딩에 대한 인스턴스 변수 확인
        System.out.println(overloading.strTest);
        System.out.println(overloading2.strTest);
        
        System.out.println();
 
        //메소드 오버로딩 결과 확인
        overloading2.print();
        overloading2.print("메소드 오버로딩 테스트");
    }
}
 

 

결과)

    기본생성자
    생성자 오버로딩 테스트

    생성자 오버로딩 테스트
    메소드 오버로딩 테스트

예제소스를 보면 알 수 있듯이 동일한 메소드 및 생성자 라도 매개변수에 따라 서로다른 메소드 및 생성자를 호출할 수 있다는것을 알 수 있다.

2. 오버라이딩

부모(상위) 클래스의 메소드를 재정의 하여 사용하는 기능을 말한다. 상속을 받았지만 자식클래스 고유의 기능을 별도로 정의할 필요가 있을때 메소드 오버라이딩을 이용한다. 이부분은 상속에서 기본적으로 사용하는 기능이니 꼭 숙지하고 넘어 가도록 하자.

parent.java

1
2
3
4
5
6

public class parent {
    
    public void print() {
        System.out.println("부모클래스에서 print() 메소드");
    }
}
 

 

exOverRidding.java

1
2
3
4
5
6
7
8
9
10
11

public class exOverRidding extends parent{
    
    public void print() {
        System.out.println("자식 클래스에서의 print() 메소드");
    }
 
    public static void main(String[] args) {
        parent test = new exOverRidding();
        test.print();
    }
}
 

 

결과)

	자식 클래스에서의 print() 메소드

자식클래스에서 print()메소드를 재정의 하였다. 객체를 생성하고 메소드를 호출하면 자식클래스에서 재정의한 메소드가 호출되는것을 확인할 수 있다.

3. 특성에 따른 사용가능 조건

구분	오버로딩	오버라이딩
매개변수 개수 및 타입	메소드 별로 서로 달라야 사용 가능	부모클래스와 동일해야함
메소드 이름	오버로딩 하는 메소드는 모두 동일해야함	부모클래스와 동일해야함
리턴타입	조건없음	부모클래스와 동일해야함

위 표에서 알 수 있듯이, 오버라이딩은 말그대로 재정의 이기 때문에 반드시 부모클래스와 매개변수 개수, 타입, 리턴타입, 이름이 동일해야하며 오버로딩은 메소드이름을 제외한 나머지 모두 달라야 사용가능함을 알 수 있다.

4. 오버라이딩과 static 메소드

static메소드는 실행되기 전에 이미 메모리에 적재되어 있는 것을 말한다. 이 static메소드는 재정의를 위해 사용하는 것은 아니지만 재정의를 한다고 해서 오류가 발생하지는 않는다.

만약 static메소드가 있는 부모 클래스를 상속받아서 해당 static메소드를 재정의하면 자식 클래스에 있는 해당 메소드는 사용할 수 없다. 이를 하이딩(hidding)이라고 한다.

2챕터에서 오버라이딩 예제소스중 print메소드를 static으로 변형한 후에 결과를 확인해 보자.

parent.java

1
2
3
4
5
6
7

public class parent {
    
    //static으로 메소드 선언
    public static void print() {
        System.out.println("부모클래스에서 print() 메소드");
    }
}
 

 

exOverRidding.java

1
2
3
4
5
6
7
8
9
10
11
12

public class exOverRidding extends parent{
    
    //부모클래스의 static메소드를 재정의해보자.
    public static void print() {
        System.out.println("자식 클래스에서의 print() 메소드");
    }
 
    public static void main(String[] args) {
        parent test = new exOverRidding();
        test.print();
    }
}
 

 

결과)

	부모클래스에서 print() 메소드

2챕터에서의 결과와는 반대로 자식객체를 생성하여 메소드를 호출했는데도 불구하고 부모클래스의 메소드가 수행되었음을 확인할 수 있다.

그림(사진) 파일 용량 줄이기

SunnyCool — Sat, 7 Sep 2019 23:28:51 +0900

jpg 용량 줄이기 위한 간단한 사이트 하나 소개할까 한다.

https://pixlr.com/editor/

Online Photo Editor | Pixlr Editor

Announcement Adobe Flash Player will no longer be supported by worldwide browsers soon. Thus, Pixlr Editor, which runs on Adobe Flash Player, will be phased out and replaced by the all-new smarter and faster PIXLR X. TRY PIXLR X NOW CONTINUE WITH EDITOR

pixlr.com

위 사이트에 접속하면 아래와 같은 창이 뜰텐데 빨간색 네모칸에 보이는것처럼 로컬 피시에 저장되어 있는 사진파일을 불러오기 한다.

그림파일을 불러온 후 화면은 다음과 같다. 참고로 간단한 메뉴도 제공하니까 좌측 메뉴에서 간단한 수정작업도 할 수 있다.

이제 File -> save 버튼을 눌러보자.

save버튼을 누르면 팝업이 하나 뜨는데 여기에서 Quality(품질)정도를 드래그바로 셋팅 할 수 있다.

당연히 숫자가 높을수록 원본그대로, 낮을 수록 낮은품질로 저장하는데 여기서 Quality를 낮추면 적은 용량으로 새로 저장 할 수 있다. 내가 선택한 Quality수치에 대한 용량은 하단에 size에서 확인할 수 있다.

단점이라면 최소 150kb이하로 저장은 불가능하다.

이클립스 서버 추가시 Server Name disable일때 해결하는 방법(Apache Tomcat)

SunnyCool — Sat, 7 Sep 2019 23:08:22 +0900

이클립스(Java EE)에서 Server -> new를 선택하여 Tomcat을 추가하려고 하는데 간혹 Server Name이 아무런 값도 안뜰 때가 있다. 이럴때 next버튼도 비활성화 되어있어 서버를 추가할 방법이 없다.

간혹 Server name 이 비활성화 되어있을때가 있다.

그럴 때는 이클립스를 완전 종료 후

"workspace디렉토리"/.metadata/.plugins/org.eclipse.core.runtime/.settings 디렉토리에서

"org.eclipse.wst.server.core.prefs", "org.eclipse.jst.server.tomcat.core.prefs" 두개의 파일을 지워 준 후에

이클립스를 재기동 해준다. 그럼 위 그림과 같이 Server name이 다시 활성화 되어있음을 확인 할 수 있다.

자바 메소드 매개변수(Method prameter) - 기본형 매개변수와, 참조형 매개변수

SunnyCool — Sat, 7 Sep 2019 22:31:20 +0900

자바에서는 메소드에 넘겨줄 매개변수를 지정된 값을 복사하여 넘겨준다.(이를 call by value 라고 한다.)

하지만 이렇게 단순히 값만이 복사되어 넘어 가는것이 아니다. 주소 값이 복사되어 넘어갈때도 있다.

이렇게 단순 값만을 복사하여 사용하는 매개변수를 기본형 매개변수라고 하며, 주소의 값이 복사되어 사용하는 매개변수를 참조형 매개변수라고 한다.

이 두가지 변수의 가장 큰 차이점은 다음과 같다.

기본형 매개변수는 원천데이터의 값이 변경되지 않지만, 참조형 매개변수의 원천데이터는 메소드에서 값을 변경하면 변경된다.

얼핏 이해가 안될수도 있으니 다음 예제를 통해 차이점을 확인해 보도록 하자.

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
35
36
37
38

public class exMethod {
    // 인스턴스 변수 
    public String pVal = "test Instance Value";
 
    public void changeValue(exMethod test, String[] pArrVal) {
        test.pVal = "change Instance Value";
        
        for(int i=0; i < pArrVal.length; i++) {
            pArrVal[i] = "change test" + Integer.toString(i);
        }
    }
    
    public static void main(String[] args) {
        //배열 
        String[] pArrVal = new String[]{"test", "test2"};
        
        exMethod test = new exMethod();
        
        System.out.println("클래스 내 멤버변수 pVal : " + test.pVal);
 
        System.out.print("배열 값 : ");
        for(String innerVal : pArrVal) {
            System.out.print(innerVal + ", ");
        }
        
        System.out.println("\n");
 
        //메소드 호출
        test.changeValue(test, pArrVal);
        
        System.out.println("메소드 호출 후클래스 내 멤버변수 pVal : " + test.pVal);
 
        System.out.print("메소드 호출 후 배열 값 : ");
        for(String innerVal : pArrVal) {
            System.out.print(innerVal + ", ");
        }
    }
}
 

 

결과)

클래스 내 멤버변수 pVal : test Instance Value
배열 값 : test, test2,

메소드 호출 후 클래스 내 멤버변수 pVal : change Instance Value
메소드 호출 후 배열 값 : change test0, change test1,

메소드를 호출 할때 Method(원천데이터, 원천데이터)로 매개변수 값을 전달한다. 이때 매개변수가 객체(클래스), 배열 이면 주소 값이 복사되므로, 메소드에서 매개변수값을 변경한다면 결국 원천데이터를 변경하는 것과 같다. 이는 C언어에서 call by reference와 같은 의미로 볼 수 있다.

이점을 유의하여 원천데이터가 변경되지 않아야 한다면 메소드 내에서 지역변수를 사용하여 대입 한 후 사용하도록 하자. 어찌 보면 되게 간단한 내용이지만 모르고 사용하는 개발자가 생각 보다 많다.

2. 일반형 매개변수

위에서 설명한 참조형 매개변수와 반대 의미이다. 객체(클래스), 배열 이외의 값의 매개변수이면 메소드에서 값을 변경하더라도 원천데이터는 변경되지 않는다. 다음 소스를 통해 확인해 보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class exMehotd2 {
 
    public static void changeValue(String testVal) {
        testVal = "change test data";
    }
    public static void main(String[] args) {
        String testVal = "test";
        
        System.out.println("일변 변수 형 호출 전 데이터 : " + testVal);
        //메소드 호출
        changeValue(testVal);
        
        System.out.println("일변 변수 형 호출 후 데이터 : " + testVal);
    }
}
 

 

결과)

일변 변수 형 호출 전 데이터 : test

일변 변수 형 호출 후 데이터 : test

메소드에서 전달받은 매개변수값을 변경해도 원천데이터는 변경되지 않았음을 확인 할 수 있다.

Mysql CharacterSet(문자열 인코딩) 확인 및 셋팅 변경 방법

SunnyCool — Sat, 7 Sep 2019 21:41:08 +0900

Mysql 설치 후 별다른 셋팅 없이 사용할 때 다음과같이 대부분의 Character set은 다음과 같이 확인할 수 있다.

Mysql > SHOW variables LIKE 'c%';

위그림과 같이 대부분 latin으로 지정이 되어 있는 것을 볼수 있는데 이상태에서 특정 테이블에 - 컬럼에 한글 값이 입력되면 ???로 확인된다.(당연하지만 latin은 한글을 지원하지 않는다.)

한글데이터가 ? 나옴

이와같은 경우 mysql셋팅파일인 my.cnf(혹은 my.ini)을 수정하여 케릭터셋(character set)을 utf8로 지정을 해주어야 한다.

이 파일은 mysql 설치 디렉토리에 있으니 설치된 디렉토리 하위에서 my.cnf를 열어보자.(linux는 my.cnf 이고 window는 my.ini이다. 헷갈리지 말자)

위 설정파일과 같이 바꾸어 주자

위 그림과 같이 connection, mysqld, server, client 각 부분에서 케릭터셋(character set)을 utf8로 변경해 준 후에 저장해준다.

저장후에 mysql을 재기동 해준다. (리눅스 : service mysql restart, 윈도우 : 트레이 아이콘 우클릭 - restart)

다시 SHOW variables LIKE 'c%'; 쿼리 질의를 하면 다음 그림과 같이 utf8로 변경되었음을 확인할 수 있다.

이제 table에 한글 데이터를 insert하게 되면

???에서 정상적으로 한글데이터가 출력됨을 알 수 있다.

자바 클래스내 변수(위치에 따른) - 클래스 변수와 인스턴스 변수?(static method, 정적메소드 추가설명)

SunnyCool — Sun, 1 Sep 2019 22:18:38 +0900

클래스 내부에는 클래스 변수와 인스턴스 변수 2가지로 나뉜다. 각각의 특징에 대해 알아보도록 하자.

1. 클래스 변수

클래스 변수는 클래스 내에서 static을 붙여서 선언한 변수를 의미한다. static을 붙였기 때문에 정적변수(Static variable)이라고도 한다.

이 클래스 변수의 특징은 클래스가 여러 인스턴스로 선언되어도 동일한 값을 가져온다는 점이다.

아래 예제코드를 통해 자세히 알아보자.

exstaticVar.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

package exVariable;
 
public class exstaticVar {
 
    public static String testVar = "test";
 
    public static void main(String[] args) {
        exstaticVar test1 = new exstaticVar();
        exstaticVar test2 = new exstaticVar();
        
        System.out.println(test1.testVar);
        
        test2.testVar = "change test";
        
        System.out.println(test1.testVar);
    }
}
 

 

결과

	test
	change test

클래스 객체 test1과 test2를 각각 생성하였다.

1. test1.testVar 을 출력함으로써 첫번째 결과인 test값이 화면에 출력됨을 확인하였다.

2. 그이후 test2.testVar = "change test"; 를 통해 test2객체에서 testVar변수에 접근하여 값을 변경하였다.

3. 그리고는 test1.testVar를 출력하였더니 값이 change test로 변함을 확인할 수 있다.

위 결과와 같이 서로다른 어느 객체에서 static변수에 접근하여 값을 바꾼다면 생성된 모든 객체 내부의 static변수는 값이 동일하게 바뀐다.

쉽게 설명하자면 static변수는 생성된 모든 객체에서 공유한다고 생각하면 된다.

이 클래스변수는 어떻게 사용할 수 있을까??. 객체가 여러 개 생성되어도 특정 데이터는 모든 객체에서 공유하여 사용하여야 할 때 활용한다.

아래 소스를 보자.

student.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

package exVariable;
 
public class student {
    public static int regStudentNum=0;
 
    public static void main(String[] args) {
        student 영수 = new student();
        student 민수 = new student();
        
        영수.regStudentNum++;
        민수.regStudentNum++;
        
        System.out.println(영수.regStudentNum);
    }
}
 

 

결과

위 소스는 학생 객체가 생길때 마다 등록된 학생수를 늘리는 예제 코드이다.

영수객체와 민수객체가 각기 생성되고, 각 개체에서 변수값을 늘려주면 서로 공유되어 있는 값이기 때문에 2라는 결과를 확인 할 수 있다.

2. 인스턴스 변수

클래스 변수의 반대로 생각하면 이해하기 쉽다. 객체가 생성되면 해당 객체에 종속되기 때문에 각 개체별로 별도의 값을 가진다. 위 student클래스에서 static만 제거하고 출력을 해보자.

student.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

package exVariable;
 
public class student {
    public int regStudentNum=0;
 
    public static void main(String[] args) {
        student 영수 = new student();
        student 민수 = new student();
        
        영수.regStudentNum++;
        민수.regStudentNum++;
        
        System.out.println(영수.regStudentNum);
    }
}
 

 

결과

static이었으면 값을 공유하기 때문에 2라는 결과를 기대했겠지만, 인스턴스 변수는 각각 객체에 값이 할당되기 때문에 1이라는 결과가 출력됨을 알 수 있다.

이 인스턴스 변수는 각 객체별로 고유한 값을 지정해야 할때 사용한다. 위 student클래스를 아래와 같이 변경하여 보자.

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

package exVariable;
 
public class student {
    public static int regStudentNum=0;     // 등록된 학생수는 객체수가 증가할때마다 늘려야 하기 때문에 static변수로 선언
    public String name;                 // 학생은 각기 고유한 이름을 가지고 있어야 하기 때문에 인스턴스 변수로 선언
 
    public static void main(String[] args) {
        student 영수 = new student();
        student 민수 = new student();
        
        //영수 객체 선언 후 등록 인원 +1, 이름 지정
        영수.regStudentNum++;
        영수.name = "박영수";
        
        //민수 객체 선언 후 등록 인원+1, 이름 지정
        민수.regStudentNum++;
        민수.name = "최민수";
        
        System.out.println(영수.regStudentNum);
        System.out.println(영수.name);
 
        System.out.println(민수.regStudentNum);
        System.out.println(민수.name);
    }
}
 

 

결과

    2
    박영수

    2
    최민수

학생이 등록되면 등록된 인원만큼 학생수를 늘려야 하기 때문에 regStudentNum은 static을 붙여 클래스 변수로 선언하였다.

하지만 각각의 학생은 고유한 이름을 가지고 있어야 하므로 name은 인스턴스 변수로 두어 각 객체마다 값을 가지도록 셋팅하였다.

3. static method(정적 메소드)

정적메소드는 메소드에 static을 붙이면 된다. 기본 골격은 다음과 같다.

접근제어 static 반환타입 메소드명(파라미터…)

이 정적메소드는 인스턴스 변수를 사용할 수 없으며 static으로 선언된 변수만 사용가능하다. 또한 사용하는 곳에서 따로 객체 생성없이 클래스명.메소드명 으로 호출이 가능하다. 그렇다면 이 정적 메소드는 어디서 사용할까? 특정한 기능을 담당하는 util성 기능에서 많이 사용한다.

calculator.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package exVariable;
 
public class calculator {
 
    public static int sum(int a, int b) {
        return (a + b);
    }
    
    public static int multi(int a, int b) {
        return (a * b);
    }
    
    public static int divide(int a, int b) {
        return (a / b);
    }
    public static void main(String[] args) {
        
        //static 메소드는 객체 생성없이 클래스명.메소드명으로 호출이 가능하다.!!!
        System.out.println(calculator.sum(3, 5));
        System.out.println(calculator.multi(2, 5));
        System.out.println(calculator.divide(20, 5));
    }
}
 

 

위 소스와 같이 더하기, 곱하기, 나누기와 같이 유용한 util기능은 static메소드로 지정후에 객체 생성없이 클래스.메소드명으로 호출하여 바로바로 사용이 가능하다. 굉장히 많이 쓰는 방식이므로 해당 내용에 대해서 반드시 숙지하도록 하자.

자바 메소드란?(Java method)

SunnyCool — Sun, 1 Sep 2019 22:07:26 +0900

메소드(Method) 정의

자바 객체지향에서 꼭 알아두어야 할 의미로서, 메소드란 특정 기능을 정의한 코드들의 집합이라고 생각하면 된다.

기본적으로 메소드를 이해하기 쉽게 설명하기 위해 입력값(parameter)과 출력값(return)으로 설명한다.

기본 골격은 위 그림과 같다.

1. 리턴타입을 정의해 주어야 하며, 반환 값이 없는경우는 void(공허한)로 지정해 주면 된다.

2. 메소드 이름을 정의한다. 보통 해당 메소드가 하는 기능을 표현하는 함축적인 단어를 선택하여 네이밍을 해준다.

3. 메소드는 파라미터라고 하는 입력값을 받을 수 있는데, 0개부터 여러개까지 지정 가능하다.

4. 반환타입이 void가 아닌 경우 반드시 해당 반환타입과 어울리는 변수 or 상수값을 반환해야 한다.

이 메소드를 정의하고 사용하는 목적이 무엇일까??

1. 불필요한 중복되어 사용하는 코드를 메소드로 정의하고 호출함으로써 가독성을 높일 수 있다.(가장 큰 이유)

2. 코드에 문제 생길 때 문제가 되는 메소드만 수정하면 됨으로써 유지보수에 도움이 된다.

1. 메소드 형태들

다음 코드를 통하여 일반적인 메소드를 확인하여 보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public class Calculator {
 
    public static class arithmetic{
        public int multi(int a, int b) {
            int multiple = a * b;
            return multiple;
        }
    }
 
    public static void main(String[] args) {
        arithmetic arm = new arithmetic();
    
        int result = 0;
        
        result = arm.multi(3,4); // 3과 4를 곱한 12의 값이 정수형 타입 변수 result에 대입된다.
        System.out.println(result);
 
        result = arm.multi(5,4); // 5과 4를 곱한 20의 값이 정수형 타입 변수 result에 대입된다.
        System.out.println(result);
    }
}
 

 

결과

	12
	20

arithmetic(산술) 클래스 내에 multi메소드가 선언되어 있다.

1
2
3
4

public int multi(int a, int b) {
    int multiple = a * b;
    return multiple;
}
 

 

multi메소드의 입력 값과 출력 값은 다음과 같다.

입력 값 : int형 a, int형 b
출력(반환) 값 : int 형

해당 메소드는 두개의 값을 입력 받아 곱한 값을 반환해주는 메소드이다.

해당 메소드를 사용할때는 위 코드처럼 반환받을변수 = 객체.메소드명(입력값 a,입력값 b) 이다.

메소드는 입력 값이 없을수도 출력 값이 없을 수도 있다.

1
2
3

public String getName() {
    return this.name;
}

 

위 메소드는 클래스 내부에 있는 name이란 변수를 리턴해주는 입력(파라미터, parameter) 값이 없는 메소드이다.

1
2
3

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

 

위 메소드는 클래스 내부에 있는 name변수에 값을 대입하기 위한 메소드로서 반환(출력, return) 값이 없는 메소드이다.

반환값이 없는 메소드는 void문을 사용한다.

1
2
3

public void print(){
    System.out.println("check name value : " + this.name);
}
 

 

위 메소드는 클래스 내부에 있는 name변수의 값을 출력하기 위한 메소드로 반환 값과 입력 값이 모두 없는 메소드이다.

2. 메소드 내부에 선언된 변수???

메소드 안에서 선언된 변수는, 메소드의 작업이 끝나면 소멸되게 된다. 또한 메소드 밖 다른 영역에서는 접근이 불가능 하다. 이렇게 메소드 안에서만 선언되어 사용되는 변수를 지역변수라고 한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public class methodVariableTest {
 
    public static class test{
        public String test = "test";
        
        public void print() {
            String test = "methodTest";
            System.out.println(test);
        }
        
        public void print2() {
            System.out.println(test);
        }
    }
    public static void main(String[] args) {
        test test = new test();
        
        test.print();
        test.print2();
    }
}
 

 

위 코드에서 print(), print2() 메소드를 보면 동일한 test 변수를 System.out.println()으로 출력하고 있다.

다만 print()메소드에서의 test는 메소드내에서 새롭게 선언한 String타입의 변수로서 클래스 내부에 선언한 test변수와는 별개다.

print2()메소드는 클래스 내부의 변수인 test를 출력하고 있다.

이처럼 메소드 안에서 선언하는 변수는 클래스 변수와 변수명이 똑같더라도 에러가 나지 않는다. 그렇다면 이렇게 이름은 똑같지만 메소드 내에서 클래스 변수에 접근하려면 어떻게 해야할까?? 바로 this를 사용하여 접근할수 있다. 사용법은 아래와 같다.

this.클래스변수명

위 print()메소드에서 지역변수가 아닌 클래스 변수를 출력하고 싶으면 아래와 같이 수정하면 된다.

1
2
3
4

public void print() {
    String test = "methodTest";
    System.out.println(this.test); // this.test는 위에서 선언한 test변수와는 완전 별개다.
}
 

 

자바 접근제어자(private, default, protected, public)

SunnyCool — Sun, 1 Sep 2019 16:16:29 +0900

접근제어자란(Access Modifier)?

자바에는 클래스에 대한 접근을 제한하는 문법이 있는데 이를 접근제어자(Access Modifier)라고 한다.

접근 제어자는 각 멤버변수들의 고유성격을 파악하여 외부에서 접근해야할 바운더리를 성격에 맞게 오픈해줘야 할 때 사용한다.

접근제어자는 다음과 같이 4가지가 있다.

private : 자기 자신 클래스에서만 접근이 가능함.
default : 특정 제어자를 선언하지 않는경우 default로 셋팅이 되며 동일 패키지에서 사용이 가능하다.
protected : 동일패키지, 자식 클래스에서 사용 가능하다.
public : 접근제한이 없다.

접근 제한의 범위는 다음과 같다.

public > protected > default > private

일반적으로 개발을 진행하다보면 알겠지만, public과 private을 가장 많이 사용한다. private으로 멤버변수 접근을 제한하고 public 메소드로 해당 멤버변수에 접근하여 값을 수정하는것이 기본 골격이기 때문.

1. private, public

private선언된 변수 혹은 메소드는 해당 클래스에서만 접근이 가능하다. public으로 선언된 변수 혹은 메소드는 어디서든 접근이 가능하다. 그래서 이 2가지는 거의 같이 쓰인다. 다음 소스를 보자

human.java

1
2
3
4
5
6
7
8
9

package exAccessModifier;
 
public class human {
    private String sex = ""; 
    
    public String getSex() {
        return this.sex;
    }
}

 

woman.java

1
2
3
4
5
6
7
8
9
10
11

package exAccessModifier;
 
public class woman {
 
    public static void main(String[] args) {
        human female = new human();
 
        female.sex = "woman";   // sex변수는 private접근제어자로 선언되었기때문에 바로 접근이 불가능하다.
        System.out.println("I am a " + female.getSex());
    }
}
 

 

woman.java를 실행하면 "The field human.sex is not visible"에러가 발생한다. human의 멤버변수 sex(성별)변수에 접근할 수 없어서 발생하는 에러이다. 일반적으로 이렇게 private으로 지정된 변수는 public메소드를 통해 접근하게 한다.

수정된 다음 소스를 확인하자.

human.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14

package exAccessModifier;
 
public class human {
    private String sex = ""; 
    
    //public으로 지정된 메소드를 통해 멤버변수의 값을 지정할 수 있게 해준다.
    public void setSex(String sex) {
        this.sex = sex;
    }
 
    public String getSex() {
        return this.sex;
    }
}
 

 

woman.java

1
2
3
4
5
6
7
8
9
10
11

package exAccessModifier;
 
public class woman {
 
    public static void main(String[] args) {
        human female = new human();
 
        female.setSex("woman");        //메소드를 통해 값을 전달한다.
        System.out.println("I am a " + female.getSex());
    }
}
 

 

결과

I am a woman

human 클래스 setSex(String sex)를 통하여 멤버변수 sex에 접근하여 값을 대입할 수 있다. 이런식으로 값을 지정함에 있어 의문점이 들수 도 있다. 객체를 생성하고 바로 멤버변수에 접근하여 값을 지정하면 소스도 간결해지고 편하지 않는가? 하지만 예외치 못한 값에 대한 예외처리를 할 수 없다. 그래서 public메소드를 지정하여 예외처리를 할 수 있는 것이다. human클래스의 setSex메소드를 다음과 같이 사용할 수 있다.

1
2
3
4
5
6
7

public void setSex(String sex) {
    if( !("man".equalsIgnoreCase(sex) || "woman".equalsIgnoreCase(sex)) ) {
        this.sex = "what is your sex..??";
    }else {
        this.sex = sex;
    }
}
 

 

위와 같이 특정 값에 대한 예외처리를 할 수 있다.

2. default

default접근제어자는 동일한 패키지 영역에서의 접근 가능하다.

Car.java

1
2
3
4
5

package exAccessModifierDefault;
 
public class Car {
    String name = "";
}
 

 

main.java

1
2
3
4
5
6
7
8
9
10
11
12

package exAccessModifierDefault;
 
public class main {
 
    public static void main(String[] args) {
        Car sonata = new Car();
        sonata.name = "sonata";
        
        System.out.println(sonata.name);
    }
 
}
 

 

exAccessModifierDefault 패키지내 main클래스에서 car클래스의 객체를 생성하고 name멤버변수에 접근할 수 있다.

3. protected

default접근자와 마찬가지로 protected도 동일 패키지내에서 접근이 가능하다. 하지만 default와 차이점이 있다면 상속관계에서(파생클래스)에서 접근이 가능하다는 점에서 default보다 접근범위가 넓다.

car.java

1
2
3
4
5
6
7
8
9

package exProtected.exam1;
 
public class car {
    protected String name = "";
    
    protected void setName(String name) {
        this.name = name;
    }
}
 

 

sonata.java

1
2
3
4
5
6
7
8
9
10

package exProtected.exam2;
 
import exProtected.exam1.car;
 
public class sonata extends car {
    public void print() {
        this.name = "sonata";
        System.out.println(this.name);
    }
}
 

 

main.java

1
2
3
4
5
6
7
8
9

package exProtected.exam2;
 
public class main{
 
    public static void main(String[] args) {
        sonata son = new sonata();
        son.print();
    }
}
 

 

sonata 클래스와 car 클래스는 위치하는 패키지는 다르지만 sonata클래스는 car클래스를 상속받음으로써 car클래스의 멤버변수에 접근할 수 있다.

자바 클래스란?(Java Class)

SunnyCool — Sun, 1 Sep 2019 11:06:11 +0900

자바 클래스란??

자바 클래스는 다음과 같이 정의할 수 있다.

변수(데이터, 속성)와 메서드(행위)를 가지고 있는 집합이다.
객체를 생성하기 위한 틀이다.
class키워드로 정의하고, new연산자를 통해서 인스턴스를 생성한다.
자바는 클래스들의 모임으로 이루어져 있다.

※ 클래스에서 객체를 생성하는 과정을 인스턴스화라고 하며, 생성된 객체를 인스턴스라고 한다.

예를들어 붕어빵을 만들기 위해서는 붕어빵틀이 필요하다.

여기서 붕어빵틀이 클래스(class)이고 이 붕어빵틀로 인해 만들어진 붕어빵을 객체(Object)라고 한다.

붕어빵틀 -> 클래스(Class)
붕어빵 -> 객체(Object)

소스 기본 골격은 다음과 같다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class fishBread {    // Class키워를 사용하여 정의한다.(Class Name)
    
    private String ingredient = "beans";    //클래스 멤버 변수 정의
    
    public void makeBread() {                //클래스 메서드 정의
        System.out.println("make fishBean Using " + ingredient);
    }
    
    public static void main(String[] args) {
        fishBread fish = new fishBread();    //fish 객체 생성
        fish.makeBread();                    //객체 생성 후 해당 클래스에서 정의한 메서드를 사용할 수 있다.
    }
 
}
 

 

위예제 소스와 같이 자바는 변수와 메서드들이 정의된 다수의 클래스들로 이루어져있다.

1. 객체 변수(Object Variable)

객체변수란 클래스 내부에서 선언된 변수를 의미한다.

1
2
3
4
5

public class fishBread {        
 
    public String ingredient;
 
}

fishBread클래스에서 선언된 ingredient는 객체 변수 이다. 이러한 객체변수는 객체를 선언하고 .연산자를 이용하여 접근할 수 있다.

1
2
3
4
5
6
7
8
9
10

public class fishBread {    
    public String ingredient;
    
    public static void main(String[] args) {
        fishBread fish = new fishBread();
        fish.ingredient = "bean";
 
        System.out.println(fish.ingredient);
    }
}
 

 

위 코드를 실행하면 다음과 같이 대입한 bean이라는 값이 출력된다.

bean

2. 메소드/메서드(method)

클래스 내부에 있는 객체 변수에 . 연산자를 이용하여 접근할 수 있다. 하지만 이전 챕터에서 말했듯이 객체지향 프로그래밍에서는 캡슐화를 통한 정보은닉을 기본 원칙으로 삼기때문에 직접적으로 객체 변수에 접근하게 코드를 만들지 않는다. 이럴때 사용할 수 있는 방법이 메소드를 이용하여 변수에 접근하는 방법이다.

(자세한 사항은 https://codehouse.tistory.com/16 확인)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class fishBread {    
    private String ingredient;
    
    public void setIngredient(String ingredient) {
        this.ingredient = ingredient;
    }
    
    public String getIngredient() {
        return this.ingredient; 
    }
    public static void main(String[] args) {
        fishBread fish = new fishBread();
        fish.setIngredient("bean");
 
        System.out.println(fish.getIngredient());
    }
}
 

 

위 예제 소스또한 bean이라는 동일한 결과를 확인 할 수 있다.

bean

다만 . 연산자를 이용하여 직접적으로 변수에 접근하는것이 아니라, 메서드를 이용하여 값을 초기화 하고, 값을 가져올 수 있다.

메소드에 대해 생소할 수 있으니 간단한 설명을 해보자면 다음과 같다.

setIngredient 메소드

1
2
3

public void setIngredient(String ingredient) {
    this.ingredient = ingredient;
}
 

 

void : 해당 메소드에서는 return(반환 값)이 없다.
입력 : String ingredient - 해당 메소드를 호출하기 위해서는 String형의 값을 입력해야 한다.

하단 main메소드에서

1

fish.setIngredient("bean");

메소드를 사용하였는데 "bean"이라는 String값을 setIngredient 메소드를 이용하여 ingredient객체 변수에 대입하게 된다.

자바 객체지향 프로그래밍이란?(Java OOP Programming)

SunnyCool — Fri, 30 Aug 2019 22:35:14 +0900

객체지향 프로그래밍(Java OOP Programming) 이란?

객제지향 프로그래밍이란(Object Oriented Programming) 절차지향 프로그래밍의 반대 의미로서 설계에 중점을 둔 이론이자 방법이라고 할 수 있다. 줄여서 OOP라 하며 프로그램 이라는 세계를 객체라는 추상적인 단위로 나눈 후에 각 객체들 간의 상호작용을 통해 로직을 구성하는 프로그래밍을 의미한다.

객제지향 프로그래밍은 다음과 같은 장점이 있다.

1. 구현해 놓은 클래스를 확장해서 다시 사용할 수 있어 재사용이 용이하다.

2. 수정작업에서 특정 역할을 하는 메서드, 혹은 변수만 수정하면 되기 때문에 유지보수 비용이 많이 단축된다.

3. 객체단위로 작업을 하기 때문에 다수의 인원들이 개발해야 하는 대형 프로젝트에 유리하다.

4. 객체와 객체의 메서드(행동), 멤버 변수(재료)를 기준으로 개발하기 때문에 개발이 간단하다.

하지만 반대로 다음과 같은 단점도 존재한다.

1. 객체단위의 개발로 인하여 용량이 증가 그에따른 처리속도가 느릴 수 있다.

2. 객체들간의 역할을 확실히 하기위해서 분석, 설계에 많은 시간과, 비용을 투자해야 한다.

객체지향 프로그래밍(OOP) 주요 키워드(주요특징) 5가지

1. 클래스(Class)와 객체(인스턴스)(Instance)

클래스란 특정 역할을 수행하기 위한 멤버변수(속성)와 메서드(행위)로 정의된 것을 의미한다. 이 클래스에서 정의한 모든것이 메모리에 할당될 때 이를 객체(인스턴스)라고 한다.

2. 추상화(Abstraction)

추상화란 공통된 행동이나 속성을 추출하는 것을 의미한다. 추후에 클래스를 구현하기 위한 일련의 설계서 역할을 담당하는 클래스라고 생각하면 이해하기 쉽다. 다음 일련의 작업이 추상화 과정을 예로 보여주는 간단한 과정이다.

구현되는 각 사물(혹은 엔티티 혹은 객체)들 간의 특징을 파악한 후에 하나의 그룹으로 묶어준다.
각 그룹별 사물들의 공통된 행동(메서드)과 속성(변수)을 추출하여 추상적인 역할을 하는 개념을 만들어 준다.

3. 캡슐화(Encapsulation)

캡슐화는 공통된 기능을 하기 위한 변수와, 메서드들을 묶어 주는 작업을 의미한다. 각 클래스들은 해당 클래스의 역할에 맡는 변수와 메서드 들로 구성이 되어야 하며, 각 변수들은 "private, protected, public"등의 지시어를 통해 외부로터의 접근을 방지해야 한다.

이를 정보은닉이라 하며, 변수에 접근하기 위해서는 메서드 를 이용하여 접근하도록 해야하며 대표적으로 많이 쓰이는 방식은 setter, getter메소드이다.

※ setter, getter 메서드와 같이 메서드를 통해 멤버변수에 접근하기 위한 이유는, 멤버변수를 개발자가 의도하지 않는 값 변환등의 행위를 제지하기 위함이다. 예를들어 은행업무 시스템에서 특정 계좌의 잔고를 담당하는 변수에 직접 접근하여 잔고를 늘리거나, 줄이거나 할 수 있다고 해보자. 시스템 자체에 대한 신뢰와 악용을 면치 못할것이므로, 이런 사태를 방지하기위해 setter(param), type getter()를 사용하여 멤버변수에 접근하게 하는것이다.

4. 상속, 재사용(Inheritance)

클래스란 개념을 사용하면서, 부모클래스를 통해 속성과 기능(행동)을 상속받아 그대로 사용할 수 있게하거나, 기능의 일부분을 수정하여 사용하는 것을 상속이라 한다.

자바에서는 C++와 다르게 다중 상속을 지원하지 않는다. 하지만 인터페이스(Interface)를 만들어 다중상속을 할 수는 있게 만들어 놓았다. 하지만 객체 지향에서 다중상속을 위해 인터페이스가 존재한다고 생각하면 안된다.

5. 다형성(Polymorphism)

특정 변수와, 메서드들이 상황에 맞게 각기 다른 역할을 수행 할 수 있게 하는것을 다형성이라고 한다.

다형성에서는 오버라이딩(Overriding)과 오버로딩(Overloading)의 개념을 이야기 하는데 의미는 다음과 같다.

오버라이딩 : 부모클래스에서 상속받은 메서드들을 재 구현하여 각기 클래스의 역할에 맡게 구현하는것

오버로딩 : 같은 이름의 메서드를 여러 개 구현하고 파라미터의 개수 혹은 타입으로 구분지어 여러방법으로 호출할 수 있게 하는 방법을 말한다.

자바 배열(Java Array) - 다차원 배열

SunnyCool — Thu, 29 Aug 2019 17:19:55 +0900

1. 다차원 배열

배열의 값을 가지는 배열이라고 생각하면 이해하기 쉽다.

1

int[][] iArray = new int[3][3];

위 배열은 3개의 정수를 가지는 배열의 개수가 3개라고 해석하면 된다. (뒤에서부터 앞으로 해석)

다음과 같이 선언과 동시에 초기화 하는 방법도 사용할 수 있다.

1

int[][] iArray = { {1,2,3}, {4,5,6}, {7,8,9} };

3차원 배열도 동일 방법으로 해석하면 된다.

1

int[][][] iArray = new int[3][3][4]

혹은

1

int[][][] iArray = { {{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}}};

위배열은 4개의 정수를 가지는 배열 3개가 총 3개라고 해석하면 된다.

일반적으로 2차원 배열을 제일 많이 사용한다. 그 이상의 배열은 조심히 사용해야 한다. 위 그림에서도 보면 알겠지만 3중,4중….으로 갈수록 데이터 관리가 어려워 지기 때문이다.

자바 배열(Java Array)

SunnyCool — Thu, 29 Aug 2019 16:54:50 +0900

자바 배열 정의

연속된 동일한 타입의 변수를 연속된 메모리 공간에 할당하고, 각 데이터에 index를 부여하여 접근할 수 있게 하는 객체이다.

다수의 변수를 지정하지 않고 관리할 수 있어 개발이 간결해지고 가독성이 좋다.

1. 기본 사용법

코드)

1
2
3
4
5
6
7
8
9
10

//배열 선언
int[] iArray;        
int iArray2[];
 
//배열크기를 지정하여 선언
String[] sArray = new String[5];
String sArray2[] = new String[5];
 
//값을 지정하여 선언
char[] cArray = {'A', 'B', 'C'};

 

배열도 객체이기 때문에 new연산자를 이용하여 사용하거나(크기를 지정해야함), 혹은 값을 지정하여 선언할 수 있다.

배열은 new혹은 값을 지정하여 선언하면 그 크기만큼 index가 부여되며 각 인덱스 번호를 이용하여 저장된 값들을 사용할 수 있다.

코드)

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

//배열크기를 지정하여 선언 후 반복문을 이용하여 값 대입
String[] sArray = new String[5];
        
for(int i=0; i < sArray.length; i++) {
    sArray[i] = "test" + i;
}
 
for(int i=0; i < sArray.length; i++) {
    System.out.println(sArray[i]);
}
 
        
//값을 지정하여 선언
char[] cArray = {'A', 'B', 'C'};
 
for(int i=0; i < cArray.length; i++) {
    System.out.println(cArray[i]);
}
 
//변수 선언 후 java.util.Arrays객체를 이용하여 특정 값으로 초기화
int[] iArray = new int[5];
 
Arrays.fill(iArray, 3);
 
for(int i=0; i < iArray.length; i++) {
    System.out.println(iArray[i]);
}
 

 

결과)

test0
test1
test2
test3
test4

A
B
C

3
3
3
3
3

2. Arrays.util을 이용한 다양한 기능

Arrays라는 배열 Util객체를 사용하여 다양한 기능을 사용할 수 있다.

코드)

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
38
39
40
41
42
43
44
45
46

int[] iArray = new int[3];
    
//Arrays.fill을 사용하여 하나의 값으로 초기화 할 수 있다.
Arrays.fill(iArray, 5);
 
for(int innerValue : iArray) {
    System.out.print(innerValue + ",");
}
 
System.out.println();
 
int[] iArray2 = {7, 5, 9};
System.out.print("정렬하기 전 : ");
for(int innerValue : iArray2) {
    System.out.print(innerValue + ", ");
}
 
System.out.println();
 
//Arrays.sort를 사용하여 배열의 값을 정렬 할 수 있다.
Arrays.sort(iArray2);
 
System.out.print("정렬 후 : ");
for(int innerValue : iArray2) {
    System.out.print(innerValue + ", ");
}
 
System.out.println();
 
//Arrays.binarySearch를 이용하여 저장된 값의 index를 가져올 수 있다.(반드시 정렬되어 있는 배열값 이어야 한다.)
int index = Arrays.binarySearch(iArray2, 7);
 
iArray2[index] = 1;
 
for(int innerValue : iArray2) {
    System.out.print(innerValue + ", ");
}
 
System.out.println();
 
//Arrays.copyOf를 이용하여 배열을 복사 할 수 있다.
int[] iArray3 = Arrays.copyOf(iArray2, 3);
 
for(int innerValue : iArray3) {
    System.out.print(innerValue + ", ");
}
 

 

결과)

5,5,5,

정렬하기 전 : 7, 5, 9,

정렬 후 : 5, 7, 9,

5, 1, 9,

5, 1, 9,

자바(Java) 반복문 (3)- for문을 이용한 별 찍기 예제

SunnyCool — Wed, 28 Aug 2019 22:00:35 +0900

참고)

자바(java) 조건문은 https://codehouse.tistory.com/7, https://codehouse.tistory.com/8 에서 확인 가능하다.

자바(java) 반복문은 https://codehouse.tistory.com/11, https://codehouse.tistory.com/12 에서 확인 가능하다.

1. 계단형

***

****

*****

******

*******

********

*********

**********

코드)

1
2
3
4
5
6
7

for(int i=1; i <= 10; i++) {
    for(int j=1; j <= i; j++ ) {
        System.out.print("*");
    }
 
    System.out.println();
}

 

2. 계단형(역방향)

*********

********

*******

******

*****

****

***

코드)

1
2
3
4
5
6
7

for(int i=1; i <= 10; i++) {
    for(int j=1; j <=10-i; j++ ) {
        System.out.print("*");
    }
    
    System.out.println();
}

 

3. 피라미드형

***

*****

*******

*********

***********

*************

***************

*****************

*******************

코드)

1
2
3
4
5
6
7
8
9

for (int i = 0; i < 10; i++) { 
    for (int j = 10-1; j > i; j--) { 
        System.out.print(" "); 
    } 
    for (int k = 0; k < 2*i+1; k++) { 
        System.out.print("*"); 
    } 
        System.out.println(); 
}
 

 

4. 피라미드형(역방향)

*******************

*****************

***************

*************

***********

*********

*******

*****

***

코드)

1
2
3
4
5
6
7
8
9
10
11

for(int i=10; i > 0; i--) {
    for(int j=0; j < 10 - i; j++) {
        System.out.print(" ");
    }
 
    for(int k=0; k< 2*i-1; k++) {
        System.out.print("*");
    }
 
    System.out.println();
}
 

 

5. 다이아몬드형

***

*****

***

코드)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

for(int i=0; i < 5; i++) {
    for(int j=0; j < 5; j++) {
        if(i <= 5 / 2) {
            if(i+j <= 5/2-1) {
                System.out.print(" ");
            }else if(j-i >= 5/2+1) {
                System.out.print(" ");
            }else {
                System.out.print("*");
            }
        }else if (i>5/2)
        {
            if (i-j>=5/2+1)
                System.out.print(" ");
            else if (i+j>=5/2*3+1)
                System.out.print(" ");
            else
                System.out.print("*"); 
        }
    }
    System.out.println();
}

 

자바(Java) 반복문 (2)- break, continue

SunnyCool — Wed, 28 Aug 2019 00:40:24 +0900

참고)

자바(java) 조건문은 https://codehouse.tistory.com/7, https://codehouse.tistory.com/8 에서 확인 가능하다.

자바(java) 반복문은 https://codehouse.tistory.com/11 에서 확인 가능하다.

1. break문

반복문을 끝까지 수행하지 않고 특정 조건을 만족했을때 반복을 중지하고 싶다면 break를 이용하여 중지할 수 있다.

다음 예제는 100이하의 자연수 중 짝수의 합이 1500이상일때 반복을 중지하는 코드이다.

예제)

1
2
3
4
5
6
7
8
9
10
11
12
13

//1부터 100까지의 자연수 중에서 짝수의 합이 1500이상이면 반복을 중지
int sum = 0; 
for(int i=1; i <= 100; i++) {
    if( i % 2 == 0) {
        if( (sum+i) > 1500) {
            System.out.println("1500까지의 합중 최대크기의 짝수는 " + i + "이다.");
            break;
        }
        sum += i;
    }
}
 
System.out.println("짝수의 합은 " + sum + "이다");

 

결과)

1500까지의 합중 최대크기의 자연수는 78이다.

짝수의 합은 1482이다

중첩 for문에서도 사용이 가능하다. 주의 해야할 점은 break는 자신의 코드 블록을 감싸고 있는 for문 밖에 중지시키지 못한다.

그러므로 중첩for문을 중지시키려면 각 코드블럭에서 모두 break문을 사용해야 한다. 다음 예제를 통해 확인해 보자

예제)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

//2단부터 9단까지 각 결과를 출력하고 각 결과의 값의 합이 200을 초과한다면 반복문을 중지하시오. 
int sum2 = 0;
for(int i=2; i <=9; i++) {
    if(sum2 > 200) {
        break;
    }
    for(int j=1; j <= 9; j++) {
        if(sum2 > 200) {
            break;
        }
        
        sum2 += (i * j);
        System.out.println(i + " X " + j + " = " + (i * j));
    }
}
 
System.out.println("최종 합은 : " + sum2);

 

결과)

2 X 1 = 2
2 X 2 = 4
2 X 3 = 6
2 X 4 = 8
2 X 5 = 10
2 X 6 = 12
2 X 7 = 14
2 X 8 = 16
2 X 9 = 18
3 X 1 = 3
3 X 2 = 6
3 X 3 = 9
3 X 4 = 12
3 X 5 = 15
3 X 6 = 18
3 X 7 = 21
3 X 8 = 24
3 X 9 = 27
최종 합은 : 225

중첩 for문을 break문을 한번만 쓰고도 모두 반복수행을 정지 시킬 수 있다. 최상위 for문에 특정 이름을 붙여주는데 이를 라벨이라며 하며

break label명; 을 해주면 해당 label의 반복문을 빠져 나오게 된다. 위 예제를 이용하면 다음과 같다.

예제)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

//2단부터 9단까지 각 결과를 출력하고 각 결과의 값이 200을 초과한다면 반복문을 중지하시오. 
int sum2 = 0;
 
exloop: // 해당 반복문 전체를 exloop라는 label을 지정해 준다.
for(int i=2; i <=9; i++) {
    for(int j=1; j <= 9; j++) {
        if(sum2 > 200) {
            //break label이름을 사용하여 전체 반복문을 수행 중지 시킨다.
            break exloop;
        }
        
        sum2 += (i * j);
        System.out.println(i + " X " + j + " = " + (i * j));
    }
}
 
System.out.println("최종 합은 : " + sum2);

 

2. continue문

특정 조건은 반복문의 처음으로 다시 되돌아가고 실을때 continue문을 사용한다. 다음 예제 코드로 확인해 보자.

예제)

1
2
3
4
5
6
7
8
9
10
11

// 1부터 10까지의 자연수 중 7을 제외한 합을 구하시오.
int sum = 0; 
for(int i=1; i <=10; i++) {
    if(i == 7) {
        continue;
    }
    
    sum += i;
}
 
System.out.println("1부터 10까지 7을 제외한 합은 : " + sum);

 

결과)

1부터 10까지 7을 제외한 합은 : 48

continue문도 break문과 마찬가지로 중첩, 라벨이름을 활용하여 사용 할 수 있다.

자바(Java) 반복문 (1)- for문, while문, do while문

SunnyCool — Wed, 28 Aug 2019 00:32:23 +0900

참고)

자바(java) 조건문은 https://codehouse.tistory.com/7, https://codehouse.tistory.com/8 에서 확인 가능하다.

자바 반복문

자바에서 특정 조건식을 걸어주면 해당 조건식의 결과가 참(true)일동안 반복적으로 코드를 수행하고 싶을 때 반복문을 사용한다.

대표적으로 for문과, while문 2가지를 사용한다. for문은 정해진 횟수만큼 반복하고 싶을 때 사용하며, while문은 조건에 따라서만 반복을 수행할 때 사용한다.

1. for문

for 문은 일정한 횟수만큼 반복할 때 유용하게 사용할 수 있다. 자바(Java)에서 거의 대부분 반복문은 for문을 사용한다.

기본문법은 다음과 같다.

for(초기식; 조건식; 증감식) {

// 초기식은 for문 최초 한번만 수행한다.

// 조건식이 참(true)일때 해당 블록 영역에 있는 코드를 반복 수행한다.

// 한번의 반복을 수행한 후에는 증감식을 수행한다.

}

초기식은 식을 초기화하기 위하여 사용한다. for문이 실행될 때 최초 한번만 수행한다.

조건식이 참일때 for블록 안에 있는 코드를 수행하며, 한번의 반복수행이 끝날때마다 증감식을 수행한다.

다시 반복 처음으로 돌아와 조건식이 참일경우 계속 코드를 반복 수행한다.

다음 예제 코드를 보며 순서를 이해해보자.

예)

1
2
3
4
5
6

int sum = 0;
for(int i=0; i <= 10; i++) {
    sum = sum + i;
}
    
System.out.println(sum);

 

결과)

위 코드 는 1부터 10까지의 합을 구하는 반복문이다. 위 반복문을 해석하는 법은 다음과 같다.

- 초기식은 int i=0; 으로 정수형 타입 변수 i를 0으로 초기화 하였다.

- 조건식은 i <= 10; 으로 현재 i의 값이 10보다 작거나 같으면 아래 코드를 수행한다.

sum = sum + i;

- 코드를 수행하였으면 증감식 i++를 수행하여 현재 i의 값을 증가시켜준 후에 처음으로 돌아간다.

결국 i의 값을 증가시킨 후(1,2,3,4,…..10) 현재 i의 값을 더해 줌으로 1부터 10까지의 최종합이 sum변수에 저장되며, 55값이 출력된다.

여기서 유의해야할점 int i=0 부분인데, i를 카운터 변수라고 한다. 그런데 해당 변수를 for문 안에서 생성하고 초기화 하

였기 때문에 i변수는 for문이 끝나면 다른 코드에서 사용할 수 없다. 오로지 for문 영역 안에서만 사용할 수 있다.

for문을 다양하게 이용하여 원하는 결과를 얻을 수 있다. 아래 코드의 주석을 참조하여 직접 이클립스에서 수행해보자.

예제)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

//100이하의 자연수 중에서 4의 배수의 합을 구하시오. 
int sum = 0;
//1부터 100까의 loop를 돌린다.
for(int i=1; i <= 100; i++) {
    //4로 나눈 나머지가 0이면 4의배수!!
    if(i % 4 == 0) {
        sum += i;
    }
}
System.out.println("1부터 100까지 4의 배수의 총합은 : "+sum);
 
 
//초항이 3이며 공차가 4인 200까지의 등차수열의 합을 구하시오.
int sum2 = 0;
//초항값으로 변수 i를 초기화 하며 증감식은 공차값으로 지정한다.
for(int i=3; i <= 200; i+=4) {
    sum2 += i;
}
 
System.out.println("초항3부터 공차가 4인 200까지의 등차수열의 합은 : " + sum2);

 

결과)

1부터 100까지 4의 배수의 총합은 : 1300

초항3부터 공차가 4인 200까지의 등차수열의 합은 : 5050

2. for문 중첩

조건문과 마찬가지로 for문도 중첩하여 사용할 수 있다. 반복수행되는 횟수는 각 for문의 반복횟수를 곱한 횟수이다.

다음 예제와 같이 for문 중첩을 사용할 수 있다.

예제)

1
2
3
4
5
6

//구구단 2단부터 4단까지의  각 결과를 출력하시오. 
for(int i=2; i<=4; i++) {
    for(int j=1; j <= 9; j++) {
        System.out.println(i + " X " + j + " = " + (i * j));
    }
}

 

결과)

3. while문

for문과 달리 지정된 횟수가 아니라 조건이 참일때 코드를 계속 반복 수행해야 한다면 while문을 사용한다.

기본문법은 다음과 같다.

while(조건식){

// 조건식이 참이라면 반복을 계속 수행한다.

}

주의 해야 할점은 조건식을 특정경우에서 빠져나올 수 있도록(거짓, false) 해주어야 한다. 그렇지 않으면 반복을 무한히 수행하게 되는데

이를 무한루프라고 한다. 다음 예제소스를 통해 확인해보자.

예제)

1
2
3
4
5
6
7
8
9
10
11
12
13

int i=1; 
int sum=0;
 
//조건 : 100이하의 자연수
while(i<=100) {
    if( i % 2 == 0) {
        sum += i;
    }
    
    i++;
}
 
System.out.println("1부터 100까지의 짝수의 합은 : " + sum);

 

결과)

1부터 100까지의 짝수의 합은 : 2550

4. do while문

while문과 비슷하게 사용 한다. do 블록에서 수행할 코드를 while에서 조건식이 참인지를 수행한다.

while문과 차이점이라면 do블록안에 있는 코드를 먼처 수행하고 조건식이 참인지 체크한다. 최초 조건식이 거짓이라도 최소 한번은 수행된다.

다음 예제는 조건식을 거짓으로 셋팅해도 한번은 수행되는것을 보여주는 예제이다.

예제)

1
2
3

do {
    System.out.println("while문 조건식의 결과가 false이지만 do블록 하위의 코드는 최소 한번 수행된다.");
}while(false);
 

 

결과)

while문 조건식의 결과가 false이지만 do블록 하위의 코드는 최소 한번 수행된다.

자바 디자인패턴(Java Design pattern) - 싱글톤/싱글턴 패턴(Singleton pattern) 예제

SunnyCool — Sun, 25 Aug 2019 13:23:02 +0900

참고)

싱글톤 패턴(Singleton pattern) 정의 및 간단한 코드 예제는 https://codehouse.tistory.com/9 에서 확인 할 수 있다. 반드시 해당 페이지에서 기본 정의에 대하여 숙지 하고 난 이후에 해당 예제 코드를 보기 바란다.

1. 블루투스(bluetooth) 신호 감지 및 등록 Singleton 예제

싱글톤패턴 예제로 블루투스의 신호를 감지하고, 기기를 등록 혹은 삭제하는 예제코드를 짜보기로 한다.

1-1 클래스 다이어그램(Class Diagram)

A - iMachine인터페이스와 laptop, phone, computer객체를 두어 블루투스 신호를 가진 기기를 구현한다.

B - BlueToothSingleton객체에서 모니터링 및 기기 삭제, 등록 역할을 수행한다. 해당 인스턴스는 lazyholder 클래스에서 한번만 생성하게된다.

1-2 예제상세

imachine.java

1
2
3
4
5
6
7
8

package exSingleton.common;
 
public interface iMachine {
    public void onSignal(); 
    public void offSignal(); 
    public boolean getStatus();
    public String getName();
}

 

computer.java

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

package exSingleton.common;
 
public class computer implements iMachine {
    private boolean signal;
    private String name = "computer";
 
    public computer() {
        this.signal = false;
    }
 
    @Override
    public void onSignal() {
        this.signal = true;
    }
 
    @Override
    public void offSignal() {
        this.signal = false;
    }
    
    public boolean getStatus() {
        return this.signal;
    }
    
    public String getName() {
        return name;
    }
 
}
 

 

laptop.java

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

package exSingleton.common;
 
public class laptop implements iMachine{
    private boolean signal;
    private String name = "laptop";
 
    public laptop() {
        this.signal = false;
    }
 
    @Override
    public void onSignal() {
        this.signal = true;
    }
 
    @Override
    public void offSignal() {
        this.signal = false;
    }
    
    public boolean getStatus() {
        return this.signal;
    }
    
    public String getName() {
        return name;
    }
}
 

 

phone.java

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

package exSingleton.common;
 
public class phone implements iMachine{
    private boolean signal;
    private String name = "phone";
    
    public phone() {
        this.signal = false;
    }
 
    @Override
    public void onSignal() {
        this.signal = true;
    }
 
    @Override
    public void offSignal() {
        this.signal = false;
    }
    
    public boolean getStatus() {
        return this.signal;
    }
    
    public String getName() {
        return name;
    }
}
 

 

BlueToothSingleton.java

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

package exSingleton;
 
import java.util.ArrayList;
import java.util.HashMap;
import exSingleton.common.iMachine;
 
public class BlueToothSingleton {
    private ArrayList<iMachine> onSignalmachine= new ArrayList<iMachine>();
    private ArrayList<iMachine> registMachine = new ArrayList<iMachine>();
 
    //생성자를 private으로 지정하여 client에서 객체생성을 금지한다.
    private BlueToothSingleton() {}
 
    //JVM에서 생성시에 해당 inner클래스를 이용하여 인스턴스를 생성시킨다.
    public static class lazyholder {
        private static final BlueToothSingleton singleton = new BlueToothSingleton();
    }
    
    //getInstance호출시 객체 return
    public static BlueToothSingleton getInstance() {
        return lazyholder.singleton;
    }
    
    public void startMonitoring(iMachine machine) {
        if(machine.getStatus()) {
            this.onSignalmachine.add(machine);
        }
    }
    
    public void stopMonitoring() {
        if(!this.onSignalmachine.isEmpty())
            this.onSignalmachine.clear();
    }
    
    public void printMonitorMachine() {
        for(int idx=0; idx < this.onSignalmachine.size(); idx++) {
            if(this.onSignalmachine.get(idx).getStatus())
                System.out.println("블루투스가 켜져있는 기계 : " + this.onSignalmachine.get(idx).getName());
        }
    }
    
    public void registerMachine(iMachine machine) {
        if(machine.getStatus()) {
            this.registMachine.add(machine);
        }else {
            System.out.println("해당장비를 등록 할 수 없습니다.");
        }
    }
    
 
    public void removeMachine(iMachine machine) {
        for(int idx = 0; idx < this.registMachine.size(); idx++) {
            if(this.registMachine.get(idx).getName() == machine.getName()) {
                this.registMachine.remove(idx);
                System.out.println(machine.getName() + " 이 등록 해제 되었습니다.");
            }
        }
    }
 
    public void printRegisterMachine() {
        for(int idx=0; idx < this.registMachine.size(); idx++) {
            if(this.registMachine.get(idx).getStatus())
                System.out.println("현재 등록된 기계 : " + this.registMachine.get(idx).getName());
        }
    }
    
}
 

 

BlueTooth.java

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

package exSingleton;
 
import exSingleton.common.computer;
import exSingleton.common.iMachine;
import exSingleton.common.laptop;
import exSingleton.common.phone;
 
public class BlueTooth {
    public static void main(String[] args) {
 
        //첫번째 bluetooth 감지 시나리오
        iMachine computer = new computer();
        iMachine phone = new phone();
        iMachine laptop = new laptop();
        
        computer.onSignal();
        phone.offSignal();
        laptop.onSignal();
    
        //singleton 인스턴스 생성
        BlueToothSingleton singleton1 = BlueToothSingleton.getInstance();
        
        //모니터링에 machine 추가
        singleton1.startMonitoring(computer);
        singleton1.startMonitoring(phone);
        singleton1.startMonitoring(laptop);
        
        //감지된 machine 리스트 출력
        singleton1.printMonitorMachine();
    
        //machine 등록
        singleton1.registerMachine(computer);
        singleton1.registerMachine(laptop);
        
        //등록된 machine 리스트 출력
        singleton1.printRegisterMachine();
        
        //모니터링 해제
        singleton1.stopMonitoring();
    
        
        //phone을 onsignal로 교체
        phone.onSignal();
        
        //singleton 인스턴스 생성
        BlueToothSingleton singleton2 = BlueToothSingleton.getInstance();
        
        //모니터링에 machine추가
        singleton2.startMonitoring(computer);
        singleton2.startMonitoring(phone);
        singleton2.startMonitoring(laptop);
        
        //감지된 machine 리스트 출력
        singleton2.printMonitorMachine();
        
        //등록된 machine중 computer 삭제
        singleton2.removeMachine(computer);
        
        //phone machine 등록
        singleton2.registerMachine(phone);
        
        //등록된 machine 리스트 출력
        singleton2.printRegisterMachine();
        
        //모니터링 해제
        singleton2.stopMonitoring();
    }
 
}
 

 

결과)

블루투스가 켜져있는 기계 : computer
블루투스가 켜져있는 기계 : laptop

현재 등록된 기계 : computer
현재 등록된 기계 : laptop

블루투스가 켜져있는 기계 : computer
블루투스가 켜져있는 기계 : phone
블루투스가 켜져있는 기계 : laptop

computer 이 등록 해제 되었습니다.

현재 등록된 기계 : laptop
현재 등록된 기계 : phone

최초 BlueToothSingleton객체를 생성하고 기기를 등록하고 나서, 다시 새로운 BlueToothSingleton변수에 인스턴스를 생성하여도 기존에 등록된 기기 정보가 그대로 유지됨을 알 수 있다.

자바 디자인패턴(Java Design pattern) - 싱글톤/싱글턴 패턴(Singleton pattern)

SunnyCool — Sun, 25 Aug 2019 11:20:03 +0900

참고)

싱글톤 패턴(Singleton pattern) 실제 예제는 https://codehouse.tistory.com/10 에서 확인할 수 있다.

1. 싱글톤패턴(Singleton Pattern) 정의

1-1 특징

인스턴스가 단 하나만 생성되는 것을 보장하여, 어느곳에서나 그 인스턴스에 접근가능한 클래스 메서드(getInstance())를 가지고 있는 패턴이다.

getInstance() 메서드를 통해 모든 클라이언트에게 동일한 인스턴스를 제공할 수 있다.

1-2 장점 및 효과

프로그램 상에 단 하나만 존재해야 하는 객체가 필요할 때 사용한다. 운용하는 객체가 하나이다 보니 관리의 집중도가 높아져 유지보수에 도움이 된다. 최초 객체 생성이후에는 객체 로딩시간이 많이 줄어든다.(이미 메모리에 할당이 되어 있기때문에)

1-3 단점

싱글톤 패턴역할을 객체가 너무 많은 일을 하면 해당 객체를 공유하는 클라이언트의 결합도가 너무 높아진다. (OOP 원칙에 어긋남 - 느슨한 결합). 결합도가 너무 높아지게 되면 해당 싱글톤객체를 수정해야할 시 해당 객체를 사용하는 모든 클라이언트에 영향을 주어 오히려 유지보수에 악영향을 끼칠 수 있다.

1-4 사용예

프로그램 선택자, 사용자 설정을 처리하는 객체, 와이파이, 블루투스 등록 등 시스템 레지스트리 등록자

2. 싱글톤패턴(Singleton Pattern) 구현 방식

2-1 고전적 방식

고전적인 싱글톤 패턴(singleton pattern)의 구현법은 다음과 같다.

예)

ClassicalSingleton.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public class ClassicalSingleton {
 
    private static ClassicalSingleton singleton;
    
    //생성자도 private으로 지정하여 접근하지 못하도록 설정한다.
    private ClassicalSingleton() {}
    
    public static ClassicalSingleton getInstance() {
        
        //객체가 지정되어 있지 않다면 객체를 생성하여 준다.
        if(singleton == null) {
            singleton =  new ClassicalSingleton();
        }
        
        return singleton;
    }
    
    public void getClassAddress() {
        System.out.println(singleton);
    }
}

 

usingSingleton.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class usingSingleton {
 
    public static void main(String[] args) {
        ClassicalSingleton singletonNum1 = ClassicalSingleton.getInstance();
        singletonNum1.getClassAddress();
        
        ClassicalSingleton singletonNum2 = ClassicalSingleton.getInstance();
        singletonNum2.getClassAddress();
    
        
        ClassicalSingleton singletonNum3 = ClassicalSingleton.getInstance();
        singletonNum3.getClassAddress();
    }
 
}
 

 

결과)

ClassicalSingleton@7852e922
ClassicalSingleton@7852e922
ClassicalSingleton@7852e922

생성자를 private로 선언하여 객체를 선언할 수 없도록 하였으며, 필요한 상황이 올때 getInstance()메서드를 호출해서 사용하도록 하였다.

이와 같이 인스턴스를 미리 만들어 놓지 않고, 필요한 상황에 생성하는 방식을 게으른 인스턴스 생성이라 한다.(lazy Instantiation)

또한 결과를 보고 알수 있듯이 인스턴스를 어느 객체변수에 생성 시켜도 동일한 객체를 사용한다는 것을 알 수 있다.

하지만 이 방식은 멀티스레드 방식에서 인스턴스가 2개이상 생성될 수 있다는 문제가 있다.

2-2 멀티 스레드(Multi Thread) 에서의 싱글톤 패턴(Singleton pattern) 구현방식

2-2-1 Synchronized 방식

고전적 방식에서 getInstance() 메서드에 동기화 키워드인 synchronized를 사용하면 된다.

예)

syncSingleton.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

public class syncSingleton {
    private static syncSingleton singleton;
 
    //생성자도 private으로 지정하여 접근하지 못하도록 설정한다.
    private syncSingleton() {}
 
    public static synchronized syncSingleton getInstance() {
 
        //객체가 지정되어 있지 않다면 객체를 생성하여 준다.
        if(singleton == null) {
            singleton =  new syncSingleton();
        }
 
        return singleton;
    }
 
    public void getClassAddress() {
        System.out.println(singleton);
    }
}
 

 

한 스레드가 위 객체를 생성하고 사용이 끝날때까지 다른 스레드는 인스턴스 생성을 기다려야 한다. 이방법을 이용하면 확실히 동시에 인스턴스가 생성되는것을 방지 할 수 있다 . 하지만 synchronized를 사용함으로써 해당 어플리케이션의 속도가 느려진다는 단점이 있다. (심각한 수준의 성능저하)

2-2-2 DCL(Double Checking Locking)방식

예)

syncSingleton.java

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

public class syncSingleton {
    private volatile static syncSingleton singleton;
 
    //생성자도 private으로 지정하여 접근하지 못하도록 설정한다.
    private syncSingleton() {}
 
    public static syncSingleton getInstance() {
 
        //인스턴스가 생성중인지 확인한다.
        if(singleton == null) {
            //동기화를 사용하여 다른 스레드가 사용중인지 확인
            synchronized (syncSingleton.class) {
                // 다시한번 인스턴스가 생성되어 있는지 확인한다.
                if(singleton == null) {
                    singleton =  new syncSingleton();
                }
            }
        }
 
        return singleton;
    }
 
    public void getClassAddress() {
        System.out.println(singleton);
    }
}
h

 

getInstance()에서 동기화를 사용하는것이 아니라, 인스턴스를 생성할 때 동기화를 사용하므로, 처음 인스턴스를 생성할 때 이후에 synchronized를 타지 않으므로 성능저하의 단점을 커버할 수 있다. 다만 이 방법은 shared-memory 방식에서 안정성이 떨어질 수 있다.

2-2-3 Initialization on demand holder idiom (holder에 의한 초기화)

클래스 안에 holder클래스를 두어 JVM의 클래스 초기화 시점에서 class를 생성하는 방식이다. 구현방식은 다음과 같다.

예)

holderSingleton.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class holderSingleton {
 
    private holderSingleton() {}
 
    //정적 class(lazyholder)생성 시 로딩 시에 인스턴스를 생성한다.
    private static class lazyholder {
        private static final holderSingleton singleton = new holderSingleton();
    }
    
    public static holderSingleton getInstance() {
        return lazyholder.singleton; 
    }
    
    public void getClassAddress() {
        System.out.println(lazyholder.singleton);
    }
}
 

 

usingSingleton.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class usingSingleton {
 
    public static void main(String[] args) {
        holderSingleton singletonNum1 = holderSingleton.getInstance();
        singletonNum1.getClassAddress();
        
        holderSingleton singletonNum2 = holderSingleton.getInstance();
        singletonNum2.getClassAddress();
        
        holderSingleton singletonNum3 = holderSingleton.getInstance();
        singletonNum3.getClassAddress();
    }
 
}
 

 

결과)

holderSingleton@7852e922
holderSingleton@7852e922
holderSingleton@7852e922

holder클래스 안의 인스턴스가 static이기 때문에 클래스 로딩시점에 한번만 생성되며 final이기 때문에 재 할당이 되는것을 방지한다. 현재 이 방식이 제일 널리 사용되고 있다.

자바 조건문 (2) - switch/case 문

SunnyCool — Tue, 20 Aug 2019 15:07:06 +0900

자바 조건문

switch / case문

하나의 수식에 여러 가지 결과로 분기를 해야 할 경우 switch 문을 사용한다.

사용법은 다음과 같다.

switch(수식)

{

case 값1 :

코드 1

break;

case 값2:

코드 2

break;

case 값3:

코드3

break;

…….

case 값N:

코드 N

break;

default :

코드

}

case문은 switch에서 사용한 식의 결과값으로 분기를 태우게 한다. 수식의 결과가 값2이면 코드 2를 수행하게 된다.

수식의 결과 값이 case에 해당하는 어떠한 값과도 일치하지 않을때는 default에 있는 코드를 수행한다.

또한 각 case문의 코드가 끝난다면 break을 이용하여 switch문을 빠져 나가게 해주어야 한다.

만약 break를 사용하지 않는다면 아래에 case문을 계속 수행한다.

다음은 switch 문의 예이다.

예)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

    int menuNumber = 3;
        
    switch(menuNumber) {
        case 1:
            System.out.println("짜장면");
            break;
        case 2:
            System.out.println("짬뽕");
            break;
        case 3:
            System.out.println("볶음밥");
            break;
            
        default :
            System.out.println("군만두");
    }

 

결과)

1

볶음밥

switch 문을 사용할때에는 다음과 같은 주의사항이 있으니 알아두도록 하자.

1. switch에 사용하는 식의 결과는 정수 혹은 문자(열) 이어야 한다.

2. switch에 사용하는 식은 논리형(boolean)값을 사용할 수 없다. --> switch(true) : 에러남

3. case에는 단일 상수, 문자(열) 값만 사용할 수 있음. --> case a > 3 : 에러남

자바 조건문 (1)- if문, if ~ else문, if ~ else if ~ else 문, 중첩 if문

SunnyCool — Tue, 20 Aug 2019 13:57:31 +0900

자바 조건문

if 문

자바에서 특정 조건에 해당하는 코드를 수행하게 될 때 if문을 사용한다.

예를 들어 코딩을 하다가 "A변수가 7보다 크면 A값을 0으로 대입해라" 라는 코드는 다음과 같이 작성한다.

1
2
3
4
5

if( A > 7 ){
 
    A = 0;
 
}

 

만약 A변수 값이 8이라면 if에서 사용되는 "A > 7" 이라는 조건식에 부합하기 때문에 "A = 0" 인 코드를 실행한다.

하지만 A변수 값이 5라면 부합하지 않기 때문에 if안의 A=0코드를 수행하지 않는다.

if ~ else문

if문은 else와 같이 작성할 수 있다. 작성방법은 다음과 같다.

if( 조건식 ) {

코드

}else {

코드

}

if에서 사용하는 조건식에 부합하면(true) if문 하위의 코드가 실행되고 조건식에 부합하지 않으면 else문 하위의 코드가 실행된다.

다음 예제 코드를 보면 이해하기 쉽다.

예제)

1
2
3
4
5
6
7
8
9
10
11
12
13

int A = 6;
 
if( A > 7 ) {
 
    A = 0;
 
}else {
 
    A = 1;
 
}
 
System.out.println(A);

 

결과)

1

1

위 코드에서 A값을 6으로 초기화 했으므로 if조건식인 "A > 7"은 성립되지 않는다. 그러므로 else 하위의 코드가 실행되므로 "A = 1" 코드가 수행되고 최종적으로 1값이 출력된다.

if ~ else if ~ else문

다수의 조건식을 필요로 할때에는 if - else if - else문을 이용하여 처리 할 수 있다. 작성방법은 다음과 같다.

if( 조건식 ) {

코드

}else if(조건식){

코드

}else if(조건식){

코드

}else {

코드

}

모든 조건식에 부합하는지 체크하며 어떤 조건식에도 부합하지 않는다면 else하위 코드가 실행된다.

다음 예제 코드를 통해 확인해보자

예제)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

int A = 6;
 
if( A > 7 ) {
 
    A = 0;
 
}else if( A > 6){
 
    A = 1;
 
}else if( A > 5) {
 
    A = 2;
 
}else {
 
    A = 3;
 
}
 
System.out.println(A);

 

결과)

1

2

변수 A를 6값으로 초기화 하였고 각 조건식 중에서 " A > 5 " 연산에 부합하기 때문에 " A = 2 " 코드가 수행되므로

2값이 출력된다.

중첩 if문

if문 하위에 if문을 사용 할 수 있다. 이를 중첩 if문 이라고 한다. 사용법은 다음과 같다.

if( 조건식 ){

코드

}

다음 예제코드를 통해 확인해 보자.

예제)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

int yourMoney = 10000;
 
String dessert= "";
 
if( yourMoney  > 5000 ) {
 
    if( yourMoney > 7000 ){
 
        dessert = "cake and coffee";
 
    }else{
 
        dessert = "coffee";
 
    }
 
}
 
System.out.println(dessert);

 

결과)

1

cake and coffee

if문과 연산자

if문에서 사용하는 조건식은 대부분 비교연산자(관계연산자)와 &&(and), ||(or), !(not)연산자들과 함께 사용되는 경우가 많다.

비교연산자는 https://codehouse.tistory.com/6 에서 확인할 수 있다.

&&, ||, ! 연산자의 의미는 다음과 같다.

구 분	사 용	의 미
&& (AND)	A && B	A와 B 모두 참(true)여야 참이다.
\|\| (or)	A \|\| B	A와 B 둘 중 하나만 참(true)여도 참이다.
! (not)	!A	A가 거짓(false)이면 참이다.

다음 예제 코드와 주석을 보면 이해하기 쉽다.

예제)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

int A = 7;
 
int B = 8;
 
if( A > 8 && B > 7) {                // A > 8 이 거짓(false)이므로  && 연산결과 거짓이기 때문에 코드가 수행되지 않는다.    
    System.out.println("해당 조건식은 모두 참입니다.");
}
 
if( A > 8 || B > 7) {                // B > 7이 참이기 때문에 || 연산결과가 참이므로 코드가 수행된다.
    System.out.println("조건식 두개중 하나만 참이어도 수행됩니다.");
}
 
if( !(A > 8)) {                // A > 8이 거짓이므로 !연산을 수행하면 참이된다. 그러므로 코드가 수행된다.
    System.out.println("해당 조건식이 false일때 !연산을 수행하면 참이된다.");
}
 
 
 

 

결과)

1
2
3

조건식 두개중 하나만 참이어도 수행됩니다.
해당 조건식이 false일때 !연산을 수행하면 참이된다.

자바연산자(Java Operator) - 연산자, 피연산자, 연산자 종류(2) - 시프트연산자, 관계연산자, 논리연산자, 삼항연산자, 대입 연산자

SunnyCool — Mon, 19 Aug 2019 23:10:05 +0900

구 분	연 산 자	우 선 순 위
우선연산자	( ) [ ] .	가장 높음
단항연산자	+ - ! ~ ( ) ++ --	높음
산술연산자	+ % / * -	높음
쉬프트연산자	<< >> >>>	높음
관계연산자	> < >= <= == !=	높음
논리연산자	& ^ \| && \|\|	낮음
삼항연산자	? :	낮음
대입연산자	= *= /= %= += -= <<= >>= >>== &= ^= !=	낮음

1. 시프트 연산자

1-1 << 좌 시프트 연산자

비트를 좌측으로 밀고 난 자리를 0으로 채운다.

2 << 2 ( 2의 비트는 0000 0010)

0000 0010 -> 0000 1000 -> 8

1-2 >> 우 시프트 연산자

비트를 우측으로 밀어준다. 밀고 난 자리는 부호비트가 0이면 0을, 1이면 1을 채워준다.

4 >> 2 (4의 비트는 0000 0100)

0000 0100 -> 0000 0001 -> 1

1-3 >>> 우 시프트 연산자2

비트를 우측 밀어준다. >> 연산자와 다른점은 부호비트와 상관없이 빈자리를 무조건 0으로 채워준다.

16 >>> 2 ( 4의 비트는 0001 0000)

0001 0000 -> 0000 0100 -> 4

2. 관계 연산자

2-1 관계연산자

관계 연산자는 좌측에 있는 변수 혹은 상수를 기준으로 해석하면 이해하기 쉽다.

a >= b : a가 b보다 크거나 같다면

a <= b : a가 b보다 작거나 같다면

a == b : a가 b와 일치한다면

a != b : a가 b와 일치하지 않는다면

3. 논리 연산자

3-1 비트논리 연산자(&, |, ^)

A값	B값	& (and)	\| (or)	^ (xor)
0	0	0	0	0
1	0	0	1	1
0	1	0	1	1
1	1	1	1	0

& 연산자 : 두 비트가 모두 1일때만 1

| 연산자 : 두 비트중 하나만 1이어도 1

^ 연산자 : 두 비트가 같은때에는 0, 다를때는 1

3-2 AND결합(&&), OR결합(||) 연산자

&& : 연산식, 혹은 피연산자의 결합이 모두 true여야 true값을 return 한다.

- ( 1 && 3>2 ) , ( ((2*3) > (2+3)) && true )

|| : 연산식, 혹은 피연산자의 결합이 둘중 하나만 true여도 true 값을 return 한다.

- ( 0 || 1), ( false || true), ( (2 < 3) || (3 > 2) )

4. 삼항연산자

4-1 삼항연산자

세개의 피연산자를 필요로 하며, 조건식이 true일때의 return 값, false일때의 return 값으로 분리된다.

이 삼항연산자는 생각보다 많이 쓰이는데 간단한 if문을 삼항연산자 한줄로 대체하여 라인수를 줄일 수 있다.

(조건식) ? 식1 : 식2

- int returnValue = ( 3 < 5 ) ? 10 : 0;

: 3이 5보다 작은 값이 맞기때문에 조건식은 true이고 true에 해당하는 10의 값이 return Value 변수에 대입된다.

5. 대입연산자

5-1 단순대입연산

대입연산자는 변수에 값이나 수식결과를 저장하기위해 사용된다. 대입연산자 좌측에는 저장될 변수가 위치되어야 하고

우측에는 상수, 혹은 수식이 올 수 있다.

int resultInteger = 3;

int returnValue = (3 + 5) * 2;

5-2 복합대입연산

대입연산자와, 다른연산자를 대입하여 사용하는 연산 표현이다. 아래 예시를 보면 이해하기 쉽다.

result += 3;

- result 변수에 result + 3을 수행한후 값을 result에 대입하라는 의미이다. result = result + 3 의 단순대입 연산과 같은

의미이다.

result *= 10

- result 변수에 result * 10을 수행한 값을 result에 대입하라는 의미이다. result = result * 10의 단순대입 연산과 같은

의미이다.

자바연산자(Java Operator) - 연산자, 피연산자, 연산자 종류(1) - 우선연산자, 단항연산자, 산술연산자

SunnyCool — Mon, 19 Aug 2019 16:14:23 +0900

연산자정의.. 연산자란??

주어진 식에 대한 계산결과를 수행하는 것을 연산이라 하며, 연산자는 이를 수행하기 위한 기호이다.

식 예시

연산자 : 연산을 수행하는 기호 ( +, -, /, * 등)

피연산자 : 연산자의 대상 (상수, 변수 등)

연산자 종류, 우선순위, 정의

연산자 종류는 아래와 같다.

구 분	연 산 자	우 선 순 위
우선연산자	( ) [ ] .	가장 높음
단항연산자	+ - ! ~ ( ) ++ --	높음
산술연산자	+ % / * -	높음
쉬프트연산자	<< >> >>>	높음
관계연산자	> < >= <= == !=	높음
논리연산자	& ^ \| && \|\|	낮음
삼항연산자	? :	낮음
대입연산자	= *= /= %= += -= <<= >>= >>== &= ^= !=	낮음

우선순위는 표에서 나오는 순서와 같다. 하나의 식에서 여러개의 연산자가 쓰인다면 위 표에 나온 연산자 순서대로 연산을 수행한다. 이제 위 표에 나오는 연산자 종류에 대해 알아보도록 하자.

1. 우선 연산자

1-1 ( ) 연산자

식에서 ( ) 안에 있는 연산을 최우선으로 수행한다.

예제) A * (B + C)

( ) 안에 있는 + 연산을 먼처 한 후 * 연산을 수행한다.

1-2 [] 연산자

배열에서 사용하는 연산자 이다.

예제) char[] a = new char[3];

=(대입) 연산보다 [] 메모리 할당을 먼처 수행하게 된다.

2. 단항 연산자

2-1 부호 연산자(+, -)

+ 연산은 부호를 유지하는 연산이며, - 연산은 부호를 변경하는 연산이다.

예제)

1
2
3
4
5

int a = -5;
 
System.out.println(+a);
 
System.out.println(-a);

 

결과)

2-2 논리부정 연산자(!)

! 연산은 boolean타입의 변수에서만 사용할 수 있는 연산자 이며 반대의 논리값으로 바꿔준다.

예제)

1
2
3
4
5
6

boolean testBool = false;
 
 
System.out.println(testBool);
 
System.out.println(!testBool);

 

결과)

1
2
3

false
 
true

2-3 비트전환 연산자(~)

~ 연산은, 피연산자(상수, 변수)값을 8Bit의 2진수로 표현했을때 0은 1로, 1은 0으로 변환시켜준다.

주의할점은 8bit중 맨앞자리 bit는 부호비트로 사용된다. (0인경우 양수, 1인경우 음수)

예제)

1
2
3
4
5

int testTilde = 10;
 
System.out.println(testTilde);
 
System.out.println(~testTilde);

 

결과)

1. 10진수를 8bit로 표현하면 00001010 이다.

2. 해당 비트의 각 자리 값들을 반대값으로 변경하면 11110101이 나오며

3. 맨 뒷자리 부터 처음으로 1을 만날때까지는 원래의 값을 유지하며 그 이후로는 값을 반대로 변환 시켜준다.

(맨앞의 부호비트는 변경하지 않는다.) 11110101 -> 10001011

4. 해당 비트는 맨앞자리(부호비트)가 1이기때문에 음수이며 나머지 비트를 계산하면 -(23 + 2 + 1) = -11

2-4 증감 연산자(++, --)

++ 연사자의 경우 값을 1증가 시키며, --연산자의 경우 값을 1감소 시킨다.

예제)

1
2
3
4
5
6
7
8
9
10
11

int in$decreaseTest = 0;
System.out.println(3 * in$decreaseTest++);
 
in$decreaseTest = 0;
System.out.println(3 * ++in$decreaseTest);
 
in$decreaseTest = 0;
System.out.println(3 * in$decreaseTest--);
 
in$decreaseTest = 0;
System.out.println(3 * --in$decreaseTest);

 

결과)

예제결과와 같이 증감연산자는 피연산자의 위치에 따라 우선순위가 달라진다.

피연산자 앞에 쓰이는 경우를 전위형 이라하며 다른 연산을 수행하기 전에 증감연산부터 수행하게 하며

피연산자 뒤에 쓰이는 경우를 후위형 이라하며 다른 연산을 수행한후 해당 피연산자를 증감시킨다.

전위형) 3 * ++in$decreaseTest

후위형) 3 * in$decreaseTest++

전위형 같은 경우 변수를 먼처 1증가 시키고 3을 곱셉하여 3이라는 결과가 나오지만,

후위형 같은 경우 3과 0을 먼처 곱셈한후 변수를 1증감시키므로 0이라는 결과가 나온다.

3. 산술 연산자

3-1 사칙 연산자(* / + - %)

사칙연산자의 경우 *(곱셈), /(나눗셈), %(나머지) 가 +(덧셈), -(뺄셈) 보다 우선순위가 높다. 사칙연산자는 다음과 같은 특징을 가지고 있다.

1. 두 피연산자의 타입을 큰타입으로 일치시킨다.

- long + int = long, float + double = double

2. 피연산자의 타입이 int형보다 작으면 int로 변환된다.

- byte + byte = int, short + byte = int

3. 정수형간의 나눗셈에서 0으로 나누는 식은 ArithmeticException이발생한다.

- int a = 3 / 0

자바변수 타입(Java variable type)종류 - primitive(원시) 자료형

SunnyCool — Sun, 18 Aug 2019 20:43:53 +0900

primitive(원시형) 변수타입 정의

변수란 특정 값들은 담는 메모리 공간이라고 전 챕터에서 정의 하였다.

이번장에서는 변수타입중에서도 primitive(원시형) 자료타입에 대해 알아보도록 한다.

primitive 자료형은 계산식 없이 일반적인 상수 값으로 셋팅할 수 있다. (상수란 변하지 않는 값을 의미)

예제)

1
2
3
4
5

int a = 0;
 
char c = 'C';
 
float a= 3.14F;

 

primitive(원시형) 변수타입 종류

primitive 변수타입의 종류는 아래 그림과 같이 '문자열', '정수형', '부동소수점', '논리형' 4가지로 구분될 수 있다.

<원시형 타입 종류>

각 타입별로 알아보도록 하자.

1. 문자열 변수타입(char)

한개의 문자 값에 대한 자료형은 'char'을 이용한다. 특징은 다음과 같다.

메모리 크기	표현 범위
2 Byte	\u0000~\uFFFF

char 형 타입은 엄밀히 말하면 유니코드 문자를 처리할 수 있도록 설계된 문자열 변수타입이다. \u0061이란 유니코드를 예로 들면 해당 코드는 문자 'a'를 저장해둔 공간을 의미하며, char uniTest = '\u0061' 과같이 값을 대입하면 문자열 A를 대입한것과 같은 의미이다. 이 유니코드를 처리할 수 있기 위해 메모리가 2Byte가 필요하다.

또한 char형 타입에 저장된 값은 실제로는 숫자를 가르킨다. 문자 'a'는 '아스키코드' 97을 의미한다.

즉 값을 대입하기 위해 다음 3가지 방법으로 값을 대입할 수 있다.

1) 단일 문자열

2) 아스키코드(문자열의 숫자값)

3) 유니코드값(문자열 맵핑 공간)

사용법은 아래와 같다.

예제)

char TestChar = 'c';
 
char TestAscii = 99;
 
char TestUnicode = '\u0063';
 
System.out.println(TestChar);
 
System.out.println(TestAscii);
 
System.out.println(TestUnicode);

결과)

c
 
c
 
c

위 소스는 모두 문자 'c'를 출력한다. 그렇다면 아스키코드, 혹은 유니코드를 왜 자바에서 사용할까?? 이 부분은 자바

기초 지식을 쌓은후에 배워야 하지만 기본적으로 국가별 언어를 나누어서 저장하고 비교하기 위해서 사용한다.

예를들어 특정 "문자열"에 한국어와 일본어가 섞여 있다고 치면 이 문자열에서 일본어만 제거하기 위해서 유니코드표를 이용하여 쉽게 제거할 수 있다. 이 부분과 관련하여 추후에 문자열 인코딩 부분에서 다루기로 한다.

2. 정수형 변수타입(byte, short, int, long)

정수형 숫자를 저장할 수 있는 변수타입을 의미한다.(정수 : 음의정수(-3,-2,-1), 0, 자연수(1,2,3,4…)을 포함하는 수의 집합).

정수형 타입은 아래와 같이 4가지로 나뉘며, 포함할 수 있는 숫자의 범위로 구분짓는다.

구 분	메모리 크기	정수 범위
byte	1 Byte	-128 ~ 127
short	2 Byte	-32,768 ~ 32,767
int	4 Byte	-2,147,483,648 ~ 2,147,483,647 (약 21억)
long	8 Byte	-263 ~ 263승-1 (9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807)

종류별 정수 범위는 메모리 크기만 알고 있다면 쉽게 유추해 낼 수 있다. 사전적 지식으로 1Byte = 8bit임을 알아야 한다.

short는 2Byte 이므로 16bit이며 이는 216을 의미한다. 이 수에서 음수와 양수를 모두 표현해야 하므로 2로 나누어 주면 216-1이 되며 즉 -215 ~ 215-1 = -32,768 ~ 32767임을 알 수 있다.

가장 광범위 하게 사용되는 타입은 int형이므로, 다른 정수형 타입은 몰라도 int형 타입이 21억까지의 음, 양의 정수를 저장할 수 있다는것을 기억해 두도록 하자.

사용법은 아래와 같다.

예제)

1
2
3
4
5
6
7
8
9
10
11
12
13

byte numericByte = 120;
 
int numericInt = 1999999999;
 
long numericLong = 19999999999L;
 
 
 
System.out.println(numericByte);
 
System.out.println(numericInt);
 
System.out.println(numericLong);

 

위 예제 소스에서 주목할만한 점은 long 타입 변수선언시에 보이는 접미사 대문자 'L'이다. 해당 문자는 long타입 변수에 int형 범위를 초과하는(약 21억) 정수형 값을 대입했을때 반드시 붙여줘야 하는 접미사이다. 이부분은 잊지말고 기억해 두도록 하자.

3. 부동소수점(실수형) 변수타입(float, double)

실수형 숫자를 저장할 수 있는 변수타입을 의미한다. (실수 : 유리수와, 무리수를 모두 합친 수)

실수형 타입도 정수형 타입과 마찬가지로, 표현 범위로 구분짓는다.

구 분	메모리 크기	표현 범위
float	4 Byte	1.40239846E-45f ~ 3.40282347E+38f
double	8 Byte	4.94065645841246544E-324 ~ 1.79769313486231570E+308

사용방법은 다음과 같다.

예제)

1
2
3
4
5
6
7
8
9
10
11
12
13

float nemericFloat = 3.14F;
 
double nemericDouble= 124.537;
 
double nemericDouble2= 1.24537e2;
 
 
 
System.out.println(nemericFloat);
 
System.out.println(nemericDouble);
 
System.out.println(nemericDouble2);

 

위 예제 소스에 주목할만한 점은 float 타입 변수선언시에 보이는 접미사 대문자 'F'이다.

실수는 디폴트로 double형으로 저장되기 때문에 접미사 'F'를 붙여줘야 한다.

또한 double 타입 변수 nemericDouble과 nemericDouble2에 대입한 실수 124.537과 1.24537e2는 같은 수 이다. e2는 102을 의미하며 1.24537e2는 1.24537 * 102을 의미한다.

4. 논리형 변수타입(boolean)

참(true), 거짓(false)의 값을 갖는 변수타입을 논리형 변수타입이라 한다.

구 분	표 현
참	true
거짓	false

사용방법은 다음과 같다.

예제)

1
2
3
4
5
6
7
8
9

boolean boolTrue = true;
 
boolean boolfalse= false;
 
 
 
System.out.println(boolTrue);
 
System.out.println(boolfalse);

 

5. 8진수, 16진수 표현(int)

8진수와 16진수는 int 변수타입으로 표현 할 수 있다.

0으로 시작하면 8진수로 인식하며, 0x로 시작하면 16진수로 인식한다.

사용방법은 다음과 같다.

예제)

1
2
3
4
5
6
7
8
9

int octalInt = 024;
 
int hexInt = 0xd;
 
 
 
System.out.println(octalInt);
 
System.out.println(hexInt);

 

결과)

자바 변수 정의(Java variable). 변수란?

SunnyCool — Sun, 18 Aug 2019 16:33:12 +0900

기본사항

변수는 데이터를 저장하는 메모리 영역을 의미한다.

변수는 수시로 값이 변경 될 수 있으며 하나의 값만 저장할 수 있다.

자바소스는 대부분 이 변수의 선언부터 시작된다고 생각하면 된다.

컴퓨터가 연산하기 위해 '특정 값'들이 저장되는 곳을 변수라고 생각하면 이해하기 쉽다.

다음예제와 같이 my_int, my_float 을 변수라고 한다.

예제)

int my_int = 0;

float my_float = 0.0;

위 예제 코드처럼 변수는 변수타입 변수이름 으로 선언한다.

my_int를 예로 들면 int형 타입(정수형타입)에 변수이름은 my_int인것을 확인 할 수 있다.

또한 값을 대입하여 저장할 수 있는데 "=" 기호를 이용하여 대입한다.

int my_int = 0을 해석하자면 "정수형 타입의 변수명 my_int를 선언하고 0값으로 초기화 한다" 이다.

자세한 사항은 하단 코드와 주석을 참조하면 된다.

기본코드)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

package variable_constant;
 
public class variable {
 
    public static void main(String[] args) {
        
        
        int number = 1; // 변수 선언과 함께 값을 대입 할 수 있다.
        
        int number2;     // 변수 선언을 한 이후에         
        number2 = 2;     // 별도로 값을 대입할 수 있다. 
        
        
        int number3 = number + number2;    // 변수선언을 다른 동일 한 변수형의 사칙연산으로 대입할 수 있다. 
        
        System.out.println(number);     // number변수는 0값을 대입하였으므로 1이 출력된다.
        System.out.println(number2);     // number2변수는 2값을 대입하였으므로 2가 출력된다.
        System.out.println(number3);    // number3변수는 number변수+number2변수의 합이므로 3이 출력된다. 
    }
 

 

소스 결과

변수 이름 지정 규칙

변수의 이름을 지정할 때에는 아래와 같은 규칙이 존재 한다. 해당 예시를 보고 반드시 숙지하도록 하자.

규 칙	예 시
영문의 대소문자가 모두 구분된다.	int testNumber; String TestNumber; 위 두 변수명 서로 다른 변수로 간주된다.
변수명의 시작이 숫자로 시작되서는 안된다.	int 1testNumber = 0; 숫자로 시작되었으로 위 코드는 에러가 발생된다.
특수문자는 '_'(언더바기호), '$'(달러기호)만 사용가능하다.	int _number1, int _number2; int $_number, number$Test;
Java에서 내부적으로 사용하는 예약어를 사용할수 없다.	예약어란? - Java에서 변수타입, 반복문, 조건문, 예외처리등에 사용하기 위해 사용하는 단어를 의미한다. 하단에 표시된 예시는 변수이름으로 사용이 불가능하다. 1. 데이터 타입 - boolean, byte, char, short, int. long, float, double 2. 접근자 - private, protected, public 3. 클래스 - class, abstract, interface, extends, implements, enum 4. 객체 - new, instaceof, this. super, null 5. 메서드 - void, return 6. 조건문, 반복문 - if, else, switch, case, default, for, do, while, break, continue 7. 논리값 - true, false 8. 예외처리 - try, catch, finally, throw, throws 9. 기타 - transient, volatile, package, import, native, final, static