SFTP 접속하는 라이브러리는 jsch 다.

sftp: <http://www.jcraft.com/jsch/>

내서버에서 다른 서버 22번 sftp 접속하는 방법이다.

public class FTPUtil {

	private static Log logger = LogFactory.getLog(FTPUtil.class);

    private Session session = null;
    private Channel channel = null;
    private ChannelSftp channelSftp = null;

   // SFTP 서버연결
    public void connect(String user, String url, String password) throws Exception{

        logger.info(url);
        //JSch 객체 생성
        JSch jsch = new JSch();
        try {
            //세션객체 생성 ( user , host, port )
            logger.info("session");
            session = jsch.getSession(user, url);
            //password 설정
            session.setPassword(password);
            //세션관련 설정정보 설정
            java.util.Properties config = new java.util.Properties();
            //호스트 정보 검사하지 않는다.
            config.put("StrictHostKeyChecking", "no");
            session.setConfig(config);
            //접속
            session.connect();
            //sftp 채널 접속
            channel = session.openChannel("sftp");
            channel.connect();

        } catch (JSchException e) {
            logger.error("connect JSchException error : " +e.toString());
            throw new Exception("JSchException");
        } catch (Exception e) {
        	 logger.error("connect error : " +e.toString());
             throw new Exception(e.toString());
		}
        channelSftp = (ChannelSftp) channel;
    }

    // 단일 파일 업로드
    public void upload( String dir , File file){
        FileInputStream in = null;
        try{ //파일을 가져와서 inputStream에 넣고 저장경로를 찾아 put
            in = new FileInputStream(file);
            channelSftp.cd(dir);
            channelSftp.put(in,file.getName());
        }catch(SftpException se){
            se.printStackTrace();
        }catch(FileNotFoundException fe){
            fe.printStackTrace();
        }finally{
            try{
                in.close();
            } catch(IOException ioe){
                ioe.printStackTrace();
            }
        }
    }


    public ChannelSftp moveDirectory(String dir){
    	 try{ //경로탐색후 inputStream에 데이터를 넣음
             channelSftp.cd(dir); // 결로 이동
         }catch(SftpException se){
             se.printStackTrace();
         }
		return channelSftp;
    }

    /**
     *
     * @param dir  서버의 저장되어 있는 경로
     * @param fileNm 다운받으려는 파일명
     * @param saveDir 현 서버의 다운받으려고 하는 경로
     */
    public void download(String dir, String fileNm, String saveDir){
        InputStream in = null;
        FileOutputStream out = null;
        //String path = "...";
        try{ //경로탐색후 inputStream에 데이터를 넣음
            channelSftp.cd(dir); // 결로 이동
            in = channelSftp.get(fileNm);

        }catch(SftpException se){
        	logger.error("download " +se.toString());
        }
        try {
            out = new FileOutputStream(new File(saveDir));
            int i;
            while ((i = in.read()) != -1) {
                out.write(i);
            }

        } catch (IOException e) {
        	logger.error("download io error : " +e.toString());
        } finally {
            try {
                out.close();
                in.close();
            } catch (IOException e) {
            	logger.error("download close error : " +e.toString());
            }
        }

    }

    /**
     * 인자로 받은 경로의 파일 리스트를 리턴한다.
     * @param path
     * @return
     */
    public Vector<ChannelSftp.LsEntry> getFileList(String path, String lsCmd) {

    	Vector<ChannelSftp.LsEntry> list = null;
    	try {
    		channelSftp.cd(path);
    		list = channelSftp.ls(lsCmd);
		} catch (SftpException e) {
			e.printStackTrace();
			return null;
		}
    	return list;
    }

    // 파일서버와 세션 종료
    public void disconnect(){
        channelSftp.quit();
        session.disconnect();
    }
}

• 클래스 정의하는 방법
• 객체 만드는 방법 (new 키워드 이해하기)
• 메소드 정의하는 방법
• 생성자 정의하는 방법
• this 키워드 이해하기

클래스란

클래스는 쉽게 설명하면 객체를 만들기 위한 틀

붕어빵은 하나의 객체로 이를 만들기 위한 붕어빵틀은 하나의 클래스로 설명할 수 있다.

이런 클래스는 class라는 키워드로 정의되며 각각 변수(속성)와 메서드(행위)를 가지게 된다.

클래스 요소

• 필드(field) - 필드는 해당 클래스 객체의 상태 속성을 나타내며, 멤버 변수라고도 불린다. 여기서 초기화하는 것을 필드 초기화 또는 명시적 초기화라고 한다.

  • 인스턴스 변수 - 이름에서 알 수 있듯이 인스턴스가 갖는 변수이다. 그렇기에 인스턴스를 생성할 때 만들어진다. 서로 독립적인 값을 갖으므로 heap 영역에 할당되고 gc에 의해 관리된다.
  • 클래스 변수 - 정적을 의미하는 static키워드가 인스턴스 변수 앞에 붙으면 클래스 변수이다. 해당 클래스에서 파생된 모든 인스턴스는 이 변수를 공유한다. 그렇기 때문에 heap 영역이 아닌 static 영역에 할당되고 gc의 관리를 받지 않는다. 또한 public 키워드까지 앞에 붙이면 전역 변수라 볼 수 있다.

• 메서드(method) - 메서드는 해당 객체의 행동을 나타내며, 보통 필드의 값을 조정하는데 쓰인다.

  • 인스턴스 메서드 - 인스턴스 변수와 연관된 작업을 하는 메서드이다. 인스턴스를 통해 호출할 수 있으므로 반드시 먼저 인스턴스를 생성해야 한다.
  • 클래스 메서드 - 정적 메서드라고도 한다. 일반적으로 인스턴스와 관계없는 메서드를 클래스 메서드로 정의한다.
• 생성자(constructor) - 생성자는 객체가 생성된 직후에 클래스의 객체를 초기화하는 데 사용되는 코드 블록이다. 메서드와 달리 리턴 타입이 없으며, 클래스엔 최소 한 개 이상의 생성자가 존재한다.

• 초기화 블록(initializer) - 초기화 블록 내에서는 조건문, 반복문 등을 사용해 명시적 초기화에선 불가능한 초기화를 수행할 수 있다.

  • 클래스 초기화 블록 - 클래스 변수 초기화에 쓰인다.

  • 인스턴스 초기화 블록 - 인스턴스 변수 초기화에 쓰인다.

    클래스 변수 초기화: 기본값 → 명시적 초기화 → 클래스 초기화 블록
    인스턴스 변수 초기화: 기본값 → 명시적 초기화 → 인스턴스 초기화 블록 → 생성자

클래스 정의

class Class {               // 클래스
    String constructor;
    String instanceVar;     // 인스턴스 변수
    static String classVar; // 클래스 변수

    static {                // 클래스 초기화 블록
        classVar = "Class Variable";
    }

    {                       // 인스턴스 초기화 블록
        instanceVar = "Instance Variable";
    }

    Class() {                // 생성자
        constructor = "Constructor";
    }

    void instanceMethod() {       // 인스턴스 메서드
        System.out.println(instanceVar);
    }

    static void classMethod() {   // 클래스 메서드
        System.out.println(classVar);
    }
}

제어자 키워드

접근 제어자 - public, protected, default, private
그 외 - static, final, abstract, transient, synchronized, volatile etc.

• 접근 제어자 - 접근 제어자는 해당 클래스 또는 멤버를 정해진 범위에서만 접근할 수 있도록 통제하는 역할을 한다. 클래스는 public과 default밖에 쓸 수 없다. 범위는 다음과 같다. 참고로 default는 아무것도 덧붙이지 않았을 때를 의미한다.

• static - 변수, 메서드는 객체가 아닌 클래스에 속한다.

• final

  • 클래스 앞에 붙으면 해당 클래스는 상속될 수 없다.
  • 변수 또는 메서드 앞에 붙으면 수정되거나 오버라이딩 될 수 없다.

• abstract

  • 클래스 앞에 붙으면 추상 클래스가 되어 객체 생성이 불가하고, 접근을 위해선 상속받아야 한다.
  • 변수 앞에 지정할 수 없다. 메서드 앞에 붙는 경우는 오직 추상 클래스 내에서의 메서드밖에 없으며 해당 메서드는 선언부만 존재하고 구현부는 상속한 클래스 내 메서드에 의해 구현되어야 한다. 상속과 관련된 내용은 6주차에 다룰 예정이다.
• transient - 변수 또는 메서드가 포함된 객체를 직렬화할 때 해당 내용은 무시된다.
• synchronized - 메서드는 한 번에 하나의 쓰레드에 의해서만 접근 가능하다.
• volatile - 해당 변수의 조작에 CPU 캐시가 쓰이지 않고 항상 메인 메모리로부터 읽힌다.

객체 생성

public class Person {
    private int age = 10;
    private String name = "jun";

    Person() {}  // 기본 생성자

    Person(int age, String name) {
        setAge(age);
        setName(name);
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

public static void main(String[] args) {
	Person p1 = new Person();
	Person p2 = new Person(15, "min");
}

new 연산자

new연산자는 클래스 타입의 인스턴스를 생성해주는 역할을 하는 연산자로 메모리(Heap 영역)에 공간을 할당받고 그 공간의 참조값을 객체에게 반환해주는 역할을 한다.

new 키워드는 새 객체에 메모리를 할당하고 해당 메모리에 대한 참조값을 반환하여 클래스를 인스턴스화한다. 

일반적으로 객체가 메모리에 할당되면 인스턴스라 부른다

생성자 정의

Person() {}  // 기본 생성자

Person(int age, String name) {
    setAge(age);
    setName(name);
}

 생성자를 명시하지 않으면 컴파일러가 자동으로 기본 생성자를 생성한다.

하지만 기본 생성자가 아닌 다른 형태의 생성자만 생성했다면 기본 생성자는 생성되지 않는다.

this 키워드

public void setAge(int age) {
    this.age = age;
}

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

this키워드는 인스턴스 자신을 가르킨다. 위 코드에서 this를 사용함으로써 지역변수 age, name와 구분할 수 있다. 당연한 말이지만 클래스 (static)메서드에서는 this를 쓸 수 없다. 왜냐하면 인스턴스가 생성되지 않았을 수도 있기 때문이다.

this()는 해당 클래스 생성자를 호출할 수 있다. 그렇기 때문에 생성자를 재사용하는 데 쓰인다. (생성자 체이닝)

public class Person {
    int age;
    String name;
    int height;

    Person(int age, String name) {
        this.age = age;
        this.name = name;
    }

    Person(int age, String name, int height) {
        this.age = age;
        this.name = name;
        this.height = height;
    }
}

super 키워드

super의 경우 this와는 다르게 자식클래스가 부모클래스로부터 상속받은 멤버로를 사용하고자 할때 사용된다.

class Parent{
   int a = 10;
}

class Child extends Parent{
    int a = 20;
    
    void childMethod(){
           System.out.println(a);         //20
           System.out.println(this.a);     //20
           System.out.println(super.a);   //10
    }
}

super 키워드와 this 키워드의 기능이 비슷하 듯이 this()와 super() 키워드 역시도 기능이 비슷하다. super() 키워드는 this()와 마찬가지로 생성자를 호출하는 함수로, 자기자신이 아닌 부모클래스의 생성자를 호출한다.

제어문

Java에서 코드는 위에서 아래 순으로 읽고 실행된다. 모든 일을 순차적으로 실행할 수 있다면 아무런 상관이 없겠지만, 어떤 코드를 반복해야 될 수도 있고 어떤 코드는 건너뛰는 등의 순서를 변경해야 되는 일이 발생한다. 이 때, 제어문을 사용하여 코드 실행 흐름을 제어할 수 있다.이러한 제어문은 선택문(if-then, if-then-else, switch)과, 반복문(for, while, do-while), 분기문(break, continue, return)으로 나뉜다.

선택문(Decision-making Statement)

if-then

if-then 문은 가장 기본적인 제어문중 하나로 지정한 조건이 만족할 시에 지정한 블록({}) 안에 있는 코드가 실행된다.

if(조건식) { // 한 줄일 경우 {} 생략 가능 
	조건이 참일 경우 실행되는 코드; 
}

만약 if-then문 안에 코드가 한 줄이라면 {}은 생략이 가능하다.

if-then-else

기본적인 if-then 문에서는 참일 경우만 실행이 됬다면, if-then-else 문은 거짓일 때도 실행할 수 있다.
즉, 조건식이 참일 경우와 거짓일 경우의 실행되는 코드들을 나눌 수 있다는 것이다.

if(조건식) { 
	참일 경우; 
} else { 
	거짓일 경우; 
}

이렇게 조건이 하나만 존재 할 수 있지만, 여러가지의 조건을 사용해야 할 경우가 생길 수 있다.(예 - 학점)
이 때는 else if()를 사용하여 또 다른 조건식을 사용할 수 있다.

switch

switch 문은 if-then과 if-then-else 문과 다르게 변수에 대해 평가를 하고 이를 분기할 수 있다.
평가 당하는 변수는 원시형 타입(int, byte, char...)일 수 있고, Enum형 혹은 String, Wrapper(Integer, Byte, Character...) 클래스도 가능하다.

switch(변수) { 
	case 값 A: 
		변수가 값 A에 해당하는 경우; 
		break; 
	case 값 B; 변수가 값 B에 해당하는 경우; 
		break; 
	default: 어떠한 값에도 해당하지 않는 경우; 
		break; 
}

위 예시는 다음과 같이 if-then-else 문으로 변경도 가능하다.

if(변수 == 값 A) { 
	변수가 값 A에 해당하는 경우; 
}else if(변수 == 값 B) { 
	변수가 값 B에 해당하는 경우; 
}else { 
	어떠한 값에도 해당하지 않는 경우; 
}

반복문(Looping Statement)

어떠한 코드가 반복적으로 사용 될 때 사용되는 구문이다.

for

프로그래머가 설정한 조건이 만족 될 때까지 지정한 코드 블럭이 계속해서 수행된다.
카운팅을 할 수도 있겠지만, 배열 혹은 컬렉션 안에 저장되어 있는 값을 순회 할 때도 많이 사용된다.

for(초기식; 조건식; 증감식) { 
	반복 될 코드; 
}

JDK 5.0 이상부터 배열 혹은 컬렉션의 순회시에 다음과 같이 조금 더 향상된 for 문을 사용할 수 있다.

for(타입 변수명 : 배열/컬렉션) { 
	반복 될 코드; 
}

foreach 스타일 for문

: 어떤 컬렉션이든 순회할 수 있음

Effetive java - item 46 : for문보다는 for-each를 사용하라

for-each문은 반복자나 인덱스 변수를 제거해 오류 가능성을 줄인다

 int[] nums = {1,2,3,4,5};
 for (int num : nums) {
	 System.out.println(num);
 }

while

특정 조건이 참일 경우에 지정한 코드 블럭이 계속해서 수행되는 구문이다.

while(조건식) { 
	조건식이 참일 경우 반복되는 코드; 
}

조건식이 항상 참일 경우에는 계속해서 해당 코드들이 실행되므로 다음 명령들을 수행할 수 없는 상태가 된다.
따라서 조건식을 잘 유의해서 사용해야 된다.

do-while

while 문이 조건식을 먼저 판별하고 코드를 수행했다면, do-while 문은 먼저 코드블럭을 수행하고 조건을 판별한다.

do { 
	조건식이 참일 경우 반복되는 코드; 
}while(조건식);

분기문(Branching Statement)

조건문에서 프로그래머의 의도에 의해 중간 흐름을 바꿀 수 있는 구문

break

break 문은 두가지 케이스로 나뉘는데, 이는 라벨링이 된 것과 안된 것이다.

먼저 라벨링이 되지 않는 break 문은 switch 문, 반복문에서 사용될 수 있으며, 해당 구문을 만났을 때 가장 가까운 조건문을 종료한다.

for(int i = 0; i <= 10; i++) { 
	if(i == 5) break;
    System.out.println(i); 
} // 출력 // 1 // 2 // 3 // 4

다음과 같은 예시가 존재할 때, i가 5가 되면 반복문을 종료하고 다음 코드로 진행하게 된다.

라벨링이 된 break 문은 똑같이 break를 만나면 제어문이 종료되지만, 해당 라벨링이 된 제어문 자체가 종료된다.
즉, 가장 가까운 제어문뿐만 아니라 자신이 표시한 위치안의 제어문을 종료하는 것이다.

int findIt = 10; 
search: 
for(int i = 0; i < arr.length; i++) { 
  for(int j = 0; j< arr[i].length; j++) { 
    if(arr[i][j] == findIt) { 
    	break search;
  	}
  } 
}

위의 예시에서는 arr의 값이 10일 경우, search: 안에 있는 두개의 for 문 모두 종료된다.

continue

continue 문은 반복문 안에서 사용되며, 조건에 해당할 경우에만 반복문을 건너뛴다.
continue 문도 break 문과 똑같이 라벨링이 된 경우와 안된 경우가 존재하고 똑같은 메커니즘으로 동작한다.

for(int i = 0; i <= 10; i++) { 
	if(i == 5) continue; System.out.println(i); 
}
// 출력 // 1 // 2 // 3 // 4 // 6 // 7 // 8 // 9 // 10

위의 예제에서는 i가 5일 경우에만 가장 가까운 반복문의 끝으로 건너뛴다.

int findIt = 10; 
search: 
for(int i = 0; i < arr.length; i++) {
  for(int j = 0; j< arr[i].length; j++) { 
    if(arr[i][j] == findIt) { 
      continue search; 
    } 
  } 
}

위의 예제의 경우, arr의 값이 10일 경우, search: 의 가장 바깥 for 문의 끝으로 건너뛰게 된다.

return

return 문은 현재 메소드를 종료시키고 해당 메소드를 호출한 위치로 돌아간다.
이 또한 메소드의 타입에 의해 뒤에 값이 올 수 있고 안올 수 있다.

int getAge(String name) { 
	if(name == "jongnan") return 28; 
	System.out.println("존재하지 않는 사람!"); 
	return -1; 
}

위의 예제는 메소드의 타입이 int 이므로 반환 값을 지정해주어야 한다.

void pringAge(String name) { 
	if(name == "jongnan") { 
    	System.out.println("28"); 
    	return; 
	} 
	System.out.println("존재하지 않는 사람!"); 
	return; 
}

Enumeration 

• 초기 Collection만 지원
• Snap-shot : 원본과 달리 사본을 남겨처리. 다른 처리가 발생하면 오류 가능성 생김
• hasMoreElements(), nextElement()

Vector<Integer> vector = new Vector<>(Arrays.asList(1,2,3));
Enumeration elements = vector.elements();
while (elements.hasMoreElements()) {
	int e = (int)elements.nextElement();
	System.out.println(e);
}

Iterator

• 모든 Collection 지원
• enumeration에 비해 빠르다.
• hasNext(), next(), remove()

Iterator<Integer> iterator = Arrays.asList(1, 2, 3).iterator();
while (iterator.hasNext()) {
	Integer number = iterator.next();
}

JUnit 5란 
문서에서는 JUnit 5는 크게 세가지 서브 프로젝트의 여러 모듈로 구성이 되어있다고 한다.

JUnit 5 = JUnit Platform + JUnit Jupiter + JUnit Vintag -e

• Junit Platform

  JVM에서 테스트를 하기 위한 기초적인 역할을 담당

  • 테스트를 하기 위한 TestEngine API 제공

  • JUnit 4(하위 버전) 기반 테스트 제공

• Junit Jupiter

  JUnit 5에서 테스트 및 확장하기 위한 프로그래밍 모델과 확장 모델의 조합이다.
  Platform에서 사용하는 TestEngine은 Jupiter를 통해 제공하는 것이다.

  Jupiter API 는 Junit5 에 새롭게 추가된 API 들을 포함하고 있다.

• Junit Vintage

  하위 버전들(JUnit 3/4) 기반의 테스트를 실행시기키 위해 해당 TestEngine을 제공한다.

 문서 설명을 보면 Platform이 가장 상단에서 개발자들에게 JUnit의 전반적인 테스트 API들을 제공하며, 이를 실제적으로 구현한 Jupiter와 Vintage가 존재한다라고 할 수 있다.

JUnit 5를 사용하기 위해서는 런타임에 Java 8 이상이 필요하나, 이전 버전의 JDK로 컴파일 된 코드들 또한 테스트가 가능하다.

참고로 Spring Boot 2.2.0 버전부터 JUnit5가 기본으로 채택되었다.

Spring Initializer를 통해 프로젝트를 만들어보면 Test 디펜던시가 다음과 같이 되어있는것을 볼 수 있습니다....

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-test</artifactId>
  <scope>test</scope>
  <exclusions>    
    <exclusion>
      <groupId>org.junit.vintage</groupId>
      <artifactId>junit-vintage-engine</artifactId>
    </exclusion>
  </exclusions>
</dependency>

junit-vintage-engine 모듈을 제외하고 있습니다. vintage-engine 자체가 JUnit4를 지원하기 위한 모듈이다보니 기본적으로는 제외하도록 설정되는 것입니다.

만약 JUnit4 테스트케이스를 같이 관리해주어야하는 상황이라면 위 exclusion 설정을 삭제하면 된다.

Annotations

Jupiter에서는 테스트와 확장된 기능을 제공하기 위해 여러가지 어노테이션들을 제공한다.

Annotaion설명

@DisplayName

기존에 테스트 결과가 보고될 때 메소드명이 테스트케이스 이름으로 사용되었는데요. 때문에 테스트케이스를 잘 설명하기 위해 한글로 하고는 했습니다.

JUnit5에서는 @DisplayName 어노테이션을 활용해 좀 더 깔끔하게 이름을 붙혀줄 수 있습니다.

public class MemberServiceTest {

  // 기존 방식
    @Test
    public void 멤버_프로필_조회() {
        ...
    }

  // JUnit5 방식
  @Test
  @DisplayName("멤버 프로필 조회")
  public void getMemberProfileTest() {    
        ...    
  }
}

 LifeCycle Hook

JUnit 테스트케이스 작성 시 개발자가 테스트 수행 전 후 특정 시점에 실행될 동작을 정의할 수 있다.

기존에는 @BeforeClass, @AfterClass, @Before, @After 어노테이션을 활용했는데.

JUnit5에서는 @BeforeAll, @AfterAll, @BeforeEach, @AfterEach 로 변경되었다. @Before와 @After는 기존에 (테스트케이스 마다)라는 의미가 없어서 혼동의 여지가 있었지만, 명확하게 네이밍이 변경되었다.

assertions

Assertion을 프로그래밍 관점에서 해석하면 표명, 가정 설정문으로 할 수 있으며, 이를 통해 자신의 로직이 정확한지 테스트 해보는 것이다.
Jupiter에서는 기존 버전에 존재했던 Assertion 메소드를 포함하고, 람다와 함께 사용하기 적합한 추가적인 메소드를 제공한다.
모든 Assertion은 정적 메소드로 정의되어 있다.

테스트에서 assertion종류가 많고 복잡한 경우 assertAll(Executable...executables)을 이용할 수 있습니다.
Executable은 파라미터와 반환값이 없는 함수형 인터페이스이기 때문에 assertAll로 그룹핑 + assertion을 람다로 작성할 수 있습니다.

assertAll("assertionGroup1",
  () -> assertEquals(expected, actual),
  ...    
)

@Test
public void shouldFailBecauseTheNumbersAreNotEqual_lazyEvaluation() {
    Assertions.assertTrue(
      2 == 3,
      () -> "Number 2 and 3 are not equal!");
}

@Test
public void shouldAssertAllTheGroup() {
    List<Integer> list = Arrays.asList(1, 2, 4);
    Assertions.assertAll("List is not incremental",
    () ->  Assertions.assertEquals(list.get(0).intValue(), 1),
    () ->  Assertions.assertEquals(list.get(1).intValue(), 2),
    () ->  Assertions.assertEquals(list.get(2).intValue(), 3));
 }

@ParameterizedTest

한 메소드에서 여러 종류의 파라미터를 받아 테스트를 수행할 수 있습니다.

@DisplayName("공백 문자열 테스트")
@ParameterizedTest(name = "문자열 {0}으로 조회")
@ValueSource(strings = " ", "")
public void isBlankStringTest(String source) {
  boolean isBlank = service.isBlank(source);
  assertTrue(isBlank);
}

참고로 @ParamterizedTest를 사용하려면 junit-jupiter-params 모듈을 추가해야합니다.

<dependency>
  <groupId>org.junit.jupiter</groupId>
  <artifactId>junit-jupiter-params</artifactId>
  <version>VERSION_TO_USE</version>
  <scope>test</scope>
</dependency>

Assumptions

Assumption은 테스트를 진행할지 안할지에 대해 테스터가 작성한 가정을 기반으로 선택된다.
즉, 설정한 가정이 참일 경우에는 테스트를 실행하고 거짓일 겅우에는 테스트는 실행하지 않는다.
이러한 Assumption은 조그마한 단위 테스트보다는 통합 테스트에 더 적절히 사용할 수 있다.
Assertion과 똑같이 정적 메소드로 정의되어 있다.

@Test
void testOnlyOnDev() {
  assumeTrue("DEV".equals(System.getenv("ENV")));
  
  DEV 환경에서만 테스트할 코드;
}

@Test
void testAllEnv() {
  assumeTrue("DEV".equals(System.getenv("ENV")),
             () -> {
               DEV 환경에서 테스트할 코드;
             });

  모든 환경에서 테스트할 코드;
}

Tagging And Filtering

Junit 4 에서는 @Category Annotation 을 사용하여 테스트를 그룹화 할 수 있다. Junit 5 에서는 @Category Annotation 이 @Tag Annotation 으로 대체된다.

@Tag("annotations")
@Tag("junit5")
@RunWith(JUnitPlatform.class)
public class AnnotationTestExampleTest {
	/* */
}

참고문헌

 https://junit.org/junit5/docs/current/user-guide/#overview [공식문서]

목표

자바가 제공하는 다양한 연산자를 학습하세요.

학습할 것

• 산술 연산자
• 비트 연산자
• 관계 연산자
• 논리 연산자
• instanceof
• assignment(=) operator
• 화살표(->) 연산자
• 3항 연산자
• 연산자 우선 순위
• (optional) Java 13. switch 연산자

산술 연산자

• Binary Operator(이항)

  • +, -, *, /, %(Modulo)
  • ArithmeticException 발생 가능
    • Divide by zero
    • Modulo by zero 

비트 연산자

• Binary Operator(이항)
  • &(AND)
  • |(OR)
  • ^(XOR)
  • >> (right SHIFT)
  • << (left SHIFT)
  • >>> (unsigned right SHIFT) : 비트값을 오른쪽으로 이동한 이후 왼쪽 공간은 모두 0로 채움, C/C++ 에 없음
• Unary Operator(단일항)
  • ~(NOT, 비트 패턴 반전)

int a = 3 & 1;  // 0011 & 0001 = 1
int b = 2 | 1;  // 0010 | 0001 = 3
int c = 3 ^ 1;  // 0011 ^ 0001 = 2
int d = b >> 1; // 0011 에서 왼쪽으로 1칸 이동, 1(0001)
int e = b << 1; // 0011 에서 오른쪽으로 1칸 이동, 6(0110)
int f = ~a;     // 0001 -> 1111 1111 1111 1111 1111 1111 1111 1110
// 1000 0000 0000 0000 0000 0000 0000 0000
// ->
// 0100 0000 0000 0000 0000 0000 0000 0000
int g = -2147483648 >>> 1;

관계 연산자

• Binary Operator(이항)
  • == : Equal to
  • != : Not equal to
  • > : greater than
  • < : less than
  • >= : greater than or equal to
  • <= : less than or equal to
• primitive type 인 피연산자에서 연산 가능
• 연산 결과 타입은 boolean

논리 연산자

• Binary Operator(이항)
  • && (LOGICAL AND)
  • || (LOGICAL OR)
• 피연산자의 타입은 boolean
• 연산 결과 타입은 boolean

instanceof

• Type introspection : 실행 시간에 객체의 타입이나 속성을 검사하는 프로그램의 능력을 뜻함

• Java 에서 대표적인 type introspection

• 객체의 타입을 비교할 때 사용

• null 은 어떤 것의 instance 도 아님

class Test {
  ...
}

class Test2 extends Test{
  ...
}

class Operator{
    public static void main(String[] args) {
        Test obj1 = new Test();
        Test obj2 = new Test2();
        System.out.println(obj1 instanceof Test);    // true
        System.out.println(obj1 instanceof Test2);   // false
        System.out.println(obj2 instanceof Test);    // true, 상속 관계이기 때문?
        System.out.println(obj2 instanceof Test2);   // true
        System.out.println(null instanceof Object);  // false
    }
}

Assignment(=) operator

• Binary Operator(이항)
  • = (ASSIGN)
  • += (ADD and ASSIGN)
  • -= (SUBTRACT and ASSIGN)
  • *= (MULTIPLY and ASSIGN)
  • /= (DIVIDE and ASSIGN)
  • %= (MODULO and ASSIGN)
  • &= (AND and ASSIGN)
  • ^= (XOR and ASSIGN)
  • |= (OR and ASSIGN)
  • <<= (LEFT SHIFT and ASSIGN)
  • >>= (RIGHT SHIFT and ASSIGN)
  • >>>= (UNSIGNED RIGHT SHIFT and ASSIGN)
• 객체에 값을 할당
• 다른 연산자와 묶어서 사용 가능
• declaration statement, assignment expression 에서 사용됨
• Java 는 reference type 의 경우 주소값을 할당한다는것에 주의해야 함

화살표(->) 연산자

• 8 버전부터 람다 표현식(lambda expression) 이 공식적으로 적용되었음

• 함수형 프로그래밍(Functional programming) 표현

  • side-effect 발생을 최소화 하기 위함
  • 조건
    • Pure function
    • Anonymous function
    • Higher-order function
  • Java 에서는 하나의 메소드가 선언된 인터페이스

• 화살표 연산자는 Java 에서 람다 표현식의 syntax 일부

  (argument, ...) -> {expression}

interface Test{
    int func(int a);
}

class Test2 {
    public void func(Test test){
        int value = test.func(3);
        System.out.println(value);
    }
}

class Operator{
    public static void main(String[] args) {
        Test2 test2 = new Test2();
				// lambda expression 사용 X 버전
        test2.func(new Test() {
            public int func(int a){
                return a + 2;
            }
        });
				// lambda expression 사용 버전
        test2.func((a) ->{
            return a + 2;
        });
    }
}

3항 연산자

• Conditional Operator

  • ?:

  • 구조

    Conditional Expression ? Expression(true인 경우) : Expression(false 인 경우);

• 3항 연산자 사용 VS if-else 사용

  • 3항 연산자: expression
  • if-else: statement
  • 문법적인 의미로 보자면 3항 연산자는 expression 이므로 statement 내부 expression이 위치할 수 있는 모든 곳에서 사용 가능, expression 이므로 3항 연산자 자체를 중첩해서 사용 가능

int a = 2;
// if-else statement 사용
if(a == 2){
a += 1;
}
else{
a += 2;
}

// 3항 연산 사용
a == 2 ? a += 1 : a+=2 ;

연산자 우선 순위

기본적으로 연산자에는 우선순위가 있으며, 괄호의 우선순위가 제일 높고, 산술 > 비교 > 논리 > 대입의 순서이며, 단항 > 이항 > 삼항의 순서이다. 연산자의 연산 진행방향은 왼쪽에서 오른쪽으로 수행되며, 단항 연산자와 대입 연산자의 경우에는 오른쪽에서 왼쪽으로 수행된다. 

OperatorsPrecedence

Ref. https://docs.oracle.com/javase/tutorial/java/nutsandbolts/operators.html

• 동일 선상에 있는 연산자들은 동일한 우선 순위를 가짐
• 할당 연산 제외한 Binary Operator 는 left ⇒ right 로 평가
• 할당 연산은 right⇒ left 로 평가

(optional) Java 13. switch 연산자

• 기존에 존재하는 switch statement 를 expression으로 추가한걸로 보임

  • Ref. https://docs.oracle.com/en/java/javase/13/language/switch-expressions.html

• 구조

switch(expression){
	case expression -> expression;
	...
	default -> expression
};

switch(expression){
	case expression:
		expression;
		yield expression;
	...
	default:
		expression;
		yield expression;
};

• 차이점

  • case : 말고도 case -> 사용 가능
    • 화살표인 경우 branch fall-through 가 아님
    • 중괄호로 감싸야 하는 경우
      • multiple statement 를 적용
      • throw statement 사용, expression이 아닌 경우
  • break statement 대신 yield statement 사용

• oracle 문서에서는 arrow case 라벨을 사용하는 것을 권장함

  • 이유:
    • colon case 라벨을 사용하면 헷갈릴 수 있음
    • 헷갈리게 되면 의도하지 않은 fall through 가 발생할 수 있음

목표

자바의 프리미티브 타입, 변수 그리고 배열을 사용하는 방법을 익힙니다.

학습할 것

• 프리미티브 타입 종류와 값의 범위 그리고 기본 값
• 프리미티브 타입과 레퍼런스 타입
• 리터럴
• 변수 선언 및 초기화하는 방법
• 변수의 스코프와 라이프타임
• 타입 변환, 캐스팅 그리고 타입 프로모션
• 1차 및 2차 배열 선언하기
• 타입 추론, var

프리미티브 타입 종류와 값의 범위 그리고 기본 값

자바 8부터 

unsigned int 및

unsigned long 이라는 개념이 추가됨.

1byte 는 8bit 이다. 1bit 가 추가 될때마다 표현가능한 숫자가 2배가 된다.

부호가 있는 자료형의 경우 1비트는 부호츨 표현하기 위해 사용하기 떄문에 1byte 의 경우 -128 ~ 127 까지 표현 가능하다.

양수는 0이 포함되기 떄문에 128이 아니다.

만약 0 ~ 255 까지 표현하고 싶다면, 부호 비트 자리도 데이터로 취급하려면 unsigned 자료형을 사용하면 된다. 음수는 표현하지 못하는 대신 양수 표현 범위가 두 배 늘어난다.

2비트로 표현 가능했던 모든 값 : 00, 01, 10, 11

자바에는 unsigned 라는 자료형은 제공하지 않고,

Integer.toUnsignedString() 메소드 등으로 제공한다. 

실수형의 경우 정수형과 비교했을 떄 메모리 크기는 비슷한데 값의 표현 범위가 훨씬 넓다.

실수는 부호(sign), 가수(Mantissa), 지수(exponent) 로 구성되며 부동 소수점 방식을 사용한다.

부동 소수점 방식을 사용하여 모든 기수를 0보다 크거나 같고 1보다 작은 값 범위의 값으로 만들고 원래 수를 표현하기 위해 10을 몇번 거듭 제곱해야 하는지 지수로 표현한다.

sign: 부호를 나타내기 위해 사용하는 비트

exponent: 지수를 사용하기 위해 사용하는 비트

Mantissa: 가수를 사용하기 위해 사용하는 비트

실수 표현 예제

-118.625를 IEEE 754(32비트 단정밀도)로 표현해 보겠습니다.

1. 우선 음수이므로 부호비트는 1이 됩니다.
2. 부호를 뺀 절대값을 이진법으로 나타내면 1110110.101(2)이 됩니다.
3. 소수점을 왼쪽으로 이동시켜 왼쪽에는 1만 남도록 만듭니다. 1110110.101 = 1.110110101 * 2^6 으로 만듭니다. 이것을 정규화된 부동소수점 수라고 합니다.
4. 가수부는 소수점의 오른쪽 부분으로, 부족한 비트 수 부분만큼 0으로 채워 23비트로 만듭니다.
5. 지수는 6이며 Bias를 더해야 합니다. 32비트 IEEE754형식에서 Bias는 127이므로 133이되고 이를 이진법으로 변환하면 10000101이 됩니다.

java에서 기본적으로 실수리터럴을 사용하면 double 형식입니다.

그렇기 때문에 float형식의 실수는 마지막에 f를 붙여 float형식의 실수라고 알려주어야 한다. 하지만 float형식은 현재 사용하지 않는 것을 권장한다. 부동 소수점 형식은 정확한 실수값이 아닌 근사값을 저장하는 방식이기 때문에 32비트인 float는 오차가 생길 확률이 크다.

프리미티브 타입과 레퍼런스 타입

Java Data Type
ㄴ Primitive Type
    ㄴ Boolean Type(boolean)
    ㄴ Numeric Type
        ㄴ Integral Type
            ㄴ Integer Type(short, int, long)
            ㄴ Floating Point Type(float, double)
        ㄴ Character Type(char)
ㄴ Reference Type
    ㄴ Annotation
    ㄴ Array
    ㄴ String
    ㄴ Class
    ㄴ Enumeration
    ㄴ Interface

위의 값들은 JVM 의 Runtime Data Area 에 저장된다. 

String name ="james";   // name 변수 와 주소값은 스택에, 실제값은 힙 영역에 생성
int age = 20; // age 변수 와 값은 스택영역에 생성
Person person = new Person(name, age);

리터럴

리터럴은 실제값 그 자체입니다. 소스코드에서 고정된 값을 대표하는 용어이며 리터럴은 변수 초기화에 사용됩니다.

• Integer Literals
  • long 타입은 L 로 끝나거나 l 로 끝나는 값
  • 그외 나머지 숫자는 int
  • 16진수: 0x 로 시작
  • 2진수: 0b 로 시작
• Floating-Point Literals
  • float 타입은 F로 끝나거나 f 로 끝나는 값
  • 그 외 나머지는 double (optional, D 혹은 d 로 끝나는 값)
• Character and String Literals
  • Unicode character
  • special escape character
    • \b : 백스페이스
    • \t : 탭
    • \n : new line
    • \f : form feed
    • \r : 캐리지 리턴
    • \" : 쌍따옴표
    • \' : 따옴표
    • \\ : 역슬래시

변수 선언 및 초기화하는 방법

선언 - Declaration?

변수를 선언한다는 것은, 저장공간을 확보하겠다는 의미로 해석할 수 있다.

int a;

위의 코드가 변수를 선언한 것인데, 해석하자면 다음과 같다.
int 타입의 값을 저장할 수 있는 공간을 확보했고(int 타입은 4byte) 그 공간을 지칭할 이름은 a 이다.

초기화 - Initialization?

변수를 초기화 한다는 것은, 저장공간에 원하는 값을 저장하는 것을 의미한다.
변수를 선언하고 나면, 해당 공간에는 아무런 의미 없는 쓰레기값이 들어가있게 된다. 그리고 그 상태에서 컴파일을 시도하면
Error:(10, 28) java: variable a might not have been initialized 와 같은 컴파일 에러코드를 볼 수 있을 것이다.
그러므로 변수는 선언 후에 초기화를 해야하며 위에 선언한 변수에 대한 초기화는 다음과 같이 할 수 있다

a = 10;

선언과 초기화

변수의 선언과 초기화를 한 줄에 하는 것도 가능하다.

int a = 10;

초기화 블록

클래스 초기화 블럭 : 클래스 변수의 복잡한 초기화에 사용된다. 클래스가 처음 로딩될 때 한번만 수행된다.

  - class 로딩시에 호출된다.

  - 인스턴스 변수나 인스턴스 메소드에 접근 못함. 

인스턴스 초기화 블럭 : 인스턴스 변수의 복잡한 초기화에 사용된다. 

  - 객체 생성할때마다 호출됨.

  - super 생성자 이후에 실행됨.

  - 생성자 보다 먼저 실행됨.

  - 모든 생성자의 공통 코드를 instance initializer block 에 넣으면 코드 줄일수 있다.

class InitBlock{
    static {
        /* 클래스 초기화 블럭 */
    }

    {   /* 인스턴스 초기화 블럭 */ }
} 

변수의 스코프와 라이프타임

클래스 변수는 static을 앞에 붙여서 선언해주어야 한다.

지역변수는 메소드 안에서 선언을 하면 지역변수로 된다.

인스턴스 변수는 클래스 내부에 생성된 변수이다.

public class scope_and_lifetime {
    int num1, num2;   		//Instance Variables
    static int result;  	//Class Variable
    int add(int a, int b){  	//Local Variables
        num1 = a;
        num2 = b;
        return a+b;
    }
}

각각의 변수의 라이프타임은 클래스 변수의 경우 프로그램이 종료할때까지 적용되고 인스턴스 변수의 경우는 인스턴스가 참조 되고 있을때에는 유지되다가 객체를 참조하는 변수가 없을 경우 JVM의 Garbage Collector가 제거하게 된다.

지역변수의 경우 메소드가 끝나면 소멸되어 사용할 수 없게 됩니다.

인스턴스변수는 클래스가 로딩될떄 생성되서, 스태틱 함수에서는 인스턴스 변수 사용 불가
스태틱 변수에도 인스턴스메소드 사용 불가
인스턴스변수에는 반대로 스태틱 변수 참조가능 왜냐하면 스태틱변수가 먼저 생성되기 때문이다.

타입 변환, 캐스팅 그리고 타입 프로모션

타입 변환으로 종류로는 캐스팅(강제 형변환)과 타입 프로모션이 있습니다(자동 형변환).

타입캐스팅이란 크기가 더 큰 자료형을 크기가 더 작은 자료형에 대입하는 것을 의미.

데이터가 작은데서 큰 곳으로 옮기는 타입 프로모션의 경우 오류나 문법의 필요없이 형변환이 가능하지만,

반대로 타입캐스팅은 데이터 표현범위가 작은 곳으로 옮길 경우 표현범위를 넘어나게 되면 전혀 다른 값이 나올수도 있다.

타입 캐스팅

// 큰 범위에서 작은범위로 캐스팅
int a = 10;     
byte b = (byte)a;
System.out.println(b); //  -> 10
(byte 는 -256~255까지 표현할 수 있음으로 타입캐스팅을 했음에도 데이터 변형이나 
손실은 오지 않았다) 

// 작은 범위에서 큰 범위로 캐스팅	
int a = 10000;     
byte b = (byte)a;
System.out.println(b); //  -> 16
(표현범위를 벗어나는 값을 강제로 타입캐스팅해 데이터에 변형이 생겼다) 

타입 프로모션

byte a = 10;
int b = a;
System.out.println(b); //  -> 10

타입변환은 레퍼런스 타입에서도 가능하다.

부모클래스로의 타입변환은 자동적으로 가능하지만 자식클래스로의 타입변환은 타입캐스팅이 필요하다.

이유는 자식클래스는 부모클래스의 필드나 메소드를 물려받음으로 자식클래스타입의 객체를 부모클래스타입으로 바꾼다고 해서 데이터의 손실이나 변형이 일어나진 않기 때문이다.

• Inheritance 관계에서만 가능
• Upcast : subclass → superclass
  • 모든 subclass 는 superclass 의 컨텐츠를 가지고 있으므로 superclass 로의 casting 이 가능함
• Downcast: superclass → subclass
  • 모든 superclass 는 subclass 의 컨텐츠를 가지고 있지 않을 수도 있음, 그러므로 오류 발생 가능성 ↑

1차 및 2차 배열 선언하기

class ArrayExample {
	public static void main(String[] args) {
        //1차원 배열
        int[] oneDimensionArrayEx1 = {1, 2, 3, 4, 5};
        int[] oneDimensionArrayEx2;
        oneDimensionArrayEx2 = new int[10];

        //2차원 배열
        int[][] twoDimensionArrayEx1 = {{1, 2}, {3, 4}};
        int[][] twoDimensionArrayEx2;
        twoDimensionArrayEx2 = new int[10][10];
    }
}

• oneDimensionArrayEx1 은 Runtime Stack 영역의 힙 영역 주소값을 가짐
• Heap 영역에 int 타입 크기의 요소 5개를 할당하여 사용됨

• 2차원 배열

• Runtime Stack 영역의 twoDimensionArrayEx1 은 2개의 요소 크기(2개 요소에 주소값을 가지고 있음)를 가진 힙 영역 주소값을 가짐

• 힙 영역에는 실제 값이 들어있는 요소들과 주소값이 들어있는 요소들로 존재하게됨

타입 추론, var

Java 10부터 추가된 특징중 하나인 Local Variable Type Inference은 로컬 변수 선언을 var를 이용하여 기존의 엄격한 타입 선언방식에서 컴파일러에게 타입추론 책임을 위임할 수 있게 되었다.

var list = new ArrayList<String>(); //infers ArrayList<String> 
var stream = list.stream();//infers Stream<String>

Local Variable Type Inference 사용 조건

• 초기화된 로컬 변수 선언시

• 반복문에서 지역변수 선언 시(enhanced for loop포함)

var 활용

1. 지역변수 선언

var numbers = Arrays.asList(1, 2, 3, 4, 5); 
for (var i = 0; i < numbers.size(); i++) { 
	System.out.println("numbers = " + numbers.get(i)); 
}

2. forEach

var numbers = Arrays.asList(1, 2, 3, 4, 5); 
for (var number : numbers) { 
	System.out.println(number); 
}

⇒ 기존에는 Object타입으로 받아서 형변환을 하거나 IDE가 아닌 개발자가 직접 타입추론해 명시적 타입선언을 해줬는데 var를 사용하여 훨씬 편하게 타입선언이 가능해진다.

3. Lambda (Java 11)

IntBinaryOperator plus10 = (@NonNull var one, @NonNull var two) -> one + two + 10;

⇒ Java 11부터는 람다 인자에도 var사용이 가능해졌는데, 이를 통해 파라미터 어노테이션 사용까지 가능해졌다.

1. java.lang.UnsupportedClassVersionError 발생 원인 

Unsupported major.minor version 52.0

Java SE 15 = 59 (0x3B hex),
Java SE 14 = 58 (0x3A hex),
Java SE 13 = 57 (0x39 hex),
Java SE 12 = 56 (0x38 hex),
Java SE 11 = 55 (0x37 hex),
Java SE 10 = 54 (0x36 hex),
Java SE 9 = 53 (0x35 hex),
Java SE 8 = 52 (0x34 hex),
Java SE 7 = 51 (0x33 hex),
Java SE 6.0 = 50 (0x32 hex),
Java SE 5.0 = 49 (0x31 hex),
JDK 1.4 = 48 (0x30 hex),
JDK 1.3 = 47 (0x2F hex),
JDK 1.2 = 46 (0x2E hex),
JDK 1.1 = 45 (0x2D hex).

java.lang.UnsupportedClassVersionError는 높은 버전의 JDK에서 컴파일한 class 파일을 낮은 버전의 JDK에서 실행을 해서 발생하는 에러다.

위 에러가 없으려면 실행환경과 컴파일할 자바버젼을 맞춰줘야 한다.

컴파일시 자바버젼을 맞추기위해서는 jacac 에 -target 옵션을 줘야 한다.

javac -target 1.2 Helloworld.java

JVM은 자바 가상머신으로 자바 바이트코드를 실행 할 수 있는 주체로 JVM 덕분에 CPU나 운영체제(플랫폼)과 독릭접으로 동작 가능하다.

JVM은 크게 Class Loader,GC, Runtime Data Area, Excute engine 세가지로 나뉜다

JVM 구성요소

1. Class Loader

컴파일된 자바 바이트코드를 Runtime Data Area 영엑에 로드한다.

자바 컴파일러가 ,java 파일을 컴파일하면 .class 파일 을 만드는데, 이게 바로 바이트코드이고 이걸 데이터영역에 로드하는 것이다.

javac 가 바이트코드로 컴파일을 하게 되는데 이건 jdk 에 있는 기능이다. JRE 는 실행환경이기 때문에 컴파일 기능이 없다.

자바 9 이후 부터는 JRE 가 따로 제공되지 않는다.

2. Excute engine

Class Loader 를 통해 JVM 내의 Runtime Data Area 에 배치된 바이트코드를 실행한다.

실행엔진으로는

명령어를 하나 하나 실행하는 인터프리터 방식과 

실행 시점에 자주 쓸만한 코드들을 기계어로 변환 시켜놓고 저장해서 사용하는 JIT 방식이 있다.

다시 말하면 JIT 컴파일러는 자주 사용되는 코드일 경우에만 기계어로 캐싱하고 그 부분이 호출이 되면 실행이 된다.

여기 실행엔진에 GC 를 넣는 사람이 있고, 실행엔진과 별개로 JVM 의 큰 범주로 나누는 사람이 있다.

GC 란 Heap 메모리 영역에 생성 된 객체들 중 사용하지 않는 객체를 탐색 후 제거하는 역할을 하는 것이다.

여기서 런타임 데이터영역은 또 여러가지 구조로 나뉜다.

3. Runtime Data Area

JVM의 메모리 영역으로 자바 애플리케이션을 실행할 때 사용되는 데이터들을 적재하는 영역이다.

이 영역은 크게 Method Area, Heap Area, Stack Area, PC Register, Native Method Stack로 나눌 수 있다.

1. Method area (메소드 영역)

클래스 멤버 변수의 이름, 데이터 타입, 접근 제어자 정보같은 필드 정보와 메소드의 이름, 리턴 타입, 파라미터, 접근 제어자 정보같은 메소드 정보, Type정보(Interface인지 class인지), Constant Pool(상수 풀 : 문자 상수, 타입, 필드, 객체 참조가 저장됨), static 변수, final class 변수등이 생성되는 영역이다.

2. Heap area (힙 영역)

new 키워드로 생성된 객체와 배열이 생성되는 영역이다.

메소드 영역에 로드된 클래스만 생성이 가능하고 Garbage Collector가 참조되지 않는 메모리를 확인하고 제거하는 영역이다.

3. Stack area (스택 영역)

지역 변수, 파라미터, 리턴 값, 연산에 사용되는 임시 값등이 생성되는 영역이다.

동적으로 객체를 생성하면 실제 객체는 Heap에 할당되고 해당 레퍼런스만 Stack에 저장된다. Stack은 스레드별로 독자적으로 가진다.

int a = 10; 이라는 소스를 작성했다면 정수값이 할당될 수 있는 메모리공간을 a라고 잡아두고 그 메모리 영역에 값이 10이 들어간다. 즉, 스택에 메모리에 이름이 a라고 붙여주고 값이 10인 메모리 공간을 만든다.

클래스 Person p = new Person(); 이라는 소스를 작성했다면 Person p는 스택 영역에 생성되고 new로 생성된 Person 클래스의 인스턴스는 힙 영역에 생성된다.

그리고 스택영역에 생성된 p의 값으로 힙 영역의 주소값을 가지고 있다. 즉, 스택 영역에 생성된 p가 힙 영역에 생성된 객체를 가리키고(참조하고) 있는 것이다.

메소드를 호출할 때마다 개별적으로 스택이 생성된다.

Heap에 있는 오브젝트가 Stack에서 참조 할 수 없는 경우 GC의 대상이 된다.

4. PC Register (PC 레지스터)

Thread(쓰레드)가 생성될 때마다 생성되는 영역으로 Program Counter 즉, 현재 쓰레드가 실행되는 부분의 주소와 명령을 저장하고 있는 영역이다. (*CPU의 레지스터와 다름)

이것을 이용해서 쓰레드를 돌아가면서 수행할 수 있게 한다.

5. Native method stack

자바 외 언어로 작성된 네이티브 코드를 위한 메모리 영역이다.

보통 C/C++등의 코드를 수행하기 위한 스택이다. (JNI)

쓰레드가 생성되었을 때 기준으로

1,2번인 메소드 영역과 힙 영역을 모든 쓰레드가 공유하고,

3,4,5번인 스택 영역과 PC 레지스터, Native method stack은 각각의 쓰레드마다 생성되고 공유되지 않는다.

JIT 컴파일러란(Just-In-Time)

JRE안에 존재하고, 

사용하는 이유는 같은 코드를 매번 해석하지 않고 실행할 때 컴파일을 하면서 해당코드를 캐싱한다.

이후엔 바뀐 부분만 컴파일 하고 나머지는 캐싱된 코드를 사용해서 인터프리터의 속도를 개선하는 역할을 한다.

JDK와 JRE의 차이

• JDK = JRE + @ 이며

• JRE는 읽기 전용, JDK 읽기 / 쓰기 전용이라 생각할 수 있다.

JRE(Java Runtime Enviroment) : 컴파일된 자바 프로그램을 실행시킬 수 있는 자바 환경

JDK(Java Development kit) : 자바 프로그래밍시 필요한 컴파일러 등 포함

Runtime Data Area 및 JIT 컴파일러에 대해서는 따로 포스팅 할 예정이다.