국비 지원 개발자 과정 _Day 4

원시형 변수

char, byte, short, int, long, float, double-정수형, 실수형(크기가 다르다, 표현 범위가 다르다, scope가 다르다)

boolean-제어문에서 중요함(흐름을 다르게 할 때)-분기문(if, switch)

호출하면 값이 나온다.

원시형 변수에는 기본값이 있다.

원시형 변수를 초기화할 때는 대입 연산자를 사용한다.

변수의 사용목적은 일괄처리에 있다.

 

변수의 단점

원시형 변수는 한 번에 하나만 담을 수 있다.

 

전역 변수

선언부에 옴(클래스 선언 다음은 전부 선언부)

초기화 생략할 수 있다(생성자가 대신해줌, 클래스급으로 취급됨)

하지만 선언과 초기화를 두 줄로(따로) 입력해선 안된다.

인스턴스 변수.변수명으로 호출 가능하다.

 

지역변수

초기화를 생략할 수 없다!(stack에 저장되기에, 클래스급이 아니라서 생성자가 대신 못해줌)

하지만 선언과 초기화를 나누어 2줄로 표현할 수 있다.

인스턴스변수.변수명으로 호출 불가능!

 

정적 변수

 

참조형 변수

호출하면 주소 번지가 나온다.

package dev_java.ch01;

public class Variable2 {
  public static void main(String[] args) {
    System.out.println("소나타");
    System.out.println("소나타");
    System.out.println("소나타");
    System.out.println("==========");
    
    String carName = "카니발"; // 변수로 일괄처리 가능
    System.out.println(carName);
    System.out.println(carName);
    System.out.println(carName);
  }
}

// 소나타
// 소나타
// 소나타
// ==========
// 카니발
// 카니발
// 카니발

 

package dev_java.ch01;

public class Variable3 {
  public static void main(String[] args) {
    int i = 1;
    System.out.println(i);
    
    i = 3;
    System.out.println(i);
    
    i = 5;
    System.out.println(i); // 변수의 단점-한 번에 하나만 담을 수 있다.(오버라이트)
  }
}

// 1
// 3
// 5

 

package dev_java.ch01;

// 클래스 안에 여러개의 변수를 가질 수 있다.
/* 아래의 정보를 모두 담으려면 인스턴스화를 3번 해야한다.
* 부서번호   부서명   지역
*   10     개발1팀   부산
*   20     개발2팀  제주도
*   30      운영팀   서울
*/

public class DeptVO { // 전역변수 선언만 함(초기화를 하지 않았기에 디폴드값으로 설정됨)
  int deptNo; // 부서번호, 디폴트값 0
  String deptName; // 부서명, 참조형타입, 디폴트값 null
  String loc; // 지역명, 참조형타입, 디폴트값 null
}

 

package dev_java.ch01;

public class DeptVOMain {
  public static void main(String[] args) {
    DeptVO deptVO = new DeptVO(); // DeptVo클래스가 인스턴스화, 객체의 선언과 생성, Heap 영역에 생성됨
    deptVO.deptNo = 10;
    deptVO.deptName = "개발1팀";
    System.out.println(deptVO.deptNo); // 10
    System.out.println(deptVO.deptName); // 개발1팀
    System.out.println(deptVO.deptNo); // 10
    
    deptVO = new DeptVO(); // 변수 선언이 아니라(앞에 타입이 없기에 선언 아님!), 새로운 객체를 생성한 것!, 주소번지가 달라짐
    deptVO.deptNo = 30;
    deptVO.deptName = "개발2팀";
    System.out.println(deptVO.deptNo); // 30
    System.out.println(deptVO.deptName); // 개발2팀
    System.out.println(deptVO.loc); // null
  }
}

// 10
// 개발1팀
// 10
// 30
// 개발2팀
// null

 

//객체의 선언 -> 클래스명 + 객체변수명;
DeptVo deptVO;

//객체의 생성 -> 객체변수명 = new 클래스명;
deptVO = new DeptVO();

//객체의 선언과 생성 -> 클래스명 + 객체변수명 = new 클래스명;
DeptVO deptVO = new Deptvo();

//객체는 생성연산자 new를 사용해 생성시킨 후 사용
//객체 생성은 메모리에 객체의 요소를 저장할 공간(주소번지)이 배정됐다는 의미

 

변수 선언-같은 이름을 두 번 선언할 순 없다!(중복금지)

변수는 하나에 한 값밖에 담을 수 없다.

같은 DeptVO타입이기에 변수 타입, 수도 같음

deptVO(인스턴스 변수)가 DeptVO와 연결됐지만, 재정의되어 기존의 연결이 끊기고(주소 번지가 폐지되고) 새로운 DeptVO에 연결됨(주소 번지가 바뀜)→타입은 같지만 서로 다른 객체가 생성됨

 

package dev_java.ch01;

class Param {
  int ival; // non-static 전역변수(초기화 생략 가능-생성자가 해준다.),
}

public class TestParam {
  void effectParam(Param p) { // 메소드의 파라미터 자리(괄호 안)는 지역변수, Param p선언(초기화, 생성x), p는 원본주소번지 @abcd1234
    // 아래에 p = new Param()이 있으면 결과가 달라진다.(없을땐 같은 원본주소번지 @abcd1234이기에 둘 다 500이 나온다.)
    p = new Param(); // p의 주소번지는 @abcd1235!(새로운 p객체가 생성되어 다른 주소번지가 생성됨), int의 디폴트값 0
    p.ival = 500; // ival호출할 수 있지만 주소번지필요 -> 간접참조방식, 새로운 p객체(@abcd1235) 초기화, 500 덮어쓰기
    System.out.println("sub ival ===> " + p.ival); // 500, 새로운 p객체(@abcd1235)
  }

  public static void main(String[] args) { // 가장 먼저 호출(실행)되는 main메소드(main쓰레드), static은 하나(복사본을 갖지않음)
    TestParam tp = new TestParam(); // tp객체(effectParam메소드)가 생성, 호출은 아직
    Param p = new Param(); // 메인메소드 안에 있기에 지역변수, new로 p객체 생성
    p.ival = 100; // 초기화, 덮어쓰기해서 100
    tp.effectParam(p); // tp의 메소드 호출, p는 17줄에서 만든 객체(원본의 주소번지를 파라미터로 넘김 -> 주소번지 @abcd1234를 넘긴다)
    System.out.println("main ival ===> " + p.ival); // 100, 원본 p객체(@abcd1234)
  }
}

// sub ival ===> 500
// main ival ===> 100

 

파라미터를 활용하면 지역변수도 다른메소드에서 사용할 수 있다.

 

TestParam.java안에 Param.class와 TestParam.class존재 →둘 다 public일순 없다

 

private(나만 가능) < protected(패키지가 다르더라도 상속관계에 있다면 접근 가능) <    (freindly, 아무것도 없는 상태, 같은 패키지 안에서만 접근 가능) < public(누구나 가능)

package dev_java.ch01;

class Object {
  int val;
}

public class TestObject {
  void methodObj(Object o) {
    o = new Object();
    o.val = 500;
    // o = new Object();
    System.out.println("sub o.val의 값: " + o.val);
  }

  public static void main(String[] args) {
    TestObject tobj = new TestObject();
    Object obj = new Object();
    obj.val = 100;
    tobj.methodObj(obj);
    System.out.println("main o.val의 값: " + obj.val);
  }
}

// 9,11번 모두 주석이면-sub 500, main 500
// 9만 주석이면-sub 0, main 500
// 11만 주석이면-sub 500, main 100
// 19줄이 주석이면-main 100

 

()생략가능 / []생략불가능

(접근 제한자) (static) [리턴 타입-void, int, double, Param 등] [이름] [(파라미터-생략도가능)]

 

package dev_java.ch01;

public class Example {
  void methodA() { // 반환x
  }

  int methodB() { // 반환값(리턴타입) int
    return 2; // 상수 int
  }

  double methodC() { // 반환값(리턴타입) double
    return 2.5; // 상수 double
  }

  boolean methodD() { // 반환값(리턴타입) boolean
    return false; // 상수 boolean
  }

  boolean isView0() { // 반환값(리턴타입) boolean(bool)
    boolean bool = false;
    return bool; // 변수
  }

  boolean isView1() { // 반환값(리턴타입) boolean(bool)
    boolean bool = true;
    return bool; // 변수
  }

  String getName() { // 반환값(리턴타입) String(name)
    String name = "이순신";
    return name; // 변수
  }

  public static void main(String[] args) {
    Example ex = new Example();
    // int x = ex.methodA(); // 해당 메소드의 반환타입이 void이기에 이렇게 사용 불가!
    int y = ex.methodB();
    // System.out.println(ex.methodA()); // 해당 메소드의 반환타입이 void이기에 이렇게 사용 불가!
    System.out.println(ex.methodB());
  }
}

 

package dev_java.ch01;

// lava.lang폴더에 없는 클래스는 모두 import문을 작성함
import javax.swing.JFrame;

public class LoginView {
  public static void main(String[] args) {
    // 윈도우 운영체제 안에서 창을 만들어 띄울 때 사용하는 클래스 JFrame
    JFrame jf_login = new JFrame();
    // 로그인창의 가로길이를 담는 변수 선언
    int width = 300;
    width = 500;
    // 로그인창의 세로길이를 담는 변수 선언
    int height = 200;
    // 내가 만든 창의 타이틀바에 문자열 찍기
    jf_login.setTitle("로그인 화면 Ver1.0");
    // 내가 만든 창의 가로, 세로 크기를 정해주는 메소드 호출
    jf_login.setSize(width, height);
    Example ex = new Example();
    // 내가 만든 창을 화면에 활성화 또는 비활성화
    jf_login.setVisible(ex.isView1());
  }
}

 

package dev_java.ch01;

public class Method1 {
  // 파라미터 자리는 비워두거나 원시형을 쓰거나 참조형도 올 수 있다.
  // 파라미터 자리는 호출하는 곳에서 결정이 된다.
  // 파라미터 자리에 변수는 메소드가 호출될 때 결정된다.
  // 메소드 호출은 main 메소드 안에서 해야 호출된다.
  // 메소드의 파라미터 자리는 오직 선언만 가능하다.(초기화는 불가능!)
  
  void m(int i) { // 파라미터 자리에는 사용자가 입력한 값이 담긴다.(호출될 때 결정'초기화됨)
    i = i + 2; // 7
    System.out.println(i + 3); // 10
  } // end of m

  void m() {
  }

  double m1(double d) {
    return 3.5;
  } // end of m1

  public static void main(String[] args) {
    // Method1 클래스안에 정의된 메소드만 호출이 가능하다.
    Method1 method1 = new Method1();
    // 자바에서는 같은 이름의 메소드를 중복선언할 수 있다.
    // 단 파라미터의 개수가 다르거나, 타입이 다를때만 가능하다.(메소드 오버로딩)
    method1.m(5); // 메소드 호출, int이기에 실수형은 적을 수 없지만 2.0까진 쓸 수 있다.
  } // end of main
}

// 10

 

package dev_java.ch01;

public class Method2 {
  // void일때와 반환형이 있을 때 출력하는 방법이 다르다.

  double m1(double d) {
    // return 3.5; // 상수를 반환했으니 항상 3.5만 반환된다.
    return d; // 변수를 반환했으니 변수 d의 값이 반환된다.
  }

  void m2(int i) {
    System.out.println(i);
  }

  public static void main(String[] args) {
    Method2 method2 = new Method2();
    // 메소드 내부에 출력하는 문장이 없는 경우, 외부의 메소드에서
    // 해당 메소드의 값을 출력하려면 반환형이 필요하다.
    double result = method2.m1(1.5);
    System.out.println(result); // 1.5
    System.out.println(method2.m1(1.5));

    method2.m2(3);
    // int result2 = method2.m2(3); // void 메소드는 사용 불가, 반환할 수 없음!
    // System.out.println(method2.m2(3)); // void 메소드는 사용 불가, 반환할 수 없음!
  }
}

// 1.5
// 1.5
// 3

 

package dev_java.ch01;

// static은 메소드 이름 앞에도 올 수 있고
// 변수명 앞에도 올 수 있다.

public class Pride {
  // 자동차 이름
  static String carName = "2023년형 프라이드"; // static이기에 인스턴스화 없이도 호출가능
  // 자동차 색상
  String carColor = "흰색"; // static이 없기에 static이 있는 main메소드에서 호출하려면 인스턴스화를 해야한다.
  // 바퀴수를 담는 변수 선언
  int wheelNum = 4;

  // 에러에는 두 가지가 있다.
  // 문법 에러, 런타임 에러(Exception)

  public static void main(String[] args) {
    // 변수이름 앞에 static이 있으면 인스턴스화 없이도 호출이 가능하다.
    // 이 말은 같은 객체를 복제하지 않는다는 의미가 포함된다.
    System.out.println(carName);

    // 인스턴스화(Pride객체가 메모리에 상주) -> 호출이 가능한 상태
    Pride myCar = new Pride();// Pride타입의 myCar 인스턴스 변수
    System.out.println(myCar); // Pride@5e91993f
    myCar.carColor = "보라색";

    myCar = null; // 클래스, 객체들은 초기값이 null이다.(주소번지가 가리키는 객체는 사라졌지만 타입은 남아있다.)
    System.out.println(myCar); // null
    // 이 줄에서는 자동차 색상을 호출, 출력할 수 없음
    // null값으로 객체와의 연결이 끊어졌기에 NullPointerException 에러

    myCar = new Pride(); // 새로운 주소번지를 갖는다
    System.out.println(myCar); // Pride@1c4af82c
    System.out.println(myCar == myCar); // True

    // myCar.carColor = "검정색";
    System.out.println(myCar.carColor); // 전역변수 carColor 호출
    myCar.carColor = "검정색";
  }
}

// 2023년형 프라이드
// dev_java.khexample.Test@5e91993f
// null
// dev_java.khexample.Test@1c4af82c
// true
// 흰색

 

package dev_java.ch01;

public class PrideMain {
  public static void main(String[] args) {
    Pride myCar = new Pride();
    System.out.println(myCar); // @1c4af82c
    
    Pride herCar = new Pride();
    System.out.println(herCar); // @379619aa

    herCar = myCar;
    System.out.println(myCar); // @1c4af82c
    System.out.println(herCar); // @1c4af82c

    System.out.println(myCar == herCar);
  }
}

 

package dev_java.ch01;

public class Pride1 {
  int speed = 0; // 현재 나는 전시장에 서있어요

  int speedUp() {
    speed = speed + 1;

    System.out.println("speedUp메소드 안에서 : " + speed); // 1
    return speed;
  }

  public static void main(String[] args) {
    Pride1 myCar = new Pride1();
    myCar.speedUp();

    System.out.println("main 메소드 안에서 : " + myCar.speed); // 1
  }
}

// speedUp메소드 안에서 : 1
// main 메소드 안에서 : 1

 

package dev_java.ch01;

public class Pride2 {

  int speedUp(int speed) {
    speed = speed + 1;

    System.out.println("speedUp메소드 안에서 : " + speed); // 1
    return speed;
  }

  public static void main(String[] args) {
    Pride2 myCar = new Pride2();
    myCar.speedUp(0);
  }
}

// speedUp메소드 안에서 : 1

 

package dev_java.ch01;

public class String1 {
  public static void main(String[] args) {
    // String 클래스는 new를 사용하지 않고 객체를 생성하면
    // 이미 같은 값이 존재할 때 기존의 값을 참조한다.
    // 참조형 타입인 경우에만 주소번지를 비교할 수 있다.
    // 원시형 변수는 주소번지를 비교할 수 없다.
    // 참조형 변수는 new를 사용하므로 무조건 새로운 객체가 생성된다.
    String s1 = "안녕";
    String s2 = "안녕";
    String s3 = new String("안녕");
    String s4 = new String("안녕");

    // s1과 s2의 주소번지는 같을까? true
    System.out.println(s1 == s2);

    // s3과 s4의 주소번지는 같을까? false
    System.out.println(s3 == s4);

    // s3의 문자열이 s4와 같을까? true
    System.out.println(s3.equals(s4));
  }
}