Java

[Java] 생성자, 형변환(casting), 연산자(operator)

Rosie_dev 2021. 1. 7. 21:50

//Main 클래스에서 실제 객체 생성(생성자)하고 실행시키는 파트

//다른 클래스에는 설계 담당하는 (추상화하기) 속성, 기본객체 틀, 기능(메서드)를 명기

 

생성자

기본 객체틀과 함께 실제 객체 생성에 사용되며, 클래스 이름과 동일한 명칭을 사용한다.

 

기본생성자와 파라미터생성자

 

기본생성자는 생성자명 뒤 ( );에 매개변수가 존재하지 않는 것을 말한다. 반대로 파라미터 생성자는 괄호 안에 매개변수를 포함하는 개념으로 new Member("hongkd", "qwer1234", "홍길동", 30, 100); 이렇게 표현된다. 구체적인 객체 생성에 도움이 된다.

 

this( )

 

현업에서는 변수명을 동일하게 하여 통일성과 가독성을 높이고자 하는데, 이 때 문제가 발생한다. 지역변수가 멤버변수보다 우선한다는 특징 때문이다. 즉, 생성자 내에서 지역변수를 멤버변수 속성에 대입하고자 하는 경우에 변수명이 같다면, 지역변수에 지역변수를 대입하는 것으로 표시되기 때문이다. 따라서 변수명이 동일한 경우 구분을 위해 this()생성자를 사용한다.

this.userid = userid; 

이렇게 구분하여 지역변수가 멤버변수에 대입될 수 있도록 한다.

 

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
package my.day03.a.constructor;
 
public class MemberMain {
 
    public static void main(String[] args) {
        
        //동일 패키지내 import 불필요
        Member hongMbr = new Member("hongkd", "qwer1234", "홍길동", 30, 100); //인스턴스 만들기
        
        //The constructor Member() is undefined ==> 기본생성자의 삭제, 파라미터 생성자에 의한 변수 설계가 안되어 있다
        Member cheongaMbr = new Member();        
        cheongaMbr.userid = "cheonga";
        cheongaMbr.passwd = "abcd";
        cheongaMbr.name = "청아";
        cheongaMbr.age = 20;
        cheongaMbr.point = 300;
                                
        hongMbr.showInfo();
        cheongaMbr.showInfo();
        
        hongMbr.changeInfo("KDhong","1234","홍길동", 25, 150);  //변경기능의 method
        
        String info = cheongaMbr.updateInfo("cha","abcd0070","청아", 21, 7000);
        System.out.println(info);
    }
 
}
 
 cs

 

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
package my.day03.a.constructor;
 
public class Member {
    
    // 항상 추상화 먼저!!
    // field(attribute == property == 속성)
    String userid;
    String passwd;
    String name;
    int age;
    int point;
    
    //*** 생성자(constructor) *** // 클래스명과 같아야 한다!, return 타입 없음(method와의 차이)
    //객체를 만들기 위해서 생성
    
/*
    public Member( ) {
        System.out.println(">> Member 클래스의 기본 생성자(default constructor)를 호출했습니다. <<"); 
//() 속에 빈 것이 기본생성자
        
    }
*/
    
    // *** 생성자를 명기하지 않으면 아래와 같은 것이 생략되어져 있다. 
// ++웹 JSP 규격서에는 반드시 기본생성자를 작성해야 한다
    public Member() {}
    //!!! 중요 !!! parameter 생성자가 선언되어 있으면 생략되어져 있던 자동적으로 기본생성자는 삭제가 되어져 버린다
    
    public Member(String userid, String passwd, String name, int age, int point) {
                  //() 속에 들어오는 변수를 매개변수(== parameter)라고 부른다
                  //parameter 생성자
        //지역변수명과 멤버변수(인스턴스변수와 static변수를 모두 지칭)명이 일치할 경우, 지역변수가 우선된다.
        //현업에서는 변수명의 동일하게 해야 통일성과 가독성을 높일 수 있다. 동일할 경우 구분을 위해 this()생성자의 사용
        this.userid = userid; //this(이것) 지역변수 값에 바로 이 값을 넣어주겠다!!
        this.passwd = passwd;
        this.name = name;
        this.age = age;
        this.point = point;
    }
    //기본생성자와 parameter 생성자를 둘 다 쓰고자하는 경우, 둘 다 추가해 놓으면 된다.
    
    
    // method(행위 == behavior == 기능)
    // parameter가 없고 return 타입도 없는 메서드 만들기 예제
    void showInfo() {        
        System.out.println(" ==== "+name+"님의 회원정보 ==== \n" //인스턴스 변수를 사용한 인스턴스 메서드
                            + "1. 아이디: "+userid+"\n"
                            + "2. 암호: "+passwd+"\n"
                            + "3. 성명: "+name+"\n"
                            + "4. 나이: "+age+"\n"                
                            + "5. 포인트: "+point+"\n");
    }
    
    // parameter가 있고 return 타입도 없는 메서드 만들기 예제    
    void changeInfo(String userid, String passwd, String name, int age, int point) {
        this.userid = userid;
        this.passwd = passwd;
        this.name = name;
        this.age = age;
        this.point = point;    
        
        System.out.println(">> 변경 후 정보 조회하기 <<");
        showInfo();      //showInfo()를 changeInfo() 기능에 넣어 Main에 추가 입력불필요
    }
    
    // parameter가 있고 return 타입도 있는 메서드 만들기 예제
        
    String updateInfo(String userid, String passwd, String name, int age, int point) {
        
        //변경전 
            String beforeInfo = "=== "+this.name+"님의 회원수정 전 결과 === \n"
                                    + "1.아이디: "+this.userid+"\n"
                                    + "2.암호: "+this.passwd+"\n"
                                    + "3.성명: "+this.name+"\n"
                                    + "4.나이: "+this.age+"\n"
                                    + "5.포인트: "+this.point+"\n";
         // 변경 후
            this.userid = userid;
            this.passwd = passwd;
            this.name = name;
            this.age = age;
            this.point = point;    
        
             String afterInfo = "=== "+this.name+"님의 회원수정 후 결과 === \n"
                        + "1.아이디: "+this.userid+"\n"
                        + "2.암호: "+this.passwd+"\n"
                        + "3.성명: "+this.name+"\n"
                        + "4.나이: "+this.age+"\n"
                        + "5.포인트: "+this.point+"\n";
                
             return beforeInfo + "\n" + afterInfo;           
             // 이렇게 간략하게 return값으로 받으면 깔끔
        
        /*
            변경 전
            System.out.println("=== "+this.name+"님의 회원수정 전 결과 === \n");   
            //새로 받은 변수이므로 this.변수로 받아줌
            //!!! 이렇게 받으면 " ==== "+name+"님의 회원정보 ==== \n"까지 나와서 보기 싫다!!!
            showInfo();
                        
            변경 후
            this.userid = userid;
            this.passwd = passwd;
            this.name = name;
            this.age = age;
            this.point = point;    
            
            return     "=== "+this.name+"님의 회원수정 후 결과 === \n"
                    + "1.아이디: "+this.userid+"\n"
                    + "2.암호: "+this.passwd+"\n"
                    + "3.성명: "+this.name+"\n"
                    + "4.나이: "+this.age+"\n"
                    + "5.포인트: "+this.point+"\n";
         */
             
    }
}
 
 cs

 

형변환 casting

1. 자동 형변환(묵시적 형변환)

 

데이터타입의 크기가 작은 것에서 큰 쪽으로 자동형변환이 발생한다. 정수타입에서 실수타입으로 char 문자형에서 int(정수형)으로 자동형변환이 가능하다.

byte(1byte) - short(2byte) - int(4byte) - long(8byte)

float(4byte) - double(8byte) 

char(2byte) 유니코드

 

2. 강제 형변환(casting)

 

데이터타입의 크기가 큰 쪽에서 작은 쪽으로 강제 형변환을 시킬 수 있는데, 실수타입의 기본형인 double에서 float 타입으로 바꾸려면, float ft2 = (float)db2; 으로 형변환이 가능하다.

 

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
package my.day03.b.casting;
 
public class CastingMain {
 
    public static void main(String[] args) {
        
        byte no1 = 100;
        System.out.println("no1 => "+no1);
        // no1 => 100
        
        short no2 = 20000;
        System.out.println("no2 => "+no2);    
        // no2 => 20000
        
        short no3 = no1;  //자동형변환
        //byte 타입인 no1을 자동적으로 short 타입으로 형변환 되어 no3에 대입해준다.
        System.out.println("no3 => "+no3);    
        
        System.out.println("\n ~~~~~~~~~ 강제형변환 ~~~~~~~~~~ \n");
        
        int no4 = 300;
        short no5 = (short) no4;  //강제형변환
        // 이 때, ()를 casting 연산자라고 부른다.
        System.out.println("no5 => "+no5);    
        // no5 => 300
    
        float ft1 = 1.234567f;  //실수 기본타입이 double이므로 접미사 f 또는 F 입력
        System.out.println("ft1 => "+ft1);
        // ft1 => 1.234567
        
        double db1 = ft1;  //자동형변환
        //float 타입인 ft1을 자동적으로 double 타입으로 형변환 되어 db1에 대입해준다.
        System.out.println("db1 => "+db1);
        // db1 => 1.2345670461654663    double 타입의 정밀도가 높음
        
        double db2 = 1.93456789123;
        float ft2 = (float)db2;  //강제형변환
        System.out.println("ft2 => "+ft2);        
        // ft2 => 1.2345679
        
        //byte 간 비교는 같은 정수형, 실수형인 경우만 가능하다
        float ft3 = 1.234567f; // float 4byte
        int n = (int)ft3;      // int 4byte
        long ln = (long)ft3;   // long 8byte
        
        System.out.println("n => "+n);    
        // n => 1
        
        System.out.println("ln => "+ln);    
        // ln => 1
    }
}
 
 cs

 

연산자 Operator

증감연산자

 

후위증감연산자(a++; b--;) 는 다른 연산을 다 마친 이후에 1씩 증감한다.

전위증감연산자(++a; --b;) 는 맨 먼저 증감을 마친 이후에 다른 연산을 한다.    

 

논리연산자

 

조건문에서 논리연산자가 &, | 로 한 개만 쓰였을 경우, 비교하고자 하는 모든 경우의 수를 실행하여 true, false를 확인하고 이하 문장이 실행된다. 반면, &&, || 와 같이 쓰인 경우, 모든 항목을 실행하지 않고 한 가지만 만족해도 실행을 멈춘다.

 

★ 논리연산자 퀴즈 다시 풀어보기

int i=1;  int j=i++; 
if( (i > ++j) & (i++ == j) ) { 
             i=i+j;
    }
System.out.println("i="+i); 

처음 문장에서 i = 2, j = 1 (후위증감연산자로 j에 i의 초기화 값인 1을 대입하고 i에는 1을 더하므로)
조건문에서 &이므로 양쪽 ( )를 모두 확인하고 true가 있으면, i = i + j;를 수행한다.
첫 괄호에서 2 > 2이므로 false.
두번째 괄호는 3 == 3이므로 false.
모두 false이므로 { }를 실행하지 않고 출력된 i는 3이다.
//여기서 주의해야 할 점은 첫 줄에서 초기화된 변수 값이 조건문을 진행하면서 값이 계속 변한다는 것이다. 조건문이 모두 false일지라도, 해당 조건문을 수행하면서 입력된 데이터는 다시 첫 줄의 초기화 값이 되지 않는다는 것이다.


+ 위와 동일한 조건에서 &&를 사용한 조건문일 때, 출력된 i는 2이다.
    &와 달리 &&에서는 첫 괄호가 false이므로 뒤에 괄호를 수행하지 않은채 출력되기 때문이다.

변하지 않는 상수 개념을 이용하려면, final int a = 1; 이렇게 작성되어야 한다. 

 

할당연산자

 

+= -= *= /= 는 연산을 먼저하고 대입한다.

 

삼항연산자 

변수선언 = (조건식)? 값1 : 값2;

조건식이 참이면 값1을, 거짓이면 값2를 변수에 대입한다.

                       

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
package my.day03.b.operator;
 
public class OperatorMain {
 
    //int n = 10;  //인스턴스 변수
    
    public static void main(String[] args) {
 
        // === 연산자 === //
// 1. 산술연산자  + - * / %(나머지)
        int n = 10; //지역변수 
        System.out.println("n + 3 = "+ (n+3));  //13
        // System.out.println("n + 3 = "+ n+3);  ==> n+3=103    
        System.out.println("n - 3 = "+ (n-3));  //7
        System.out.println("n * 3 = "+ (n*3));  //30
        
        System.out.println("n / 3 = "+ (n/3));  //3    몫
        System.out.println("n / 3 = "+ (n/3f));  //3.3333333
        System.out.println("(((double)n)/3) = "+ (((double)n)/3));  
        //3.3333333333333335 실수/정수=실수
        
        System.out.println("n % 3 = "+ n%3);  //1      나머지
        //10을 3으로 나누었을때의 나머지 1
        
// 2. 증감연산자  ++  --
        //int a = 7;
        //int b = 3;
        // 또는 
        int a=7, b=3;
        System.out.println("a => "+ a); //a => 7
        //a = a+1; 또는 
        a++;
        System.out.println("a => "+ a); //a => 8
        ++a;
        System.out.println("a => "+ a); //a => 9        
        
        System.out.println("b => "+ b); //b => 3        
        //b = b-1; 또는
        b--;
        System.out.println("b => "+ b); //b => 2
        --b;
        System.out.println("b => "+ b); //b => 1    
        
        // !!! 꼭 암기하세요 !!! ///
        // 후위증감연산자(a++; b--;) 는 다른 연산을 다 마친 이후에 1씩 증감한다.
        // 전위증감연산자(++a; --b;)    는 맨 먼저 증감을 마친 이후에 다른 연산을 한다.    
        int x=10, y=10;
        int z=++x;
        System.out.println("z => "+z);  //z => 11
        System.out.println("x => "+x);  //x => 11
        //전위증감연산자이므로 x를 1 증가시킨 후인 11을 z에 넣는다. 계산 먼저하고 대입
        
        z=y++;
        System.out.println("z => "+z);  //z => 10
        System.out.println("y => "+y+"\n");  //y => 11        
        //후위증감연산자이므로 y를 z에 대입한 후에 y를 1 증가시킨다. 대입 먼저하고 계산
 
// 2. 논리연산자   &  |  &&  ||(vertical line)
        /*
             수학에서는  T ∧  T ∧  F  ==> F
             수학에서는  T ∧  T ∧  T ==> T
             
             수학에서는  T ∨  T ∨ F ==> T
             수학에서는  T ∨  T ∨ T ==> T
             수학에서는  F ∨  F ∨ F ==> F
         */
        
        int c=50, d=60, e=70;
        
        boolean bool1 = ( c > d ) && ( d < e ) && ( c == e );
                    //        F           스킵                        스킵
                    //  &&의 경우에는  처음 값이 F이면  뒤에 값은 연산 안하고 False
        System.out.println("bool1 => "+bool1); //bool1 => false
        
        boolean bool2 = ( c > d ) || ( d < e ) || ( c == e );
                    //        F            T            스킵             
                    //  ||의 경우에는  처음 값이 F여도 뒤에 T 나올 때까지 연산한다. 그 다음은 스킵
        System.out.println("bool2 => "+bool2); //bool2 => false
        
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
        
        //한 개 있는 논리연산자는 스킵이 없다.
        boolean bool3 = ( c > d ) & ( d < e ) & ( c == e );
                    //        F           T            F             
                    //  &의 경우에는 다 연산하고 False
        System.out.println("bool3 => "+bool3); //bool3 => false
        boolean bool4 = ( c > d ) | ( d < e ) | ( c == e );
                    //        F           T            F             
                    //  |의 경우에는 다 연산하고 True
        System.out.println("bool4 => "+bool4); //bool4 => true
        
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
        
        //조건이 참일 때만, 실행해야할 명령을 구동한다.
        //조건이 거짓일 때는 구동 안 함 
        
        int n1=10;
        
        if(n1 < 20) {
            System.out.println(">> n1은 20보다 작습니다.");
        }
    
// 퀴즈풀이        
        System.out.println("\n~~~~~ 퀴즈1 ~~~~~~\n");
        
        //퀴즈1의 처음 문제는 &, 두번째 문제는 &&
        
        int i=1;    
        int j=i++;  
        
        //논리연산에 ()의 계산에 의한 i와 j 값이 변한다. 앞 ()에 의해 변경된 값이 뒤 ()의 연산에 영향을 미침
        //논리연산에 의한 if()값이 false이면 {}의 값을 실행하지 않는다.
        //false여서 {} 값을 수행하지 않더라도 ()에 의한 실행 값이 보존
        
        if( (i > ++j) & (i++ == j) ) {  
             i=i+j;
        }
              
        System.out.println("i="+i);  // i=3
              
        i=1;    
        j=i++;  
              
        if( (i > ++j) && (i++ == j) ) { 
            i=i+j;
        }
              
        System.out.println("i="+i);  // i=2
              
        System.out.println("\n~~~~~ 퀴즈2 ~~~~~~\n");
              
        int m1=0; 
        n1=1;
 
        if( (m1++ == 0) | (n1++ == 2)  ) {
             m1=42;   
        }
              
        System.out.println("m1=>"+m1 + ", n1=>"+n1); //m1=42, n1=2
 
              
        m1=0; 
        n1=1;
        if( (m1++ == 0) || (n1++ == 2) ) { 
             m1=42;   
        }
              
        System.out.println("m1=>"+m1 + ", n1=>"+n1); //m1=42, n1=1
 
// 4. 비교연산자   ==  !=  >  <  >=  <=
 
// 5. 할당연산자(연산 후 대입 연산자)
        int no = 1;
        no+=3; // no = no+3; no에 3을 더해주고 대입한다
        System.out.println("no = "+no); //no=4
        no-=2; // no = no-2; no에 2를 빼고 대입한다
        System.out.println("no = "+no); //no=2
        no*=5; // no = no*5; no에 5를 곱하고 대입한다
        System.out.println("no = "+no); //no=10
        no/=4; // no = no/4; no에 4를 나눈 몫을 대입한다
        System.out.println("no = "+no); //no=2
        no%=3; // no = no%3; no에 3을 나눈 나머지를 대입한다
        System.out.println("no = "+no); //no=2
        
// 6. 삼항연산자***
        /*
             변수선언 = (조건식)? 값1 : 값2;
             변수를 선언하고 나서 값을 부여하고자 할 때 사용되어지는데
             조건식이 참이라면 변수에 값1을 대입해주고, 
             만약에 조건식이 거짓이라면 변수에 값2를 대입해준다.
         */
        int num1=50, num2=60;
        int num3=(num1 > num2)?num1:num2;
        System.out.println("num3 => "+num3);  //num3 =>60
    }
}      
 
 cs

 

'Java' 카테고리의 다른 글

[Java] Scanner문, 유효성 검사  (0) 2021.01.11
[Java] Java의 설치와 기본 개념  (0) 2021.01.09
[Java] 데이터와 변수  (0) 2021.01.07
Java 별찍기 문제  (0) 2021.01.03
18 [인강] 자바의정석 ch08  (0) 2020.12.29
댓글