[필기정리]Day20 - 래퍼클래스(Wrapper class), Boxing&UnBoxing

SW/Java

2020. 7. 7. 11:35

Q. 복사 메소드 호출 시, 아래의 PersonalInfo 클래스가 깊은 복사를 수행하도록 코드를 변경하시오.

class Business
{
	private String company;
	private String work;

	public Business(String company, String work)
	{
		this.company = company;
		this.work = work;
	}
	public void showBusinessInfo()
	{
		System.out.println("회사 : " + company);
		System.out.println("업무 : " + work);
	}
	public void changeWork(String work)
	{
		this.work=work;
	}
}

class PersonalInfo
{
	private String name;
	private int age;
	private Business bness;

	public PersonalInfo(String name, int age, String company, String work)
	{
		this.name = name;
		this.age = age;
		bness = new Business(company, work);
	}
	public void showPersonalInfo()
	{
		System.out.println("이름 : " + name);
		System.out.println("나이 : " + age);
		bness.showBusinessInfo();
		System.out.println("");
	}
	public void changeWork(String work)
	{
		bness.changeWork(work);
	}
}

class DeepCopyImpl
{
	public static void main(String[] args)
	{

			PersonalInfo pInfo = new PersonalInfo("James", 22, "HiMedia", "encoding");
			PersonalInfo pCopy = (PersonalInfo)pInfo.clone();
			pCopy.changeWork("decoding");

			pInfo.showPersonalInfo();
			pCopy.showPersonalInfo();
	}
}

 

A.

class Business implements Cloneable
{
	private String company;
	private String work;

	public Business(String company, String work)
	{
		this.company = company;
		this.work = work;
	}
	public void showBusinessInfo()
	{
		System.out.println("회사 : " + company);
		System.out.println("업무 : " + work);
	}
	public void changeWork(String work)
	{
		this.work=work;
	}
    public object clone() throws CloneNotSupportedException
    {
    }
}

class PersonalInfo implements Cloneable
{
	private String name;
	private int age;
	private Business bness;

	public PersonalInfo(String name, int age, String company, String work)
	{
		this.name = name;
		this.age = age;
		bness = new Business(company, work);
	}
	public void showPersonalInfo()
	{
		System.out.println("이름 : " + name);
		System.out.println("나이 : " + age);
		bness.showBusinessInfo();
		System.out.println("");
	}
	public void changeWork(String work)
	{
		bness.changeWork(work);
	}
    public Object clone() throws CloneNotSupportedException
    {
    	PersonalInfo cpy = (PersonalInfo)super.clone();
        cpy.bness = (Business) bness.clone();
        return cpy;
    }
}

class DeepCopyImpl
{
	public static void main(String[] args)
	{

			PersonalInfo pInfo = new PersonalInfo("James", 22, "HiMedia", "encoding");
			PersonalInfo pCopy;
            try
            {
            	pCopy= (PersonalInfo)pInfo.clone();
				pCopy.changeWork("decoding");

				pInfo.showPersonalInfo();
				pCopy.showPersonalInfo();
             }
             catch(CloneNotSupportedException e)
             {
             	e.printStackTrace();
             }
	}
}

 

Q. 때로는 int, double과 같은 기본 자료형 데이터들도 인스턴스로 표현을 해야만 하는 경우가 있다. 

    예를 들어 다음과 같이 정의된 메소드가 존재한다고 가정해보자.

    (이 메소드는 이미 정의되어있고, 여러분은 이 메소드를 반드시 활용해야만 하는 상황이라고 가정하자.

    기능의 단순함에는 신경 쓰지 말자).

public static void showData(Object obj)
{
	System.out.println(obj);
}

그런데 이 메소드를 통해서 출력해야 할 데이터가 정수 3과 실수 7.15이다. 

이러한 상황에서는 정수 3과 실수 7.15가 Object 클래스를 상속하는 인스턴스의 형태가 되어야만 

위 메소드의 인자로 전달될 수 있다. 

이것이 기본 자료형 데이터가 인스턴스로 표현되어야 하는 상황인데, 

이렇듯 인스턴스의 참조 값을 요구하는 자리에 기본 자료형 데이터를 놓아야 하는 경우, 

기본 자료형 데이터를 인스턴스로 표현해야 한다.

그러면 위에 있는 메소드를 이용하여 정수 3을 출력하도록 하자.
기본 자료형 데이터를 인스턴스로 표현하기 위해서 여러분이 직접 클래스를 정의해도 된다.

 

A.

class NumberMain
{
	public static void showData(Object obj)
	{
		System.out.println(obj);
	}
}

class Number
{
	private int num;
    
    public Number(int num)
    {
    	this.num = num;
    }
    

    
}

 

# 래퍼클래스(Wrapper Class) : 기본 자료형들을 인스턴스로 만들기 위해 사용되는 클래스

                                        각각의 자료형에 대응되는 클래스가 있음

                                        String과 성격이 비슷하며, 새로운 객체가 생성되는 것이다.

                                        값을 변경할 수 없다.

 

기본자료형 Wrapper class 생성자 활용 예시
boolean Boolean Boolean(boolean value)
Boolean(String s)		 Boolean b = new Boolean(true);
Boolean b2 = new Boolean("true");
char Character Character(char value) Character c = new Character('a');
byte Byte Byte(byte value)
Byte(String s) 		 Byte b = new Byte(10);
Byte b2 = new Byte("10");
short Short Short(short value)
Short(String s) 		 Short s = new Short(10);
Short s2 = new Short("10");
int Integer Integer(int value)
Integer(String s) 		 Integer i = new Integer(100);
Integer i2 = new Integer("100");
long Long Long(long value)
Long(String s) 		 Long l = new Long(100);
Long l2 = new Long("100");
float Float Float(double value)
Float(float value)
Float(String s) 		 Float f = new Float(1.0);
Float f2 = new Float(1.0f);
Float f3 = new Float("1.0f");
double Double Double(double value)
Double(String s) 		 Double d = new Double(1.0);
Double d2 = new Double("1.0");

<표 출처 : Java의 정석 3rd Edition p.491>

 

- Character 클래스를 제외한 모든 Wrapper 클래스에는 

   String의 참조 값을 인자로 받는 생성자들이 정의되어 있어서,

   문자열로 표현된 데이터를 기반으로 하는 인스턴스의 생성도 가능하다.

Interger num1 = new Integer("240");
Double num2 = new Double("12.257");

 

# Boxing : 기본자료형을 인스턴스 형태로 만드는 것 (상자처럼 싸는 것)

  Unboxing : 인스턴스 형태를 기본자료형으로 꺼내는 것 (상자에서 꺼내는 것)

 

//Tip : Wrapper 클래스는 산술연산을 위해 정의된 클래스가 아니다. 
         따라서 Wrapper 클래스의 인스턴스에 저장된 값은 변경이 불가능하다. 
         다만 위 예제에서 보인 것처럼,

         증가된 값을 저장하는 새로운 인스턴스의 생성 및 참조만이 가능할 뿐이다.

 

- Auto Boxing & Auto Unboxing : 자바 버전 5.0부터 Boxing과 Unboxing이 필요한 상황에서

                                             이를 자동으로 처리하기 시작했다.

ex)

class AutoBoxingUnboxing
{	
	public static void main(String[] args)
	{
		Integer iValue=10; 	
		Double dValue=3.14;  // Auto Boxing
		
		System.out.println(iValue);	
		System.out.println(dValue);
		
		int num1=iValue;		
		double num2=dValue;		// Auto Unboxing
		System.out.println(num1);
		System.out.println(num2);
	}
}

ex 해설1) Interger형 참조 변수에는 Integer형 인스턴스의 참조 값이 저장되어야 한다.
            그런데 이 문장에서는 정수 10을 저장하려 하고 있다.

            이러한 경우에는 정수 10을 바탕으로 Integer형 인스턴스가 자동으로 생성되고,
            이 인스턴스의 참조 값이 대신 저장된다.

            이러한 현상을 가리켜 Auto Boxing이라 한다.

 

ex 해설2) num1에 저장될 값으로 int형 데이터가 등장해야 하는데,

             Integer형 참조변수 iValue가 등장하였다.

             이 경우에는 iValue.intValue()가 자동으로 호출되어,

            그 반환 값이 변수 num1에 저장된다.

            이러한 현상을 가리켜 Auto Unboxing이라 한다.

 

 

- 위 예제에서 보이듯이 Integer형 참조변수가 와야 할 위치에

   int형 데이터가 오면 Auto Boxing이 진행된다. 
  그리고 int형 데이터가 와야 할 위치에

  Integer형 참조변수가 오면 Auto Unboxing이 진행된다. 


  이러한 Auto Boxing과 Auto Unboxing은 보다 다양한 상황에서 다양한 형태로 적용이 되어, 
  다음 예제에서 보이는 코드의 구성도 허용한다.

 

ex)

class AutoBoxingUnboxing2
{	
	public static void main(String[] args)
	{
		Integer num1=10;
		Integer num2=20;
		
		num1++;				// Unboxing과 Boxing이 동시에 진행된다.
						// num1 = new Integer(num1.intValue() + 1);
		System.out.println(num1);
		
		num2+=3;			// num2 = new Integer(num2.intValue() + 3);
		System.out.println(num2);	
		
		int addResult=num1+num2;
		System.out.println(addResult);
		
		int minResult=num1-num2;	
		System.out.println(minResult);	
	}
}

- Wrapper 클래스는 산술연산을 위해 정의된 클래스가 아니라고 하였는데, 

  이 사실에는 변함이 없다.  
  다만 이러한 Wrapper 클래스가 

  Auto Boxing과 Auto Unboxing으로 인해서 산술연산이 가능해졌을 뿐이다.

 

Q.

[static 메소드를 이용한 인스턴스의 생성]
기본 자료형 데이터를 이용한 Wrapper 클래스의 인스턴스 생성 방법에는(= boxing)

다음과 같이 두 가지가 존재한다.


* 키워드 new를 이용한 일반적인 인스턴스의 생성방법
* static 메소드를 이용한 인스턴스의 생성방법

아래와 API문서를 참조하여 폴더에 있는 예제를 static 메소드를 이용해서

Boxing 처리하는 형태로 바꿔보자.

class AboutStaticWrapping
{
	public static void main(String[] args)
	{
		Integer iValue1 = new Integer(10);
		Integer iValue2 = new Integer(10);

		if(iValue1==iValue2)
			System.out.println("iValue1과 iValue2는 동일 인스턴스 참조");
		else
			System.out.println("iValue1과 iValue2는 다른 인스턴스 참조");
	}
}

 

A. 

class AboutStaticWrapping
{
	public static void main(String[] args)
	{
		Integer iValue1 = new Integer(10);
		Integer iValue2 = new Integer(10);

		if(iValue1==iValue2)
			System.out.println("iValue1과 iValue2는 동일 인스턴스 참조");
		else
			System.out.println("iValue1과 iValue2는 다른 인스턴스 참조");
	}
}


/*
class AboutStaticWrapping
{
	public static void main(String[] args)
	{
		Integer iValue1 = new Integer(10);
		Integer iValue2 = new Integer(10);

		System.out.println("------------- Constructor -------------");
		if(iValue1==iValue2)
			System.out.println("iValue1과 iValue2는 동일 인스턴스 참조");
		else
			System.out.println("iValue1과 iValue2는 다른 인스턴스 참조");

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

		Integer iValue3 = Integer.valueOf(20);
		Integer iValue4 = Integer.valueOf(20);

		if(iValue3==iValue4)
			System.out.println("iValue3과 iValue4는 동일 인스턴스 참조");
		else
			System.out.println("iValue3과 iValue4는 다른 인스턴스 참조");
	}
}
*/

 

- jdk 구 버전부터는 사용을 권장하지 않고 있다.

  성능 상으로도 좋지 않고 추후 이 생성자를 삭제할 예정이기 때문!

 

- ValueOf()를 사용하는 것을 더 권장한다.

  (string에서 인스턴스 생성 대신  " "를 쓰는 것과 같은 이유이다.)

 

  "valueOf 메소드를 이용한 인스턴스의 생성은 성능의 향상으로 이어진다.  
  따라서 특별한 상황이 아니라면,  
  static으로 선언된 valueOf 메소드를 이용해서 인스턴스를 생성하기 바란다." 

 

# BigInteger(class)

  Long 범위를 벗어나는 정수를 저장하고 싶을 때 기본자료형으로 저장할 수 없을 때 사용

  저장할 때 문자(" ")로 저장하는데, 이는 integer보다 크기가 커 저장할 수 없기 때문이다.

 

ex)

import java.math.*;

class SoBigInteger
{
	public static void main(String[] args)
	{
		System.out.println("최대 정수: " + Long.MAX_VALUE);
		System.out.println("최소 정수: " + Long.MIN_VALUE);
		
		BigInteger bigValue1=new BigInteger("100000000000000000000"); // 문자열로 만들어 저장하는 것
		BigInteger bigValue2=new BigInteger("-99999999999999999999");
		
		BigInteger addResult=bigValue1.add(bigValue2);
		BigInteger mulResult=bigValue1.multiply(bigValue2);
		
		System.out.println("큰 수의 덧셈결과: "+addResult);
		System.out.println("큰 수의 곱셈결과: "+mulResult);
	}
}

 

#BigDecimal(class) : 오차없는 실수 연산을 하기 위함

 

- 실수는 기본적으로 오차를 가지고 있다.

  float - 소수점 이하 6자리까지

  double - 소수점 이하 13 자리까지 정확도를 갖는다.

  하지만 저장 과정에서 오차를 발생시킬 수 있기 때문이다! 

 

ex) 

import java.math.*;

class NoErrorBigDecimal
{
	public static void main(String[] args)
	{
		BigDecimal e1=new BigDecimal("1.6");
		BigDecimal e2=new BigDecimal("0.1");
		
		System.out.println("두 실수의 덧셈결과: "+ e1.add(e2));
		System.out.println("두 실수의 곱셈결과: "+ e1.multiply(e2));
	}
}

 

Q. API문서를 참고하여 BigDecimal로 표현하시오.

class DoubleError
{
	public static void main(String[] args)
    {
    	double e1=1.6;
        double e2=0.1;
        
        System.out.println("두 실수의 덧셈결과 :"+(e1+e2));
        System.out.println("두 실수의 곱셈결과 :"+(e1*e2));
    }
}

 

A.

import java.math.*;

class WowDoubleError
{
	public static void main(String[] args)
    {
    	Bigdecimal e1 = new Bigdecimal("1.6"); // BigInteger처럼 문자열로 저장!
        Bigdecimal e2 = new Bigdecimal("0.1");
        
        System.out.println("두 실수의 덧셈결과 :" + e1.add(e2));
        System.out.println("두 실수의 곱셈결과 :" + e1.multiply(e2));
    }
}

 

Q. [BigDecimal 클래스의 활용] 
    프로그램 사용자로부터 두 개의 실수를 입력 받은 후,

    두 실수의 차에 대한 절대값을 계산하여 출력하는 프로그램을 작성하자.

    단, 오차가 존재하지 않아야 하며

    문제의 해결을 위해서 반드시 BigDecimal 클래스의 API 문서를 참조하기 바란다.

 

A.

import java.util.Scanner;
import java.math.BigDecimal;

class BigDecimalABS
{
	public static void main(String[] args)
	{
		Scanner sc = new Scanner(System.in);
		System.out.print("실수 1 입력 : ");
		String val1 = sc.nextLine();

		System.out.println("실수 2 입력 : ");
		String val2 = sc.nextLine();

		BigDecimal e1 = new BigDecimal(val1);
		BigDecimal e2 = new BigDecimal(val2);

		BigDecimal subResult = e1.subtract(e2);
		System.out.println("두 실수의 차에 대한 절대값 : " + subResult.abs());
	}
}

 

# Math 클래스 (java.Math 패키지)
  Math 클래스는 모든 멤버가 static으로 선언되어 있는

  수학관련 기능의 제공을 위해 정의된 클래스일뿐,

  인스턴스의 생성을 목적으로 정의된 클래스는 아니다.

 

- Math.random() : 0~1 미만까지의 실수를 반환하는 것

 

ex)

class MathClass
{	
	public static void main(String[] args)
	{
		System.out.println("원주율: " + Math.PI);
		System.out.println("2의 제곱근: " + Math.sqrt(2));
		
		System.out.println(
				"파이에 대한 Degree: " + Math.toDegrees(Math.PI));
		System.out.println(
				"2파이에 대한 Degree: " + Math.toDegrees(2.0*Math.PI));	
		
		double radian45=Math.toRadians(45);	// 라디안으로의 변환!
		System.out.println("싸인 45: " + Math.sin(radian45));
		System.out.println("코싸인 45: " + Math.cos(radian45));
		System.out.println("탄젠트 45: " + Math.tan(radian45));
		
		System.out.println("로그 25: " + Math.log(25));
		System.out.println("2의 4승: "+ Math.pow(2, 4));
	}
}

 

# Random 클래스(java.util 패키지)의 메소드 종류

메소드명 메소드 기능
boolean nextBoolean()  boolean형 난수 반환 
int nextInt() int형 난수 반환 
long nextLong() long형 난수 반환 
int nextInt(int n) 0 이상 n 미만의 범위 내에 있는 int형 난수 반환
float nextFloat() 0.0 이상 1.0 미만의 float 형 난수 반환 
double nextDouble() 0.0 이상 1.0 미만의 double 형 난수 반환


- 컴퓨터가 생성하는 난수를 가리켜 'Pseudo-random number'라 하는데, 이는 '가짜 난수'라는 뜻이다. 
ex)

import java.util.Random;

class PseudoRandom
{	
	public static void main(String[] args)
	{
		Random rand=new Random(12); // 씨드가 고정되어서 결과값이 동일하게 나온다.
		
		for(int i=0; i<100; i++)
			System.out.println(rand.nextInt(1000));
	}
}

 

Q. [난수의 활용] 문제1 
    프로그램 사용자로부터 최대 정수 A와 최소 정수 B를 입력 받는다.

    그리고 A와 B사이에 존재하는(A와 B도 포함) 난수 10개를 생성해서

    출력하는 프로그램을 작성해보자.

 

A.

import java.util.Scanner;
import java.util.Random;

class RandomBetween
{
	public static void main(String[] args)
	{
		Scanner keyboard = new Scanner(System.in);
		System.out.print("최대 : ");
		int max = keyboard.nextInt();

		System.out.print("최소 : ");
		int min = keyboard.nextInt();

		Random rand = new Random();

		int randVal;
		for(int i=0;i<10;i++)
		{
			randVal = rand.nextInt(max-min+1);
			randVal += min;
			System.out.println(randVal);
		}
	}
}

 

Q. [난수의 활용] 문제2

    API 문서를 참조해서(사실참조하지 않고도 구현 가능하다),

    Math.random 메소드를 호출하여 0이상 10미만의 난수 5개를 생성해서

    출력하는 프로그램을 작성해보자.

    참고로 이 메소드는 0.0 이상 1.0 미만의 난수를 생성함에 주의해야 한다.

 

A.

class UseMathRandom
{
	public static void main(String[] args)
	{
		int randVal;
		for(int i=0;i<5;i++)
		{
			randVal = (int)(Math.random()*10);			
			System.out.println(randVal);
		}
	}
}

# StringTokenizer(class) 

StringTokenizer st=new StringTokenizer(문자열, ":"); // :는 구분자

 

- hasMoreTokens() : 뒤에 토큰이 더 남았는지 물어보는 것(boolean값 반환)

- nextToken()

  ㄴ 역할  ① 현재 문자열 토큰 출력

              ② 다음 토큰 위치로 포인터 이동

 

Q. 수학 클래스를 이용하여 다음을 구하시오. 

1. short 그리고 int와 같은 정수 자료형의 문제점은 매우 큰 수의 표현이 불가능하다는데 있고, 

   float 그리고 double과 같은 실수 자료형의 문제점은

   정밀한 값의 표현이 불가능해 항상 오차가 존재한다는데 있다.

   자바는 이러한 문제점의 해결을 위해서 (  ) 클래스와 (  ) 클래스를 제공하고 있다.

A. BigInteger클래스, BigDecimal 클래스

2. Wrapper 클래스의 static 변수를 이용하여 가장 큰 수와 가장 작은 수를 출력하시오.

A. 

System.out.println(Integer.MIN_VALUE);
System.out.println(Integer.MAX_VALUE);

 

3. 1번에서 설명한 클래스를 이용하여 100000000000000000000 와 

  -99999999999999999999 를 각각 저장하고 두 수를 서로 더하고 곱한 결과를 출력하시오.

A. 

import java.math.*;

class SoBigInteger
{
	public static void main(String[] args)
	{
		System.out.println("최대 정수: " + Long.MAX_VALUE);
		System.out.println("최소 정수: " + Long.MIN_VALUE);
		
		BigInteger bigValue1=new BigInteger("100000000000000000000"); // 문자열로 만들어 저장하는 것
		BigInteger bigValue2=new BigInteger("-99999999999999999999");
		
		BigInteger addResult=bigValue1.add(bigValue2);
		BigInteger mulResult=bigValue1.multiply(bigValue2);
		
		System.out.println("큰 수의 덧셈결과: "+addResult);
		System.out.println("큰 수의 곱셈결과: "+mulResult);
	}
}


4. 1번에서 말한 클래스를 이용하여 실수 1.6과 0.1을 더한 값과 곱한 값을 각각 구하시오.

A. 

import java.math.*;

class NoErrorBigDecimal
{
	public static void main(String[] args)
	{
		BigDecimal e1=new BigDecimal("1.6");
		BigDecimal e2=new BigDecimal("0.1");
		
		System.out.println("두 실수의 덧셈결과: "+ e1.add(e2));
		System.out.println("두 실수의 곱셈결과: "+ e1.multiply(e2));
	}
}


5. 컴퓨터의 현재시간을 기준으로, 

   1970년 1월1일 자정 이후로 지나온 시간을

   밀리 초(1/1000초) 단위로 계산해서 반환하는 메소드는?

A.  currentTimeMillis()

6. 매개변수 없는 난수 발생 생성자의 원리는?

public Random() 
{ 
	this(System.currentTimeMillis()); // 씨드 값을 전달받는 또 다른 생성자의 호출 
}

 Math 클래스에 static으로 선언되어 있는 random 메소드를 이용해서 난수를 생성하는 방법도 있다.

 Math 클래스에 정의되어 있는 random 메소드는 Random 클래스의 nextDouble 메소드와 마찬가지로 

 0.0 이상 1.0 미만의 double 형 난수를 반환한다. 

 물론 실행할 때마다 새로운 씨드 값이 설정되기 때문에, 실행할 때마다 다른 유형의 난수가 생성된다. 

A. 

import java.util.Random;

class SeedChangeRandom
{	
	public static void main(String[] args)
	{
		Random rand=new Random(12);
		rand.setSeed(System.currentTimeMillis());
		
		for(int i=0; i<100; i++)
			System.out.println(rand.nextInt(1000));
	}
}

 

7. 문자열을 조건에 따라 나눌 때 쓰는 클래스와

   그 클래스와 문자열을 구분자를 기준으로 나눌 때 쓰는 생성자는?
   (문자열에서는 콜론이 '구분자(delimiter)'이다.

    그리고 구분자를 기준으로 나뉘어지는 문자열 정보를 가리켜 토큰(token)이라 한다.)

A. StringTokenizer

8. 다음 토큰 반환할 때 쓰는 메소드

A. String nextToken()


9. 반환할 토큰이 남았는지 확인하는 메소드

A. boolean hasMoreTokens()


10. "11:22:33:44:55" 를 ":"를 구분자로 하여 각각의 토큰을 출력하시오.

A. 

import java.util.StringTokenizer;

class TokenizeString
{	
	public static void main(String[] args)
	{
		StringTokenizer st=new StringTokenizer("11:22:33:44:55", ":"); // 문자열, "구분자"
		
		while(st.hasMoreTokens()) // 뒤에 토큰이 더 남았는지 물어보는 것(boolean값 반환)
			System.out.println(st.nextToken()); // 1. 현재 문자열 토큰 출력 2. 다음 토큰 위치로 포인터 이동
	}
}


11.  "TEL 82-02-997-2059"를 " "을 구분자로 하여 각각의 토큰을 출력하시오.

      "num+=1"를 "+="을 구분자로 하여 각각의 토큰을 출력하시오.

A. 

import java.util.StringTokenizer;

class TokenizeString2
{	
	public static void main(String[] args)
	{
		String phoneNum="TEL 82-02-997-2059"; 	//국제 전화번호
		String javaCode="num+=1";
		
		System.out.println("First Result...........");
		StringTokenizer st1=new StringTokenizer(phoneNum);
		while(st1.hasMoreTokens())
			System.out.println(st1.nextToken());
		
		System.out.println("\nSecond Result...........");
		StringTokenizer st2=new StringTokenizer(phoneNum, " -");
		while(st2.hasMoreTokens())
			System.out.println(st2.nextToken());
		
		System.out.println("\nThird Result...........");
		StringTokenizer st3=new StringTokenizer(javaCode, "+=", true);
		while(st3.hasMoreTokens())
			System.out.println(st3.nextToken());
	}
}

 

# Generic

 

Q. 예제 GenericBaseFruitBox.java의 FruitBox<T> 클래스에 생성자를 추가하여, 

    다음의 main 메소드가 컴파일 및 실행됨을 확인해보자.

class GenericBaseFruitBox
{	
	public static void main(String[] args)
	{
		FruitBox<Orange> orBox=new FruitBox<Orange>(new Orange(10));
		Orange org=orBox.pullOut();
		org.showSugarContent();
		
		FruitBox<Apple> apBox=new FruitBox<Apple>(new Apple(20));
		Apple app=apBox.pullOut();
		app.showAppleWeight();
	}
}

 

A. 

class Orange
{
	int sugarContent;	// 당분 함량
	public Orange(int sugar) { sugarContent=sugar; }
	public void showSugarContent()
	{ 
		System.out.println("당도 "+sugarContent);
	}
}

class Apple
{
	int weight;	// 사과의 무게
	public Apple(int weight) { this.weight=weight; }
	public void showAppleWeight()
	{ 
		System.out.println("무게 "+weight);
	}	
}

class FruitBox<T>
{
	T item;
	FruitBox(T item)
	{
		this.item = item;
	}
	public void store(T item) { this.item=item; }
	public T pullOut() { return item; }
}

class GenericBaseFruitBox
{	
	public static void main(String[] args)
	{
		FruitBox<Orange> orBox=new FruitBox<Orange>(new Orange(10));
		Orange org=orBox.pullOut();
		org.showSugarContent();
		
		FruitBox<Apple> apBox=new FruitBox<Apple>(new Apple(20));
		Apple app=apBox.pullOut();
		app.showAppleWeight();
	}
}

 

728x90

'SW > Java' 카테고리의 다른 글

[필기정리]Day21 - 문제 step1  (0) 2020.07.08
[필기정리]Day21 - Generic(제네릭)  (0) 2020.07.08
[필기정리]Day19 - equals(), clone() 등  (0) 2020.07.06
[필기정리]Day18 - 전화번호 관리 프로그램 문제 06단계  (0) 2020.07.03
[필기정리]Day 17 - 예외사항(try catch), throwable 클래스  (0) 2020.07.02

티스토리툴바