객체는 메모리에서 동적으로 생성되며, 객체가 더 이상 필요 없게 되면 GC(Gabage Collector)에 의해 제거됨

• Class로 부터 생성되는 객체는 모두 다른 메모리 공간에 존재
  • 해당 객체를 가르키 것은 주소인 래퍼런스
• 레퍼런스와 객체는 new keyword로 연결되어 있지만
  • null을 통해 끊으면 더 이상 레퍼런스는 객체를 가르키지 않음
• 가르키고 있지 않은 객체는 GC에 의해서 메모리 회수
  • 해당 레퍼런스도 객체의 속성과 메서드를 호출해서 접근할 수 없음
• null로 초기화된 레퍼런스는 사라지지 않음
  • new를 통해 동적으로 객체 생성 한 후 할당 연산자를 통해 다시 연결할 수 있음

2. 레퍼런스(가르킨다)

생성된 객체의 주소를 변수에 저장하는 것

3. 자료형이 같아도 다른 객체

자료형이 같아도 다른 공간에 존재하는 객체는 다른 객체

4. null과 NullPointException

레퍼런스에 null 저장되면 객체의 연결이 끊기며, 더 이상 객체를 이용할 수 없음. NullPointException 발생

메서드는 변수와 같이 선언 및 정의 후 필요시 호출하여 사용

메서드 선언 및 정의

StudentClass

//메서드 선언
public void getInfo() {
    // 메서드 정의
    System.out.println("-- getInfo() --");
}

• public void getInfo() : 메서드 선언부
  • public : 접근자
  • void : 반환 형
  • getInfo : 메서드 이름. 일반적으로 소문자로 시작
  • () : 매개변수
• { } : 메서드 정의

메서드 호출

Mainclass

StudentClass student1 = new StudentClass();        
student1.getInfo();

2. 매개변수(Parameter)

메서드를 호출할 때 데이터를 전달할 수 있음 필요시에만 정의됨

StudentClass

package basicGrammar;

public class StudentClass {

    public String name;
    public String gender;
    public int age;

    public StudentClass() {
        System.out.println("-- StudentClass Constructor --");
    }
    //매개변수
    public void setInfo(String n, String g, int a) {
        System.out.println("-- setInfo() --");

        this.name = n;
        this.gender = g;
        this.age = a;

    }

    public void getInfo() {
        System.out.println("-- getInfo() --");

        System.out.println("name :" + name);
        System.out.println("gender :" + gender);
        System.out.println("age :" + age);
    }

}

MainClass

package basicGrammar;

public class MainClass {

    public static void main(String[] args) {

        StudentClass student2 = new StudentClass();
        student2.setInfo("BBB", "M", 30);
        student2.getInfo();    
    }
}

출력
-- StudentClass Constructor --
-- setInfo() --
-- getInfo() --
name :BBB
gender :M
age :30

3. 중복 메서드 (Overloading)

이름은 같고. 매개변수의 개수 또는 타입이 다른 메서드 생성 가능

public void getInfo() {
    System.out.println("-- getInfo (1) --");
}
public void getInfo(int x, int y) {
    System.out.println("-- getInfo (2) --");
    System.out.println("parameter -> x : %d, y : %d\n", x,y);
}
public void getInfo(String s1, String s2) {
    System.out.println("-- getInfo (3) --");
    System.out.println("parameter -> s1: %s, s2 : %s\n", s1, s2);
}

4. 접근자

메서드를 호출할 때 접근자에 따라 호출이 불가

private void myNum() {
    System.out.println("-- myNum() --");
}

• 메서드 호출부는 객체의 private 메서드를 호출 할 수 없음
  • public 메서드는 호출 가능
• 객체 내에서는 private, public 메서드 모두 호출 가능

클래스는 맴버 변수(속성), 메서드(기능), 생성자 등으로 구성

package basicGrammar;

//클래스 이름 : Smartphone
public class Smartphone {

    //맴버 변수(속성)
    public String color;
    public String storage;
    public int price;

    // 생성자
    public Smartphone() {
        System.out.println("Smartphone constructor");
    }

    //매서드
    public void power() {
        System.out.println("--power on--");
    }


}

클래스

• 클래스의 이름은 일반적으로 첫글자는 대문자 ex) Smartphone
• 클래스 안에 멤버 변수, 메서드, 생성자 등이 있음

  맴버 변수

• 일반적으로 맴버 변수를 생성 ex) color, storage, price

  생성자

• 생성자는 클래스와 이름이 동일하고 반환형이 없음
• 외부에서 해당 클래스를 통해 객체를 만들 때 가장 먼저 호출
• 생성을 할 때 필요한 내용을 기술
  • 만약 생성시 필요한 내용이 없다면 빈값도 가능

메서드

• 메서드에서 void는 반환되는 자료형
  • power()라는 기능을 수행 후 반환 값이 없음을 의미
• 만약에 반환 값이 있다면

    public Strinf power() {
        System.out.println("--power off--");
            return "Hello";
    }

객체 생성

클래스로부터 'new'를 이용해서 객체를 생성

여러 객체를 생성해 보자!

• 클래스 Smartphone

  package basicGrammar;
  

public class Smartphone {

public String color;
public String storage;
public int price;

public Smartphone() {
    System.out.println("Smartphone constructor");
}

public void power() {
    System.out.println("--power on--");
}

public void off() {
    System.out.println("--power off--");
}

public void info() {
    System.out.println("--info()--");
    System.out.println("color : " + color);
    System.out.println("storage : " + storage);
    System.out.println("price : " + price);
}

}

 - MainClass
 ```java
 package basicGrammar;

public class MainClass {

    public static void main(String[] args) {

        Smartphone myPhone1 = new Smartphone();
        // 속성
        myPhone1.color = "black";
        myPhone1.storage = "128GB";
        myPhone1.price = 100;
        // 기능
        myPhone1.power();
        myPhone1.off();
        myPhone1.info();


        Smartphone myPhone2 = new Smartphone();
        // 속성
        myPhone2.color = "gray";
        myPhone2.storage = "258GB";
        myPhone2.price = 120;
        // 기능
        myPhone2.power();
        myPhone2.off();
        myPhone2.info();
    }
}

출력
Smartphone constructor
--power on--
--power off--
--info()--
color : black
storage : 128GB
price : 100
Smartphone constructor
--power on--
--power off--
--info()--
color : gray
storage : 258GB
price : 120

여러 생성자를 생성해 보자!

• 클래스 Television

  package basicGrammar;
  

public class Television {

public String color;
public int price;

//생성자
public Television() {
    System.out.println(" Television constructor --1 ");
}

// 생성과 동시에 객체의 속성을 정할 수 있음
public Television(String c, int p) {
    System.out.println(" Television constructor --2");
    this.color = c;
    this.price = p;
}

public void info() {
    System.out.println(" -- info() -- ");
    System.out.println("color : " + color);
    System.out.println("price : " + price);
}

}

- MainClass
```java
package basicGrammar;

public class MainClass {

    public static void main(String[] args) {

        Television myTelevision1 = new Television();
        //속성
        myTelevision1.color = "white";
        myTelevision1.price = 200;
        //기능
        myTelevision1.info();


        Television myTelevision2 = new Television("red", 250);
        //기능
        myTelevision2.info();

        // 재초기화
        myTelevision2.color = "ivory";
        myTelevision2.info();
    }
}

출력
 Television constructor --1 
 -- info() -- 
color : white
price : 200
 Television constructor --2
 -- info() -- 
color : red
price : 250
 -- info() -- 
color : ivory
price : 250

세상에 존재하는 모든 것 프로그래맹에서는 속성과 기능을 가지는 프로그램 단위

클래스란

객체를 생성하기 위한 틀로 모든 객체는 클래스로 부터 생성 ex. 핸드폰 - 주문에 따라 색상 및 용량 선택하여 생산

클래스의 구성요소

클래스는 속성(맴버 변수)와 기능(메서드)로 구성

예, 자전거

• 속성(맴버 변수)
  • 안장, 핸들, 바구니, 기어, 페달
• 기능(메서드)
  • 기속 변속, 가속, 브레이크

특정 조건에 따라 반복적으로 진행

• for/while문 : 조건이 참일 때까지 반복 수행

2. for 문

for(int i = 0; i < 5; i++) {} i가 1부터 5보다 작을 때 까지 i에 1씩 더해가며 진행

package basicGrammar;

import java.util.Scanner;

public class Variable {

    public static void main(String[] args) {
        System.out.print("숫자를 입력해주시오 : ");
        Scanner inputData = new Scanner(System.in);
        int result = inputData.nextInt();

        for (int i = 1; i < 5; i++) {
            System.out.printf("%d * %d = %d \n", result, i, (result * i));
        }
        inputData.close();
    }
}

출력
숫자를 입력해주시오 : 8
8 * 1 = 8 
8 * 2 = 16 
8 * 3 = 24 
8 * 4 = 32 

3. while문

while(num1 < 10) {} num1이 10보다 작을때 까지 진행(true일 때) 조건식이 false가 되면 반복 멈춤

package basicGrammar;

import java.util.Scanner;

public class Variable {

    public static void main(String[] args) {
        System.out.print("숫자를 입력해주시오 : ");
        Scanner inputData = new Scanner(System.in);
        int result = inputData.nextInt();
        int i = 1;

        while (i < 5) {
            System.out.printf("%d * %d = %d \n", result, i, (result * i));
            i++;
        }

        inputData.close();
    }
}

출력
숫자를 입력해주시오 : 4
4 * 1 = 4 
4 * 2 = 8 
4 * 3 = 12 
4 * 4 = 16 

4. do~while문

while문과 비슷하지만 조건 결과에 상관없이 무조건 최초 한번은 {...} 수행 후 while의 조건식이 true면 do의 {...}반복 수행

package basicGrammar;

public class Variable {

    public static void main(String[] args) {
        do {
            System.out.println("조건 상관없이 1번은 실행");
        } while (false); //while문이 true만 실행
    }
}

출력
조건 상관없이 1번은 실행

조건의 결과에 따라 선택 진행

• 양자택일 : 주로 if문 사용
• 다자택일 : 주로 switch문 사용

2. if문

조건식이 참이면 실행 if, if else, if else if

package basicGrammar;

public class Variable {

    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 20;
        int num3 = 15;

        // if(조건식)
        if (num1 < num2) {
            System.out.println("num1이 num2보다 작다");
        }

        // if(조건식) else
        if (num2 < num3) {
            System.out.println("num2이 num3보다 작다");
        } else {
            System.out.println("num2이 num3보다 크거나 같다");
        }

        // if(조건식) else if(조건식)
        if (num1 < num2) {
            System.out.println("num1이 num2보다 작다");
        } else if (num1 > num2) {
            System.out.println("num1이 num2보다 크다");
        } else {
            System.out.println("num1과 num2가 같다");
        }
    }
}

출력
num1이 num2보다 작다
num2이 num3보다 크거나 같다
num1이 num2보다 작다

3. switch문

비교대상이 되는 결과값과 선택사항이 많을 경우

package basicGrammar;

import java.util.Scanner;

public class Variable {

    public static void main(String[] args) {
        System.out.print("점수를 입력하시오 : ");
        Scanner inputData = new Scanner(System.in);
        int score = inputData.nextInt();

        switch (score) {
            case 5:
            case 4:
                System.out.println("참 잘했어요");
                break;

            case 3:
                System.out.println("잘했어요");
                break;

            case 2:
            case 1:
                System.out.println("아쉽네요");
                break;

            default:
                System.out.println("다시 입력해주세요");
                break;
        }
        inputData.close();
    }
}

출력
점수를 입력하시오 : 4
참 잘했어요

배열을 구성하는 데이터의 자료형에 따라 배열의 메모리 크기가 결정됨

2. 배열을 가르키는 배열이름

변수는 기본 자료형 데이터를 담고 있고 배열 변수는 배열 데이터의 주소를 담고 있음

• 배열 안의 값인 100,200...은 배열 i에 들어있는 것이 아니라 각각 메모리에 들어가 있음
• 배열 i의 메모리는 별개로 존재하고 배열 i에는 배열의 첫번 째 인덱스 i[0]의 주소를 담고 있음

3. 배열 기본속성

package basicGrammar;

import java.util.Arrays;
import java.util.Scanner;

public class Variable {

    public static void main(String[] args) {
        int[] arr1 = {10, 20, 30, 40, 50};
        int[] arr2 = null;
        int[] arr3 = null;

        // 배열의 길이
        System.out.println("arr1.length : " + arr1.length);

        // 배열 요소 출력
        System.out.println("arr1 : " + Arrays.toString(arr1));

        //배열 요소 복사
        arr3 = Arrays.copyOf(arr1, arr1.length);
        System.out.println("arr3 : " + Arrays.toString(arr3));

        //배열 레퍼런스
        arr2 = arr1;
        System.out.println("arr1 : " + arr1);
        System.out.println("arr2 : " + arr2);
        System.out.println("arr3 : " + arr3);

    }
}

출력
arr1.length : 5
arr1 : [10, 20, 30, 40, 50]
arr3 : [10, 20, 30, 40, 50]
arr1 : [I@6d06d69c 
arr2 : [I@6d06d69c // 메모리 주소를 대입
arr3 : [I@7852e922 // 배열 요소만 복사로 주소가 다름

4. 다차원 배열

배열 안에 또 다른 배열이 존재

package basicGrammar;

import java.util.Arrays;

public class Variable {

    public static void main(String[] args) {
        int[][] arrMat = new int[3][2]; //3행 2열
        arrMat[0][0] = 1;
        arrMat[0][1] = 2;
        arrMat[1][0] = 10;
        arrMat[1][1] = 20;
        arrMat[2][0] = 100;
        arrMat[2][1] = 200;

        System.out.println("arrMat[0] : " + Arrays.toString(arrMat[0]));
        System.out.println("arrMat[1] : " + Arrays.toString(arrMat[1]));
        System.out.println("arrMat[2] : " + Arrays.toString(arrMat[2]));

    }
}

출력
arrMat[0] : [1, 2]
arrMat[1] : [10, 20]
arrMat[2] : [100, 200]

인덱스를 이용하여 자료형이 같은 데이터를 관리

배열의 선언 및 초기화

변수와 마찬가지로 선언과 초기화 과정을 거쳐 사용

package basicGrammar;

public class Variable {

    public static void main(String[] args) {
        // 배열 선언 후 초기화
        int[] arr1 = new int[3];
        arr1[0] = 10;
        arr1[1] = 20;
        arr1[2] = 30;

        System.out.println("arr1[0] : " + arr1[0]);
        System.out.println("arr1[1] : " + arr1[1]);
        System.out.println("arr1[2] : " + arr1[2]);

        // 배열 선언과 초기화 동시에
        int[] arr2 = {10, 20, 30};
        System.out.println("arr2[0] : " + arr2[0]);
        System.out.println("arr2[1] : " + arr2[1]);
        System.out.println("arr2[2] : " + arr2[2]);
    }
}

출력
arr1[0] : 10
arr1[1] : 20
arr1[2] : 30
arr2[0] : 10
arr2[1] : 20
arr2[2] : 30

배열을 이용한 학사관리

package basicGrammar;

import java.util.Scanner;

public class Variable {

    public static void main(String[] args) {
        String[] subject = {"국어", "수학", "영어"};
        int[] score = new int[3];
        Scanner scanner = new Scanner(System.in);

        System.out.printf("%s의 점수를 입력하시오 : ", subject[0]);
        score[0] = scanner.nextInt();

        System.out.printf("%s의 점수를 입력하시오 : ", subject[1]);
        score[1] = scanner.nextInt();

        System.out.printf("%s의 점수를 입력하시오 : ", subject[2]);
        score[2] = scanner.nextInt();

        System.out.printf("%s 점수 : \t%.2f\n", subject[0], (double)score[0]);
        System.out.printf("%s 점수 : \t%.2f\n", subject[1], (double)score[1]);
        System.out.printf("%s 점수 : \t%.2f\n", subject[2], (double)score[2]);

        double ave = (double)(score[0] + score[1] + score[2]) / 3;
        System.out.printf("----------------------\n평 점 : \t%.2f", ave);

        scanner.close();
    }
}

출력
국어의 점수를 입력하시오 : 80
수학의 점수를 입력하시오 : 90
영어의 점수를 입력하시오 : 100
국어 점수 :     80.00
수학 점수 :     90.00
영어 점수 :     100.00
----------------------
평 점 :     90.00

• 단항 연산자 : 피연산자가 하나 존재 ex) +x, -x, !x
• 이항 연산자 : 피연산자가 두개 준재 ex) x = y, x < y, x != y
• 삼항 연산자 : 피연산자가 세개 존재 ex) 조건식 : true ? false

대입 연산자

오른쪽의 결과를 왼쪽에 대입(할당)한다 = 오른쪽과 왼쪽이 같을 때 == 로 표현

산술 연산자

피연산자를 이용하여 +, -, *, /, % 등을 수행

package basicGrammar;

public class Variable {

    public static void main(String[] args) {
        int x = 1;
        int y = 2;

        // + 덧셈
        System.out.println("x + y = " + (x+y));

        // - 뺄셈
        System.out.println("x - y = " + (x-y));

        // * 곱셈
        System.out.println("x * y = " + (x*y));

        // / 나눗셈
        System.out.println("x / y = " + (x/y));

        // % 나머지
        System.out.println("x % y = " + (x%y));

    }
}

출력
x + y = 3
x - y = -1
x * y = 2
x / y = 0 // int형끼리의 연산으로 결과도 int로 표현
x % y = 1

복합 대입연산자

산술 연산자와 대입 연산자를 결합한 연산자

package basicGrammar;

public class Variable {

    public static void main(String[] args) {
        int x = 100;

        // + 덧셈
        System.out.println("x += 2 : " + (x += 2));

        // - 뺄셈
        x = 100;
        System.out.println("x -= 2 : " + (x -= 2));

        // * 곱셈
        x = 100;
        System.out.println("x *= 2 : " + (x *= 2));

        // / 나눗셈
        x = 100;
        System.out.println("x /= 2 : " + (x /= 2));

        // % 나머지
        x = 100;
        System.out.println("x %= 2 : " + (x %= 2));

    }
}

출력
x += 2 : 102
x -= 2 : 98
x *= 2 : 200
x /= 2 : 50
x %= 2 : 0

관계 연산자

두개의 피연산자를 비교하여 참/거짓의 결론을 돌출

package basicGrammar;

public class Variable {

    public static void main(String[] args) {
        int x = 10;
        int y = 20;

        // a > b : a가 b보다 크면 참
        System.out.println("x > y :" + (x > y));

        // a < b : a가 b보다 작으면 참
        System.out.println("x < y :" + (x < y));

        // a >= b : a가 b보다 크거나 같으면 참
        System.out.println("x >= y :" + (x >= y));

        // a <= b : a가 b보다 작거나 같으면 참
        System.out.println("x <= y :" + (x <= y));

        // a == b : a가 b보다 같으면 참
        System.out.println("x == y :" + (x == y));

        // a != b : a가 b보다 같지 않으면 참
        System.out.println("x != y :" + (x != y));

    }
}

출력
x > y :false
x < y :true
x >= y :false
x <= y :true
x == y :false
x != y :true

증감 연산자

1만큼 증가 하거나 감소를 수행

package basicGrammar;

public class Variable {

    public static void main(String[] args) {
        int x = 10;

        // ++a : 1만크 증가 후 출력
        System.out.println("++x : " + (++x));

        // --a : 1만큼 감소 후 출력
        x = 10;
        System.out.println("--x : " + (--x));

        // a++ : 출력 후 1만큼 증가
        x = 10;
        System.out.println("x++ : " + (x++));
        System.out.println("x : " + x);

        // a-- : 출력 후 1만큼 감소
        x = 10;
        System.out.println("--x : " + (x--));
        System.out.println("x : " + x);

    }
}

출력
++x : 11
--x : 9
x++ : 10
x : 11
--x : 10
x : 9

논리 연산자

피연산자의 논리곱(AND), 논리합(OR), 논리부정(NOT) 수행

package basicGrammar;

public class Variable {

    public static void main(String[] args) {
        boolean b1 = false;
        boolean b2 = true;

        // && 논리곱(AND) : 모두 참이면 참
        System.out.println("b1 && b2 : " + (b1 && b2));

        // || 논리합(OR) : 하나라도 참이면 참
        System.out.println("b1 || b2 : " + (b1 || b2));

        // ! 논리부정(NOT) 상태 부정
        System.out.println("!b1 = " + (!b1));
        System.out.println("!b2 = " + (!b2));


    }
}

출력
b1 && b2 : false
b1 || b2 : true
!b1 = true
!b2 = false

조건(삼항) 연산자

삼항 연산자로 두개의 피연산자 연산 결과에 따라 나머지 피연산자가 결정

package basicGrammar;

public class Variable {

    public static void main(String[] args) {
        int x = 10;
        int y = 20;
        int result = 0;

        // 조건식 ? 참일 때 : 거짓일 때
        result = (x > y) ? 100 : 200;
        System.out.println("result : " + result);

        result = (x < y) ? 100 : 200;
        System.out.println("result : " + result);

        result = (x == y) ? 100 : 200;
        System.out.println("result : " + result);

    }
}

출력
result : 200
result : 100
result : 200

비트 연산자

데이터를 bit단위로 환산하여 연산을 수행 다른 연산자보다 연산 속도가 향상

package basicGrammar;

public class Variable {

    public static void main(String[] args) {
        int x = 2; // bit : 00000010
        int y = 3; // bit : 00000011

        // & : AND 연산, 모두 1이면 1
        System.out.println("x & y : " + (x & y));

        // | : OR 연산, 하나라도 1이면 1
        System.out.println("x | y : " + (x | y)); 

        // ^ : XOR 연산, 서로 같지 않으면 1
        System.out.println("x ^ y : " + (x ^ y));
    }
}

출력
x & y : 2 // 00000010
x | y : 3 // 00000011
x ^ y : 1 // 00000001

일반 문자가 아닌 특수한 목적으로 사용되는 문자

package basicGrammar;

public class Variable {

    public static void main(String[] args) {
        // \t : 탭
        System.out.println("탭을\t사용");

        // \n : 줄 바꿈
        System.out.println("개행\n사용");

        // \' : 작은 따움표
        System.out.println("\'작은 따움표\' 사용");

        // \" : 큰 따움표
        System.out.println("\"큰 따움표\" 사용");

        // \\ : 역슬래시 
        System.out.println("역슬래쉬\\ 사용");

    }
}

출력
탭을    사용
개행
사용
'작은 따움표' 사용
"큰 따움표" 사용
역슬래쉬\ 사용

서식 문자

일반 문자가 아닌 서식에 사용되는 문자

package basicGrammar;

public class Variable {

    public static void main(String[] args) {

        System.out.println("println은 자동 개행이 됩니다");

        // 서식 문자는 printf() 메서드 이용
        System.out.printf("서식 문자 중 %d진수를 사용해 보겠습니다.\n", 10);
        System.out.printf("여러 서식 문자 %d, %d 도 가능합니다\n", 10, 20);

        // 10진수, 8진수, 16진수
        int num1 = 40;
        System.out.printf("num1의 10진수: %d\n", num1);
        System.out.printf("num1의 8진수: %o\n", num1);
        System.out.printf("num1의 16진수: %x\n", num1);

        // 문자 & 문자열
        System.out.printf("책은 영어로 %s라고 합니다\n", "Book");

        // 실수
        double d = 3.14;
        System.out.printf("d = %f", d);
    }
}

출력
println은 자동 개행이 됩니다
서식 문자 중 10진수를 사용해 보겠습니다.
여러 서식 문자 10, 20 도 가능합니다
num1의 10진수: 40
num1의 8진수: 50
num1의 16진수: 28
책은 영어로 Book라고 합니다
d = 3.140000

서식 문자의 정렬과 소수점 제한

package basicGrammar;

public class Variable {

    public static void main(String[] args) {
        // 왼쪽 정렬
        System.out.printf("%d\n", 123);
        System.out.printf("%d\n", 1234);
        System.out.printf("%d\n", 12345);

        // 오른쪽 정렬, 5칸이 미리 생성되어있음
        System.out.printf("%5d\n", 123);
        System.out.printf("%5d\n", 1234);
        System.out.printf("%5d\n", 12345);

        // 소수점 제한
        System.out.printf("%f\n", 3.14);
        System.out.printf("%.0f\n", 3.14);
        System.out.printf("%.1f\n", 3.14);
        System.out.printf("%.2f\n", 3.14);
        System.out.printf("%.3f\n", 3.14);

    }
}

출력
123
1234
12345
  123
 1234
12345
3.140000
3
3.1
3.14
3.140

데이터가 변수에 직접 저장

• 정수형

  • byte(1byte) : 8bit로 -128~128까지만 표현 가능
  • char(2byte) : 단일 문자 하나 ex)A, b, c 문자라도 아스키코드로 변환하기에 정수형에 포함
  • short(2byte) : 정수를 표현하지만 큰 수를 담을 수 없음
  • int(4byte) : 32bit로 일반적으로 가장 많이 사용
  • long(8byte) : 매우 큰 숫자까지 표현 가능

• 실수형

  • float(4byte) : 소수점과 같이 실수를 표현
  • double(8byte) : float보다는 double을 더 많이 사용

• 논리형

  • boolean(1byte) : 참과 거짓

package basicGrammar;

public class Variable {

    public static void main(String[] args) {
        char c = 'x'; // 문자
        System.out.println("c = " + c);

        int i = 20; // 정수
        System.out.println("i = " + i);

        double d = 3.14; // 실수
        System.out.println("d = " + d);

        boolean b = false; // 블리언
        System.out.println("b = " + b);
    }
}

출력
c = x
i = 20
d = 3.14
b = false

객체 자료형

갹체 메모리 주소가 변수에 저장 C계열에서는 포인터, java에서는 래퍼런스라고 한다

• 문자열
  • String(4byte) : 문자열 표현 ex) ABCD, abCd

package basicGrammar;

public class Variable {

    public static void main(String[] args) {
        String txt = "Hello java world";
        System.out.println("txt = " + txt);
    }
}

출력
txt = Hello java world

형 변환

- 자동적 형 변환, 묵시적 형 변환

작은 공간의 메모리에서 큰 공간의 메모리로 이동

package basicGrammar;

public class Variable {

    public static void main(String[] args) {
        byte a = 10;
        int b = a;
        System.out.println("b = "+ b);

    }
}

출력
b = 10

- 명시적 형 변환

큰 공간의 메모리에서 작은 공간의 메모리로 이동

package basicGrammar;

public class Variable {

    public static void main(String[] args) {
        int intVar = 100;
        byte byteVar = (byte)intVar;
        System.out.println("byteVar = " + byteVar);

        intVar = 12345;
        byteVar = (byte)intVar;
        System.out.println("byteVar = " + byteVar );
    }
}

출력
byteVar = 100
byteVar = 57 //데이터 손실 발생

말 그래도 변하는 수, 데이터를 임시로 담을 수 있는 메모리 공간

변수 선언, 값 대입

변수의 자료형(형태)를 선택하고 이름을 정하는 것

package basicGrammar;

public class Variable {

    public static void main(String[] args) {
        int i // 정수형 변수 i를 선언
        i = 100; // i 변수에 값 100 대입
        System.out.println("i = " + i); // i 출력

    }
}

변수 초기화

변수에 처음 값을 대입하는 것 변수 선언과 동시에 또는 선언 이후 대입할 시점에 초기화 가능

package basicGrammar;

public class Variable {

    public static void main(String[] args) {
        int i = 10 ; // 선언과 동시에 초기화
        int j; // 선언 후
        j = 100; // 초기화
        System.out.println("i + j = " + (i+j));

    }
}

변수 데이터 변경

선언은 한번만, 값은 언제나 변경 가능

package basicGrammar;

public class Variable {

    public static void main(String[] args) {
        int i = 10; // 선언과 동시 초기화
        System.out.println("i = "+ i);

        i = 100; // 값 변경
        System.out.println("i = "+ i);        
    }
}