JAVA 정리 - '5분 요약 자바'

 

JAVA 와 C/C++ 등의 객체지향언어 차이점

가장 큰 차이점은 실행환경이다.

JAVA 개발 : 컴파일 OR 컴파일 + JAR 압축

JAVA는 링크 과정이 없이 컴파일러가 바로 바이트코드를 생성해준다.

C/C++ 개발 : 컴파일 + LINK

---

JAVA 언어의 장단점

장점

운영체제에 독립적이다

JVM 이라는 가상머신에서 동작하기 때문에, 특정 운영체제에 종속되지 않는다.

객체지향 언어이다.

객체지향적으로 프로그래밍 하기 위해 캡슐화, 상속화, 추상화, 다형성 등의 특징을 갖고있다.

비교적 이해하고 배우기 쉽다.

자동으로 메모리를 관리 해준다.

Gabage Collector가 일어나서 정리해줌.

별도의 관리가 필요없으니, 로직에 집중하기 좋다.

오픈 소스이다.

많은 JAVA 개발자가 존재하고 생태계가 잘 구축되어, 오픈소스 라이브러리가 풍부하다.

멀티스레드를 쉽게 구현 가능하다.

자바는 스레드 생성 및 제어와 관련된 라이브러리API를 제공하고 있기 떄문에 실행되는 운영체제에 상관없이 멀티 스레드를 쉽게 구현할 수 있다.

동적 로딩을 지원한다. (Dynamic Loading)

애플리케이션이 실행될 때 모든 객체가 실행되지 않고, 각 객체가 필요한 시점에 동적 로딩 후 생성한다.

단점

비교적 속도가 느리다

JAVA는 JVM에 의해 기계어로 번역되고 실행하는 과정을 거치기 때문에 C, C++보다 속도가 느리다.

예외처리가 불편하다.

프로그래머 검사가 필요한 예외가 등장하면 무조건 프로그래머가 예외 선언을 해줘야 한다.

---

JAVA의 접근 제어자

public (+) 어떤 클래스에서든 접근이 가능하다.

private (-) 이 클래스에서 생성된 객체들만 접근이 가능하다.

protected (#) 이 클래스와 동일 패키지에 있거나 상속 관계에 있는 하위 클래스의 객체들만 접근이 가능하다.

package (~) 동일 패키지에 있는 클래스의 객체들만 접근이 가능하다.

---

OOP 의 특징

추상화

구체적인 사물들의 공통적인 특징을 파악해서 이를 하나의 개념으로 다루는 것.

캡슐화

정보은닉 : 필요가 없는 정보는 외부에서 접근하지 못하도록 제한하는 것

일반화 관계

여러 개체들이 가진 공통 특성을 부각시켜 하나의 개념이나 법칙으로 성립시키는 과정

다형성

서로 다른 클래스의 객체가 같은 메세지를 받았을 때 각자의 방식으로 동작하는 능력

---

OOP의 원칙 (SOLID)

S : 단일 책임의 원칙 ( SRP : Single Responsibility Principle )

객체는 단 하나의 책임만 가져한다.

O : 개방-폐쇄 원칙(OCP, Open Closed Principle)

기존의 코드를 변경하지 않으면서 기능을 추가할 수 있도록 설계가 되어야 한다.

L : 리스코프 치환 원칙(LSP, Liskov Substitution Principle)

자식 클래스는 최소한 자신의 부모클래스에서 가능한 행위는 수행할 수 있어야 한다.

I : 의존 역전 원칙(DIP, Dependency Inversion Principle)

의존 관계를 맺을때 변화하기 쉬운 것 또는 자주 변화하는 것 보다는 벼화하기 어려운것, 거의 변화가 없는것에 의존하라는 것이다.

D : 인터페이스 분리 원칙(ISP, Interface Segregation Principle)

인터페이스를 클라이언트에 특화되도록 분리 시키라는 설계원칙이다.

---

객체지향 프로그래밍과 절차지향 프로그래밍의 차이점

절차 지향 프로그래밍

• 실행하고자 하는 절차를 정하고, 절차대로 프로그래밍하는 방법이다.
• 목적을 달성하기 위한 일의 흐름에 중점을 둔다.

객체 지향 프로그래밍

• 실세상의 물체를 객체로 표현하고, 이들 사이의 관계, 상호 작용을 프로그램으로 나타낸다.
• 객체를 추출하고 객체들의 관계를 결정하고 이들의 상호 작용에 필요한 함수(메서드)와 변수(필드)를 설계 및 구현한다.
• 객체 지향의 행심은 연관되어 있는 변수와 메서드를 하나의 그룹으로 묶어서 그룹핑하는 것이다.
• 사람의 사고와 가장 비슷하게 프로그래밍을 하기 위해서 생성된 기법
• 하나의 클래스를 바탕으로 서로 다른 상태를 가진 인스턴스를 만들면 서로 다른 행동을 하게 된다. 즉, 하나의 클래스가 여러 개의 인스턴스가 될 수 있다는 점이 객체 지향이 제공하는 가장 기본적인 재활용성이라고 할 수 있다.

 

---

객체지향(Object-Oriented)이란

java의 non-static 멤버와 static 멤버의 차이

non-static 멤버

공간적 특성: 멤버는 객체마다 별도로 존재한다. (인스턴스 멤버)

시간적 특성: 객체 생성 시에 멤버가 생성된다.

• 객체가 생길 때 멤버도 생성된다.
• 객체 생성 후 멤버 사용이 가능하다.
• 객체가 사라지면 멤버도 사라진다.

공유의 특성: 공유되지 않는다.

• 멤버는 객체 내에 각각의 공간을 유지한다.

static 멤버

공간적 특성: 멤버는 클래스당 하나가 생성된다.

• 멤버는 객체 내부가 아닌 별도의 공간에 생성된다.
• 클래스 멤버 라고 부른다.

시간적 특성: 클래스 로딩 시에 멤버가 생성된다.

• 객체가 생기기 전에 이미 생성된다.
• 객체가 생기기 전에도 사용이 가능하다. ( 즉 객체 생성 하지 않고도 사용가능 )
• 객체가 사라져도 멤버는 사라지지 않는다.
• 멤버는 프로그램이 종료될 때 사라진다.

공유의 특성: 동일한 클래스의 모든 객체들에 의해 공유된다.

---

java의 final 키워드 (final/finally/finalize)

final 키워드

• 개념 : 변수나 메서드 또는 클래스가 "변경 불가능 " 하도록 만든다.
• 원시(Private) 변수에 적용시 해당 변수의 값은 변경이 불가능하다.
• 참조 (Reference) 변수에 적용 시, 참조 변수가 힙(HEAP) 내의 다른 객체를 가르키도록 변경할 수 없다.
• 메서드에 적용시, 해당 메서드를 오버라이드 할수 없다.
• 클래스에 적용 시, 해당 클래스의 하위 클래스를 정의할 수 없다.

finally 키워드

• 개념 : TRY / CATCH 블록이 종료 시 항상 실행될 코드 블록을 정의하기 위해 사용된다.
• finally는 선택적으로 try 혹은 catch 블록 뒤에 정의 할 때 사용된다. 단 JVM 이 try 블록 실행 중에 종료되는 경우는 제외한다.
• finally 블록은 종종 뒷 마무리 코드를 작성하는 데 사용된다.
• finally 블록은 try catch 블록 다음과 통제권이 이전으로 다시 돌아가기 전 사이에 실행된다.

finalize () 메서드

• 개념 : 가비지 콜렉터가 더이상 참조하지 않는 객체를 메모리에서 삭제하겠다고 결정하는 순간 호출된다.
• Object 클래스의 finalize() 메서드를 오버라이드해서 맞춤별 GC를 정의할 수 있다.

JAVA의 Generic , C++의 Template 차이점

Generic

• 개념 : 모든 종류의 타입을 다룰 수 있도록 일반화된 타입 매개 변수로 클래스나 메서드를 선언하는 기법이다.
• 처리방법 : 타입 제거라는 개념에 근거한다.
  • 소스 코드를 JVM이 인식하는 바이트 코드로 변환할 때 인자로 주어진 타입을 제거하는 기술이다.
  • 제네릭이 있다고 해서 크게 달라지는 것은 없다.
  • 제네릭은 문법적 양념이라고 부른다.

Vector<String> vector = new Vector<String>(); 
vector.add(new String("hello")); 
String str = vector.get(0); // 컴파일러가 아래와 같이 변환해준다. 
Vector vector = new Vector();
vector.add(new String("hello")); 
String str = (String) vector.get(0);

Template

• 개념: 템플릿은 하나의 클래스를 서로 다른 여러 타입에 재사용할 수 있도록 하는 방법이다. ( ex : 연결리스트의 자료구조 )
• 처리방법 : 컴파일러는 인자로 주어진 각각의 타입에 대해 별도로 템플릿 코드를 생성한다. 하지만 java에서 정적 변수는 제네릭(Generic) 인자로 어떤 타입을 주었는지에 관계없이 MyClass로 만든 모든 객체가 공유한다. 즉, 템플릿은 좀 더 우아한 형태의 매크로다.

/** MyClass.h **/
template<class T> class MyClass {
public: static int val; MyClass(int v) { val = v; } }; 
/** MyClass.cpp **/
template<typename T> int MyClass<T>::bar; 
template class MyClass<Foo>; template class MyClass<Bar>;
/** main.cpp **/ MyClass<Foo> * foo1 = new MyClass<Foo>(10);
MyClass<Foo> * foo2 = new MyClass<Foo>(15);
MyClass<Bar> * bar1 = new MyClass<Bar>(20);
MyClass<Bar> * bar2 = new MyClass<Bar>(35);
int f1 = foo1->val; // 15 int f2 = foo2->val; // 15 int b1 = bar1->val; // 35 int b2 = bar2->val; // 35

 

---

java의 제네릭과 c++의 템플릿의 차이

• List처럼 코드를 작성할 수 있다는 이유에서 동등한 개념으로 착각하기 쉽지만 두 언어가 이를 처리하는 방법은 아주 많이 다르다.
• c++의 Template에는 int와 같은 기본 타입을 인자로 넘길 수 있지만, java의 Generic에서는 Integer을 대신 사용해야 한다.
• c++의 Template은 인자로 주어진 타입으로부터 객체를 만들어 낼 수 있지만, java에서는 불가능하다.
• java에서 MyClass로 만든 모든 객체는 Generic 타입 인자가 무엇이냐에 관계없이 전부 동등한 타입이다.(실행 시간에 타입 인자 정보는 삭제된다.)
• c++에서는 다른 Template 타입 인자를 사용해 만든 객체는 서로 다른 타입의 객체이다.
• java의 경우 Generic 타입 인자를 특정한 타입이 되도록 제한할 수 있다. 예를 들어 CardDeck을 Generic 클래스로 정의할 때 CardGame의 하위 클래스만 사용되도록 제한할 수 있다.
• java에서 Generic 타입의 인자는 정적 메서드나 변수를 선언하는 데 사용될 수 없다. 왜냐하면 MyClass나 MyClass가 이 메서드와 변수를 공유하기 때문이다.
• c++ Template은 이 두 클래스를 다른 클래스로 처리하므로 Template 타입 인자를 정적 메서드나 변수를 선언하는 데 사용할 수 있다.

클래스, 객체, 인스턴스의 차이점

• 클래스(Class)
  • 객체를 만들어 내기 위한 설계도 혹은 틀이다.
  • 연관되어 있는 변수와 메서드의 집합이다.
• 객체 (Object)
  • 소프트웨어 세계에 구현할 대상이다.
  • 클래스에 선언된 모양 그대로 생성된 실체이다.
  • 클래스의 인스턴스라고 부른다.
  • OOP관점에서 클래스의 타입으로 선언되었을때 '객체'라고 부른다.

인스턴스

• 설계도를 바탕으로 소프트웨어 내에 구현된 구체적인 실체이다.
  • 객체를 소프트웨어에 실체화 하면 인스턴스이다.
  • 인스턴스는 메모리에 할당된다.
• 인스턴스는 객체에 포함된다.
• 메모리에 할당되어 실제 사용될 때 인스턴스라고 부른다.

// 클래스
public class A { } 

public class B { 
	public static void main(String[] args) {
      A a, b; //객체
      a = new A(); // 인스턴스화
 } }

• 추상화 기법
  1. 분류 ( Classification )실제하는 객체들을 공통적인 속성을 공유하는 범부 또는 추상적인 개념으로 묶는 것.
  2. 객체 → 클래스
  3. 인스턴스화 ( Instantitation )분류의 반대개념으로, 범주나 개념으로 부터 실제하는 객체를 만드는 과정이다.
  4. 구체적으로 클래스 내의 객체에 대해 특정한 변형을 정의하고, 이름을 붙인 다음, 물리적인 어떤 장소에 위치시키는 작업 등을 통해 인스턴스를 만드는 것을 말한다
  5. 클래스 → 인스턴스화

 

---

오버로딩과 오버라이딩의 차이점 ( Overloading vs Overriding )

• 오버로딩 ( Overloading )
  • 메서드의 이름은 같으나, 이낮의 수나 자료의 형태가 다른경우.public int a (String a) {.. } public int a ( String a, String b ) {.. }
• 오버라이딩 ( Overriding )
  • 상위 클래스의 메서드와 이름이 같은 함수를 하위클래스에 재정의 하는것이다. ( 상속 )
  • 상속 관계에 있는 클래스 간에 같은 이름 메서드를 정의한다.

값에 의한 호출 Call by Value , 참조에 의한 호출 Call by Reference

• 값에 의한 호출
  • 함수가 호출 될 때 메모리 공간 안에서는 함수를 위한 별도의 임시공간이 생성된다.
  • 함수 호출시 인자로 전달되는 벼눗의 값을 복사하여 함수의 인자로 전달한다.
  • 복사된 인자는 함수 안에서 지역적으로 사용되는 local 값의 특성을 지닌다.
  • 즉, 함수안에서 인자의 값이 변경되어도 외부 변수의 값은 변경되지 않는다.
  • 자바는 항상 값에의한 호출이다.
  • 함수가 호출 될 때 메모리 공간 안에서는 함수를 위한 별도의 임시공간이 생성된다.
  • 함수 호출시 인자로 전달되는 변수의 레퍼런스를 전달한다. (해당 변수를 가르킨다.)
  • 따라서 함수 안에서 인자의 값이 변경되면, 인자로 전달된 변수의 값도 함께 변경된다. )참조에 의한 호출

---

인터페이스와 추상 클래스의 차이 ( Interface VS Abstract Class )

• 추상 메서드 (Abstract Method )
  • 선언만 되고, 코드는 작성되지않는다.

  public abstract String abc();​

• 추상 클래스 ( Abstract Class )
  • 개념 : abstract 로 선언된 클래스이다.
    1. 추상 메서드를 최소한 한가지 이상 가지고, 선언된 클래스.
    2. 최소 한개의 추상 메서드를 포함하는 경우, 반드시 추상 클래스로 선언하여야 한다.
    3. 추상 메서드가 없어도 abstract 로 선언한 클래스
    4. 추상 메서드가 하나도 없어도 추상 클래스로 선언할 수 있다.
  • 구현
    • 서브 클래스에서 슈퍼클래스의 모든 추상 메서드를 오버라이딩하여 실행가능한 코드로 구현한다.
  • 목적
    • 상속을 위한 부모 클래스로 활용하기 위한 목적이다.
    • 여러 클래스들의 공통된 부분을 추상화 하여 상속받는 클래스에게 구현을 강제화 하기 위한 것이다.
    • 추상클래스의 추상 메서드를 자식 클래스가 구체화하여 그 기능을 확장하는것에 목적이 있다.

  abstract class Shape { // 추상 클래스 
  Shape() {...} void edit() {...}
  abstract public void draw(); // 추상 메서드 }​

• 인터페이스 ( Interface )
  • 개념 : 추상메서드와 상수만을 포함하며, interface를 선언한다.
  • 구현
    • 인터페이스를 상속 받고, 추상 메서드를 모두 구현한 클래스를 작성한다.
    • implements를 통해 구현
  • 목적
    • 상속받을 서브 클래스에게 구현 할 메서드들의 원형을 모두 알려주어 클래스가 자신의 목적에 맞게 메서드를 구현하도록 하는 것이다.
    • 구현 객체의 같은 동작을 보장하기 위한 목적이다.
    • 서로 관련없는 클래스에서 공통적으로 사용하는 방식이 필요하지만 기능을 각각 구현할 필요가 있는 경우에 사용한다.
  • 특징
    • 인터페이스는 상수 필드와 추상 메서드만으로 구성된다.
    • 모든 메서드는 추상 메서드로서 abstract public 속성이며 생략이 가능하다.
    • 상수 public static final 속성이며, 생략하여 선언할 수 있다.
    • 인터페이스를 상속받아 새로운 인터페이스를 만들 수 있다.

    interface MobilePhone extends Phone { 
    /* 인터페이스의 개념 */
    interface Phone {// 인터페이스
    int BUTTONS = 20;
     // 상수 필드 (public static final int BUTTONS = 20;과 동일) void sendCall(); // 추상 메서드 (abstract public void sendCall();과 동일)
    abstract public void receiveCall(); // 추상 메서드 } }​

  •  
• 추상 클래스와 인터페이스의 공통점
  • 인스턴스(객체)를 생성 할 수없다.
  • 선언만 있고, 구현 내용은 없다.
  • 자식 클래스가 메서드의 구체적인 동작을 구현하도록 책임을 위임한다.
• 추상 클래스와 인터페이스의 차이점
  • 서로 다른 목적을 갖고 있다.
    • 추상 클래스는 추상 메서드를 자식 클래스가 구체화 하여 그 기능을 확장하는데 목적이 있다.
    • 인터페이스는 서로 관련이 없는 클래스에서 공통적으로 사용하는 방식이 필요하지만 기능을 각각 구현할 필요가 있는경우이다.
  • 추상 클래스는 클래스이지만 인터페이스는 클래스가 아니다.
  • 추상 클래스는 단일 상속이지만 인터페이스는 다중 상속이 가능하다.
  • 추상 클래스는 is a kind of 인터페이스는 can do this
  •  

---

JVM 의 구조와 형태

Java Collection Framework

• MAP
  • 검색할 수 있는 인터페이스
  • 데이터 삽입 시 KEY : VALUE 형태로 삽입 되며, Key를 이용해 Value를 얻을 수 있다.
• Collection
  • List
    • 순서가 있는 Collection
    • 데이터의 중복이 포함된다
  • Set
    • 집합적인 개념의 Collection
    • 순서의 의미가 없다.
    • 데이터의 중복이 포함되지 않는다.
• Collections Framework 선택 과정
  1. Map VS Collection 인터페이스 선택 시 사용목적에 따라 List 와 Set중에 선택한다
  2. 사용목적에 따라 Map, List, Set 각각 하위 구현체를 선택한다.
     1. Map : HashMap, LinkedHsahMap, HashTable, TreeMap
     2. List : LinkedList, ArrayList
     3. Set : TreeSet, HashSet

Map 인터페이스 구현체 설명

HashMap

• Entry<Key,Value> 의 배열로 저장이 되며, 배열의 인덱스는 내부 햄쉬 함수를 통해서 계산된다
• 내부 Hash값에 따라 키 순서가 정해지므로 특정 규척 없이 출력 된다.
• Key , Value 값은 null 값을 허용한다.
• 비동기 처리를 위해 사용한다.
• 시간 복잡도 설명 : O(1)

LinkedHashMap

• HashMap을 상속 받으며, LinkeList로 저장된다.
• 입력한 순서대로 출력된다.
• 비동기 처리를 위해 사용
• 시간 복잡도 설명 : O(n)

ConCurrentHashMap

• multiple Lock
• update할때만 동기 처리
• key : value에 null 을 허용하지 않는다.

HashTable

• single Lock
• 모든 메서드에 대해서 동기 처리한다.
• key : value에 null을 허용하지 않는다.

Set 인터페이스 구현체의 종류

HashSet

• 저장 순서를 유지하지 않는 데이터의 집합이다.
• 해시알고리즘을 사용하여 검색속도가 빠르다.
• 내부적으로 HashMap인스턴스를 이용해 요소를 저장한다.

LinkedHashSet

• 저장 순서를 유지하는 HashSet

TreeSet

• 데이터가 정렬된 상태로 저장되는 이진 탐색 트리의 형태로 요소를 저장한다.
• 이진 탐색 트리 중에 성능을 향상시킨 레드-블랙 트리로 구현되어 있다.
• Compartor 구현으로 정렬 방법을 지정 할 수 있다.

List 인터페이스 구현체의 종류

ArrayList

• 단방향 포인터 구조로 각 데이터에 대한 인덱스를 가지고 있어 데이터 검색에 적합하다.
• 데이터의 삽입, 삭제시 해당 데이터 이후 모든 데이터가 복사되므로 삽입, 삭제 가 빈번한 데이터에는 부적합하다.

LinkedList

• 양방향 포인터 구조로 데이터의 삽입, 삭제 시 해당 노드의 주소지만 바꾸면 되므로 삽입, 삭제가 빈번한 데이터에 적합하다.
• 더이터의 검색 시 처음부터 노드를 순회하므로 검색에는 부적합하다.
• 스택, 큐, 양방향 큐 등을 만들기 위한 용도로 쓰인다.

Vector

• 내부에서 자동으로 동기화 처리가 일어난다.
• 성능이 좋지 않고 무거워 잘 쓰이지 않는다.

Wrapper Class

Annotation

String, StringBuilder, StringBuffer

String

• 새로운 값을 할당할 떄마다 새로 클래스에 대한 객체가 생성된다.
• String에 저장되는 문자열은 private final char[] 형태이기 때문에 String 값은 바꿀 수 없다.
  • private : 외부 접근 불가능
  • final : 초기값 변경 불가능
• String + String + String ..
  • 각각의 String 주소값이 Stack 에 쌓이고 ,Garbage Collector 가 호출 되기 전까지 생성된 String 객체들은 Heap에 쌓이기 때문에 메모리 관리에 치명적이다.
  • String을 직접 더하는것보다는 String buffuer, StringBuilder 가 효율적이다.

StringBuilder, StringBuffer

• 메모리에 append 하는 방식, 클래스에 대한 객체를 직접생성 하지는 않는다.
• StringBuilder
  • 변경 가능한 문자열이다.
  • 비동기 처리한다.
• • 변경 가능한 문자열이다.
  • 동기 처리이다.
  • mutiple Tread 환경에서 안전한 클래스이다. ( Tread Safe )StringBuffer

---

리플렉션 ( Reflection )

리플렉션이란 ?

• 자바에서 이미 로딩이 완료된 클래스에서 또 다른 클래스를 동적으로 로딩하여 생성자, 멤버 필드, 그리고 멤버 메서드 등을 사용할 수 있는 기법이다.
• 클래스의 패키지 정보, 접근 지정자, 수퍼 클래스, 어노테이션 등을 얻을 수 있다.
• 컴파일 시간이 아니라 실행시간에 동적으로 특정 클래스의 정보 객체화를 통해 분석 및 추출 해 낼수 있는 프로그래밍 기법이다.

사용 방법

• Class.forName (" 클래스의 이름" )
• 클래스의 이름으로부터 인스턴스를 생성 할 수 있고, 이를 이용하여 클래스의 정보를 가져올 수 있다.

public class DoHee {
  public String name; 
  public int number; 

public void setDoHee (String name, int number) { 
	this.name = name; this.number = number; 
} 
public void setNumber(int number) {
	this.number = number; 
} 
public void sayHello(String name) {
	System.out.println("Hello, " + name); 
    } } 
    
===============================================

 import java.lang.reflect.Method; 
 import java.lang.reflect.Field;
 /* ReflectionTest 클래스 */
 public class ReflectionTest { 
 public void reflectionTest() { try { 
 Class myClass = Class.forName("DoHee");
 Method[] methods = myClass.getDeclaredMethods(); 
 /* 클래스 내 선언된 메서드의 목록 출력 */
 /* 출력 : 
 public void DoHee.setDoHee(java.lang.String,int)
 public void DoHee.setNumber(int) 
 public void DoHee.sayHello(java.lang.String) */ 
 
 for (Method method : methods) { 
 System.out.println(method.toString()); 
 }
 /* 메서드의 매개변수와 반환 타입 확인 */
 
 /* 출력 : 
 Class Name : class DoHee
 Method Name : setDoHee 
 Return Type : void */
 
 Method method = methods[0];
 System.out.println("Class Name : " + method.getDeclaringClass());
 System.out.println("Method Name : " + method.getName());
 System.out.println("Return Type : " + method.getReturnType());
 /* 출력 : Param Type : class java.lang.String Param Type : int */ 
 
 Class[] paramTypes = method.getParameterTypes();
 for(Class paramType : paramTypes) {
 System.out.println("Param Type : " + paramType); 
 }
 
 /* 메서드 이름으로 호출 */
 Method sayHelloMethod = myClass.getMethod("sayHello", String.class);
 sayHelloMethod.invoke(myClass.newInstance(), new String("DoHee")); 
 // 출력 : Hello, DoHee 
 
 /* 다른 클래스의 멤버 필드의 값 수정 */
 Field field = myClass.getField("number");
 DoHee obj = (DoHee) myClass.newInstance();
 obj.setNumber(5);
 System.out.println("Before Number : " + field.get(obj));
 // 출력 : Before Number : 5 field.set(obj, 10);
 
 System.out.println("After Number : " + field.get(obj));
 // 출력 : After Number : 10 } catch (Exception e) { // Exception Handling }
 } 
 
 public static void main(String[] args) {
 new ReflectionTest().reflectionTest(); 
 }

사용 이유 :

• 실행 시간에 다른 클래스를 동적으로 로딩하여 접근 할 때
• 클래스와 멤버 필드 그리고 메서드등에 관한 정보를 얻어야할때
• 리플렉션 없이도 완성도 높은 코드를 구현할 수 있지만 사용한자면 더 유연한 코드를 만들 수 있다.

주의점

• 외부에 공개되지않는 private 멤버도 Filed.setAccessible() 메서드를 true로 지정하면 접근과 조작이 가능하기에 주의해야함.

 

 

---

https://gmlwjd9405.github.io/2017/10/01/basic-concepts-of-development-java.html
본 글은 위의 글을 참고하여 작성 되었습니다.