[12일차] 국비교육

 

<자동차 연습문제>

 

 

package 자동차종합연습;
// 추상 클래스 : setMode를 반드시 오버라이딩 해야하므로
public abstract class Car {
    int maxSpeed; // 최고속도
    int fuelEff; // 연비
    int fuelTank; // 연료 탱크
    int seatCnt; // 좌석 수
    String name; // 차량 이름

    //이동 횟수 구하기
    int getMovingCnt(int passCnt){
        if(passCnt % seatCnt != 0 ){ // 좌석수로 나눈 나머지가 있으면 승객이 남아 있으므로 추가 운행 필요
            return(passCnt /seatCnt)+1;
        }else return passCnt / seatCnt;
    }
    // 이동 비용 구하기
    int getTotalCost(int dist, int moveCnt){
        return (dist/fuelEff * 2000)*moveCnt;
    }
    // 주유 횟수 구하기
    int getRefuelCnt(int dist, int moveCnt){
        if(((dist * moveCnt)/fuelEff) % fuelTank != 0)
        return (((dist * moveCnt)/fuelEff) / fuelTank) +1;
        else return (((dist * moveCnt)/fuelEff) / fuelTank);
    }
    double getMovingTime(int dist, int moveCnt){
        return(double)dist * moveCnt / maxSpeed;
    }
    abstract void setMode(boolean isMode);

}

package 자동차종합연습;

public class Sedan extends Car {

        public Sedan(String name) {
            this.name = name;
            this.maxSpeed=200;
            this.fuelEff =12;
            this.fuelTank = 45;
            this.seatCnt= 4;
        }

        @Override
        void setMode(boolean isMode) {
            if(isMode) seatCnt +=1;
        }
    }

package 자동차종합연습;

public class SportsCar extends Car {

        public SportsCar(String name) {
            this.name = name;
            this.maxSpeed=250;
            this.fuelEff =8;
            this.fuelTank = 30;
            this.seatCnt= 2;
        }

        @Override
        void setMode(boolean isMode) {
           if(isMode) maxSpeed *= 1.2;
        }
    }

package 자동차종합연습;

    public class Bus extends Car {
        public Bus(String name) {
            this.name = name;
            this.maxSpeed = 150;
            this.fuelEff = 5;
            this.fuelTank = 100;
            this.seatCnt = 20;
        }
        @Override
        void setMode(boolean isMode) {
            if(isMode) fuelTank += 30;
        }
    }

package 자동차종합연습;

import java.util.Scanner;

// 매개변수 다형성을 이용해서 moveCnt = car.getMovigCnt(passCnt)부터 줄일 수 있음
public class CarTotalExMain {
    public static void main(String[] args){
        final int[] dist = {0, 400, 150, 200, 300};
        int moveCnt = 0; // 이동 횟수를 반환 받기 위해 사용
        Car car; // 부모 클래스로 참조 타입 변수, 자식 객체를 동적 바인딩 할 수 있다.
        //동적 바인딩은 런타임중 결정 남 
        Scanner sc = new Scanner(System.in);
        System.out.print("이동 지역 선택 [1]부산, [2]대전, [3]강릉, [4]광주 : ");
        int cityLoc  = sc.nextInt();
        System.out.print("이동할 승객 수를 입력 하세요 : ");
        int passCnt = sc.nextInt();
        System.out.print("이동할 차량 선택 : [1]스포츠카, [2]승용차, [3]버스 : ");
        int carSel = sc.nextInt();
        System.out.print("부가 기능 [1]ON, [2]OFF : ");
        int option = sc.nextInt();
        switch(carSel) {
            case 1 :
                car = new SportsCar("Ferrari"); // 카 객체에 SportsCar에 참조 변수를 받음
                if(option == 1) car.setMode(true);
                else car.setMode(false);
                moveCnt = car.getMovingCnt(passCnt);
                System.out.println("총 비용 : " + car.getTotalCost(dist[cityLoc], moveCnt));
                System.out.println("총 주유 횟수 : " + car.getRefuelCnt(dist[cityLoc], moveCnt));
                System.out.printf("총 이동 시간 : %.3f\n", car.getMovingTime(dist[cityLoc], moveCnt));
                break;
            case 2 :
                car = new Sedan("GV80");
                if(option == 1) car.setMode(true);
                else car.setMode(false);
                moveCnt = car.getMovingCnt(passCnt);
                System.out.println("총 비용 : " + car.getTotalCost(dist[cityLoc], moveCnt));
                System.out.println("총 주유 횟수 : " + car.getRefuelCnt(dist[cityLoc], moveCnt));
                System.out.printf("총 이동 시간 : %.3f\n", car.getMovingTime(dist[cityLoc], moveCnt));
                break;
            case 3 :
                car = new Bus("BUS");
                if(option == 1) car.setMode(true);
                else car.setMode(false);
                moveCnt = car.getMovingCnt(passCnt);
                System.out.println("총 비용 : " + car.getTotalCost(dist[cityLoc], moveCnt));
                System.out.println("총 주유 횟수 : " + car.getRefuelCnt(dist[cityLoc], moveCnt));
                System.out.printf("총 이동 시간 : %.3f\n", car.getMovingTime(dist[cityLoc], moveCnt));
                break;
            default :
                System.out.println("차량 선택이 잘 못 되었습니다.");
        }
    }
}

 

 

 

출력

 

이동 지역 선택 [1]부산, [2]대전, [3]강릉, [4]광주 : 2
이동할 승객 수를 입력 하세요 : 5
이동할 차량 선택 : [1]스포츠카, [2]승용차, [3]버스 : 2
부가 기능 [1]ON, [2]OFF : 2
총 비용 : 48000
총 주유 횟수 : 1
총 이동 시간 : 1.500

 

 

package 직업상속과인터;

public abstract class Person {
    String name; // 인스턴스 필드가 포함될 수 있다.
    int age;
    abstract void eat(); // 추상 메소드는 구현부를 가지면 안된다.
    // 생성자를 생략하면 기본 생성자가 호출 된다.
}

 

package 직업상속과인터;

public interface Hobby {
    void setHobby(String hobby); // abstract 가 자동으로 추가 된다.
}

package 직업상속과인터;

public interface Friend {
    void setFriend(String friend);
}

package 직업상속과인터;
// 추상 상속을 여러개 받을 수 있다
public class Student extends Person implements Hobby, Friend {
    private String study;
    private String hobby;
    private String friend;

    public Student(String study, String hobby, int age,String name) {
        this.study = study;
        this.hobby = hobby;
        this.age = age;
        this.name = name;
    }

    @Override
    void eat() {
        System.out.println(name + "밥을 먹습니다." );
    }

    @Override
    public void setHobby(String hobby) {
        this.hobby = hobby;

    }
    void getInfo(){
        System.out.println("하는 일  : " + study);
        System.out.println("이름  : " + name );
        System.out.println("나이  : "+ age);
        System.out.println("취미 : " + hobby);
        System.out.println("친구 : " + friend);
    }

    @Override
    public void setFriend(String friend) {
        this.friend = friend;
    }
}

package 직업상속과인터;

public class JobsMainEX {
    public static void main(String[] args){
         Student student = new Student("공부", "게임", 18,"나희도");
         student.setHobby("펜싱");
         student.setFriend("고유림");
         student.getInfo();

    }
}

 

출력

 

하는 일  : 공부
이름  : 나희도
나이  : 18
취미 : 펜싱
친구 : 고유림

 

<익명 클래스>

 

• 1회용으로 한번 사용되는 클래스를 만들때 사용
• 이벤트 또는 쓰레드 처리 이용 

 

package 익명클래스;

public interface RemoteControl {
    //선언만 함
    void turnON();
    void turnOFF();
    void setVolume(int volume);
}

package 익명클래스;
// 굳이 기억하지 않아도 되고 존재한다는 것만 기억
public class AnonymousMain {
    public static void main(String[] args) {
        // 선언만 해서 여기에서 구현해야함
        // 부모클래스 이름을 적어줌
        RemoteControl remoteControl = new RemoteControl() {
            @Override
            public void turnON() {
              System.out.println("자동차의 에어컨을 켭니다.");
            }

            @Override
            public void turnOFF() {
              System.out.println("자동차의 에어컨을 끕니다.");
            }

            @Override
            public void setVolume(int volume) {
              System.out.println("에어컨의 세기를 " + volume + "변경 합니다." );
            }
        }; // 클래스가 끝났음을 의미
        remoteControl.turnON();
        remoteControl.turnOFF();
        remoteControl.setVolume(100);
    } // 괄호를 만나면 한번 사용하고 없어짐
}

출력

 

자동차의 에어컨을 켭니다.
자동차의 에어컨을 끕니다.
에어컨의 세기를 100변경 합니다.

 

<중첩 클래스와 중첩메소드>

 

• 추상 클래스나 인터페이스 문법이 더 중요하고 중첩클래스나 중첩메소드, 익명클래스는 사용 횟수가 적다.

package 중첩클래스;
// 하나의 클래스 내부에 선언된 또 다른 클래스를 의미
public class ComplexMain {
    public static void main(String[] args) {
        A a = new A();
        A.B b= a.new B(); // 내부 객체를 생성하기 위해서는 외부 객체를 만들어야 함.
        b.testMethod();
        System.out.println(A.C.test); // 중첩 클래스 내부에 정적 클래스 호출 
    }
}

class A{
    class B{ // 인스턴스 멤버 클래스
        void testMethod(){
            System.out.println("중첩 클래스의 메소드 입니다.");
        }
    }
    static class C{ // 정적 멤버 클래스 
        static String test = "test";
    }
}

package 중첩인터페이스;

public class Button {
    onClickListener listener;

    public void setListener(onClickListener listener) {
        this.listener = listener;
    }
    void touch(){
        listener.onClick();
    }

    interface onClickListener{
        void onClick(); // 추상메소드
    }
}

class CallListener implements Button.onClickListener{

    @Override
    public void onClick() {
        System.out.println("전화를 겁니다.");
    }
}
class MessageListener implements Button.onClickListener{

    @Override
    public void onClick() {
        System.out.println("메세지를 보냅니다.");
    }
}

package 중첩인터페이스;
// 클래스 내부에 인터페이스를 포함하는 경우
public class ComplexInterMain {
    public static void main (String[] args){
        Button btn = new Button();
        btn.setListener(new CallListener());
        btn.touch();
        btn.setListener(new MessageListener());
        btn.touch();
    }

}

출력

전화를 겁니다.
메세지를 보냅니다.

 

-->button부분은 만들어 진 것을 가져올 수 있지만 오버라이딩 부분은 구현할 수도 있음

 

 

<어노테이션>

자바보다는 백엔드쪽에서 많이 사용

 

<패키지>

• 클래스와 인터페이스의 집합 
• 패키지는 하나의 디렉토리 의미
• 클래스 이름이 동일하더라도 패키지가 다르면 다른 클래스로 인식
• import java.sql.*;   *은 전부를 의미 ---> date는 import java.util도 있음 
• 패키지 이름은 변수 이름 생성 규칙이랑 같음 

 

<객체를 배열로 관리하기>

 

변수nameCards는 배열을 가리키고 있고 그 배열은 NameCard객체를 가르키고 있음

 

package 객체를배열로;
public class NameCard {
    private String name;
    private String mail;
    private String phone;
    private int age;

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

    public void setMail(String mail) {
        this.mail = mail;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public void printCard() {
        System.out.println("이름 : " +  name);
        System.out.println("나이 : " + age);
        System.out.println("연락처 : " + phone);
        System.out.println("메일 : "+ mail);
    }
}

package 객체를배열로;

import java.util.Scanner;

// 객체를 배열로 관리하기
public class ObjectArrMain {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.print("입력 인원 : ");
        int cnt = sc.nextInt();
        NameCard[] nameCards = new NameCard[cnt];
        // 객체 저장 공간만 만듦
        System.out.println("정보입력");
        System.out.println("-------------------");
        for(int i = 0; i < cnt; i++){
            nameCards[i] = new NameCard();
            System.out.print("이름 : ");
            nameCards[i].setName(sc.next());
            System.out.print("나이 : ");
            nameCards[i].setAge(sc.nextInt());
            System.out.print("메일 : ");
            nameCards[i].setMail(sc.next());
            System.out.print("전화 : ");
            nameCards[i].setPhone(sc.next());
        }
        for(NameCard e : nameCards) e.printCard();
    }
}

 

입력 인원 : 3
정보입력
-------------------
//입력
이름 : 우영우
나이 : 27
메일 : yyy@gmail.com
전화 : 010-1234-5678
이름 : 동그라미
나이 : 25
메일 : ddd@gmail.com
전화 : 010-1111-2222
이름 : 최수연
나이 : 27
메일 : ccc@gmail.com
전화 : 010-5678-1234

//출력
이름 : 우영우
나이 : 27
연락처 : 010-1234-5678
메일  : yyy@gmail.com
이름 : 동그라미
나이 : 25
연락처 : 010-1111-2222
메일  : ddd@gmail.com
이름 : 최수연
나이 : 27
연락처 : 010-5678-1234
메일  : ccc@gmail.com

아이패드 만들기, 자동차 만들기 종합(인터페이스 상속)은 여유 있을 때 하면 좋음

 

<알고리즘: 단어공부> 

 

 

package 단어공부;
// 문자열을 입력 받아 가장 많이 사용된 알파벳이 무엇인지 확인
// 만약, 가장 많이 사용된 단어가 여러개인 경우 ? 출력
import java.util.Scanner;

public class StudyMain {
    public static void main(String[] args){
        // 단어를 입력 받기 위한 스캐너 객체 생성
        Scanner sc = new Scanner(System.in);
        System.out.print("단어 입력 : ");
        String str = sc.next(); // 스캐너 객체를 이용해 문자열을 입력 받음
        // 가장 많이 등장하는 단어를 찾기 위해 알파벳 수 만큼의 배열 생성(대소문자 구분 안함으로..)
        int[] al = new int[26];
        int max = 0;
        char result = 0;
        // 입력 받은 단어의 길이 만큼 반복문을 수행하면서 알파벳을 정수로 변환한 인덱스에 값 누적
        for(int i =0; i < str.length(); i++){
            // charAt(인덱스) : 문자열에서 해당 인덱스의 문자를 뽑아냄
            if(str.charAt(i) >= 'a') al[str.charAt(i) - 'a']++;
            //소문자 기준으로 계산 소문자 'a' 빼면 순수 배열의 값 나옴 
            //-> 배열 값 대입 해주므로 증가 연산자
            else al[str.charAt(i) - 'A']+=1;
        }
        // 반복문을 순회하면서 가장 많이 등장한 알파벳 찾기(여러개인 경우 ?)
        for(int i = 0; i<al.length; i++) {
            if(al[i] == max) result ='?'; // 가장 많이 등장하는 수가 여러개인 경우
            else if(al[i] > max){ // 현재 인덱스의 문자 갯수가 max 보다 큰 경우
                max = al[i]; // max값이 들어오면서 찍힘
                result = (char)('A'+i);
                // 찾은 결과값이 인덱스값(정수)이므로 문자로 변경 후 출력 -> 출력 예제가 대문자임
                // 결과를 문자로 출력하기 위해서 인덱스의 정수값을 문자로 변환
            }
        }
        System.out.println(result);

    }


}

출력

단어 입력 : aAbedd
?

단어 입력 : aAefere
E

 

 

<자바 API>

• 자바 API는 라이브러리라고 부름 
• java.lang : 자바에서 가장 기본적 동작 수행, import문 사용 하지 않음

 

java.lang 패키지

 

• object: 자바 최상위 클래스
• System :  표준 입출력 장치로 부터 입력 받거나 출력할 때 사용, 쓰레기 수집기를 실행요청, 자바의 JVM을 종료 시킬때 사용 
• Byte, Short,Charactr,Integer,Float,Double,Boolean,Long : 기본 타입의 데이터를 갖는 객체를 만들 때 사용 , 문자열을 기본 타입으로 변환할 때 사용, 입력값 검사에 사용

java.util 패키지

 

• Arrays : 배열을 조작비교, 복사, 정렬, 찾기 등에 사용
• Objects : 객체 비교, null 여부 등을 조사
• Random 
• StringTokenizer

<Objcet클래스>

 

• toString()메소드 : 해당 인스턴스에 대한 정보를 문자열로 반환 -> 문자열은 클래스 이름과 함께 구분자로 '@'가 사용
•                               + 16진수 해시코드추가
• **clone()메소드 : 얇은 복사를 방지

 

package API클래스;
// java.lang.* : 기본적으로 포함되어 있음
// Object 클래스 : 모든 클래스의 최고 조상 클래스
public class ApiMainEx extends Object {
    public static void main(String[] args) {
        Car car1 = new Car();
        Car car2 = new Car();
        // 해당 인스턴스에 대한 정보를 문자열로 반환
        // 인스턴스(주소값을 가지고 있으면)
        // 16진수 해시 코드값은 주소값으로 인스턴스마다 다름
        System.out.println(car1.toString());
        System.out.println(car2.toString());
        //equals() 메소드 : 해당 인스턴스를 매개변수로 전달 받는 참조변수와 비교
        System.out.println(car1.equals(car2));
        car2 = car1;
        System.out.println(car1.equals(car2));
    }
}
class Car {

}

출력

API클래스.Car@6a5fc7f7
API클래스.Car@3b6eb2ec
false
true

 

<clone() 메소드 -> 얇은 복사> 

// clone() 메소드 : 해당 인스턴스를 복제하여, 새로운 인스턴스를 생성해 반환
// 객체를 복사하는 경우 참조 타입 변수인 경우 필연적으로 얕은 복사가 일어남.
// 이런 문제를 해결하기 위해 clone()메소드를 사용하며, clone()메소드는
// 데이터의 보호 이유로 Cloneable 인터페이스를 구현한 클래스의 인스턴스만 사용 할 수 있음
public class ApiMainEx extends Object {
    public static void main(String[] args) {
        Member mem1 = new Member("bear", "곰돌이","12345",30, true);
        Member mem2 = new Member("fox", "헌터","6789",24, true);
        mem1 = mem2;
        mem2.age = 18;
        mem2.name = "테스터";
        System.out.println("이름 : " + mem1.name);
        System.out.println("이름 : " + mem2.name);
        System.out.println("나이 : "+ mem1.age);
        System.out.println("나이 : "+ mem2.age);


    }
}

package API클래스;

public class Member implements Cloneable{
    public String id;
    public String name;
    public String password;
    public int age;
    public boolean adult;

    public Member(String id, String name, String password, int age, boolean adult) {
        this.id = id;
        this.name = name;
        this.password = password;
        this.age = age;
        this.adult = adult;
    }
    // getMember() 메소드의 반환 타입이 Member(클래스)
    public Member getMember() throws CloneNotSupportedException {
        Member cloned = null;
        cloned = (Member) clone();
        return cloned;

    }
}

이름 : 테스터
이름 : 테스터
나이 : 18
나이 : 18

 

<얇은 복사를 피하는 법>

public class ApiMainEx extends Object {
    public static void main(String[] args) throws CloneNotSupportedException {
        Member mem1 = new Member("bear", "곰돌이","12345",30, true);
        Member mem2 = mem1.getMember();
        mem2.age = 18;
        mem2.name = "테스터";
        System.out.println("이름 : " + mem1.name);
        System.out.println("이름 : " + mem2.name);
        System.out.println("나이 : "+ mem1.age);
        System.out.println("나이 : "+ mem2.age);


    }
}

이름 : 곰돌이
이름 : 테스터
나이 : 30
나이 : 18

<StringBuffer>

 

package 스트링버퍼;
// StringBuffer() : 문자열을 추가하거나 변경할 때 사용

public class StringBufferMain {
    public static void main(String[] args){
        StringBuffer sb= new StringBuffer(); // 무조건 객체 생성해야함
        /*sb.append("hello");
        sb.append(" ");
        sb.append("Java");
        sb.append("^^");
        System.out.println(sb);*/
        // 수정 가능 : 기존 객체 공간에 값을 바꿔가면서 사용중, 문자가 길면 유리
        String buff = "";
        buff = "hello";
        buff += " ";
        buff += "Java";
        buff += "^^";
        System.out.println(buff);
        // 수정 불가능 : 수정하지 않고 새롭게 String 객체 생성중 (메모리, 성능 부분에서 많이 사용)
        // 문자 짧으면 유리
    }
}

hello Java^^

 

package 스트링버퍼;
// StringBuffer() : 문자열을 추가하거나 변경할 때 사용

public class StringBufferMain {
    public static void main(String[] args){
        // StringBuilder 성능이 우수하지만 싱글 쓰레드용
        // StringBuffer 멀티 쓰레드용 , 사용방법은 같지만 객체 생성부분 수정해야함
        // delete(시작인덱스, 끝인덱스) : 전달된 인덱스의 문자열을 제거
        // insert(인덱스, "추가할 문자열") : 문자열 삽입
        StringBuilder sb= new StringBuilder();
        sb.append("hello");
        sb.append("Java");
        sb.append("^^");
        sb.delete(0, 5); //시작인덱스에서 끝인덱스 미만까지 삭제
        sb.insert(0,"Hi^^ ");
        System.out.println(sb);
        System.out.println(sb.substring(0,8)); // 문자열 자르기
    }
}

Hi^^ Java^^
Hi^^ Jav

<Math클래스> --> 종류만 알고 있으면 됨

• static 클래스임

• random()
• abs()
• floor(),ceil(),round()
• max(),min()

package 매쓰API;
// Math 클래스 : 수학에서 자주 사용하는 메소드를 모아둔 것
// static 메소드이므로 객체 생성없이 사용 가능
// random() : 0.0 ~ 1.0 미만의 임의의 double 형 값을 생성하여 반환
public class MathMainEx {
    public static void main(String[] args){
        // 0 ~ 45까지의 46개의 랜덤값을 생성한 후 1을 더해줌(1 ~ 46)
        int lotto = (int)(Math.random() *46) + 1;
        int val1 = (int)(Math.random() * 6); // 0 ~ 5까지 6개의 랜덤값
        int val2 = (int)(Math.random() * 6) + 1; //1 ~ 6까지의 랜덤값
        int val3 = (int)(Math.random() * 6) + 3; // 3 ~ 8까지
        System.out.println("로또 : " + lotto);
        System.out.println("0 ~ 5 : " + val1) ;
        System.out.println("1 ~ 6 : " + val2);
        System.out.println("3 ~ 8 : " + val3);
    }
}

출력

로또 : 40
0 ~ 5 : 4
1 ~ 6 : 3
3 ~ 8 : 3

 

// abs() : 절대값 구하기(전달된 값이 음수이면 양수로 반환, 양수면 그냥 양수)
public class MathMainEx {
    public static void main(String[] args){
       System.out.println(Math.abs(10));
       System.out.println(Math.abs(-10));
        System.out.println(Math.abs(-3.14));
    }
}

출력

10
10
3.14

// floor() : 소수점 이하를 무조건 날림
// ceil() : 소수점 이하가 있으면 무조건 올림
// round() : 전달 받은 실수를 소수점 첫째 자리에서 반올림

public class MathMainEx {
    public static void main(String[] args){
        System.out.println(Math.ceil(10.0));
        System.out.println(Math.ceil(10.1));
        System.out.println(Math.ceil(10.000000001));
        System.out.println(Math.floor(10.0));
        System.out.println(Math.floor(10.1));
        System.out.println(Math.floor(10.9999999));
        System.out.println(Math.round(10.51));
        System.out.println(Math.round(10.499999));
        System.out.println(Math.round(10.500000));

    }
}

출력

10.0
11.0
11.0
10.0
10.0
10.0
11
10
11

// max() : 전달된 두 값을 비교하여 큰 값을 반환
// min() : 전달된 두 값을 비교하여 작은 값은 반환
public class MathMainEx {
    public static void main(String[] args){
       System.out.println("MAX : " + Math.max(1.4444,1.4555));
       System.out.println("MAX : " + Math.max(1,11));
       System.out.println("MAX : " + Math.max('a','A'));

        System.out.println("MIN : " + Math.min(1.4444,1.4555));
        System.out.println("MIN : " + Math.min(1,11));
        System.out.println("MIN : " + Math.min('a','A'));
    }
}

출력

MAX : 1.4555
MAX : 11
MAX : 97
MIN : 1.4444
MIN : 1
MIN : 65

<Wrapper 클래스>

• 8개의 기본 타입에 해당하는 데이터를 객체로 포장해주는 클래스
• 객체 타입을 원하는 클래스가 있어서 필요
• 오토박싱, 오토언박싱 -> 자동으로 실행됨

public class MathMainEx {
    public static void main(String[] args){
      //Integer num = new Integer(17);
        Integer num = 17;
        int n = num.intValue();
        //int n = num;
        System.out.println(n);
        Character ch = 'X';
        char  c = ch; // 언박싱이 일어남.
        System.out.println(c);
    }
}

17
X