추상클래스란?

인터페이스의 역할도 하면서 클래스의 기능도 가지고 있는 클래스.

'abstract' 키워드를 사용해 선언해야 함

인터페이스와 추상 클래스의 차이

유사한 기능을 가지고 있으나, 추상 클래스는 일반 클래스처럼 객체변수, 생성자, private 메서드 등을 가질 수 있음

그러나 다중 상속은 불가능함!

추상클래스 사용 예

abstract class Predator extends Animal {
    abstract String getFood();   

    void printFood() {     
        Systehttp://m.out.printf("my food is %s\n", getFood());
    }
    static int LEG_COUNT = 4; 

    static int speed() {   
        return LEG_COUNT * 30;
    }
}

interface Barkable {
    void bark();
}

class Animal {
    String name;

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

class Tiger extends Predator implements Barkable {
    public String getFood() {
        return "apple";
    }
    public void bark(){
        System.out.println("어흥");
    }
}
class Lion extends Predator implements Barkable {
    public String getFood() {
        return "banana";
    }
    public void bark() {
        System.out.println("으르렁");
    }
}

class Zookeeper {
    void feed(Predator predator){
        System.out.println("feed "+ predator.getFood());
    }
}

class Bouncer {
    void barkAnimal(Barkable animal) {
        animal.bark();
    }
}
public class Day17 {
    public static void main(String[] args) {
        Zookeeper zookeeper = new Zookeeper();
        Tiger tiger = new Tiger();
        Lion lion = new Lion();

        tiger.printFood();
        zookeeper.feed(tiger);  //feed apple 출력
        System.out.println();

        lion.printFood();
        zookeeper.feed(lion);   // feed banana 출력
        System.out.println();

        Predator.speed();
        System.out.println(Predator.LEG_COUNT);
        System.out.println();

        Bouncer bouncer = new Bouncer();
        tiger.bark();
        zookeeper.feed(tiger);
        lion.bark();
        bouncer.barkAnimal(tiger);
    }
}

다형성(Polymorphism)이란?

하나의 객체가 여러 개의 자료형 타입을 가질 수 있는 것

>> 복잡한 형태의 분기문을 간단하고 효율적으로 처리할 수 있다.

다형성의 장점

1) 확장성 : 상위클래스나 인터페이스의 기능을 가지는 하위클래스를 생성하여 기존 코드를 변경하지 않고 확장할 수 있다.

2) 유지관리 용이 : 클래스 간의 결합도를 낮춰 코드가 유연해지므로 수정이 필요한 해당 클래스만 수정할 수 있음

3) 유연성 : 한 타입의 참조 변수로 여러 타입의 객체를 참조할 수 있음

interface 다중상속

Java에서 클래스는 다른 클래스를 다중 상속할 수 없고 오직 1개만 상속이 가능하다.

그러나 인터페이스는 다중 상속을 지원한다!

(예시)

interface BarkablePredator extends Barkable, Predator {

}

다형성의 예시

아래 코드에서,

Tiger클래스의 객체인 tiger는 여러 가지 자료형으로 표현할 수 있다.

Tiger tiger = new Tiger();                   → Tiger is a Tiger

Animal animal = new Tiger();             → Tiger is a Animal

Predator predator = new Tiger();       → Tiger is a Predator

Barkable barkable = new Tiger();      → Tiger is a Barkable

interface Predator {
    String getFood();     // 메서드 추가 (몸통이 없음)

    default void printFood() {      // 디폴트 메서드
        System.out.printf("my food is %s\n", getFood());
    }
    int LEG_COUNT = 4;  // 인터페이스 상수

    static int speed() {    // 스태틱 메서드
        return LEG_COUNT * 30;
    }
}

interface Barkable {
    void bark();
}

interface BarkablePredator extends Barkable, Predator{
}



class Animal {
    String name;

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

class Tiger extends Animal implements BarkablePredator {
    public String getFood() {
        return "apple";
    }
    public void bark(){
        System.out.println("어흥");
    }
}
class Lion extends Animal implements BarkablePredator {
    public String getFood() {
        return "banana";
    }
    public void bark() {
        System.out.println("으르렁");
    }
}

class Zookeeper {
    void feed(Predator predator){
        System.out.println("feed "+ predator.getFood());
    }
}

class Bouncer {
    void barkAnimal(Barkable animal) {
        animal.bark();
    }
}
public class Day17 {
    public static void main(String[] args) {
        Zookeeper zookeeper = new Zookeeper();
        Tiger tiger = new Tiger();
        Lion lion = new Lion();

        tiger.printFood();
        zookeeper.feed(tiger);  //feed apple 출력
        System.out.println();

        lion.printFood();
        zookeeper.feed(lion);   // feed banana 출력
        System.out.println();

        Predator.speed();
        System.out.println(Predator.LEG_COUNT);
        System.out.println();

        Bouncer bouncer = new Bouncer();
        tiger.bark();
        zookeeper.feed(tiger);
        lion.bark();
        bouncer.barkAnimal(tiger);
    }
}

인터페이스란?

interface Predator {
    void sleep();
    String getFood();
}​

클래스가 가져야 할 구조를 정의하는 추상 타입

클래스를 생성할 때마다 그 안에 공통적인 특성을 넣어야 할 때 효율적으로 사용할 수 있다.

인터페이스 쓰임새

- 여러 클래스가 같은 방식으로 동작하도록 강제하고 싶을 때

- 클래스를 사용하는 쪽과 구현하는 쪽을 구분하여 독립시키고 싶을 때

- 여러 클래스 사이에서 공통적인 특성을 추출하고 싶을 때

인터페이스 특징

- 인터페이스는 "규칙"이다!

- 메서드와 상수만 정의될 수 있고, 항상 public으로만 선언된다.

- 메서드도 메서드명과 반환타입 정도만 "규정" 할 수 있다.

디폴트 메서드

인터페이스를 구현하는 클래스들이 공통으로 사용할 수 있게 해준다.

인터페이스에 해당 메서드를 만들어두면, 각 클래스에서 구현하지 않아도 사용이 가능한 메서드.

스태틱 메서드

인터페이스 이름으로 직접 호출할 수 있는 메서드이다.

인터페이스명.스태틱메서드명  으로 호출 가능

따라 작성해보기

interface Predator {
    String getFood();     // 메서드 추가 (몸통이 없음)

    default void printFood() {      // 디폴트 메서드
        Systehttp://m.out.printf("my food is %s\n", getFood());
    }
    int LEG_COUNT = 4;  // 인터페이스 상수

    static int speed() {    // 스태틱 메서드
        return LEG_COUNT * 30;
    }
}



class Animal {
    String name;

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

class Tiger extends Animal implements Predator {
    public String getFood() {
        return "apple";
    }
}
class Lion extends Animal implements Predator {
    public String getFood() {
        return "banana";
    }
}

class Zookeeper {
    void feed(Predator predator){
        System.out.println("feed "+ predator.getFood());
    }
}

public class Day16 {
    public static void main(String[] args) {
        Zookeeper zookeeper = new Zookeeper();
        Tiger tiger = new Tiger();
        Lion lion = new Lion();

        tiger.printFood();
        zookeeper.feed(tiger);  //feed apple 출력

        lion.printFood();
        zookeeper.feed(lion);   // feed banana 출력

        Predator.speed();
        System.out.println(Predator.LEG_COUNT);
    }
}

생성자란?

클래스의 인스턴스를 새롭게 생성할 때 사용되는 메서드의 일종

- 클래스명과 메서드명이 같음

- 반환 타입이 없음(void조차 없음)

생성자의 쓰임새

인스턴스의 초기화 작업에 사용됨.

객체 생성 시 반드시 정해진 타입의 입력값을 받고자 할 때 사용

(예시)

Dog(String name) {               → Dog자료형의 객체 생성 시 문자열로 된 이름을 반드시 입력하도록 강제
     this.setName(name);
}

....생략....
Dog dog1 = new Dog("Geun");  → main 메서드에서 dog1 개체 생성 시 이름을 반드시 넣어 생성해야함

디폴트 생성자

생성자의 받을 입력항목이 없고 생성자 내부에도 아무런 코드가 없는 생성자

클래스에 생성자가 없을 때, 컴파일러가 자동으로 만드는 생성자임

클래스 내부에 생성자가 있을 때, 입력값이 없는 인스턴스를 새로 정의할 수 없음.

사용하기 위해서는 직접 디폴트생성자를 만들어 주어야 함

(예시)

Dog() {          → 입력항목도 없고, 내부에도 아무 내용이 없음
}

생성자 오버로딩

받을 입력값을 다르게 한다면, 같은 이름의 생성자를 여러 개 만들 수있음

(예시)

class Dog extends Animal {   
    Dog(String name) {            → 문자열 타입 생성자 Dog
        this.setName(name);
    }
    Dog(int type){                     → 정수 타입 생성자 Dog
        if (type==1) {
            this.setName("Yorkshire");
        } else if (type==2) {
             this.setName("bulldog");
        }

따라 연습해보기

class Vehicle{
    String name;

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

class Car extends Vehicle {
    void run() {
        System.out.println(this.name + " is running");
    }
}

class Benz extends Car {
    void run() {
        System.out.println(this.name + " is running on the road");
    }

    void run(int hour) {
        System.out.println(this.name + " is running for " + hour + " hours on the road");}

    Benz(String name) {     // 생성자 : 클래스명과 동일하고 void 형태인 메서드=
        this.setName(name);
    }
    Benz(int grade) {
        if(grade == 1) {
            this.setName("S Class");
        } else if(grade == 2) {
            this.setName("E Class");
        } else if(grade == 3) {
            this.setName("C Class");
        }
    }
}
public class Day15 {
    public static void main(String[] args) {
        Benz benz = new Benz("Pang");
        benz.run();
        benz.run(3);
        System.out.println(benz.name);
        System.out.println();

        Benz eClass = new Benz(2);
        System.out.println(eClass.name);
        System.out.println();

        benz.setName("Benz S class");
        benz.run();
        benz.run(3);
        System.out.println(benz.name);
    }
}

상속이란?

자식 클래스가 부모 클래스의 기능을 그대로 물려받을 수 있는 기능.

자식클래스에 굳이 메서드를 넣지 않아도 자식 클래스의 인스턴스를 생성 하고 부모클래스의 메서드 사용 가능

>> 자식클래스에서 부모클래스의 기능에 더하여 더 많은 기능을 갖도록 만들 수 있음

형태

class 자식클래스명 extends 부모클래스명 {

}

IS-A 관계

상속 관계를 의미함.

자식클래스의 객체는 부모클래스의 자료형인 것처럼 사용 가능

(예시)

Animal : 부모클래스, Dog : 자식클래스 일떄

Animal dog = new Dog();     → Dog is a Animal (O)

Dog dog = new Animal();     → Animal is a Dog (X)

메서드 오버라이딩 : 덮어쓰기

자식클래스가 우선!!

부모클래스와 자식클래스에 같은 이름의 메서드가 정의되었을 때, 메서드를 호출하면 자식클래스의 메서드가 작동한다.

메서드 오버로딩

같은 이름의 메서드라도 받는 입력값의 형태가 다르면 같은 클래스 안에 생성 가능

다중 상속 X

하나의 클래스가 둘 이상의 클래스를 상속받을 수 없음

class A extends B, C {      → 불가능

}

/* 5-5 상속\
  "extends" 자식 클래스가 부모 클래스의 기능을 그대로 물려받을 수 있는 기능 */
class Animal {
    String name;    // 객체변수 생성

    void setName(String name) {             → 메서드(setName) 생성, 입력값 문자열
        this.name = name;                         → 객체의 객체변수값에 이름 저장
    }
}

class Dog extends Animal {                   → Animal 클래스를 상속한다
    void sleep() {
        System.out.println(this.name+" zzz");
    }
}

class HouseDog extends Dog {
    void sleep(){
        System.out.println(this.name+" zzz in house");
    }

    void sleep(int hour){
        System.out.println(this.name+" zzz in house for " + hour + " hours");
    }
}

public class Day14_2 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setName("poppy");
        System.out.println(dog.name);
        dog.sleep();

        HouseDog houseDog = new HouseDog();
        houseDog.setName("happy");
        houseDog.sleep();       → 메소드 오버라이딩 : 자식 클래스의 메서드가 더 우선순위 >> zzz in house 출력
        houseDog.sleep(3);     → 메서드 오버로딩 : 같은 메서드명에서도 입력값에 차이를 두어 생성 가능 
                                                                                                                           >> zzz in house for 3 hours 출력
    }
}

메서드 호출 시, 입력값으로 값을 전달하는 것과 객체를 전달하는 것의 차이가 있다.

값에 의한 호출

class Updater {
    void update(int count) {         → update라는 메서드를 생성 (입력값으로 정수값을 전달받음)
        count++;                            → 전달받은 값에 +1
    }
}

class Counter {    
    int count = 0;    →객체변수 생성
}

public class Day14 {
    public static void main(String[] args) {
        Counter myCounter = new Counter();    → Counter클래스의 인스턴스인 myCounter 생성
        System.out.println("before update:"+myCounter.count);      → myCounter객체의 객체변수값 호출 = 0
        Updater myUpdater = new Updater();      →Updater 클래스의 인스턴스인 myUpdater 생성                 
        myUpdater.update(myCounter.count);     →update메서드 호출 (입력값 myCounter.count = 0 )
        System.out.println("after update:"+myCounter.count);   
→ myCounter의 객체변수 자체를 넣은 것이 아닌 myCounter의 객체변수의 값만을 사용한 것이므로,
     myCounter.count값은 그대로 0
    }
}

>>실행결과 : 

before update:0

after update:0

객체에 의한 호출

class Updater {
    void update(Counter counter) {    → update라는 메서드를 생성 (입력값으로 객체 자체를 전달받음)
        counter.count++;                      → 객체의 객체변수값 자체를 +1 
    }
}

class Counter {
    int count = 0;    → 객체변수 생성
}
public class Day14 {
    public static void main(String[] args) {
        Counter myCounter = new Counter();    → Counter클래스의 인스턴스인 myCounter 생성
        System.out.println("before update:"+myCounter.count);      → myCounter객체의 객체변수값 호출 = 0
        Updater myUpdater = new Updater();      → Updater 클래스의 인스턴스인 myUpdater 생성                 
        myUpdater.update(myCounter);     → update메서드 호출 (입력값 myCounter)
        System.out.println("after update:"+myCounter.count); 
    }
}

>>실행결과 : 

before update:0

after update:1

메서드란?

클래스 안에 존재하며, 코드들의 집합.

즉 함수라고 생각하면 됨.

다른 언어에는 함수와 메서드가 구분되나, 자바에서는 클래스 밖에 존재하는 것이 없으므로 구분하지 않음

매개변수와 인수

명칭 확실히 구분할 것!

매개변수 : 메서드에 넣을 입력값을 저장하는 변수   (int a, int b)

인       수 : 메서드를 호출할 때 넣는 입력값   (3, 4)

메서드의 구조

리턴자료형 메서드명(입력자료형1 매개변수1, 입력자료형2 매개변수2, ...) {
         수행할 코드 1;
         수행할 코드 2;
         ....
         return 리턴값;
}

1) 입력값 O, 리턴값 O : 메서드 만들 때 리턴자료형 넣어줌, 마지막에 return 코드 사용

int sum(int a, int b) {

    return a+b;

}

2) 입력값 X, 리턴값 O : 입력값에 빈칸, return코드 및 리턴자료형 사용

String say() { 

    return "Hi";

}

3) 입력값 O, 리턴값 X :  리턴자료형 void 사용

void sum(int a, int b) {

    System.out.println("a와 b의 합은 "+(a+b)+"입니다.");

}

4) 입력값 X, 리턴값 X

void say() {

    System.out.println("Bye");

}

※ void 인 메서드(=리턴값이 없는 메서드)에서는 중간에 return; 사용 시 마치 break;처럼 해당 메서드를 빠져나옴

public class Day13 {
/* 5-3 메서드 더 알아보기
 구조 :
 리턴자료형 메서드명(입력자료형1 매개변수1, 입력자료형2, 매개변수2, ...) {
 ...
 return값;                                                       */


    int a;
void varTest(Day13 sample) {
        sample.a++;
    }

void varTest1() {
        this.a++;  // 굳이 입력값으로 객체를 안 받고 this를 활용할 수도 있음
    }

// 입력값O 리턴값O 메서드
int sum(int a, int b) {      //a, b는 매개변수
    return a+b;
}

// 입력값X 리턴값O 메서드
String open() {
    return "Hi";
}

// 입력값O 리턴값X
void multi(int a, int b) {
    System.out.println(a+"과 "+b+"의 곱은 "+ (a*b) + "입니다.");
}

// 입력값X 리턴값X
    void close(){
        System.out.println("Bye");
    }

// return의 또 다른 쓰임 : void메서드에서 return; 만 사용 시 해당 메서드를 즉시 빠져나감
    void sayNick(String nick) {
        if("바보". equals(nick)) {
            return;
        }
        System.out.println("나의 별명은 "+nick+"입니다.");
    }

    //리턴값 없이 값만 1 증가했으므로 main 메서드값에 영향 X
    void varTest(int d) {
        d++;
    }

public static void main(String[] args) {
    int a = 3;
    int b = 4;

    Day13 sample = new Day13();
    int c = sample.sum(a, b);

    System.out.println(c);    // 입력값O 리턴값O
    System.out.println();

    String result = sample.open();   // 입력값X 리턴값O
    System.out.println(result);
    System.out.println();

    sample.multi(a, b);           //입력값O 리턴값X
    System.out.println();

    sample.close();              //입력값X 리턴값X
    System.out.println();


    sample.sayNick("야호");
    sample.sayNick("바보"); // 출력되지 않음
    System.out.println();

    int d = 1;
    sample.varTest(d);
    System.out.println(d);
    System.out.println();

    sample.a = 1;  //객체변수에 접근하여 1 값을 대입
    sample.varTest(sample);   // varTest메서드에 입력값으로 sample객체 넣음 >> sample의 객체변수 a에 1 더해짐
    System.out.println(sample.a);  // 2 출력
}
}

클래스란?

클래스는 객체를 생성하기 위한 틀 혹은 설계도이다.

Animal이라는 클래스를 만든다고 하면, 

동물의 종, 색상, 성별, 나이 등의 다양한 속성들을 가지고 있다.

이러한 속성들은 클래스 내에서 변수와 메서드로 정의된다.

이 Animal 클래스를 기반으로 만들어진 '동물'이 바로 객체이자 인스턴스라고 한다.

클래스와 객체

Animal 클래스를 기반으로 cat이라는 새로운 변수를 생성한다.  >>  Animal cat = new Animal();

이때 cat이 바로 "객체"가 된다.

그리고 "Animal이라는 클래스의 인스턴스"라고도 부른다.

cat, dog, horse 등 다양한 객체들을 Animal 클래스로 만들 수 있다.

객체 변수

Animal 클래스 영역에 선언하는 변수를 객체 변수라고 한다.

같은 말로 인스턴스 변수, 멤버 변수, 속성 이라고도 한다. 

객체변수를 호출하거나 접근하려면  도트 연산자(.)를 이용해야 한다.

< 객체. 객체변수 > 

   ex) System.out.println(cat.name);

메서드

메서드란 클래스 내에 구현된 함수를 말한다.

클래스에 쓰일 속성을 만드는 방법 중 메서드를 이용하는 방법이 있다.

생성한 Animal 클래스 내에 특정 기능을 하는 메서드(함수)를 추가해 두면,

추후 객체와 속성을 지정할 때 해당 메서드를 호출하여 간편하게 이용할 수 있다.

이름을 지정하는 메서드를 만들 때

public void setName(String name) {

    this.name = name;

}

이렇게 만들어 두면,

추후 cat이라는 객체를 생성하고 이름을 지을 때

cat.setName("geun"); 

이렇게 메서드를 호출해 주면 바로 이름을 부여해 줄 수 있다.

이때 this는 Animal 클래스에 의해 생성된 객체를 지칭한다.

객체 변수는 공유되지 않는다

클래스의 존재 이유, 클래스에서 가장 중요한 부분!

객체마다 고유의 객체변숫값을 부여할 수 있다!

/* 5-2 클래스
 클래스는 과자틀, 객체는 과자!
 */
class Animal {          // 클래스 생성
    String name;    // 클래스에 선언된 변수 : "객체변수 = 인스턴스변수 = 멤버변수 = 속성"

    public void setName(String name) {    // 메서드 생성
        this.name = name;   // this : 해당 클래스의 객체(cat) 의미함
    }
}

public class Day12 {
    public static void main(String[] args) {
        Animal cat = new Animal();    // cat은 객체이자 Animal 클래스의 인스턴스다.
        System.out.println(cat.name);   // 객체.객체변수 형태로 접근 ; null 출력

        cat.setName("boby"); // 객체.메서드명 : 메서드 호출
        System.out.println(cat.name);

        Animal dog = new Animal();

        dog.setName("happy");
        System.out.println(cat.name);
        System.out.println(dog.name);
    }
}

객체 지향(Object Oriented) 프로그래밍이란

현실 세계의 사물을 모델로 하여 문제를 해결하는 개념 중 하나이다.

현실 세계의 모델을 프로그램으로 옮겨와서,

그 모델들 간 상호 작용을 통해 문제를 해결하려는 프로그래밍 방식이다.

(1) 객체

현실 세계의 사물이나 개념을 프로그램 안에서 모델링한 것

ex) 자동차, 사람, 동물 등...

(2) 클래스

객체를 정의하기 위한 틀로, 설계도 역할을 함. 객체들의 속성과 동작을 정의한다.

클래스를 통해 생성된 객체를 "인스턴스"라고 한다.

(3) 캡슐화(Encapsulation)

데이터와 메서드를 하나의 단위로 묶고, 외부에서의 직접적 접근을 제한하는 것

데이터 보호 및 코드 모듈화 가능

(4) 상속(Inheritance)

이미 존재하는 클래스를 기반으로 새로운 클래스를 만들어 확장하는 것

기존 클래스 특성을 물려받아 새로운 클래스에서 재사용 가능하게 함

(5) 다형성(Polymorphism)

하나의 인터페이스나 기본 클래스를 사용해 여러 형태로 구현할 수 있는 능력

계산기를 프로그램 구현 시,  하나의 계산기 클래스를 생성하고

한 클래스에서 여러 개의 계산기 객체를 생성할 수 있다.

/* 5-1 객체지향 프로그래밍이란?

 */
//더하기 계산기
class Calculator1 {
    static int result = 0;

    static int add(int num) {
        result += num;
        return result;
    }
}

class Calculator2 {
    static int result = 0;
    static int add(int num) {
        result += num;
        return result;
    }
}
// 객체지향프로그램
class Calculator3 {
    int result = 0;   // static 빠짐

    int add(int num) {
        result += num;
        return result;
    }
    int sub(int num) {
        result -= num;
        return result;
    }
}

public class Day11 {

    public static void main(String[] args) {
        System.out.println(Calculator1.add(3));
        System.out.println(Calculator1.add(4));

        System.out.println(Calculator2.add(3));
        System.out.println(Calculator2.add(7));
        System.out.println();


        Calculator3 cal1 = new Calculator3();   //계산기 1 객체를 생성한다
        Calculator3 cal2 = new Calculator3();   //계산기 2 객체를 생성한다

        System.out.println(cal1.add(3));    // 기존 static result값인 7부터 시작
        System.out.println(cal1.add(4));

        System.out.println(cal2.add(3));
        System.out.println(cal2.sub(2));
    }
}

1. 원시 자료형(Primitive type): 

변수에 실제 값을 가지는 자료형

2. 참조 자료형(Reference type):

실제 값을 갖는 것이 아닌 데이터가 저장된 메모리의 주소 값을 가지는 자료형

3-1. 리터럴 표기란?

객체를 생성하지 않고 고정된 값을 그대로 대입하는 방식. 원시자료형에서 사용

    ex) String a = "Geun's blog"

          >> a라는 변수에 "Geun's blog"라는 문자열 값을 그대로 대입

3-2. 참조자료형에서는?

 new키워드를 사용하여 객체 만들어 사용. 객체 중심으로 코드 작성에 유리

    ex) String a = new String("Geun's blog")

          >> 항상 새로운 String 객체를 만든다.

3-3. Wrapper 클래스

  원시자료형을 객체로 다루기 위해 객체화 시키는 클래스. 객체 지향 프로그래밍의 모든 기능을 활용할 수 있게 한다.

4. 형 변환

 (1) 문자열 → 정수 

       int n = Integer.parseInt(문자열)               

                 *정수 형태로 이루어진 문자열이어야 한다. (실수형태의 문자열은 정수형태로 변환 불가)

 (2) 정수 → 문자열

       String num = "" + (정수)                           *정수 앞에 빈 문자열("") 더하기

       String num = String.valueOf(정수)  

       String num = Integer.toString(정수)   

 (3) 실수 → 정수

       int n = (int) (실수)                                     *실수 앞에 (int) 붙임