<자바의 신> 16장 클래스 안에 클래스가 들어갈 수도 있구나

16장 클래스 안에 클래스가 들어갈 수도 있구나

 

Netesd 클래스

코드를 간단하게 표현하기 위해 클래스 안에 클래스를 작성

 

• 자바 기반의 UI 처리를 할 때 사용자의 입력이나, 외부의 이벤트에 대한 처리를 하는 곳에서 많이 사용 → 소스의 가독성과 유지보수성을 높임
• 한 곳에서만 사용되는 클래스를 논리적으로 묶어서 처리할 필요가 있을 때 (static)
• 캡슐화가 필요할 때 → 내부 구현을 감추고 싶을 때 (inner class)
• Static nested 클래스
  • static으로 선언됨
• 내부(Inner) 클래스: static이 없음
  • 내부 클래스
  • 익명 클래스

 

static nested class

public class OuterOfStatic{
    static class StaticNested{  // static nested class
        private int value=0;

        public int getValue(){
            return value;
        }

        public void setValue(int value){
            this.value = value;
        }
    }
}

public class NestedSample{
    public satic void main(String[] args){
        OuterOfSatatic.StaticNested staticNested = new OuterOfStatic.StaticNested();
        staticNested.setValue(3);
        // 클래스명.nested클래스명으로 객체 생성
    }
}

＊OuterOfStatic 클래스를 컴파일하면 별도의 클래스 파일로 생성됨
→ OuterOfStatic.class와 OuterOfStatic$StaticNested.class 두개의 클래스가 생성됨

• 사용 예시

public class University{
	static class Student{ ... }
}

 

 

public class School{
	static class Student{ ... }
}

 

＊겉으로 보기에는 유사하지만 내부적으로 구현이 달라야 할 때 사용

 

내부 클래스와 익명 클래스

• 내부 클래스 (Inner Class)

public class OuterOfInner{
	class Inner{ // static이 없음 
		private int value=0;

		public int getValue(){
			return value;
		}
		
		public void setValue(int value){
			this.value = value;
		}
	}
}

public class InnerSample{
	public satic void main(String[] args){
		OuterOfInner outer = new OuterOfInner();
		OuterOfInner.Inner inner = outer.new Inner();
		inner.setValue(3);
		// Inner 클래스의 객체를 생성하기 전 OuterOfInner 클래스의 객체를 먼저 생성 후
		// 그 객체를 통해서 Inner 클래스의 객체를 생성
	}
}

＊하나의 클래스에는 어떤 공통적인 작업을 수행하는 클래스가 필요한데 다른 클래스에서는 그 클래스가 전혀 필요하지 않을 때 내부 클래스를 만들어 사용

 

• 익명 클래스 (Anonymous Class) : 이름이 없는 클래스

(1) 익명 클래스 사용 전

public interface EventListener{
    public void onClick();
}

public class MagicButton{
    public MagicButton() { }
    private EventListener listener;
    public void setListener(EventListener listener){
        this.listener=listener;
    }
    public void onClickProcess(){
        if(listener != null){
            listener.onClick();
        }
    }
}

class MagicButtonListener implements EventListener{
    public void onClick(){
        System.out.println("Magic Button Clicked !!");
    }
}

public class AnonymousSample{
    public static void main(String args[]){
        AnonymousSample sample = new AnonymousSample();
        sample.setButtonListner();
    }
    public void setButtonListener(){
        MagicButton button = new MagicButton();
        MagicButtionListner listener = new MagicButtonListener(); // EventListener를 구현한 클래스 객체
        button.setListener(listener);
        button.onClickProcess();
    }
}

 

(2) 익명 클래스

public class AnonymousSample{
    public static void main(String args[]){
        AnonymousSample sample = new AnonymousSample();
        sample.setButtonListner();
    }
    public void setButtonListener(){
        MagicButton button = new MagicButton();
        button.setListener(new EventListener(){ // 익명 클래스 선언
            public void onClick(){
                System.out.println("Magic Button Clicked !!");
            }
        }); // 메소드 호출 과정 내에 클래스가 있기 때문에 세미콜론 필수
        button.onClickProcess();
    }
}

＊클래스에는 이름이 없지만 onClick()과 같이 메소드가 구현되어 있음

＊클래스 이름도 없고 객체 이름도 없기 때문에 다른 클래스나 메소드에서는 참조 불가

＊ 만약 객체를 해당 클래스 내에서 재사용하려면 객체를 생성한 후 사용 ↓

public void setButtonListenerAnonymousObject(){
        MagicButton button = new MagicButton();
        EventListener listener = new EventListener(){ // 객체 생성 후 익명 클래스 사용
            public void onClick(){
                System.out.println("Magic Button Clicked !!");
            }
        };
        button.setListener(listener);
        button.onClickProcess();
    }

＊자바에서는 클래스를 만들고 그 클래스를 호출하면 그 정보는 메모리에 올라감

→ 클래스를 많이 만들면 만들수록 메모리는 많이 필요해지고애플리케이션을 시작할 때 더많은 시간이 소요됨

→ 익명 클래스를 사용하면 간단하게 객체를 생성 가능

 

＊익명 클래스나 내부 클래스는 모두 다른 클래스에서 재사용할 일이 없을 때 생성해야 한다

Nested 클래스의 참조 가능 변수

public class NestedValueReference{
    public int publicInt = 1;
    protected int protectedInt = 2;
    int justInt = 3;
    private int privateInt = 4;
    static int staticInt = 5;

    static class StaticNested{ // static nestec class
        public void setValue(){
            staticInt = -5;
        }
    }

    class Inner{ // inner class
        public void setValue(){
            publicInt = -1;
            protectedInt = -2;
            justInt = -3;
            privateInt = -4;
            staticInt = -5;
        }
    }

    public void setValue(){
        EventListener listener = new EventListener(){ // anonymous class
            public void onClick(){
                publicInt = -1;
                protectedInt = -2;
                justInt = -3;
                privateInt = -4;
                staticInt = -5; 
            }
        };
    }
}

＊Static Nested 클래스는 부모 클래스의 static 변수만 참조 가능

＊내부 클래스와 익명 클래스는 부모 클래스의 어떤 변수라도 참조 가능

＊반대의 경우도 가능 → 부모 클래스에서 nested 클래스의 변수 참조 가능(private 이어도)

 

---

 

17장 어노테이션이라는 것도 알아야 한다

어노테이션(Annotation)

클래스나 메소드 등의 선언시에 @을 사용하는 것으로 메타데이터라고도 한다

어노테이션은

• 컴파일러에게 정보를 알려주거나
• 컴파일할 때와 설치(deployment)시의 작업을 지정하거나
• 실행할 때 별도의 처리가 필요할 때

사용하고, 클래스 메소드 변수 등 모든 요소에 선언 가능하다

 

자바에서 정해져 있는 어노테이션 (JDK 6)

@Override

: 해당 메소드가 부모 클래스에 있는 메소드를 Override했다는 것을 명시적으로 선언

import c.inheritance.Parent;

public class AnnotatinOverride extends Parent{
    @Override
    public void printName(){
        System.out.println("AnnotationOverride");
    }
}

＊AnnotationOverride 클래스에 printName() 메소드 말고도 많은 메소드가 선언되어 있다면 어떤 메소드가 부모 클래스에 있는 것을 Override했는 지 알아보기 힘들기 때문에 어노테이션으로 선언하면 쉽게 확인 가능

 

@Deprecated

: 미리 만들어져 있는 클래스나 메소드가 더 이상 사용되지 않는 경우 선언

public class AnnotationDeprecated {
    @Deprecated
    public void noMoreUse(){ ... }
}

public class AnnotationSample{
    public void useDeprecated(){
        AnnotationDeprecated child = new AnnotationDeprecated();
        child.noMoreUse();
    }
}

$ -Xlint:deprecation javac c/annotatin/AnnotationSample.java
c\annotation\AnnotationSample.java:6: warning: [deprecation] noMoreUse() in c.anotation.

＊Deprecated된 메소드를 컴파일 할 때 “-Xlint:deprecation”이라는 옵션을 추가해 컴파일하면 noMoreUse()라는 메소드는 deprecated되었으니 조심하라는 경고가 발생

→ “에러”가 아닌 “경고”

 

@Supress Warnings

: 컴파일 경고를 사용하지 않도록 선언

public class AnnotationSample{
    @SupressWarnings("deprecation")
    public void useDeprecated(){
        AnnotationDeprecated child = new AnnotationDeprecated();
        child.noMoreUse();
    }
}

＊해당 어노테이션을 선언 후 컴파일하면 경고가 나타나지 않음

 

어노테이션을 선언하기 위한 메타 어노테이션(Meta Annotation)

: 직접 어노테이션을 선언할 때 사용

: java.lang.annotation

 

@Target

: 어노테이션을 어떤 것에 적용할 지를 선언할 때 사용

@Target(ElementType.METHOD)
@Target({ElementType.METHOD, ElementType.TYPE})
// 괄호 안에 적용 대상을 지정

요소	타입대상
CONSTRUCTOR	생성자 선언 시
FIELD	enum 상수를 포함한 필드 값 선언 시
LOCAL_VARIABLE	지역 변수 선언 시
METHOD	메소드 선언 시
PACKAGE	패키지 선언 시
PARAMETER	매개 변수 선언 시
TYPE	클래스, 인터페이스, enum 등 선언 시

 

@Retention

: 얼마나 오래 어노테이션 정보가 유지되는 지

@Retention(RetentionPolicy.RUNTIME)
// 괄호 안에 적용 대상을 지정

	대상
SOURCE	어노테이션 정보가 컴파일 시 사라짐
CLASS	클래스 파일에 있는 어노테이션 정보가 컴파일러에 의해서 참조 가능하지만 가상 머신에서는 사라짐
RUNTIME	실행시 어노테이션 정보가 가상 머신에 의해서 참조 가능

@Documented

: 어노테이션에 대한 정보가 Javadocs(API) 문서에 포함된다는 것을 선언

 

@Inherited

: 모든 자식 클래스에서 부모 클래스의 어노테이션을 사용 가능하다는 것을 선언

 

@Interface

: 어노테이션을 선언할 때 사용

어노테이션 생성 예제

import java.lang.annotation.*;

@Target(ElementType.METHOD)          // 이 어노테이션은 메소드에 사용 가능
@Retention(RetentionPolicy.RUNTIME)  // 실행 시에 이 어노테이션을 참조
public @interface UserAnnotation{    // @UserAnnotation으로 어노테이션 사용 가능
    public int number();
    public String text() default "This is first annotation";
    // 메소드처럼 어노테이션 안에 선언해 놓으면 어노테이션을 사용할 때 해당 항목에 대한 타입으로 값을 지정 가능
    // default 예약어를 사용할 경우, 기본 값 지정 가능
}

// 어노테이션 사용
public clss UserAnnotationSample{
    @UserAnnotation(number=0) // number는 default가 없기 때문에 UserAnnotation 선언 시 반드시 값을 지정
    public static void main(String args[]){
        ...
    }

    @UserAnnotation(number=2, text="second")
    public void annotationSample1(){ ... }

＊자바의 리플렉션 API를 사용하면 직접 선언하여 사용하는 어노테이션에 대한 정보를 확인 가능

 

어노테이션 특징

• 어노테이션은 상속이 불가능 → extends 예약어 사용 불가
• 어노테이션 용도
  • 제약사항 등을 선언: @Deprecated, @Override, @NotNull
  • 용도 표현: @Entity, @TestCase, @WebService
  • 행위 표현: @Statefull, @Transaction
  • 처리 표현: @Column, @XmlElement
• lombok (롬복)
  • https://projectlombok.org/
  • @Getter, @Setter

 

 

---

 

 

18장 이제 기본 문법은 거의 다 배웠으니 정리해 봅시다

 

 

19장 이쯤에서 자바의 역사와 JVM에 대해서 알아보자

JDK (Java Development Kit)

* JDK 1.0 → JDK 1.1

 

J2SE (Java 2 Standard Edition)

* J2SE 1.2 → J2SE 1.3 → J2SE 1.4 → J2SE 5

 

Java SE (Java Standard Edition)

* Java SE 6 → Java SE 7 → Java SE 8

 

JRE (Java Runtime Environment) : 자바를 실행할 수 있는 환경의 집합

 

 

Java 특징

• 자바는 “단순하고, 객체지향이며, 친숙”해야 한다 (simple, object-oriented and familiar)

: 다형성, 캡슐화 등 객체지향 언어의 특징들을 지원할 수 있는 구조

: 개발하면서 필요한 여러 기능들은 API를 통해 제공

: 여러 라이브러리를 통해 쉽게 개발할 수 있는 환경 제공

• 자바는 “견고하며, 보안상 안전”하다 (robust and secure)

: 컴파일할 때와 실행할 때 문법적 오류를 체크

: 메모리 관리 모델이 단순

: 분산 환경에서 사용하기 위해 디자인 → 보안 중요

• 자바는 “아키텍처에 중립적이어야 하며 포터블”해야 한다 (architecture-neutral and portable)

: 자바로 작성한 프로그램은 매우 다양한 하드웨어 아키텍처에서 수행 가능

: 아키텍처에 중립적인 바이트 코드를 생성 → 자바의 버전만 동일하다면 동일한 프로그램은 어떤 플랫폼에서도 실행 가능

: 하드웨어와 소프트웨어 아키텍처에 따른 데이터 타입의 호환성에 문제가 발생하지 않음 → JVM

• 자바는 “높은 성능”을 제공해야 한다 (high performance)

: 가비지 컬렉터는 낮은 우선 순위의 쓰레드로 동작하기 때문에 높은 성능 제공

• 자바는 “인터프리트 언어이며, 쓰레드를 제공하고, 동적인 언어”이다 (interpreted, threaded, and dynamic)

: 자바 인터프리터는 자바 바이트 코드를 어떤 장비에서도 수행 가능하도록 제공

: 멀티 쓰레드 환경을 제공하기 때문에 동시에 여러 작업 수행 → 빠른 사용 환경 제공

: 컴파일 시 정적인 점검을 하고 실행 시 동적으로 필요한 프로그램들을 링크

 

 

Java 버전별 차이

• JDK 1.0
• JDK 1.1
  • AWT(Abstract Window Toolkit)의 이벤트 모델의 확장 및 변경
  • 내부 클래스(inner class) 추가
  • JavaBeans, JDBC(Java Database Connectivity), RMI(Remote Method Invocation) 등 추가
• JDK 1.2
  • strictfp 예약어 추가
  • 자바에서 GUI를 제공하기 위한 Swing이 코어 라이브러리에 추가
  • JIT(Just-In-TIme)라는 컴파일러가 Sun JVM에 추가
  • 자바 플러그인 추가
  • CORBA라는 기술과 데이터를 주고받기 위한 IDL 추가
  • Collections라는 프레임워크 추가
    ＊JIT : 어떤 메소드의 일부 혹은 전체 코드를 네이티브 코드로 변환하여 JVM에서 번역하지 않도록 함으로써 보다 빠른 성능을 제공하는 기술
• JDK 1.3
  • HotSpot JVM 추가
  • CORBA와의 호환성을 위해서 RMI 수정
  • JavaSound 라이브러리 추가
  • JNDI(Java Naming and Directory Interface)가 코어 라이브러리에 추가
  • JPDA(Java Platform Debugger Architecture) 추가
  • Synthetic 프록시 클래스 추가
    ＊JNDI : 어떤 객체를 쉽게 찾을 수 있도록 도와주는 이름을 지정한 후, 나중에 그 이름으로 객체를 찾아가는 것을 의미
• JDK 1.4
  • assert 예약어 추가
  • 정규 표현식 추가
  • exception chaining을 통해 하위 레벨의 예외의 캡슐화 가능
  • IPv6 지원 시작
  • NIO(New Input/Output) 이라는 non-blocking 추가
  • logging API 추가
  • image I/O API 추가
  • 통합 XML 파서, JAXP라는 XSLT 프로세서 추가
  • JCE, JSSE, JAAS와 같은 통합 보안 및 cryptography extensions 추가
  • Java Web Start 추가
  • Preferences API (java,.util.prefs) 추가
    ＊정규표현식 : 어떤 문자열에서 특정 조건에 맞는 값이 있는지를 확인하는 데 사용
    ＊NIO : 이전 버전까지의 IO를 처리할 때 사용한 java.io 패키지에서 제공하는 기능의 단점을 보완하기 위한 것으로 성능이 매우 빠름
• Java 5
  • generic 추가 → 안전한 컬렉션 데이터 처리
  • 어노테이션이라 불리는 메타데이터 기능 추가
  • autoboxing과 unboxing 기능 추가
  • enum 추가
  • varargs 추가 (String … strs)
  • 향상된 for 루프 추가
  • static import 추가
  • concurrent(java.util.concurrent) 패키지 추가
  • Scanner 클래스 추가
• Java 6
  • 스크립팅 언어가 JVM 위에서 수행 가능
  • 각종 코어 기능의 성능 개선
  • Compiler API가 추가되어 프로그램에서 자바 컴파일러 실행 가능
  • 안정성과 확장성
• Java 7
  • 자바의 신[30장 - 31장]
• Java 8
  • 람다 표현식 가능

 

JIT 컴파일러 : 동적 변환

명칭은 컴파일러지만 실행 시에 적용되는 기술

 

프로그램 실행 방식

• 인터프리트 : 프로그램을 실행할 때마다 컴퓨터가 알아 들을 수 있는 언어로 변환하는 작업을 수행 → 간편하지만 성능이 느림
• 정적 컴파일 : 실행하기 전에 컴퓨터가 알아 들을 수 있는 언어로 변환하는 작업을 미리 수행
• JIT : 인터프리터에 의해서 변환 작업은 지속적으로 수행되지만, 필요한 코드의 정보는 캐시에 담아두었다가 재사용

 

javac

• javac : java 파일을 바이트 코드로 변환
• JIT 컴파일러 : 바이트 코드를 컴퓨터가 알아 들을 수 있는 언어(기게어)로 변환

 

JVM과 GC

JVM

• Java Virtural Machine 자바 가상 머신
• 자바 프로그램이 수행되는 프로세스 → 애플리케이션이 수행되면 JVM 위에서 애플리케이션이 동작
• 자바는 JVM이 메모리 관리를 하기 때문에 개발자가 할 필요 없음

GC

• Garbage Collector 가비지 컬렉터
• JVM내에서 메모리 관리를 해줌
• G1을 제외한 나머지 JVM은 영역을 나누어 Heap에 객체들을 관리

• Eden : 객체를 생성하자마자 저장되는 장소
• Young 영역 : Eden + 2개의 Survivor
• Old 영역
• Perm : 클래스나 메소드에 대한 정보가 쌓이는 영역
• Minor GC (Young GC)
  (1) Eden 영역에서 객체가 생성
  (2) Eden 영역이 꽉 차면 살아있는 객체만 Survivor 영역으로 복사되고, 다시 Eden 영역을 채움
  (3) Survivor 영역이 꽉 차게 되면 다른 Survivor 영역으로 객체가 복사되고 Eden 영역에 있는 객체들 중 살아있는 객체들도 다른 Survivor 영역으로 복사 → S0 S1 둘 중 하나는 비어있음
• Magor GC (Full GC)
  (1) 오래 살아있는 객체들은 Old 영역으로 이동
  (2) 지속적으로 이동하다가 Old 영역이 꽉차면 GC가 발생

 

 

---

 

 

20장 가장 많이 쓰는 패키지는 자바랭

java.lang 패키지

: java.lang 패키지에 있는 클래스들을 자바의 패키지 중 유일하게 import를 안해도 사용 가능

언어 관련 기본

타입	항목
인터페이스	Cloneable, Comparable, Iterable, Readable
클래스	Class, ClassLoader, Compiler, Enum, Object, Package, SecurityManager, StackTraceElement, System, Void
예외 및 에러	ArrayIndexOutOfBoundsException, ArrayStoreException, ClassCastException, ClassNotFoundException, CloneNotSupportedException, EnumConstantNotPresentException, IllegalAccessException, IllegalArgumentException, IndexOutOfBoundsException, InstantiationException, NegativeArraySizeException, NoSuchFieldException, NoSuchMethodException, NullPointerException, RuntimeException, SecurityException, TypeNotPresentException, UnsupportedOperationException

문자열 관련

타입	항목
인터페이스	Appendable, CharSequence
클래스	String, StringBuffer, StringBuilder
예외 및 에러	StringIndexOutOfBoundsException

기본 자료형 및 숫자 관련

타입	항목
클래스	Boolean, Byte, Character, Character.Subset, Character.UnicodeBlock, Double, Float, Integer, Long, Math, Number, Short, StrictMath
예외 및 에러	ArithmeticException, NumberFormatException

쓰레드 관련

타입	항목
인터페이스	Runnable, Thread.UncaughtExceptionHandler
클래스	InheritableThreadLocal, Thread, ThreadGroup, ThreadLocal, Thread.State
예외 및 에러	IllegalMonitorStateException, IllegalThreadStateException, InterruptedException

예외 관련

타입	항목
클래스	Throwable
예외 및 에러	Exception

런타임 관련

타입	항목
클래스	Process, ProcessBuilder, Runtime, RuntimePermission
예외 및 에러	IllegalStateException

에러

• OutOfMemoryError(OOME) : 메모리가 부족하여 발생하는 에러
• StackOverflowError: 호출된 메소드의 깊이가 너무 깊을 때 발생하는 에러

 

 

기본 자료형 타입의 클래스

• Byte
• Short
• Integer
• Long
• Float
• Double
• Character
• Boolean

＊Wrapper Class : Byte, Short, Integer, Long, Float, Double

→ Number라는 abstract 클래스를 확장

→ 겉으로 보기에는 참조 자료형이지만 기본 자료형처럼 사용 가능 (자바 컴파일러에서 자동으로 형변환)

Q>숫자를 처리하는 참조 자료형을 만든 이유

A>

• 매개 변수를 참조 자료형으로만 받는 메소드를 처리하기 위해
• 제네릭과 같이 기본 자료형을 사용하지 않는 기능을 사용하기 위해
• MIN_VALUE나 MAX_VALUE와 같이 클래스에 선언된 상수 값을 사용하기 위해
• 문자열을 숫자로, 숫자를 문자열로 수비게 변환하고, 2/8/10/16진수 변환을 쉽게 처리하기 위해

 

 

메소드

• parse타입이름() : 기본 자료형을 리턴, Character 클래스는 제외
• valueOf() : 참조 자료형을 리턴, Character 클래스는 제외 

public void numberTypeCheck(){
	String value1 = "3";
	String value2 = "5";
	byte byte1 = Byte.parseByte(value1); // byte로 변환
	byte byte2 = Byte.parseByte(value2); 
	System.out.println(byte1+byte2);

	Integer refInt1 = Integer.valueOf(value1); // integer로 변환
	Integer refInt2 = Integer.valueOf(value2);
	System.out.println(refInt1+refInt2+"7"); // refInt1+refInt2는 숫자처럼 계산
}

// 결과
8
87

＊parse타입이름()과 valueOf()는 모두 static 메소드 → 타입의 객체를 생성할 필요 없이 바로 사용 가능

 

상수

• MIN_VALUE : 최소값, Boolean 클래스 제외
• MAX_VALUE : 최대값, Boolean 클래스 제외

System.out.println(Byte.MIN_VALUE + ", " + Byte.MAX_VALUE);
System.out.println(Integer.toBinaryString(Integer.MIN_VALUE) + ", " + Integer.toBinaryString(INTEGER.MAX_VALUE));

//결과
-128, 127
10000000000000000000000000000000
1111111111111111111111111111111

＊toBinaryString() : 2진수로 변환

＊toHexString() : 16진수로 변환

 

 

System 클래스

: 생성자가 없다

System 클래스의 메소드

(1) 시스템 속성(Property)값 관리

리턴 타입	메소드 이름 및 매개 변수	설명
static String	clearProperty(String key)	key에 지정된 시스템 속성을 제거
static Properties	getProperties()	현재 시스템 속성을 Properties 클래스 형태로 제공
static String	getProperty(String key)	key에 지정된 문자열로 된 시스템 속성값(value)를 얻음
static String	getProperty(String key, String def)	key에 지정된 문자열로 된 시스템 속성값을 얻고, 만약 없으면 def에 지정된 값을 리턴
static void	setProperties(Properties props)	Properties 타입으로 넘겨주는 매개 변수에 있는 값들을 시스템 속성에 넣음
static String	setProperty(String key, String value)	key에 지정된 시스템 속성의 값을 value로 대체

＊java.util.Properties

: Hashtable의 상속을 받은 클래스로 자바 프로그램을 실행하면 Properties 객체가 생성되며, 그 값은 언제 어디서든 같은 JVM내에서는 꺼내서 사용 가능하다

System.out.println(System.getPropert("java.version")); // java-version이라는 키에 잆는 값을 출력

//결과
java.version=1.8.0_92

 

(2) 시스템 환경(Environment) 값 조회

리턴 타입	메소드 이름 및 매개 변수	설명
static Map<String, String>	getenv()	현재 시스템 환경에 대한 Map형태의 리턴값을 받는다
static String	getenv(String name)	지정한 name에 해당하는 값을 받는다

＊read만 가능

System.out.println(System.getenv("JAVA_HOME")); // JAVA_HOME이라는 JDK가 설치되어 있는 경로 출력

//결과
JAVA_HOME=C:\jdk1.8.92

 

(3) GC 수행

리턴 타입	메소드 이름 및 매개 변수	설명
static void	gc()	가비지 컬렉터를 실행
static void	runFinalization()	GC처리를 기다리는 모든 객체에 대해 finalize() 메소드를 실행

＊사용하지 말기

자바는 메모리 처리를 개발자가 별도로 수행하지 않고 JVM이 알아서 더 이상 필요 없는 객체를 처리하는 GC작업과 finalization 작업을 실행

 

(4) JVM 종료

리턴 타입	메소드 이름 및 매개 변수	설명
static void	exit(int status)	현재 수행중인 JVM을 종료

＊사용하지 말기

 

(5) 현재 시간 조회

리턴 타입	메소드 이름 및 매개 변수	설명
static long	currentTimeMillis()	현재 시간을 밀리초 단위로 리턴
static long	nanoTime()	현재 시간을 나노초 단위로 리턴

＊밀리초 : 1/1000초, 1000ms = 1s (현재 시간을 확인)

＊나노초 : 1/1,000,000,000초 (시간 측정)

 

 

System 클래스의 static 변수

선언 및 리턴 타입	변수명	설명
static PrintStream	err	에러 및 오류를 출력할 때 사용
static InputStream	in	입력값을 처리할 때 사용
static PrintStream	out	출력값을 처리할 때 사용

＊ System.out.println()

• System : 클래스 이름
• out : static으로 선언된 변수 이름 (PrintStream 타입)
• println() : PrintStream 클래스에 선언된 static 메소드
• 모두 static으로 선언되어 있기 때문에 별도의 클래스 객체를 생성할 필요 없이 사용 가능
• 출력과 관련된 메소드는 java.io.PrintStream 클래스에서 찾아야 함(System 클래스가 아니라)

 

System.out

• PrintStream 클래스의 출력을 위한 메소드
  (1) print() : 매개변수에 있는 내용들을 줄바꿈하지 않고 출력
  (2) println() : 매개변수에 있는 내용들을 출력하고 줄바꿈
  (3) format()
  (4) printf()
  (5) write()
• print(), println()의 매개 변수

print(boolean b)	print(char c)	print(char[] s)	print(doubld d)	print(float f)
print(int i)	print(long l)	print(Object obj)	print(String s)

println(boolean b)	println(char c)	println(char[] s)	println(doubld d)	println(float f)
priprintln(int i)	println(long l)	println(Object obj)	println(String s)	println()

• null 객체 출력

＊null 객체를 toString()으로 출력하면 예외 발생 (NullPointerException)

＊valueOf() 메소드를 사용하여 출력하는 것이 훨씬 안전