Bibliothek

○ Wrapper 클래스

   1. 자바에서는 언어 수준에서 제공하는 기본 데이터를 제외한 나머지는 클래스로 정의하여 객체 단위로 처리한다.
  따라서 자바에서는 이러한 기본형 데이터를 객체 단위로 처리할 수 있도록 클래스를 제공할 수 밖에 없는데
  이러한 클래스들을 가리켜 Wrapper 클래스라 한다.

  "10" → String → 객체 → Object
     ↓
 객체  → Integer → 메소드 parseInt() → 10
   
   2. 기본 자료형인
  byte, short,  int,        long,  float, double,  char,         boolean 형에 대응하는
  Byte, Short, Integer, Long, Float, Double, Character, Boolean 의 Wrapper 클래스 및 큰 숫자들을 다루기 위한
  java.math.BigInteger 와 java.math.BigDecimal 클래스를 제공한다.

  Wrapper 클래스는 java.lang 패키지에 포함되어 있으므로 별도의 import 과정 없이 바로 사용하는 것이 가능하며 기본형과 마찬가지로 Wrapper 클래스도 내부 메소드를 통해 형 변환이 가능하고 동등비교와 같은 연산도 가능하다.

  ex) java.lang.Integer 클래스
      int 기본 자료형의 Wrapper 클래스로 정수를 다루는데 필요한 상수나 메소드, 진수 변환 등에 필요한 메소드 등을 포함하고 있다.

  static int parseInt(String s)
  문자열 형식으로 저장된 숫자를 정수 형태로 반환한다

  static Integer valueOf(int i)
  int 형을 Integer 형으로 반환한다.

  byte byteValue(), int intValue()
  , short shortValue, long longValue()
  , float floatValue(), double doubleValue()
  해당 기본 자료형으로 형 변환한 값을 반환한다.

○ 박싱(Boxing)과 언박싱(Unboxing)

   박싱 : 기본 타입의 값을 Wrapper 객체로 변환

   언박싱 : Wrapper 객체에 들어 있는 기본 타입의 값을 빼내는 것

○ 오토 박싱(Auto-Boxing)과 오토 언박싱(Auto-Unboxing)

   일반적으로 레퍼런스 형과 기본 자료형은 호환되지 않으며 이 경우 발생하는 문제 해결을 위해 자바에서는 Wrapper 클래스를 제공하게 되었다. 하지만, JDK 1.5 부터 레퍼런스 형과 기본 자료형이 다음과 같은 방식으로 형 변환이 가능하게 되었다.

   int a=10, b;
   Integer ob;
   ob = a;
   기본 자료형(int)이 Integer 형으로 자동 변환(오토 박싱)
   실제로는 ... 『ob = new Integer(a);』

   b = ob;
   Integer(객체)가 기본 자료형 int 형으로 자동 변환(오토 언박싱)
   실제로는 ... b = ob.IntValue();

   이는 JDK 1.5 이후 추가된 오토 박싱 / 오토 언박싱이라는 기능으로 인해 가능해진 것이다.

/*========================================
  ■■■ 자바의 주요(중요) 클래스 ■■■
  - Wrapper 클래스
==========================================*/

public class Test135
{
	public static void main(String[] args)
	{
		int a = 10, b;
		Integer c;
		Object d;

		b = a; //-- int 형 데이터(자료) → int 형 변수
		c = new Integer(0);

		// ※ 레퍼런스 형(참조 타입)과 기본 자료형(값 타입)은 호환되지 않는다.
	
		b = c;					//-- Integer 형 데이터(객체) → int 형 변수(오토 언박싱)
		b = c.intValue();		//-- 언박싱

		d = new Object();
		System.out.println("d.toString() : " + d.toString());
		//--==>> d.toString() : java.lang.Object@15db9742

		d = new Integer(10);	//-- 업 캐스팅
		System.out.println("d.toString() : " + d.toString());
		//--==>> d.toString() : 10

		d = new Double(12.345);	//-- 업 캐스팅
		System.out.println("d.toString() : " + d.toString());
		//--==>> d.toString() : 12.345

		d = 10;					//-- 오토 박싱
		/*
		Integer i = 10;
		→ Integer i = new Integer(10);

		Object o = i;
		→ Object o = new Integer(10);

		Object o = 10;
		*/
		System.out.println("d.toString() : " + d.toString());
		//--==>> d.toString() : 10

	}
}

/*========================================
  ■■■ 주바의 주요(중요) 클래스 ■■■
  - Object 클래스
==========================================*/

class NewCar
{
	private int velocity;			//-- 자동차의 속도
	private int wheelNum;			//-- 자동차의 바퀴 갯수
	private String carName;			//-- 자동차의 이름

	NewCar(int speed, String name, int wheel)
	{
		velocity = speed;
		carName = name;
		wheel = wheel;
	}
}

public class Test134
{
	public static void main(String[] args)
	{
		NewCar nCar1 = new NewCar(100, "볼보", 4);
		NewCar nCar2 = new NewCar(150, "BMW", 4);

		// equals()
		System.out.println("1-1 : " + nCar1.equals(nCar2));		
		System.out.println("1-2 : " + (nCar1 == nCar2));	
		//--==>> 1-1 : false
		//	     1-2 : false

		NewCar nCar3 = nCar1;	//-- 객체 복사 → 얕은 의미 복사(참조형)
								//   → 주소값 복사

		System.out.println("2-1 : " + nCar1.equals(nCar3));
		System.out.println("2-2 : " + (nCar1 == nCar3));
		//--==>>2-1 : true
		//		2-2 : true

		
		// toString()
		System.out.println("3-1 : " + nCar1.toString());
		System.out.println("3-2 : " + nCar2.toString());
		System.out.println("3-3 : " + nCar3.toString());
		//--==>> 3-1 : NewCar@15db9742
		//		 3-2 : NewCar@6d06d69c
		//		 3-3 : NewCar@15db9742
		

		// hashCode()
		System.out.println("4-1 : " + nCar1.hashCode());
		System.out.println("4-2 : " + nCar2.hashCode());		
		System.out.println("4-3 : " + nCar3.hashCode());
		//--==>>4-1 : 366712642
		//		4-2 : 1829164700
		//		4-3 : 366712642
		//-- 결과값을 16진수 형태로 바꾸게 되면
		//   『toString()』메소드가 반환한 결고값 확인 가능


		// getClass()
		System.out.println("5-1 : " + nCar1.getClass());
		System.out.println("5-2 : " + nCar2.getClass());
		System.out.println("5-3 : " + nCar3.getClass());
		//--==>> 5-1 : class NewCar
		//		 5-2 : class NewCar
		//		 5-3 : class NewCar
		//-- 생성된 객체를 통해
		//   기반 설계도 클래스를 확인할 수 있는 기능을 가진 메소드

		
		// clone()		//-- 객체 복사

		// finalize()	//-- 객체 직렬화

		// 기타 나머지 메소드는 스레드 처리와 관련이 있다.


	}
}

 객체(Object)들을 비교하는 과정에서 사용하는 『==』 연산자는
 크기를 비교하는 것이 아니라 객체의 주소값을 비교.

 『==』 연산자와 Object 클래스의 『equals()』 메소드는
 동일한 개념으로 객체의 주소값을 비교.

/*========================================
  ■■■ 주바의 주요(중요) 클래스 ■■■
  - Object 클래스
==========================================*/

// import java.lang.*;

class Test // extends Object
{
	/*
	public boolean equals(Object obj)
	{
	}
	*/

	private int a = 10;

	public void write()
	{
		System.out.println("a : " + a);
	}
}



public class Test133
{
	public static void main(String[] args)
	{
		Test ob1 = new Test();
		Test ob2 = new Test();
		
		System.out.println("10 == 9 : " + (10 == 9));
		//--==>> 10 == 9 : false

		int a = 10;
		int b = 10;
		System.out.println("a == b : " + (a == b));
		//--==>> a == b : true
		
		System.out.println("ob1 == ob2 : " + (ob1 == ob2));
		//--==>> ob1 == ob2 : false
		//-- 객체(Object)들을 비교하는 과정에서 사용하는 『==』 연산자는
		//   크기를 비교하는 것이 아니라 객체의 주소값을 비교.

		// 『equals()』
		System.out.println("ob1.equals(ob2) : " + (ob1.equals(ob2)));
		//--==>> ob1.equals(ob2) : false
		//-- 『==』 연산자와 Object 클래스의 『equals()』 메소드는
		//   동일한 개념으로 객체의 주소값을 비교.

		System.out.println();
		System.out.println("----------------------------------------");		
		System.out.println();


		System.out.println("ob1            : " + ob1);
		System.out.println("ob1.toString() : " + ob1.toString());	
		//--==>>ob1            : Test@15db9742
		//		ob1.toString() : Test@15db9742

		// 『클래스명@16진수해시코드』

		// ※ 해시코드(hashcode)
		//    : 자바 내부적으로 객체를 구분하기 위해 사용하는 것
		//		메모리의 주소값으로 생각하면 절대 안된다.


		// check~!!!
		// ※ 객체가 같은면 hashcode(해시코드)가 같지만
		//    hashcode(해시코드)가 같다고 같은 객체는 아니다.
		

	}
}

○ 개요

   일반적으로 클래스는 하나만 존재하는 것이 아니라 같은 종류의 클래스를 여러개 묶어서 사용하게 되는데 이러한 클래스나 인터페이스의 묶음을 패키지(package)라고 한다. Sun(Oracle)사에서는 자바 프로그램을 효율적으로 작성할 수 있도록 자바 표준 패키지를 제공하며, 자바 표준 패키지에는 그래픽, 네트워크, 데이터베이스 등의 다양하고 유용한 클래스들이 포함되어 있다.

○ import 구문
   
   자바 표준 패키지나 사용자에 의해 외부에서 만들어진 패키지를 사용하기 위해서는 컴파일을 수행하기에 앞서 프로그램에 포함시키는 과정이 필요한데, 이 때, 『import』 문을 이용하여 패키지 또는 클래스를 프로그램에 포함시키게 된다.
   하지만, 『java.lang.*』 이 패키지의 클래스들은 import 하지 않고 바로 사용하는 것이 가능하다.
   import 문은 반드시 클래스 설계 구문 전에 선언되어 있어야 하며 형식은 다음과 같은 두 가지가 있다.

   import [static] 패키지.클래스;
   import [static] 패키지.*;

   ※ JDK 1.5 부터는 import 다음에 『static』 키워드를 붙임으로써 정적으로 패키지를 import 할 수 있는 기능을 제공하게 되었다. 만약 패키지를 정적으로 import 한 경우라면 모든 접근 가능한 메소드와 멤버 변수들은 접두사(ob, br, sc 처럼...)를 붙이지 않고 사용하는 것이 가능하다.

○ Object 클래스

   『java.lang.Object』 클래스는 자바 클래스의 최상위 클래스로 자바 표준 패키지의 클래스나 사용자에 의해 작성된

모든 클래스는 기본적으로 이 클래스로부터 상속받는다. 따라서 자바의 모든 클래스는 『java.lang.Object』클래스의 메소드를 가지고 있으며, 바로 사용하는 것이 가능하다.

위에서 설명했듯이 모든 클래스는 『java.lang.Object』클래스를 상속 받기때문에 Object 클래스에 정의된 toString()메소드를 사용할 수 있다.

/*========================================
  ■■■ 자바의 주요(중요) 클래스 ■■■
==========================================*/

// ※ Test132.java 와 비교~!!!

//import java.lang.*
// → import java.lang.Object

public class Test131 //extends Object
{
	/*
	Object 클래스로부터 상속받은 멤버들
	...
	
	String toString()
	{
	}
	*/
	
	/*
	public Test131()	// default 생성자의 접근제어지시자는 클래스의 접근제어지시자와 같음
	{
	}	
	*/

	public static void main(String[] args)
	{
		Test131 ob = new Test131();

		// 객체.xxx();
		//-- 해당 객체를 생성시키는 대상 클래스의 메소드 xxx() 호출

		//Rect ob = new Recr();
		//ob.input();
		//-- ob 객체를 생성시키는 대상 클래스 → Rect 클래스
		//   Rect 클래스에 정의되어 있는 input() 메소드 호출

		// 객체.xxx();
		//-- 해당 객체를 생성시키는 대상 클래스에 
		//   xxx() 메소드가 존재하지 않을 경우...
		//   → 에러 발생
		
		//ob.test();
		//System.out.printlb(ob.test());
		//--==>> 에러 발생

		System.out.println(ob.toString());
		//--==>> Test131@15db9742
		//-- 『클래스명@16진수해시코드』
		//				---------------
		//				자바가 객체를 구분하기 위해 임의로 부여하는 식별번호
		//-- 에러가 발생하지 않는 상황
		//   → toString() 메소드가 Test131 클래스에 존재
		//		→ Object 클래스로부터 상속

		System.out.println(ob);
		//--==>> Test131@15db9742


	}
}

Object 클래스의 메소드를 재정의 해서 사용할 수도 있다

/*========================================
  ■■■ 주바의 주요(중요) 클래스 ■■■
  - Object 클래스
==========================================*/

// ※ Test131.java 와 비교~!!!

//import java.lang.*;
// → import java.lang.Object;

public class Test132 //extends Object
{
	/*
	...
	public String toString()
	{
	}		
	*/
	
	@Override
	public String toString()
	{
		return "재정의한 toString()...";
	}

	public static void main(String[] args)
	{
		Test132 ob = new Test132();

		System.out.println(ob.toString());
		//--==>> 재정의한 toString()...

		System.out.println(ob);
		//--==>> 재정의한 toString()...


	}
}

   4. 무명 클래스(익명 클래스, annoymous class) 이름 없는 클래스

  - 클래스 또는 인터페이스에 대한 객체를 생성하면서 바로 클래스 또는 인터페이스를 정의하는 클래스
  - 정의하는 부분과 생성하는 부분이 하나로 묶여져 new 수식이 있는 곳에서 바로 클래스 또는 인터페이스를 정의하는 것을 의미한다.

   - AWT 나 안드로이드 이벤트 처리에서 일반적으로 사용.
   - 상위 클래스 메소드를 하나 정도 재정의할 필요성이 있을 때 사용.
   - 클래스의 객체가 필요하면 또 다시 클래스를 생성해야 하는 번거로움으로 인해 익명의 클래스를 생성하여 처리할 수 있다.


 ○ 형식 및 구조
   
    new 상위클래스의 생성자()
    {
           접근제어지시자 자료형 메소드()
           {
                 ...;
           }
    }; // ← 반드시 세미콜론 필요함~!!!

무명 클래스(익명 클래스, annoymous class) 이름 없는 클래스의 예시

/*===========================
  ■■■ 클래스 고급 ■■■
  - 중첩 클래스(내부 클래스)
=============================*/

// package default;

// import java.lang.*;	→ import java.lang.Object;

class Test3 //extends Object
{
	/*
	
	Object 클래스의 멤버들...
	...
	...

	public String toString()
	{
		...;
	}
	
	*/

	public Object getString()
	{
		//return ...;
		//	   ----
		//     Object 타입

		//return new Object(){....};
		//	     -------------------
		//     Object 타입

		return new Object()
		{
			@Override
			public String toString()
			{
				return "익명의 클래스...";
			}
		};		// ← 세미콜론 check~!!!
	}
}


public class Test130//extends Object
{
	/*
	Object 가 갖고있는 멤버들
	즉, Object 로 부터 상속받은 멤버들
	...
	*/

	public static void main(String[] args)
	{
		Test3 ob1 = new Test3();
		Test3 ob2 = new Test3();

		System.out.println(ob1.toString());
		//--==>> Test3@15db9742

		System.out.println(ob2.getString());
		//--==>> 익명의 클래스...


	}
}



/*
public int 메소드명()
{
	return 10;
		   ---
		   int 타입
}

public Scanner 메소드명()
{
	Scanner sc = new Scanner(System.in);

	return sc;
	       --
		   Scanner 타입
}

public FruitSeller 메소드명()
{
	return new FruitSeller();
		   -----------------
		       FruitSeller 타입
			       
}
*/

   3. 지역 클래스(로컬 클래스, local class)
      메소드 내부에... 『public class 클래스명』 or 『public static class 클래스명』

  - 클래스의 메소드 안에서 클래스를 정의하는 것으로 내부 멤버 클래스와 유사한 성격을 가지고 있긴 하지만 접근제어지시자는 붙일 수 없다.

지역 클래스(로컬 클래스, local class)의 예시

/*===========================
  ■■■ 클래스 고급 ■■■
  - 중첩 클래스(내부 클래스)
=============================*/

// outer
class InnerOuterTest
{
	static int a = 10;
	int b = 20;

	class InnerNested
	{
		int c = 30;

		void write()
		{
			System.out.println("inner 의 write()...");
			System.out.println("a : " + a);
			System.out.println("b : " + b);
			System.out.println("c : " + c);
		}
	}

	void write()
	{
		System.out.println("outer 의 write()...");
		InnerNested ob1 = new InnerNested();
		ob1.write();	//-- inner 의 write() 메소드 호출
	}
}

public class Test129
{
	public static void main(String[] args)
	{
		InnerOuterTest ob2 = new InnerOuterTest();
		ob2.write();	//-- outer 의 write() 메소드 호출
		//--==>> outer 의 write()...
		//		 inner 의 write()...
		//		 a : 10
		//		 b : 20
		//		 c : 30

		//InnerNested ob3 = new InnerNested();
		//--==>> 에러 발생

		//InnerOuterTest.InnerNested ob4 = new InnerOuterTest.InnerNested();
		//--==>> 에러 발생

		// ※ 중첩 내부 클래스(static 중첩 클래스)와는 달리
		//    외부 클래스의 인스턴스(객체)를 사용하지 않고
		//    단독으로 내부 클래스의 인스턴스를 생성하는 것은 불가능하다.

		// ※ Test127.java 파일과 비교할 것~!!!

		InnerOuterTest.InnerNested ob5 = ob2.new InnerNested();
		ob5.write();
		//--==>> inner 의 write()...
		//		 a : 10
		//		 b : 20
		//		 c : 30

		InnerOuterTest.InnerNested ob6 = new InnerOuterTest().new InnerNested();
		ob6.write();
		//--==>> inner 의 write()...
		//		 a : 10
		//		 b : 20
		//		 c : 30


	}
}