디바이스 융합 자바(Java) day01 - 변수,자료형,연산자

Java의 기본 단위

     : Class 클래스

          >> 01day 사용 불가

          >> day01 사용 가능

 - 숫자를 앞에 사용하는 것 불가

        >> 클래스는 앞글자를 대문자로 작성 ex ) Day01

        >> 메서드(함수), 변수, 객체, ... 와 반대되는 것이 클래스

 

y = f(x)라고 했을 때, 

x : 인자, 인수, 매개변수, argument(args), input, 입력값, 파라미터

y : output, 결과값, 출력값, return, 반환값,리턴값

 

10 = age;

틀린 이유

1) 대입 연산자 규칙에 맞지 않는다( 오른쪽 값을 왼쪽에 대입한다는 대입연산자의 규칙)

2) 식별자의 이름 규칙(숫자가 먼저 오지 못한다)

 

4byte : 32bit

1byte : 8bit

 

int num = 12

00000000 00000000 00000000 00001100

 

package day01;  // 디폴트 패키지 xxx

public class Test01 {

}

 

- 디폴트 패키지는 만들지 않는 것이 좋다. 만들지 않아도 생성은 되지만 패키지 내에 넣어서 하는 것을 추천!

---------------------------
package class04;

public class Test03 { 

       // "메인공간 -> 메인함수"
       public static void main(String[] args) {
             System.out.println("안녕하세요!");
       } 
       // public 공개범위
       // static "객체와 무관하게"
       // C언어 자료형, JAVA 변수
       // void 공백(無) => y
       // main 함수 => f(x) <= main(String[] args)

       //  ctrl+S -> 실행
       // 주석 ★★★★ 줄 정렬
       // "코딩, 프로그래밍" -> "유지보수"
       /*
       줄바꿈
       이렇게도
       가능하다!
        */
}

 

- 주석을 달아 놓는 것을 습관화하자!

- 나중에 누가 봐도 편할 수 있도록 기억해 놀 것!
--------------------------

package class04;

public class Test04 {
       public static void main(String[] args) {

             System.out.println("Hello");
             System.out.print("Hello");
             System.out.println("안녕하세요!"); // newLine 줄 바꾸기 = ln
       }
}

- 출력하는 방법! 

- System.out.println()  << 기본적인 방법

- System.out.print() << 줄을 띄우지 않는 출력방법, 띄우고 싶으면 "\n"을 써서 넣기

-----------------------------
package class05;

public class Test05 {
       public static void main(String[] args) {
             // "줄 정렬" ctrl + A, ctrl + I

             // [변수와 자료형]
             // 기억 : 레벨 10 -> 공간(메모리)

             // 1) 공간
             // 2) 자료형(data type)
             //      int 정수 4byte 0 10 -100
             //      double 실수 8byte 3.14 -1.111 0.01 6.0
             //      char 문자 
             //      String 문자열
             //      boolean 진위형 true false
             // 3) 공간의 이름(주소를 기억하기 어렵기 때문에)
             // 4) 값 xxxxx

              // '점수'데이터를 저장하고 싶다... 변수를 생성해보자!
              // 정수
              // score
             double score = 90.0; // 변수명, 식별자(갈색) <-> 키워드, 예약어(붉은색(분홍색))
             // 값까지 정해주는 경우에는 변수를 초기화했다.

             // 변수를 생성했다(선언했다, 정의했다).
             int age=21; // 문법적으로 문제가 있다없다?
             // 초기화는 일반적으로 처음에 진행하자!

             // 식별자 이름규칙
             // 특수기호 x, 한글 x, 띄어쓰기 x, 숫자가 앞에 있으면 안됨

             System.out.println(age + "살 입니다><");

             // 연산자
             // +, -, * /
             // = 대입연산자
       }
}

 

- 줄을 정렬하기 위해서 "ctrl + A(all)" 한 후, "ctrl + I" 실행

- 변수를 만들기 위해 충족해야 하는 조건

   1) 공간

   2) 자료형(data type)

int	정수	4 byte
double	실수	8 byte
char	문자
String	문자열
boolean	진위형(true / false)

  3) 공간의 이름(주소를 기억하기 어렵기 때문에!)

  4) 값을 넣지 않아도 문법적으로 문제가 없지만 출력할 시에는 에러가 난다. 

 

- 변수명, 식별자는 갈색으로 표기

- 키워드, 예약어는 붉은색(혹은 핑크색)으로 표기

- 값을 직접 정해 넣어주는 것을 "변수를 초기화했다." 라고 지칭

        >> 변수를 초기화한다는 언어를 기억해 놓고 나중에 회사에서 초기화라고 하면

             진짜 초기화가 아닌 값을 지정해줄 것

        >> 초기화는 일반적으로 초기에 진행할 것

- 식별자의 이름 규칙

      >> 특수기호 불가

      >> 한글 불가

      >> 띄어쓰기 불가

      >> 숫자가 앞에 나오는 것 불가

 

- 연산자

   >> 기본적으로 +, -, *, / 존재

   >> 대입연산자인 = 도 존재

----------------------------------
package class05;

public class Test06 {
       public static void main(String[] args) {
             int a = 10;
             double b = 3.14;
             char c = 'a'; // 1글자
             String d = "apple"; // 문자열 "" 클래스(대문자)
             boolean e = true;

             a=1234;

             System.out.println(a);
             System.out.println(b);
             System.out.println(c);
             System.out.println(d);
             System.out.println(e);
       }
}

 

- char인 문자는 오직 한 글자만 포함( 한글 사용 불가)

  ' ' 를 이용함

- String은 문자열로 " "를 이용하여 값 초기화

  String의 색이 검고, 앞문자가 대문자인 이유는 클래스이기 때문

- 앞에서 a를 초기화 해주었지만 나중에 a의 값을 다시 지정해주면

  그 값으로 a값이 초기화 되어 결국 a값으로는 1234가 튀어나옴

-----------
package class06;

public class Test07 {
       public static void main(String[] args) {

             // 코드를 컴퓨터가 실행할 수 있는 형태로 번역해주는 친구
             // : 컴파일러
             int a = (int)3.14; // 형변환(타입캐스팅) : 명시적 형변환
             // 데이터 손실 발생여지가 있다!
             // 큰 데이터를 작은 곳에 넣을 때는 문제 발생

             double b = 5; // 자동 형변환
             // int를 double로 다 쓰게 되면
             // 공간 낭비는 물론 사람도 보기 힘들다.

             System.out.println(a);
             System.out.println(b);
       }
}

 

- 컴파일러 : 코드를 컴퓨터가 실행할 수 있는 형태로 번역해주는 것

 

- 위와 같이 double인 3.14를 int형으로 변환하는 것을 형변환이라고 하며

  double(8byte)에서 int(4byte)로 변환되는 것(큰 것에서 작은 것으로 변환)을 명시적 형변환이라고 함.

- 명시적 형변환의 경우 자동으로 되지 않기에 직접 입력해야 함

  ex) int a = (int)3.14;

- 하지면 명시적 형변환의 경우 큰 것에서 작은 것으로 변환되는 과정에서 데이터 손실 발생의 여지가 존재

- 즉 문제가 발생

 

- 하지만 double b = 5와 같이 작은 int형을 큰 double형으로 변환하게 되면 직접 입력하지 않아도 변환

  >> 이것을 자동 형변환이라고 함

- 그렇다고 int형을 다 double형으로 쓰게 되면 메모리 공간의 낭비가 발생함

- 당연히 사람도 보기 힘듬...(가독성)

-----------
package class06;

public class Test08 {
       public static void main(String[] args) {
             // 객체지향언어
             // C -> JAVA -> 파이썬(객체지향에 모든 것을 가진 것)
             // -> C언어에 객체지향언어 넣은 것이 C++, C#

             // Integer i = new Integer(10);
             // int num = 10; // 위와 아래가 같은 것
             //
             // String str = new String("apple");
             int num = 123;
             char ch = 'A'; // 아스키코드
             // 'a' -> 97 -> 2진수로 바뀌어서 저장
             // 'A' -> 65 -> 2진수로 바뀌어서 저장
             System.out.println(num);

             int a = 'a';
             System.out.println(a);

             char b = 65;
             System.out.println(b);
       }
}

 

- Java는 객체지향언어

- C언어는 객체지향언어가 아니다.

   >> 객체지향언어를 넣은 것이 C++, C#

- C언어와 Java의 모든 것을 가진 것이 파이썬

- 원래의 필기 방식은 Integer i = new Integer(10); 이지만

                                  int i = 10; 으로 변환

        >> String str = new String("apple")로 작성(과거에)

        >> 요즘은 Integer, 혹은 String 방식을 쓰면 중간줄이 그어지면서 쓰지 않는 것을 권장함

 

- int에는 숫자를, 그리고 char에는 'a'와 같은 문자를 넣는 것이 일반적

- 하지만 int에 'a'를 넣게 되면 아스키코드로 인해 97이 출력

- 마찬가지로 char에 65를 넣게 되면 'A'가 출력 

-----------
package class07;

public class Test09 {
       public static void main(String[] args) {
             // 연산자
             // 대입 연산자
             // 산술 연산자

             int a = 10, b = 20;
             int num = a+b; // 두가지 액션을 한번에 처리할 수 없음
             // -> 연산자 우선순위
             // 대입 연산자의 우선순위가 낮기 때문!
             // 연산자 우선순위를 생각하지 않고 진행했기 때문이다.

             double score = (10 + 20 + 31)*1.0/3;
             // 가독성을 위해
             // double score = (10 + 20 + 31)/3.0; 가능하지만 가독성이 좋지 않음
             System.out.println(score);

             System.out.println(10/3); // / 몫, INT 연산자
             System.out.println(10%3); // % 나머지, MOD 연산자
       }
}

 

- 연산자에는 대입연산자와 산술연산자 존재

- int num = a + b;와 같이 두 가지 액션을 한번에 처리 가능

- a + b가 먼저 진행된 후 num에 대입

 

- double score = (10 + 20 + 31)/3; 을 진행하게 되면 소수점은 나오지 않고 정수.0 값이 나온다.

- 연산자 우선순위로 보면 산술연산자가 대입연산자보다 앞서기에 double 보다 정수값의 계산을 먼저 진행

- 그렇기에 정수로서 계산된 값은 소수점 값을 계산능력은 존재하지만

  소수점값을 갖지 못한 채 score에 대입되게 되고 실수값을 받은 score는 정수값.0으로 출력

- 전체 실수값으로 받고 싶으면 

  double score = (10 + 20 + 31) * 1.0 / 3;으로 작성하는 것이 좋다.

- 1.0을 빼고 3을 3.0으로 하는 것도 가능하지만 3으로 나눈다는 가독성을 상실해버리기에 

  / 앞에 쓰는 것이 좋다.

 

- / 는 몫, INT 연산자 값을 내놓는 연산자 

  ex ) 10 / 3 = 3

- % 는 나머지, MOD 연산자 값을 내놓는 연산자

  ex ) 10 % 3 = 1

-----------
package class07;

public class Test10 {
       public static void main(String[] args) {
             // 복합대입 연산자
             int a = 1000;
             int b = 2000;
             int c = 1500;
             int total = 0;

             total += a; // 연산자 2개, total 변수 공간을 2번 방문
             total += b; // -> 연산자가 1개, total 변수 공간을 1번 방문
             total += c; // total = total + c;

             System.out.println(total);
       }
}

 

- 복합대입연산자는 total = total + a;와 같이 같은 변수가 2개 존재하며 연산자도 2개 존재할 때 사용

- =과 +를 합하여 total += a;로 간단히 줄이는 것이 가능

-----------
package class07;

public class Test11 {
       public static void main(String[] args) {
             /*
             int num = 0;
             num = num + 1;
             System.out.println("num : " + num);
             num += 1;
             System.out.println("num : " + num);
             num++; // 증감연산자 -> 후위 증감연산자
             System.out.println("num : " + num);
             ++num; // -> 전위 증감연산자
             System.out.println("num : " + num);
             */

             int a = 10, b = 12;
             int c = a++; // "연산자 우선순위" 

             // 후위 증감연산자의 우선순위는 매우 낮음!
             // int c = a; a++;
             int d = ++a; // 전위 증감연산자의 우선순위는 매우 높음!
             // a++; int d = a;
             System.out.println("a : " + a);
             System.out.println("c : " + c);
             System.out.println("d : " + d);

             int num1 = 10;
             int num2 = 20;
             int res = num1++ + ++num2;
             System.out.println(num1 + " | " + num2 + " | " + res);

       }
}

 

- num = num + 1;을 쉽게 표현한 식이 num += 1; 이지만 이것보다 더 쉽게 표현 가능

    >> 그것이 num++;

    >> 1씩 증가하게 되면 ++ ,감소하게 되면 -- 사용

- 1을 우선적으로 증가시키는 연산자를 전위 증감연산자라고 하며 표시는 ++num;

   >> 전위 증감연산자는 우선순위가 매우 높음

- 1을 마지막에 증가시키는 연산자를 후위 증감연산자라고 하며 표시는 num++;

   >> 후위 증감연산자는 우선순위가 매우 낮음

 

*디버깅표

 

int c = a;
a++;

a      c       d
--------------------
10    10
11
12            12

 

 

num1   num2   res
-------------------------
10        20
           21  
                    31
11

 

-----------------------------------
package class07;

public class Test12 {
       public static void main(String[] args) {
             int a = 10;
             int b = ++a; // ++a; b=a;
             int c = b++; // c=b; b++;
             int d = ++b + ++c; // b++; c++; b+c;

             int a1 = 10;
             int b1 = --a1; // --a; b=a;
             int c1 = b1++; // c=b; b++;
             int d1 = b1-- + --c1; // --c; b+c; b--;

             System.out.println(a + " | " + b + " | " + c + " | " + d);
             System.out.println(a1 + " | " + b1 + " | " + c1 + " | " + d1);
       } 
}

 

디버깅표

1) 
int a = 10;
int b = ++a;
int c = b++;
int d = ++b + ++c;

a      b       c       d
-------------------------
10
11    11
               11
       12    
       13     12     25
                

2)
int a1 = 10;
int b1 = --a1;
int c1 = b1++;
int d1 = b1-- + --c1;

a1     b1      c1       d1
--------------------------
10
9       9
                  9
        10
                  8        18
         9
       

 

추가문제(6/8 풀이 및 편집 시 편집완료 작성) - day02 앞부분에 풀이

 

int a = 5;

int b = --a;

int c = a++ - b--;

syso(a);

syso(b);

syso(++c);

 

디버깅표

a            b             c

----------------------------

5

4            4

                            0

5            3

 

syso(a); // 5

syso(b); // 3

syso(c); // 1