Java

간단한 게임 케릭터 공격 프로젝트로 총정리 해보자.

1. 부모클래스가 될 Hero 클래스를 만들어주자. 게임의 케릭터를 담당할 것이다.

  • 이름변수, 공격메소드 + 생성자를 생성해준다.

2. 각 직업인 Warrior, Archer, Wizard 클래스를 만들어준다.

  • 부모클래스에서 받은 필드(name)를 초기화할 생성자를 만들어준다.
  • 각 직업에 해당하는 기술메소드()를 만들고, 출력문에 해당 기술명을 적어주자.

public class Warrior extends Hero {

    public Warrior(String name) {
         super(name);
        
     }
    
     public void groundCutting() {
         System.out.println("대지 가르기!");
     }

}

3.  메인클래스-메인함수를 만들고 구현해보자.

  1. 먼저 각 직업 클래스들을 담을 Hero클래스의 변수 배열을 만들자(다형성 개념으로, 부모클래스에는 자식클래스 어느것이든 담긴다)
    Hero[] heros = new Hero[3];
  2. 배열의 각 원소에다가 해당클래스 객체를 생성해서 참조해주자.
    heros[0] = new Warrior("전사");
    heros[1] = new Archer("궁수");
    heros[2] = new Warrior("마법사");

  3. for문안에 각 원소들에서 attack()메소드를 사용하도록 해보자. 공통적인 부모클래스의 메소드이므로, for문에서 한번에 해결할 수 있다.
  4. 바로 밑에서는 if문 + < instanceof > 를 이용하여, 부모클래스인 Hero변수안에 있지만, 각 직업클래스의 객체인지 판별하여 –> 
    해당 객체가 맞다면, 그 클래스의 참조변수 temp안에다가 형변환을 해서 넣은 뒤-> 특수기술메소드()를 사용할 수 있게 호출해주자.
    *형변환을 하는 이유는 지금 객체가 <부모클래스인 Hero의 참조변수 의 배열 >속에 있기 때문이다.
    for(int i = 0; i< heros.length; i++) {
       
        heros[i].attack();
       
        if(heros[i] instanceof Warrior) {
            Warrior temp = (Warrior) heros[i];
            temp.groundCutting();
        }
       
    }
  5. 마찬가지로 다른 직업도 같은 작업을 해주고, 출력해보자.

자바 (2)

  1. 2019.11.29 21:07

    비밀댓글입니다

  2. 2019.11.29 21:10

    비밀댓글입니다

Obejct클래스는 모든 객체의 조상인 부모클래스이다. 모든 객체가 암시적으로 extends Object를 가지고 있다고 생각하면 된다.

이런 계층구조를 가지는 이유는, 객체를 만들어내는 모든 클래스가 공통으로 포함하고 있어야 하는 기능을 제공하기 위해서이다.


Object가 모든 클래스의 부모이며, 다형성의 개념으로서, 어느 객체든 변수에 받을 수 있을 뿐만 아니라
어느클래스든 자식클래스가 되므로 (형변환)하여 대입할 수 있다는 개념을 이용해서
비교시 하는 메소드()의 파라미터에 해당 객체형이 아닌 Obejct형으로 받아서, 그것을 형변한 해도 비교가 가능하다는 것을 실습해보자.


1. 같은 클래스지만, 다른 필드값을 가질 객체를 생성할 Archer클래스를 만들어보자.

이름과, 공격력 변수를 만들고, 생성자도 만들어, 사용되는 곳에서 초기화 될 수 있게 하자

2. 다형성을 이용해서, 부모클래스의 참조변수 Object안에 들어있는 객체가 Archer객체로서, 필드값(name, power) 같는지 물어보고
   boolean을 반환하는 equals()메소드를 만들어주자.
  ( 비교할 때, 둘 다 Archer객체를 만들어서 비교할 것임)

확인하는 방법은

  1. 들어오는 Object변수를, 확인해줄 Archer클래스로 형변환 한다. 그러면 Object변수는 Archer의 객체가 된다.
    그러면 자동으로, Archer의 필드인 name과 power를 가지고 있게 된다.
    ( 상위계층(Object) –> 하위계층(Archer)에 대입할 때는 형변환 필수)
  2. Object에서 비롯하여 형변환이 된 Archer객체를 –> Archer의 참조변수 temp 에 넣는다.
    이렇게 object변수를 Archer형으로 형변환할 수 있는 이유는 <더 상위계층, 부모클래스>이기 때문에 가능하다.
    넘어온 매개변수 Object는 암시적으로 자신을 상속한 Archer클래스로 형변환이 가능하다.
  3. if문으로 Archer객체가 가지는 name과 < – > temp속 name이 같은지 물어본다. 동시에 power도 같은지 물어본다.
  4. 같으면 true, 그렇지 않다면 false를 return한다.


public class Archer {
    
     String name;
     String power;
    
     public Archer(String name, String power) {
         this.name = name;
         this.power = power;
        
     }
    
    
     public boolean equals(Object obj) {
         Archer temp = (Archer) obj;
         if( name == temp.name && power == temp.power) {           
            
             return true;   
            
         }else {
            
             return false;
            
         }
        
     }
    
    
}


3. 메인클래스-메인함수를 구현해서, Archer클래스의 객체를 생성하고, 사용해보자.

  1. 2개의 객체를 생성하고, 참조변수에 넣어준다.
  2. 이제 2개의 객체를 비교해주기 위해서,  출력문에 archer1 == archer2 객체를 바로 비교한다. 당연히 false가 출력된다.
    필드값들이 서로 다르게 초기화 되었기 때문에 서로 다른 객체이다.
  3. 만약 초기화값을 같게 해줘도, false가 반환된다. 기본적으로 각각 생성된 객체는 hashCode가 다르기 때문에,
    초기화하여 내부 필드들이 갔더라도 완전이 다른 객체이다.
  4. 이제 Archer클래스의 equals()메소드를 이용해서 비교해보자. 초기화 값이 같다면 true가 반환된다.
    equals()라는 메소드는 같은 Archer객체로서, 들어있는 필드값이 같은지를 물어보기 때문이다.

public class Main {

    public static void main(String[] args) {
        
         Archer archer1 = new Archer("궁수1", "상");
         Archer archer2 = new Archer("궁수1", "상");
         System.out.println(archer1 == archer2);
         System.out.println(archer1.equals(archer2));

    }

}

정리

모든 클래스의 조상은 Object클래스이다. 같은 종류의 객체를 비교하는 메소드를 만들 때,  파라미터에 (Object obj)가 들어있어도
호출시에는 자식이되는 모든 클래스들을 넣어도 상관없다. 대신 형변환을 해줘야 같은 객체의 필드값들이 같은지 비교할 수 있다.

다형성이란 객체를 사용할 때, 변수형태를 바꾸어서 여러타입의 객체를 참조할 수 있다.

결과적으로 이러한 다형성의 개념을 적절하게 이용할 때, 소스코드를 유연하게 구성할 수 있다.

다형성은 <부모 클래스 타입의 참조변수><하위 클래스의 객체를 참조할 수 있게 해준다.>

과일 정보 프로젝트를 구현해보자

1. 부모클래스가 될 Fruit 클래스를 생성하자

  1. 과일의 이름과 가격 , 신선도 변수를 선언해주자.
  2. 변수를 출력할 메소드도 만들어주자.

public class Fruit {

    String name;
     int price;
     int fresh;
    
     public void show() {
         System.out.println("이름 : " + name);
         System.out.println("가격 : " + price);
     }
    
}

2. 자식 클래스가 될 Peach클래스를 생성하자.

  1. 부모클래스의 필드를 초기화 해주자
  2. 만약, 부모클래스안에 부모필드를 초기화하는 생성자가 있다면,  자식클래스에서는 super.( , , ); 초기화 하는 것이 맞다.

public class Peach extends Fruit {
    
     public Peach() {
        
         price=1500;
         name = "복숭아";
         fresh = 75;
        
     }

}

3. 메인클래스와 메인함수를 생성한다.

4. 이제 다형성의 개념으로서, 부모클래스의 참조변수 에다가, 자식클래스의 객체를 생성해서 넣어준다.
   비록 부모클래스의 변수에 넣었지만, 필드나 메소드가 작동하는 것은 new뒤에 붙은 자식클래스의 객체가 본질이다.
   show()메소드는 부모클래스에만 존재하기 때문에, 부모의 메소드를 호출한다. 필요하다면 오버라이딩해서 쓰면된다.

public class Main {

    public static void main(String[] args) {
        
         Fruit fruit = new Peach();
         fruit.show();

    }

}

5. 또하나의 자식클래스 Banana를 만들고, 부모 필드를 초기화해주자.

public class Banana extends Fruit {
    
     public Banana() {
     price = 1000;
     name = "바나나";
     fresh = 80;
     }

}

6. 메인 클래스의 메인함수에서 다시 부모클래스 참조변수에 Banana객체를 넣자.

Fruit fruit2 = new Banana();
fruit2.show();


실제로 어떤 것을 구현할 때, 복숭아인지 / 바나나인지 사용자가 임의적으로 선택할 수 있게 한다.

자식클래스의 인스턴스(객체)를   자신의 변수에다가 넣는 것이 바로 다형성이다.


7. 실제적으로 사용되는 코드로 만들어보자.

  1. 스캐너를 생성한 뒤, 복숭아/ 바나나를 숫자로 입력받도록하자.(입력받을땐 println이 아니라 print로 출력)
  2. 담을 변수는 미리 선언해놓고, 넣을 객체만 if문에 따라 new Banana인지 new Peach인지 구분해서 넣어준다.

public class Main {

    public static void main(String[] args) {
        
        
         Scanner sc = new Scanner(System.in);
         System.out.print("복숭아는 1, 바나나는 2를 입력하세요 : ");
         int input = sc.nextInt();
        
         Fruit fruit;
         if(input == 1) {
             fruit = new Peach();
             fruit.show();
         }else if(input ==2) {
             fruit = new Banana();
             fruit.show();
         }
        
     }

}

다형성 정리

다형성을 이용해서 만약 과일이 아니라, 게임케릭터라고 생각해보면, 입력받은 숫자대로 전사/마법사 등등을 선택 할 수 있다

미리 부모클래스를 만들어, 을 만들어놓은 다음

사용자가 입력한 값에 따라서, 선택된 그리고 완전히 다른 인스턴스 (객체)를 쉽게 바꿔서 대입할 수 있다는 측면에서

유동적으로 자기자신의 변수에 불러오므로, 내용도 유동적으로 바꿔줄 수 있다.

자바














추상클래스와 비슷한 개념으로서,  추상같은 경우, 어느 클래스안에 어느 메소드가 사용될지 암시해주는 설계제공이었다.
인터페이스 같은 경우, 더 선호되는 설계기능으로, 비록 같은 추상메소드를 가지고 있으나, 차이점은

  1. 다중 상속이 가능하게 한다.
  2. 사전에 정의된 상수만 가질 수 있다.(추상클래스는 필드를 여러개 가질 수 있고, 상수가 아니어도 된다)
  3. 사전에 정의된 추상메소드만 가질 수 있다.(추상클래스는 추상메소드 이외에 다른 일반 메소드들도 가질 수 있다. 따라서 일반메소드의 body{}도 채워놓을 수 있다.)
    추상클래스보다 요구되는 설계의 기준이 더 높아서 더 체계적이라 할 수 있다.


[1] 인터페이스를 선언하고 메소드를 다루어보자.


1. Dog라는 인터페이스를 만들고, abstract로 추상메소드를 만들자(추상메소드를 만드는 과정은 추상클래스와 동일하다)
public interface Dog {
    
     abstract void crying();
     public void show();
    

}


2. 메인클래스, 메인함수를 만들어서 인터페이스를 상속(implements)해서 구현화해보자.  반드시 구현화할 메소드들을 오버라이딩해야한다.

public class Main implements Dog{

   
     public static void main(String[] args) {

    }

    @Override
     public void crying() {
         // TODO Auto-generated method stub
        
     }

    @Override
     public void show() {
         // TODO Auto-generated method stub
        
     }

}

3. 재정의로 구현화할 메소드 내용을 채워준다.

4. 메인클래스에서 상속했으니, static인 메인메소드에서 사용하려면, Main 객체를 만들어서 사용해야한다.

public class Main implements Dog{

   
     public static void main(String[] args) {
        
         Main main = new Main();
         main.crying();
         main.show();
        

    }

    @Override
     public void crying() {
        
         System.out.println("월 월!");
        
     }

    @Override
     public void show() {
         System.out.println("Hello World!");
     }

}


[2] 인터페이스의 다중 상속을 학습해보자.


  -  2개의 추상클래스를 만들어서, 2개를 모두 상속하면 오류가 난다.

1. Dog 인터페이스를 복사해서 , Cat 인터페이스를 만들어보자.

2. 메인클래스에서 implements Dog, Cat 으로 2개의 인터페이스를 다중상속해보자.

3. 반드시 오버라이딩해야하는 인터페이스의 메소드들을 추가해보자.
   만약 2개의 인터페이스의 추상메소드가 겹칠 경우, 하나만 구현화해줘도 문제가 없다.

public class Main implements Dog, Cat{

   
     public static void main(String[] args) {
        
         Main main = new Main();
         main.crying();
         
         main.dog();
         main.cat();
        

    }

    @Override
     public void crying() {
        
         System.out.println("월 월!");
        
     }


     @Override
     public void cat() {
         System.out.println("고양이 입니다.");
     }

    @Override
     public void dog() {
         System.out.println("개 입니다.");
        
     }

}

절대로 변하지 않는 특정한 것을 사용할 때 final을 사용한다. 변수 메소드 클래스에 모두 사용할 수 있다.
변수의 경우, 변하지 않는 상수
메소드의 경우,  상속한 자식클래스에서 오버라이딩(재정의)가 불가능한 메소드
클래스의 경우, 상속이 불가능한 완전한 클래스가 된다.

[정리] final을 사용해서, 더이상 바뀌지 않게 보호하는 기능을 한다고 할 수 있다.

cf) 인터페이스의 필드는 모두 final이 생략되어있다.

[1] final 상수를 만들어보자.

1. final 변수(상수)를 만들어보자. 이 때, 어떠한 수를 다시 대입하면 오류가 난다.

        final int number = 10;
         System.out.println(number);
        
         number=5; //오류가 난다.

[2] final 메소드를 만들어보자.(1 ~3 까지는 final이 아니라서, 재정의된 오버라이딩 메소드를 호출한다.)

1. Parent클래스를 만들고, 출력문을 가진 메소드 show()를 만들자.

public class Parent {

    public void show() {
        
         System.out.println("Hi from Parent");
        
     }   
    
}

2. 메인클래스에서 Parent 클래스를 상속받고, (STATIC 메인메소드에서도, 재정의한 메소드를 호출할 수 있게)메인클래스 객체를 생성해서,
   부모parent에 있는 show()메소드를 이용해보자.

public class Main extends Parent{
     public static void main(String[] args) {
         Main main = new Main();
         main.show();       
     }
}

3. 이제 부모클래스의 show()를 오버라이딩 해서, 재정의한 show();가 호출되도록 해보자.

public class Main extends Parent{

    @Override
     public void show() {
         System.out.println("hello from Main");
     }

    public static void main(String[] args) {

        Main main = new Main();
         main.show();
        
     }
}

4. 이제 Parent 클래스의 show()메소드에 final을 붙혀보자. -> 자식인 Main클래스에서 오버라이딩 한 곳에서 오류가 난다.
   ***final이 붙은 메소드는, 부모클래스의 것이더라도 자식이 오버라이딩해서 사용 못한다!

    public final void show() {       
         System.out.println("Hi from Parent");       
     }
    


[3] 클래스에 final을 붙혀보자.

1. Parent클래스에 public을 빼고, final class로 바꿔보자.  => 상속한 자식인 Main클래스에서 오류가 난다.
  *** final이 붙은 클래스는, 다른 클래스에서 더이상 상속하지 못한다.

MY) 완전한 설계도이므로, 객체를 생성해서 사용할 수 밖에 없다. 상속할 자식은 더이상 존재할 수 없음.

[정리] final을 사용해서, 더이상 바뀌지 않게 보호하는 기능을 한다고 할 수 있다.

객체지향을 본격적으로 활용하기 위해, 추상(Abstract)와 인터페이스(interface)의 개념이 존재한다.

  • 자바에서는, 일종의 미완성 클래스라고 할 수 있는 추상(Abstract)클래스를 제공하는데, 추상클래스는 직접적으로 객체(인스턴스)를 생성할 수 없지만,
    < 새로운 클래스(추상클래스를 상속하는 자식 클래스) 를 작성하는데 밑바탕이 되는 역할을 해준다는 것>에 의미가 있다.
    예를 들어, 사각형/ 원/ 삼각형 이라는 클래스는 <공통적으로 넓이()와 모양()>이라는 메소드가 필요하다.
    그것을 반드시 구성할 수 있도록 추상 클래스에 설계해놓고 알려준다.
    - 규칙 : 추상클래스 꼭 상속받아야 하며, 모든 추상메소드는 자식클래스에서 구현이 되어야한다.


[1] 추상의 개념을 이용해서, 음악 플레이어 클래스를 구현해보자.

  1. Player클래스를 만들어보자. 그리고 접근제한자 public 대신 <abstract>로 바꿔서 추상클래스로 바꾸자.
  2. 안에 추상메소드를 넣어줘야한다. 인터페이스처럼 body{}가 없다.3가지 매소드를 넣어주자.
    abstract class Player {
       
         abstract void play(String songName);
         abstract void pause();
        abstract void stop();
  3. }


  4. 메인클래스를 만들고 추상클래스를 상속(extends Player)하자.
    *추상 클래스를 상속했다면, 그 안의 추상 메소드들은 모두 implements해야한다. 오류가 뜨는 것을클릭해서 메소드들을 구현하자.
      -> 오버라이딩 되면서, 추상클래스들의 추상 메소드들이 implements된다.


    @Override
     void play(String songName) {
         // TODO Auto-generated method stub
        
     }

    @Override
     void pause() {
         // TODO Auto-generated method stub
        
     }

    @Override
     void stop() {
         // TODO Auto-generated method stub
        
     }

4. 이제 비어있는, 추상 메소드들을  구현화하자.
     @Override
     void play(String songName) {
         System.out.println(songName+"곡을 재생합니다");       
     }

    @Override
     void pause() {
         System.out.println("곡을 일시정지 합니다");       
     }

    @Override
     void stop() {
         System.out.println("곡을 정지합니다");
     }

5. 메인메소드에서 구현화한 추상메소드들을 이용해보자. 이 때, 그냥 평소 호출하듯이 play("");를 호출하면, 오류가 뜬다. 그 이유는 메인메소드가 static이기 때문이다.
     클래스의 것으로, 클래스에서만 사용할 수 있도록 만든 static 메소드 내부에서는 반드시 호출되는 메소드들도 static이어야만 한다.*****
  ==> 이러한 것을 해결하는 방법으로, 호출하는 메소드에 static을 붙혀줄 수 도 있지만,
      ****< 메인클래스의 객체를 생성한 뒤, 객체.를 이용해서 호출하면 static이 붙은 메인메소드안에서 호출이 가능하다.>****

    public static void main(String[] args) {

        Main main = new Main();
         main.play("따르릉 by 홍진영");
        
     }

6. 다른 메소드 2개도 호출하여 실행해본다.


public class Main extends Player {

    public static void main(String[] args) {

        Main main = new Main();
         main.play("따르릉 by 홍진영");
        
         main.pause();
         main.stop();
        
     }

    @Override
     void play(String songName) {

        System.out.println(songName+"곡을 재생합니다");
        
     }

    @Override
     void pause() {

        System.out.println("곡을 일시정지 합니다");
        
     }

    @Override
     void stop() {

        System.out.println("곡을 정지합니다");

    }

}


[2] 추상의 개념을 이용해서 동물 클래스를 구현해보자.


1. Animal클래스를 만들고, 추상클래스로 바꾸자. 그리고  abstract void crying(); 메소드 하나를 넣어주자.

2. Dog클래스를 만들고 Animal 추상클래스를 상속하자. 추상메소드를 가져와서, 개가 우는 방식으로 구현화하자.

public class Dog extends Animal{

    @Override
     void crying() {
         System.out.println("월 ! 월 !");
     }

}

3. 마찬가지로 Cat 클래스를 만들고 추상클래스를 상속해서, 추상메소드를 구현화해주자.

4. 메인클래스에서, dog/cat객체를 만들어서, crying()을 호출해준다.
  - [1]에서는 메인클래스가 직접 추상클래스를 상속해서 이너메소드로 추상메소드가 오버라이딩 되었다. 하지만 이너메소드이면서 static메소드인 메인메소드에서 nonstatic 이너메소드를 호출 할 수없으니, 메인객체를 만들어서, 외부에서 호출하는 것처럼 만들었다.
    하지만, 이번에는 메인클래스에서 추상클래스를 상속한 것이 아니므로, 메인클래스의 객체를 생성할 필요가 없다.

    public static void main(String[] args) {

        Dog dog = new Dog();
         Cat cat = new Cat();
         dog.crying();
         cat.crying();
        
     }



[정리] 이렇게 추상클래스를 상속함으로써, 반드시 구현화해야하는 추상 메소드들을 알려준다. 사용자는 상속한 자식클래스에서 꼭 implements를 통해 오버라이딩해서 구현화해야하니 , 필요한 메소드들을 미리 알림을 받을 수 있고, 설계적인 측면에서 효율적으로 가져오면서, 안빠트리고 사용할 수 있다.

[1]enum(상수값들의 집합)

 - 프로그램에서 미리 정해놓아야할 값들(상수들)이 존재할 때, 사용한다.

 - 문법 형식 : 


 public enum FoodMenu {

  PIZZA("피자"), KIMCHI("김치), CHIKEN("치킨");

 }

  그외에, 필드 와 생성자를 내부에 가질 수 있다.


 - 실제로는 java.lang.Enum 클래스의 자식 클래스로 생성된다. 많이 쓰는 메소드로 enum변수.name(), ordinal()이 가장 많이 쓰인다.

 - 자동적으로 제공되는 메소드 :  values() - return 타입 : E[]에다가 안에 있는 상수들을 다 뽑아 낼 수 있다 valueOf(String name) - E 타입 하나를 뽑아 낼 수 있다

 - 사용은 Enum명.상수명 을 이용해서 불러와, Enum변수에다가 집어넣어서 --> 보통 swtich -case문에 많이 사용한다. 

    FoodMenu f = FoodMenu.KOREAN

f.na



[2] 가변형 인자(var args) (String... a)

 - 인자값(파라미터, argumen)의 개수를 정하지 않는 것

 - 배열과 같게 취급이 되어, 확장for문  for(String s : a) 형식으로 사용된다.

 - 문법 형식 : 

   public void method(String... a){

for(String s : a) {

System.out.println(s);

}

   }

  인자값이 1개가 됬든, 10개가 됬든, String형 배열에 담겨서 그것들을  확장for문으로 뽑아낼 수 있다.

 - 반드시 마지막 인자값으로 가변형 인자가 들어가야한다. (String a, int b, String... c)


[3] 추상 클래스(abstract Class)

 - class이지만, 객체를 생성할 수 없다. 불완전한 설계도이므로 상속받는 자식클래스에서 객체를 생성해야한다.

 - 추상메소드를 가지는 것은 인터페이스와 동일하다. 하지만 , 필드와 일반메소드들도 가질 수 있는 점에서 인터페이스와 차이가 난다.

 - 목적미리 만들어진 메소드를 자식클래스가 반드시 오버라이딩해서 가지도록 하기위해서이다.(인터페이스가 더 추상적이라 설계적인 측면에서 선호된다)

 

[4] 중첩 클래스(nested class)  : 3가지가 존재한다.

 - 클래스안에 클래스가 들어간다는 의미이다. 

   만약 클래스안의 클래스인데, static이 붙어있으면, static-nested class라 한다.

   만약 클래스안에 들어간 클래스가 static이 없으면, inner class라고 부른다.

   만약, 클래스이름이 없고, 인터페이스를 상속(new Runnable(){})해서 바로 body{}만 있는 것이라면, anonymous - inner class라 부란다




   my) 클래스는 객체를 생성하기 위한 것이다. 만약 static이 붙어서 클래스의 것이 되면, 외부에서 객체생성 못한다.

         대신 클래스 내에서는 객체생성이 가능하다.


  래스안에 클래스(중첩클래스)가 존재하는 것은 3가지 경우이다.

1) static이 붙은 중첩클래스 : 스태틱이 붙어 있으므로, 클래스의 것 => 클래스 내부에서만 객체생성이 가능하다.

2) static이 안붙은 이너클래스스태틱이 안붙어 있으므로, 객체의 것 => 어디서든 객체를 생성해서 사용한다.

3) 클래스의 이름이 없이 인터페이스를 상속한 new Runnable() { } 클래스 : 어노니머스-이너클래스 => 클래스이름이 없고 바로 내부에 실행매쏘드를 가진다.


 - 목적 : 오로지 한 클래스 안에서만 필요한, 클래스(외부에서 객체를 만들필요가 있을 경우)가 필요할 때 사용한다.

  encalsulation이 강화된다. 프로세스가 돌아갈 때, 안쪽 한군데서만 돌아가도록 하고, 메소드를 통해서, 통신만 하도록 하게 하는 것이 강해진다.

 - 가장 많이 쓰이는 곳 : Swing(ui), android에서 이벤트 처리용으로 많이 사용한다.

 

 static-nested class의 static은 소유제한자이며, class의 것이다. 클래스에서 객체를 생성해서 사용한다.

 

public class Outer {

private static class StaticNested { } : static이 붙은 [ 중첩클래스 ]이며, 클래스내에서만 객체가 생성 가능하다.

private class Inner{ } : static이 안붙어 있는, 클래스안의 클래스를  [ 이너클래스 ]라고 한다. static이 안붙었기 때문에, 객체의 것이므로, 객체를 생성해서 사용해야한다.

private Runnable run = new Runnable(){ } : [anonymous - inner class]로, java.lang.패키지에 있는 Runnable이라는 인터페이스이다.

}

- new Runnable( ) { } 이라는 것이 Runnable이라는 인터페이스의 객체를 생성하는 것 처럼 보이지만, 사실은 인터페이스를 상속하고 있는 또다른 클래스를 만드는 과정이다. 그래서 {  }안에는 필드와 메소드가 들어간다. 

  - 인터페이스를 상속받고 있는 클래스이지만, 이름이 없다.

 


 -  중첩클래스의 객체를 생성하는 문법 형식

1)static-nested class(스태틱- 중첩클래스) :  <클래스 내부에서> 클래스명.중첩클래스명  변수 = new 클래스명  .중첩클래스명();

2)inner class(이너 클래스) :   클래스명.이너클래스명  변수 = new 클래스명(). new 이너클래스명(); 

   [ Outer객체 > Inner클래스 ] -- [ Inner객체 ]

3)anonymous-inner class(어노니머스-이너클래스 ) : 인터페이스명  변수 = new 인터페이스명() { 오버라이딩 메소드 };

   - 인터페이스 객체를 생성하는 것이 아니라 인터페이스를 상속하는 어노니머스 이너클래스를 만드는 과정



[5] annotation(애노테이션)

 - 프로그램에 대한 정보를 제공하는 것이다.

 - 목적 : 컴파일러에게 정보제공 / 컴파일 시 자동으로 소스를 만들어줌  /  xml을 생성기능 / 실행시에 검사하기 위해서

 - 활용 : Spring 프레임워크에서 많이 사용된다.


 - 컴파일러에게 정보제공 할 때 쓰이는 방식

  @Deprecated : 더이상 쓰지 말아야할 곳에 쓴다

  @Override : 반드시 오버라이딩 해야할 곳

  @SuppressWarnings : Generics( )를 제대로 사용하지 않았거나, Deprecated된 메소드를 사용할 때 Warning이 발생하는 곳에 막아주는 기능


[6] final

 - 변수 앞에 붙어서 상수로 만들어준다

 - 메소드 앞에 붙어서 자식이 오버라이딩(재정의) 못하게 한다

 - 클래스 앞에 붙어서 자식이 상속할 수 없게 한다.



[7] 실습


1. 메인메소드를 가진, package enumpack, public class TestEnum 를 만들어준다.

(1) 중첩클래스처럼, 내부에 enum을 만들어준다.

     public class TestEnum {

public enum Language{

}

(2) 대문자로 상수를 만들어준다.

KOREAN, ENGLISH, JAPANESE;


(3)[  ctrl+space ] 를 눌러서 생성자를 넣어준다. (사용은 안할 것이다)


(3) 보통 메인함수에서 참조형 변수를 생성한 뒤에 Language.상수명을 넣은 다음, 변수를  switch case문에 넣어서 사용한다.

public static void main(String[] args) {


Language l = Language.ENGLISH;

switch(l) {

case KOREAN : System.out.println("한글입니다."); break;

case ENGLISH : System.out.println("영어입니다 " + Language.ENGLISH); break;

}

}

(4) 이제 enum명. values()를 이용해서 선언한 상수들을 모두 배열에 넣은다음, 확장for문을 이용해 하나씩 꺼내보자.

     for문안에서는 사용된 변수.name()을 상수명을, 변수.ordinal()을 이용해서 index순서도 같이 찍어주자.


for(Language lang : Language.values()) {

System.out.println(lang.name() +"은 "+ lang.ordinal()+"번째 상수입니다.");

}


2. abs패캐지, abstract 클래스를 만들자. 메인함수도 넣어주자.

(1) class앞에 abstract를 추가해주자.

(2) 메소드를 만드는데 반환형 앞에다가 abstract를 넣어줘야한다. 순서바뀌면 안됨.

(3) 인터페이스와는 다르게, 일반메소드도 넣어줄 수 있다. 


package abs;

public abstract class TestAbs {

public abstract void test() ;

 

public void test2() {

System.out.println("추상클래스안의 일반메소드");

}

 

public static void main(String[] args) {


}


}



(4) abs패키지안에, 추상클래스를 상속받을 자식클래스를 만들어주자. [browse]를 눌러서 부모클래스를 TestAbs를 선택해주자. 메인함수도 포함시키자

 - 부모클래스가 추상클래스이므로, 자식클래스가 반드시 오버라이딩 해야하는 매쏘드가 , 자동으로 작성되어있다.


public class TestAbsSub extends TestAbs {


@Override

public void test() {

// TODO Auto-generated method stub


}

(5) 메인메소드에서 사용해보자. 

*** 나는 객체를 생성해서, 변수에 넣고, 변수.메소드()를 호출하지만 , 변수 없이 바로 객체생성후.메소드()를 호출 할 수 있다.

클래스의 메소드를 사용하는 것은 [ new 생성자() ] 의 객체가 메소드를 사용해서 통신


public static void main(String[] args) {


//객체를 생성해서 변수에 넣고 이용하는 방법

TestAbsSub tab = new TestAbsSub();

tab.test();

//객체 생성하자마자 바로 메소드를 이용하는 방법

new TestAbsSub().test();

//부모인 추상클래스의 일반 메소드를, 자식이 사용하기

new TestAbsSub().test2();

}



3. 중첩클래스를 만들어보자.

(1) 클래스안에,  Runnable인터페이스를 상속받는 [이너클래스]를 만들자. -> Runnable인터페이스안의 추상메소드를 상속해야한다.

(2) run()함수안에는 for문으로 0부터 9까지 출력시키는 코드를 넣어주자.


//이너클래스

private class Target implements Runnable {


@Override

public void run() {

for(int i=0;i<10;i++) {

System.out.println("i : "+i);

}

}

}


(3) 메인메소드에서 Target클래스의 객체를 만들자. 하지만 이너클래스는 static 이너클래스인 메인메소드 안에 바로 들어갈 수 없다.

    바깥쪽 TestOuter객체를 만들고 그것을 이용해야한다.

   ***** 이너클래스의 객체는 바로 생성하지 못한다 ==> 현재 바깥 클래스의 객체를 만들고 난 뒤, 변수를 선언할 때는, 클래스명. 을 / 객체를 생성할 때는, 객체명. 을 써서 생성한다.

   ***** [바깥 클래스명].[이너클래스명]  변수명    =    [바깥 클래스 객체]. new [이너클래스명](); 

    왜냐면, 변수 선언은   [설계도 클래스명]이 앞에 오고 / 객체 생성은, [객체]에서 비롯 되기 때문이다.

public static void main(String[] args) {


TestOuter out = new TestOuter();

TestOuter.Target t = out.new Target(); 

}


(4) 쓰레드를 하나 만들어고, 파라미터에는 Runnable인터페이스를 상속한 클래스의 변수를 넣어준다.

    - Runnable 인터페이스의 run()메소드는 쓰레드의 파리미터에 넣어서 실행된다. 그것을 상속한 자식의 run()메소드도 쓰레드에서 실행된다.


Thread th = new Thread(t);

th.start();


(5) anonymous-inner class를 메인함수에서 바로 만들어주자.

     먼저 쓰레드 객체를 생성하고, 파라미터에는 new Runnable() {  }을 만들어준 다음, ctrl+space로 run()매소드를 오버라이딩 하자.


//어노니머스 이너클래스

Thread th2 = new Thread(new Runnable() {

@Override

public void run() {

for(int i=0;i<10;i++) {

System.out.println("i : "+i);

}

}

});

th2.start();


단축키) 

생성자/겟셋터 : ALT +SHIFT + S

한줄 삭제 : Ctrl + d

자바독 : ALT+SHIFT+J



[1] 인터페이스(interface)


안드로이드에서 인터페이스는 어떤동작을 듣고 있는 귀이다. 귀를 달아준 뒤 귀에 들릴 때, 행동할 것은 우리가 적어서 한다.


리모콘의 버튼을 누르는 것이 인터페이스이다.  노래방 기계 개발자가 노래목록을 api로 제공하는 것이 인터페이스다.

예를 들어서, 1111을 누르면, 자동으로 노래를 불러온다. 하지만, 리모콘을 눌러도, 안쪽에 캡슐화가 되어있기 때문에 어떻게 돌아가는지는 모른다.


1. 인터페이스의 문법적 특징 

 - final이 붙어 있는 상수가 존재한다.(인터페이스 내부의 필드들은 다 상수다. final이 없다면 생략된 것이다.)

 - 메소드는 선언으로만 이루어진다.(내용(body부분 {  }) 은 비어있고 나중에 인터페이스를 상속하는 곳에서 내용을 채워 사용한다. 

   예를 들어, 안드로이드의 버튼의클릭 리스너는 내용은 비어있다)

 - 모든 상수와 메소드는 public이다.

 - 여러개 상속이 가능하다.

 - 클래스와 달리 객체 생성(new 생성자)은 불가능하다.

   (변수는 생성가능하다. 해당 인터페이스를 상속한 자식 클래스의 객체가 생성된 것을 참조할 수 있다.)

 - 서브클래스(상속받는 자식클래스)는 메소드 내용 구현이 필수적이다.

 - 인터페이스가 인터페이스를 상속할 때는, extends로 상속한다. 클래스가 상속할 때는 implements로 한다.


public interface InterSub extends Inter1, Inter2 { // 인터페이스가 인터페이스를 상속할 때는, extends로 상속한다. 클래스를 상속할 때는 implements로 한다.

public static final int HEIGHT = 768; // 인터페이스에서 필드를 선언하지만, 모두 상수값이 된다.

int width = 1024; // public static final은 생략이 가능하다. 인터페이스에서 선언한 필드는 다 상수다.


public abstract void open(); //인터페이스의 매쏘드는 { }의 내용이 구현되어 있지 않다.

void close(); // 인터페이스의 public abstract는 생략이 가능하다. 인터페이스에서 선언한 [반환형 + 매쏘드()]는 다 내용이 구현되어 있지 않다.


}


* abstract : 메소드의 body{ }가 없는 경우에 붙이게 되는 예약어이다. 인터페이스들의 메소드는 다 abstract를 가지고 있는데 생략되어 있다.

* 나중에 메소드를 추가 혹은 변경 하고 싶다면, 해당 인터페이스를 상속받는 자식 인터페이스를 만드는 것을 추천한다. 

  왜냐하면, 인터페이스는 외부에 공개가 되는 것이다. 전세계 사람들이 open(), close()메소드를 쓰고 있을 것이다. 이것을 변경하면 안된다.


[2] JavaDoc(/**  */)

 -  // 한줄주석, /* */ 여러줄 주석, 그리고 바로 /** */ (안드로이드의 초록색 주석)--> javadoc

 - [api용 문서]로 사용이 된다. (커서를 갖다놓으면 자바독이 바로바로 뜬다)

 - 내용으로는 인터페이스 생성 정보, 메쏘드에 대한 설명 등을 인터페이스를 사용하는 사용자들에게 정보를 제공하는 문서가 된다.


[3] 상속(inheritance)

 - 부모클래스가 자식클래스에게 필드와 메소드를 물려주는 것

 - is a 관계

 - 계층구조도 맨 꼭대기에는 Object라는 클래스가 있다. 모든 클래스는 Object를 상속하고 있다. 모든 클래스는 Object이다.

 - 필드와 메소드만 물려주기 때문에, 생성자는 상속되지 않는다.


[4] 형변환 (Type Casting)

 - Reference Type 변수(참조형 변수, 대문자로 시작하는 클래스 변수)의 type을 변환하는 것이다. ( 실제로 객체가 변하는 것은 아니다)

 - 암시적 형변환 :  

Human h = new Human(); 에서,  new Human();은 <하위계층>인 사람 클래스의 객체를 <참조형 변수>가 받았다

Obeject o = h; 에서, <하위계층>인 사람클래스의 참조형 변수 h는 <상위계층>인 Object클래스의 참조형 변수 o에 형변환(캐스팅)없이 바로 대입 할 수있다

 - 명시적 형변환 :  

Object o = new Human(); 에서, <하위계층>인 사람 객체를 , <상위계층>인 객체의 참조형 변수에 넣었다. 암시적 형변환으로 형변환 없이 바로 작은 것을 큰것에 넣을 수 있다

Human h = (Human) o; 에서, <상위계층>인 Object 클래스의 참조형 변수 o<하위계층>에 넣을 때는, 반드시 형변환을 해줘야한다.


  my) 큰 단위(Object)에 <=====더 작은 단위(human)을  대입할 때는 형변환 캐스팅 없이 암묵적으로

        더 작은단위(Human)에 <==큰 단위(Object)를  대입할 때는, 큰것 앞에다가 ( )로  형변환 캐스팅 해줘야한다.


[5] 오버라이딩(Overriding) - my)부모 메소드 재정의

 - 부모클래스에서 상속받은 메소드를  <현재 클래스에 맞는 형태로 재정의>하는 것이다.

 - ***규칙 : 부모 메소드와 똑같은 선언부를 가진다.(내용만 원하는대로 재정의한다) or 접근제한자가 더 넓은 범위를 써야한다.(부모 protected - > 자식 public or protected)


[6] 다형성(Polymorhism)

- 하나의 객체가 -->  다양한 형태로 모습(부모의 변수 or 자식의변수에 대입)이 변하는되는 것 : 형변환( or 오버라이딩 : 메소드명은 같으나 내용이 재정의 되어있다.)

- 다른 형태인 형변환( or 오버라이딩) 상태에서 처음생성된 해당 객체의 메소드가 실행되는 것 : 다형성

 ex> 오버라이딩 : 부모클래스의 메소드를  자식클래스가 오버라이딩해서 사용한다면, 부모의 메소드와는 전혀 다른 자식의 메소드가 실행된다.

 ex> 형변환 : new 사람() 객체는 동물객체가 될 수 있다.(is a 관계). 이때, 사람객체를 형변환해서 동물객체에 넣고, 동물객체.움직인다()를 호출하더라도,                      new 로 생성한 객체는 사람이다. new뒤에 붙은 객체의 메소드 ,사람객체.움직인다()가 실행된다.


     - new 뒤에 적힌것만 보고 어느계층의 메소드()가 호출되는지 판단하면 된다.******************



Human extends Animal

Monkey extends Animal 상황에서


Animal a = new Animal();

Animal h = new Human(); //작은 것(하위계층)을 대입한, 암시적 형변환

Animal m = new Monkey();// 작은 것(하위계층)을 대입한 암시적 형변환


이때, 메소드를 출력하면

a.move(); // Animal 클래스의 move()메소드가 호출됨

h.move(); // Animal  변수에 담겨있지만, new 뒤의 Human클래스의 오버라이딩 한 move()메소드가 호출

m.move();// Animal 변수에 담겨있지만, new 뒤의 Monkey클래스의 오버라이딩 한 move()메소드가 호출


[7] super 사용( 클래스의 생성자 or 메소드의 오버라이딩 )

 - this는 클래스 자기자신의 객체를 뜻한다. 그래서 this.필드명 을 치면 private한 필드에도 접근이 가능하다.

 - super는 부모 클래스의 객체를 뜻한다. 


 사용방법은 2가지

1. [자식클래스의 버라이딩 된 메소드 안에서] 오버라이딩된 자식메소드가 아닌, <부모클래스 속의 메소드>를 그대로 호출할 때, 메소드 안에 적어준다.  그 뒤에 추가로 재정의 할 수 도 있다.


@overridng

 void move(){

super.move(); //부모클래스객체 super.를 이용해서 부모의 메소드 move()를 그대로 호출한다.

System.out.printlm("사람이 움직인다"); // 추가적으로 자식클래스의 오버라이딩 메소드만의 추가적인 재정의를 더해줄 수 있다.

 }


2. [자식클래스의 생성자를 만들 때], 부모클래스의 필드를 초기화하기 위해, 부모생성자를 호출한다.

 - 모든 생성자의 첫번째 줄에는 부모생성자가 생략되어있다!! 컴파일러가 자동으로 super();를 자동으로 넣어준다.

 public class Human extends Animal {

public Human() {

super(); //자식클래스의 생성자에서는 부모클래스의 생성자를 먼저 호출한다. 없다면 생략된 것이다.

}

 }

  

 - 만약 부모클래스에 <파라미터가 비어있는> 기본생성자가 없고,  <파라미터를 가진 > 사용자정의 생성자( public Human(int height) {  this.height = height }  )를 가지고 있다면

    자식클래스에서는  super();를 생략하면 컴파일 오류가 난다. super( 초기화할 값 );  super ( 10, 20); 등 사용자가 정의한 생성자의 초기값을 파라미터로 넣어줘야한다.







[8] 실습 (javase07)

1. 자바프로젝트의 src> 우클릭 >new> interface를 선택해준다. 패키지명은 song, 인터페이스명은 [ Singable ]로 준다.

 (1) 인터페이스의 필드를 만든다. 인터페이스의 필드는 상수이므로, 대문자로 변수를 선언한다. (상수를 의미하는 public static final이 생략되어있다)

      아래의 상수는 다른 것 같지만 2개 모두 절대 변하지 않는 인터페이스의 상수이다.


String NO_1111= "미안해요";

public static final String NO_1234 = "제발";


 (2)  인터페이스의 메소드를 만든다. public abstract는 생략되어있다. 반환형과 메쏘드( )명, 그리고 파라미터도 하나 넣어준다.


int sing(String songNo);


 * 문법적으로는 완성되었지만 아직 미완성이다. 실제 인터페이스는 외부에 공개가 되어있는 것이므로, JavaDoc을 붙혀줘야한다.


package song;


public interface Singable {

String NO_1111= "미안해요";

public static final String NO_1234 = "제발";


int sing(String songNo);

}



 4. song 패키지에 우클릭해서 Singable 인터페이스를 상속받는 클래스 [ Singer ]를 만든다. 이때, [ add ]버튼을 눌러서 만든 Singable.java 인터페이스를 상속한다. 메인메쏘드도 추가해준다.

 (1) 새롭게 만든 Singer 클래스는 , Singable이라는 인터페이스를 implements(상속)했기 때문에, 인터페이스의 sing()메쏘드를 자동으로 @overridng 하고 있다.

      인터페이스를 상속한 클래스는 반드시 body{}가 없었떤 것을 구현화 해줘야하기 때문이다.

 (2) //TODO 주석은 [Ctrl + D] 로 지워준다.

 (3) song()메소드에는 구현화하는 내용으로, [1] 넘어오는 songNo의 노래를 불렀다고 출력문 + [2] 몇분동안 불렀는지 int 시간을 return 해준다.


5. 메인메소드에서 Singer 객체를 만들어서 참조형변수에 넣어준다.

***(1) 인터페이스 Singable의  new Singable이라는 객체를 생성할 수 없다

        하지만, new Singer객체를 만든 것을, 부모인 인터페이스 Singable의  변수에는 넣을 수 있다.

클래스끼리 만이 아니라, 클래스->인터페이스로 형변환해서 대입해주는 것이 가능하다.( 인터페이스를 클래스가 상속하고 있으니, 인터페이스 객체가 더 상위계층)


Singer s = new Singer();

Singable s1 = s; //클래스끼리만이 아니라, 클래스->인터페이스로 형변환이 가능하다.  인터페이스가 부모이므로, 더 상위계층이라 캐스팅 없이 바로 대입가능


 (2) heap Area의 같은 객체 new Singer()을 공유하는, s.와 s1.을 이용해서 매쏘드를 사용해보자.

s.sing(NO_1111);

s1.sing(NO_1234);


 (3) 출력값 

미안해요노래를 불렀다.

제발노래를 불렀다.


6. Singable 인터페이스는 외부에 공개하는 api이므로, JavaDoc을 붙혀줘야한다. ( 단축키 : ALT+SHIFT+J )

 - 인터페이스 선언부에 커서를 대고, [ALT + SHIFT + J]를 눌러보자.

 - @를 입력하면 자동완성으로 각종 title을 고를 수 있다.

 -  필드, 메소드에도 자바독을 달 수 있다.


package song;


/**

 * @author cho

 * 노래를 부르고, 노래시간을 반환하는 인터페이스

 * @since 2018. 02. 20

 * @version 1.0

 */

public interface Singable {

/** 김건모의 미안해요 자바독*/

String NO_1111= "미안해요";

public static final String NO_1234 = "제발";


/** 메소드에도 자바독을 달 수 있다. 인자값 : 노래번호를 받아서, 노래제목을 출력, 노래시간을 반환하는 메소드

* @param songNo Singable에 선언된 필드값을 노래번호로 넣어라.

* @return 노래한 시간을 반환한다.

*/

int sing(String songNo);

}


 - 자바독을 다 완성하고 난 뒤에는 

    [ 자바프로젝트(jaavase07)  우클릭 ] > [ Export ] >  [java폴더] > [JavaDoc ] 클릭

    [Configure ]버튼을 눌러서 javadoc.exe 위치를 잡아줘야한다 (C:\Program Files\Java\jdk1.8.0_144\bin\javadoc.exe)  > [Finish]

 - 콘솔창에 자바독이 만들어지는 과정이 보인다.

 - 자바프로젝트 > doc폴더가 보인다 > index.html 을 실행해보자. 자세한 설명이 나와있다.

 - 이제 Singer클래스에서 쓰인 인터페이스의 메소드 song()에 마우스를 갖다대변 자세한 설명이 나온다.


7. Singer클래스를 상속받는 BalladSinger를 만들어보자. 메인메소드도 추가해준다.

(인터페이스는 add버튼으로 만들 때 바로 상속가능, 클래스의 상속은 직접 extends 적어줘야한다)


(1) sing메소드를 오버라이딩 하자.  [ sing을 치고, ctrl+space로 자동완성해야지 오버라이딩 할 수 있다]

(2) return super.sing(songNo); 를 보자. 아직 구체적으로 오버라이딩해서 return값을 재정의 안해준다면, 부모의 메소드를 호출해서 return을 미리 채워놨다.

(3) 먼저, super.sing(NO_1111);을 호출하자. [ 생성자가 아닌 메소드 오버라이딩에서의 super는 부모 메소드내용을 그대로 갖다쓴다는 의미이다.]

     참고로, 부모 Singer의 sing()메소드는,, 인터페이스를 구현화 했는데,, 출력문이 이미 존재했다. 또 출력문이 발생할 것이다.

     부모의 sing()메소드는 int 노래시간을 return하므로, int로 받아준다.


int i = super.sing(NO_1111);


(4) return은 부모메소드에서 반환될 값 필요 없이, 10으로 그냥 넣어준다.


public class BalladSinger extends Singer {


@Override

public int sing(String songNo) {


int i = super.sing(NO_1111);

System.out.println(songNo + "란 노래를 발라드싱어가 불러요. ");

return 10;

}


8. BalladSinger의 메인함수에서, Singer객체, BalladSinger 객체 -> 더 상위계층 부모인 Singer 변수에 담아서(암묵적 형변환)  sing()을 호출해보자.

public static void main(String[] args) {


Singer s = new Singer();

Singer s2 = new BalladSinger();

s.sing(NO_1111);

s2.sing(NO_1234);

}


9. 출력값을 확인하면 출력문이 3개 인 것을 알 수 있다.


미안해요노래를 불렀다.

미안해요노래를 불렀다.

제발란 노래를 발라드싱어가 불러요. 


 (1) 첫 줄은, Singer가 Singable인터페이스를 상속한다음, sing()을 구체화하는 과정에서 출력문을 넣었다.

 (2) 2,3번째 줄은, BalladSinger가, Singer를 상속하여 sing()메소드에 이미 출력문1개를 가진 상태에서 , 오버라이딩으로 또 출력문을 하나 더 추가했다.


10. 가장 상위계층인 인터페이스의 Singable 변수에 new Singer();객체와 new BalladSinger();객체를 넣어 형변환시켜서 대입해도 제대로 작동한다. 


Singable s = new Singer();

Singable s2 = new BalladSinger();

s.sing(NO_1111);

s2.sing(NO_1234);




*** 객체 지향의 꽃 : 상위계층의 변수에, 하위계층(자식)들의 객체(new 클래스();)를 암묵적 형변환으로 대입해서도 바로 사용할 수 있다. 

                           어떠한 메소드를 호출한다면, 상위계층의 메소드가 아닌, 생성한 객체의 메소드가 호출된다. 


11. 새로 song패키지에, Excute라는 클래스를 메인함수를 포함해서 만들자. 

    그리고 메소드를 만드는데, 파라미터(인자값)으로 Singable변수 s와, String songNo를 받도록 하고, body{}에다가 s.sing(songNo);로 호출해보자.


void execute(Singable s, String songNo) {

s.sing(songNo);

}


 - Execute 클래스와 <--> Singable만 연결된 것 처럼 보인다. ( Singer나 BalladSinger 클래스와는 상관없어보인다.)

   그러나 파라미터 자리에 Singable 객체가 아니라, 자식인 Singer나 BalladSinger 객체를 넣으면, Singer나 BalladSinger의 sing()이 호출된다.


(1) BalladSinger의 메인함수에서 Execute 객체를 만들고, 변수에 참조해준다. 그리고 e.execute(  ,  );를 호출해준다.

*** 이때, 파라미터에는 Singerable의 변수가 들어가야 하나,  new BalladSinger() 객체를 생성해서 넣어준다.


Execute e = new Execute();

e.execute( new BalladSinger(),Singable.NO_1111);


(2) 실제 실행은 Execute클래스의 execute()메소드에서 Singable 변수 s.sing();으로 호출되지만, 

     Singable 변수 뿐만 아니라 그 자식들인 Singer 객체, BalladSinger객체가 들어와도 아무 상관이 없이 잘 작동하게 된다.

    위에 처럼 BalladSing 객체가 들어간다면, BalladSinger의 sing() 메소드 (출력문2개)가 호출되어 출력된다.


[정리]  전혀 상관없어보이는 클래스의 메소드에 파라미터에다가, (부모의 객체타입) 을 받도록 했다면,

          거기에는 상속하고 있는 (자식객체) 아무거나 넣어도 된다. 메소드를 호출할 때도, 부모의 메소드가 호출 되는 것이 아니라 

          자식이 <인터페이스의 메소드의 내용을 구현화 한것 > 또는 <오버라이딩해서 재정의 한 것>의 메소드가 호출된다.


형변환에 의해서 Singeable을 상속하는 무엇이든 그 자리를 차지할 수 있다.


미리 만든 [Person - 이름, 키, 나이, 몸무게 ]클래스를 상속하면, 

아래 자식클래스들[ Student - 학점, 학번, 학년 + (상속)이름, 키,나이,몸무게 ] , [ Teacher - 교직원 번호, 월급, 년차  + (상속)이름, 키,나이,몸무게] 를 만들 때,  상속해서 그 속성을 쓸 수 있다. 불필요한 코드를 줄여서, 효율적으로 코딩할 수 있다.




[1] 부모클래스(4가지 변수)를 만들고 자식클래스(3가지변수 + 부모 4가지 변수)에서 상속해보자.


1. 사람의 특징을 가진 [Person]클래스를 만든다.( private 필드 -> getter/setter -> 생성자 -> 그외 매쏘드 순)

(1) 각각 private로 필드들을 만든다. 

(2) 보안private필드에 접근할 수 있는 get/set()매쏘드를 만든다.(이번에는 한번에 만들 수 있는 자바기능을 이용한다)

  *** 클래스 내부에서 우클릭 > [ Source ]  >  [ Generate getter / setter ]

  cf) 외부에서 꺼내쓰는 int get() / 내부에 입력하는 void set(int x)


(3) 각 필드(private 필드=멤버변수)에 대한 생성자를 만든다.  우클릭 > source > Generate Constructor using Field

 *** 이 때 super()라는 것은, 부모클래스의 생성자를 호출해서 초기화 시키겠다는 의미이다. 

       그러나, Person은 가장 상위 클래스로, 아직 상속한 부모클래스가 없기 때문에, 비어있다.


public class Person {

private String name;

private int age;

private int height;

private int weight;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public int getHeight() {

return height;

}

public void setHeight(int height) {

this.height = height;

}

public int getWeight() {

return weight;

}

public void setWeight(int weight) {

this.weight = weight;

}

public Person(String name, int age, int height, int weight) {

super();

this.name = name;

this.age = age;

this.height = height;

this.weight = weight;

}


}


2. Person이라는 클래스를 상속하는 Student클래스를 만들자.

(1) 클래스를 만들고, extends Person 으로 상속하자.

(2) 학생클래스에 필요한 필드를 만들어주자.

(3) getter/setter를 만들고

(4) 생성자를 만들어주자. 이때, Student클래스에 만든 필드들 이외에, 

    상속한 Person클래스의 필드(name, age, height, weight)들까지 입력되어있다.*******

 - 개발의 편의성을 위해, 자신이 상속한 부모클래스의 필드들까지 한꺼번에 초기화 해주기 위한 것이다.

 - super( 파라미터)부모가 가진 생성자를 호출해서, 초기화 한다는 의미이다.****


public Student(String name, int age, int height, int weight, String studentID, int grade, double gPA) {

super(name, age, height, weight);

this.studentID = studentID;

this.grade = grade;

GPA = gPA;

}

(5) 이제 추가적으로 Student클래스 내부에 show() 라는 매쏘드도 만들어주자. 출력시 get변수명()으로 꺼내쓰자.

  *** 이때 Person클래스 내부 필드인 name을 getName()할 때는, 상속받은 상태이므로 Person.getName()이 아니라 getName()으로 바로 사용할 수 있다.

public void show() {

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

System.out.println("학생 이름 : " + getName());

System.out.println("학생 나이 : " + getAge());

System.out.println("학생 키 : " + getHeight());

System.out.println("학생 몸무게 : " + getWeight());

//위에는 상속받은 Person클래스의 매쏘드를 바로 사용함

System.out.println("학생 학번 : " + getStudentID());

System.out.println("학생 학년 : " + getGrade());

System.out.println("학생 학점 : " + getGPA());

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

}



3. 이제 메인클래스를 만들고 메인함수에서 객체를 만들고, show()매쏘드를 호출해보자.



public class Main {


public static void main(String[] args) {


Student student1 = new Student("조재성", 32, 163, 55, "1111048", 3, 4.1);

Student student2 = new Student("김석영", 31, 167, 47, "1311051", 3, 3.8);

student1.show();

student2.show();

}


}


4. 출력물을 확인해보자.

-----------------------------

학생 이름 : 조재성

학생 나이 : 32

학생 키 : 163

학생 몸무게 : 55

학생 학번 : 1111048

학생 학년 : 3

학생 학점 : 4.1

-----------------------------

-----------------------------

학생 이름 : 김석영

학생 나이 : 31

학생 키 : 167

학생 몸무게 : 47

학생 학번 : 1311051

학생 학년 : 3

학생 학점 : 3.8

-----------------------------


[2] 또하나의 클래스를 만들고 출력해보자. 


1. Teacher클래스를 만들고, extends Person을 해보자.

(1) 3가지 private필드를 만들고 -> 외부에서 접근할 수 있는 public 겟셋터 -> 생성자까지 만들자.

(2) show()함수를 만들어서 3+ 부모4 총 7가지 변수를 출력해주자.


2. 메인클래스 메인함수로 가서, Teacher객체를 만들면서 초기화해주고, 출력도 해보자.

Teacher teacher1 = new Teacher("이숭인", 38, 171, 55, "0000000", 400, 5);

teacher1.show();

------------------

교사 이름 : 이숭인

교사 나이 : 38

교사 키 : 171

교사 몸무게 : 55

교직원 번호 : 0000000

교사 월급 : 400

교사 연차 : 5

------------------



[3]배열을 이용해서 많은 객체들을 관리해보자.


1. Student클래스 객체100개를 배열로 생성하자.

 *** 객체배열을 만들때는, 생성자호출이 아니므로 new Student() [ 배열 ] ; 이 아니라, new Student[ 배열 ]; 로 우항을 적는다.  

     생성자로 초기화하는 것은 따로 해줄 것이다.


Student[] students = new Student[100];


2. for문을 이용해서 100명의 학생들을 모두 [ 생성자를 이용한 초기화 ]를 한번해 해주자. 대신 학번만 다르게 주자.

- 학번은 숫자가 하나의 단어로 인식되는 String 문자열이다. index인 i를 쓰더라도 뒤에 [ + "" ] 로 끝나야한다.( i + "" )


for(int i=0;i<100;i++) {

students[i] = new Student("홍길동 "+i+"번째", 20, 175, 70, i + "" , 1, 4.5 );

students[i].show();

}



3. 출력값 


for(int i=0;i<100;i++) {

students[i] = new Student("홍길동 "+i+"번째", 20, 175, 70, i + "" , 1, 4.5 );

students[i].show();

}



[4] Scanner로 실제 입력을 받아서 객체를 초기화하여, 출력해주자.

1. Scanner 변수를 생성해서, 콘솔창에서 총 학생수를 입력받고, 그 숫자로 배열을 만들자.


Scanner sc = new Scanner(System.in);

System.out.print("총 몇명의 학생이 존재합니까?(배열수) : ");

int number = sc.nextInt();


2. for문을 만들고, 각 학생들마다 입력받을 정보들을 Student클래스의 생성자의 파라미터에서 복사해와서 가져온 뒤

   임시적으로 변수로 선언하여 받은 다음, 생성자로 초기화 해준다.

< 객체 생성시, 생성자로 초기화해줄 파라미터는, 클래스의 생성자부분의 파라미터를 복사해와서 편하게 작성할 수 있다>


(1) Student 클래스에서 생성자의 파라미터에 각 변수들을 복사해오자

public Student(String name, int age, int height, int weight, String studentID, int grade, double gPA)


(2) 그것을 for문 안에 변수선언으로서 수정하자.


for(int i = 0 ; i <number ; i++) {

String name;

int age;

int height;

int weight;

String studentID;

int grade;

double gPA;


}

(3) 출력문 + sc.nextInt() 등 7가지를 만들어서, 각 변수에다 대입해준다.

 *** 이때, String은 sc.nextString()이 아니라 , sc.next()이다! / double 은 sc.nextDouble()


for(int i = 0 ; i <number ; i++) {

String name;

int age;

int height;

int weight;

String studentID;

int grade;

double gPA;


System.out.print("학생의 이름을 입력하세요 : ");

name = sc.next();

System.out.print("학생의 나이를 입력하세요 : ");

age = sc.nextInt();

System.out.print("학생의 키를 입력하세요 : ");

height = sc.nextInt();

System.out.print("학생의 몸무게를 입력하세요 : ");

weight = sc.nextInt();

System.out.print("학생의 학번을 입력하세요 : ");

studentID = sc.next();

System.out.print("학생의 학년을 입력하세요 : ");

grade = sc.nextInt();

System.out.print("학생의 학점을 입력하세요 : ");

gPA = sc.nextDouble();

}


(4) 입력받은 값을 가진 변수들을 이용해서, 생성자를 호출하여 각 배열[i]에 new Student(~ , , , ,~)로 초기화해준다.

*** Student 클래스의 파라미터를 다시 복사해 온 뒤, 자료형을 다 지워주면 쉽게 생성자호출을 할 수 있따.


my) 생성자의 파라미터에 Model타입에 직접 값을 입력해주는 것이 아니라, 생성자의 변수명과 똑같은 변수를 선언한 뒤, 입력받아서 변수에 넣고,

      생성자의 파라미터를 활용해서 자료형만 지워주면, 바로 대입하는 식을 만들 수 있다.


students[i] = new Student(name,age,  height,  weight,  studentID, grade, gPA);



3. 출력도 for문을 써서 show()로 출력해준다.


for(int i = 0; i < number ; i++) {

students[i].show();

}



4. 출력값을 보자.


총 몇명의 학생이 존재합니까?(배열수) : 3

학생의 이름을 입력하세요 : 조재성

학생의 나이를 입력하세요 : 20

학생의 키를 입력하세요 : 19


-----------------------------

학생 이름 : 조재성

학생 나이 : 20

학생 키 : 19

  1. 박카스 2019.02.15 16:10

    혹시 안드로이드에서도 상속이 쓰이나요??

    혹시 안된다면 xml이 없는 class에서도 startactivity를 할 수 있는 지 여쭤 보고 싶어요

    • nittaku 2019.02.15 16:34 신고

      안드에서 상속을 쓰려고 공부했어요. 함수에 추가 기능을 넣을때요. 근데 제가 한 개인프로젝트에서는 못써봤어요!

    • nittaku 2019.02.15 16:36 신고

      안드가 현재는 코틀린으로 가고있으나 자바입니다. 다 가능합니다!

  2. ㅇ_ㅇ 2021.09.03 17:29

    잘 봤습니다. 감사합니다.

단축키) [Alt + Shift + S ] : 겟셋터/생성자 자동생성해주는 메뉴를 띄운다(안드로이드의 [alt + insert ]와 동일)


객체지향 프로그래밍에 있어서 가장 기본이 되는 것으로, 가장 대표적으로 많이 사용되는 것이 Node클래스이다. 이는 하나의 장소나 위치를 의미할 수 도 있으며 자료구조에서 말하는 이진 탐색트리의 하나의 서브 트리가 될 수도 있다. 

개발프로젝트에서는 종종 Student클래스와 같이 < 하나의 처리할 데이터 단위를 명시> 하는데 사용된다.


클래스는 공장, 객체는 물건이라고 생각하면 좋다.  new Car();와 같이 객체를 만드는 과정을 <인스턴스 화>라고 한다.

클래스에서 만들어진, 사용가능한 변수를 <인스턴스>라 한다.

my) 인스턴스 = 객체형 변수


[클래스 구조 정리]

클래스내부에서는 보안관계상 private으로 변수(필드, 멤버변수)들을 선언한다.

외부에서 접근이 바로 안되므로, public getter/setter를 만든다.

기본적으로 외부에서 객체를 만들 때, 초기화하는 생성자도 만든다.
그외 필요한 메소드를 만든다.




[1] 하나의 점을 의미하는 Node 클래스를 생성하자


1. 이번에는 클래스가 2개가 필요하다. 기존에 만든 Main클래스( 메인함수 포함)을 만들고 + Node라는 클래스도 생성한다.


2. Node클래스에서 private 형 변수 2개를 생성한다( 클래스 필드(멤버변수)는 private으로 생성하는 것이 좋다)

 *** 보안을 굉장히 중요시 하므로, private 형태로 만들어서, < 클래스 외부에서 함부로 변형이 안되도록 만든다>

public class Node {

private int x;

private int y;


}


3. public int getX() 라는 매쏘드를 만들고, return x를 통해 외부에 x를 반환해준다. (get은 외부에서 꺼내는 반환형 get - return private 필드)

 *** [ private 변수 ] 는 자체적으로는 외부에서 접근이 안된다. 대신 [ public 반환형 get 매쏘드 ]를 만들어서  클래스 내부의 

      private필드 x --> 외부에서 꺼내는 get하도록 반환 해주는 매쏘드다.


public int getX() {

return x;

}


4. public void setX(int x)라는 매쏘드를 만들고, x를 받아서 클래스의 필드인 [ private int x = this.x ] 에다가 값을 set해준다. 

   (set은 내부에 넣어주는 void set(파라미터) - this.필드 = 파라미터; )

 ***  [private 변수 ] 에 외부에서 받은 값을 대입해주기 위해서 [public void set (int x) 매쏘드]를 만들어서  외부의 x --> 클래스 내부의 x에 set하도록 입력해주느 매쏘드다.


public void setX(int x) {

this.x = x;

}


5. y도 마찬가지로 복사해서 만들어준다.


6. 이제 생성자를 만들어준다. 이때, this.x, this.y에다가 넘어온 값을 넣어줘야한다.( 생성자는 new 객체 만들 때, 필드 초기화해주는 것)


 - 생성자는 메인함수에서 객체(인스턴스)를 만들어줄 때, 직접 클래스필드(멤버변수)에 값을 넣어 초기화해주는 것이다. 

public Node(int x, int y) {

this.x = x;

this.y = y;

}


7. 파라미터로 Node객체를 받아서, 초기화된 필드 x,y를 기준으로 <중앙좌표를 계산>한 뒤 new Node( x좌표, y좌표)를 만듬과 동시에 를 반환하는 , 

  public Node getCenter(Node other)를 만들어준다.


(1) 자신의 x좌표 [ this.x ] 와  넘어오는 다른 곳의 Node other의 x좌표를 의미하는 [ other.getX() ] 를 더한 뒤 2를 나누어서 중앙 x좌표를 구하고

  * other도 Node클래스의 객체이므로, getX()메소드를 사용할 수 있다.

(2) y도 똑같이 구한 다음

(3) new Node( 중앙x, 중앙y); 객체를 생성함과 동시에, 변수에 안넣어주고 바로 return한다.


public Node getCenter(Node other) {

return new Node(  (this.x + other.getX())/2  ,(this.y + other.getY() )/2 );

}


my)

****** priavate 변수로 클래스 필드의 보안을 만들고, public 외부에서 꺼내는 get() / 내부에 넣어주는 set() 매쏘드를 만들어서 소통하는구나!

****** 생성자는, 필요한 곳에서 객체를 만들때, 클래스 필드(멤버변수)에 값을 넣어 초기화 해주는 것이다.

****** new Car(); 는 기본생성자를 이용한 것이다. 만약 기본생성자가 없다면,, 생성안된다.(안드로이드는 컴파일시 자동생성 되기도 한다)



[2] Node클래스를 이용하여 두 점 사이의 중점을 구하는 프로그램을 작성해보자.


1. 메인함수에서 생성자를 이용해서, 새로운 객체를 만들자. -> one이라는 객체는 생성자를 통해 priavte 변수(필드)인 x와 y에 10, 20을 가지고 있다.

Node one = new Node(10, 20);

2.  two라는 객체를 만들자.

3. 이제 one이라는 node를 기준으로해서 two와의 중앙점을 구하자. getCenter()는 기준Node인 one. getCenter ( 비교할 Node); 로 사용하는 것이다. 그것을 Node result에 넣어주자.

Node one = new Node(10, 20);

Node two = new Node(30, 40);

Node result = one.getCenter(two);

4. result라는 Node객체에서 getX(), getY()를 이용해 좌표들을 출력해보자.


System.out.println("중앙 x : "+ result.getX());

System.out.println("중앙 y : "+ result.getY());




5. 전체코드


[Node.java]

public class Node {

private int x;

private int y;


public int getX() {

return x;

}

public void setX(int x) {

this.x = x;

}


public int getY() {

return y;

}

public void setY(int y) {

this.y = y;

}

public Node(int x, int y) {

this.x = x;

this.y = y;

}

public Node getCenter(Node other) {

return new Node(  (this.x + other.getX())/2  ,(this.y + other.getY() )/2 );

}

}




[Main.java]


public class Main {


public static void main(String[] args) {


Node one = new Node(10, 20);

Node two = new Node(30, 40);

Node result = one.getCenter(two);

System.out.println("중앙 x : "+ result.getX() + " 중앙 y : "+ result.getY());

}


}

배열이 배열의 원소에 들어가는 구조로, 이차원 배열은 M X N 구조를 가진다.


a[0][0]  a[0][1] ...

a[1][0]  a[1][1] ...


앞[]에 배열이 , 뒤에 배열[]을 의미한다.

그냥 단순배열 a[]에서는 열을 의미한다고 생각한다.



[1] 50 X 50의 이차원배열에 0~9사이의 랜덤 정수를 생성해서 전체 데이터를 분석해보자


1. 배열크기를 의미하는 상수하나를 선언한다.

int N = 50;


2. int형 2차원 배열을 선언하고, 1에서 만든 상수를 배열의 크기에 집어넣는다.

int[][] array= new int[N][N];


3. 2차원 배열을 처리할 때는, 이중 for문 (중첩 for문)을 사용한다. ( 행 > 열 순서로 for문 순서를 지정한다.) 

    index 0번째 행에서--> 0~49까지 각 열이 채워준다. 그걸 50번 반복


4. 이제 0부터 9까지 사이의 랜덤한 수를 배열에 집어넣는다 ( 랜덤 수 0<= x<1  에 10을 곱해서 0<=x<10 을 정수형으로)


for(int i = 0; i<N ; i++) {

for(int j = 0; j<N ;j++) {

array[i][j] = (int)(Math.random() * 10 );

}

}


5. 이제 집어넣은 50 X 50 2차원 배열을 출력할 때도 이중 FOR문을 써야한다.

 (1) 열에 있어서는, print 로 배열[i][j] + "  "; 로 빈칸을 두도록 출력하고

 (2) 행에 있어서는, println으로 한줄씩 내려가도록 만든다.


** 이차원 배열은 2d게임의 좌표설명 / 미로찾기 등을 개발할 때 많이 사용된다.



public class Main {


public static void main(String[] args) {


int N = 50;

int[][] array= new int[N][N];

for(int i = 0; i<N ; i++) {

for(int j = 0; j<N ;j++) {

array[i][j] = (int)(Math.random() * 10 );

}

}

for(int i = 0; i < N; i++) {

for(int j = 0; j < N ; j++) {

System.out.print(array[i][j] + " ");

}

System.out.println();

}

}


}


단축키) 

[syso] 치고 + [ctrl + space] : 출력문 자동완성

[Ctrl+Alt+아래 화살표 ] : 한줄복사.



1. 클래스(Class)의 구조

  패키지 선언 >

 import구문(java.lang.* 패키지 안에 것들은 생략되어있음) >

 접근제한자 (public ~) > 클래스 선언 > extends Object(생략, 자바계층구조도의 최상위는 Object) > 인터페이스 implement >

 필드or멤버변수 > 

 생성자 > 

 매쏘드


2. 생성자(Constructor)

 - 생성자 : 객체 생성시 호출이 된다.(new 생성자( 생성자의 파라미터)).  메소드와 형식이 비슷하지만, [이름이 클래스명과 같고 ] [리턴타입이 없다]

       생성자를 통해서, 클래스안의 필드들에 기본값을 넣어준다.

 - 기본생성자(default constructor) : 클래스의 접근제한자와 이름이 같은 것을 가지고, 인자값(파라미터, 매개변수)가 아무것도 없는 생성자.

   만약 생성자가 하나도 없으면, 컴파일러가 자동으로 기본생성자를 만들어준다.


//생성자 생성 [Ctrl + Space]로 default 생성자를 바로 생성할 수 있다.

//default 생성자. 클래스와 똑같은 public이라는 접근제한자를 가진다.

public Car() {

}

//직접 생성자 생성. 접근제한자는 클래스의 접근제한자와 동일하게 해주는 것이 좋다. 파라미터를 추가했다. 

public Car(String owner) {

this.owner = owner; //받은 파라미터를 클래스의 멤버변수(필드)에 대입하려면 this.멤버변수(필드) 에 대입한다.

//다른 방식으로서, 인자를 2개를 가지고 있지 않더라도,인자 1개의 생성자라도 임의의 값을 넣어서 인자 2개인 생성자를 호출할 수 있다.

//this("임의의색으로 다른 생성자 호출", owner);

}

//생성자 오버로딩을 이용해서, 파라미터를 더 추가했다. 

public Car(String color, String owner) {

this.color = color;

this.owner = owner;

}




3. 오버로딩(Overloading)

 - 메소드 혹은 생성자와 같은 이름을 가지나, 인자(파라미터, 매개변수)의 형태나 갯수, 순서가 달라서, 완전히 다른 것으로 인식 되는 것.

 - 개발의 편의성을 위해 존재한다.


//생성자 오버로딩을 이용해서, 파라미터를 더 추가했다. 

public Car(String color, String owner) {

this.color = color;

this.owner = owner;

}



4. this(예약어) - 파라미터로 넘어온 것을, 클래스의 것인 필드(멤버변수)에 대입할 수 있다.

 -  현재 객체의 참조형으로, 예를 들어


 public class Point {


private int x, y; //필드(멤버변수) 2개.


//4개의 생성자가 오버로딩 되어있다.


public Point(int x, int y){ // 1. 파라미터로 넘어온 x를 --> 클래스안의 필드(멤버변수)에다가 집어넣고 싶을 땐, this.x 에 집어 넣는다. 

        클래스안에서 기본값을 넣어준다.

this.x = x; // 즉, 클래스의 x를 this.x <--> 파라미터로 넘어온 것은 그냥 x

this.y = y;

}


public Point(){ // 2. 클래스명과 동일한 접근제한자+이름 을 가진다. 인자(파라미터)에는 아무것도 없으니, 기본 생성자다.

this(0, 0);  // 이때, 이 2번 기본생성자의 this(0,0)는 --> 파라미터가 2개인 1번 생성자 class Point(int x, int y)를 호출해서 x와 y에다가 0,0을 넣어주게 된다.

}


public Point(int x){

this(x,0);

}

public Point(int y){

this(0,y);

}



}


5. 접근 제한자(Access Modifier)

 - 클래스, 멤버변수, 메소드, 인터페이스 등에 붙어서 접근가능여부(사용여부)를 알려주는 예약어 이다.

 - public > protected > default > private 순으로 범위가 좁아진다

(1) private : 클래스 안에서 선언되면, [같은 클래스 안]에서만 쓰인다. 

(2) default : 접근제한자가 없는 것으로, 클래스의 안에서 선언되도, [패키지 안]의 어느 클래스에서나 사용가능하다.

(3) protected : default보다는 넓은 범위로, 한 패키지내에서 다른 클래스가 다 사용가능하고 + [ 다른패키지라도 자식클래스(subclass) ]라면 사용가능한 것이다.

(4) public : [ 제한 없는 것], 다른 컴퓨터에서도 네트워크로도 접근가능하다. 네트워크프로그래밍에서는 필수


 *** 마땅한 이유가 없으면 필드(멤버변수)는 반드시 private로 선언하는 것이 좋다.

 *** 상수(final)이 아닌 경우에는 public을 쓰지 않는 것이 좋다.




6. 소유제한자(Static)

 - 클래스내부의 메소드나 변수 앞에 붙어서 [누구의 것인지]를 나타낸다.

 ex> String s; --> 생성된 각 [객체]의 것, ===> 메인함수에서, 객체.변수명으로 사용

static String s; --> [클래스]의 것     ===> 메인함수에서, 클래스명.변수명으로 사용 && 어느 객체의 객체.변수명으로도 접근이 가능하나, 클래스에 저장된다.

 - static이 붙어 있으면 클래스의 것으로, 객체.를 이용해서 사용하는 것이 아니라, 클래스.을 이용해서 사용하는 것이 좋다.

***여러개의 어느 객체에서든 객체.변수명에 새로운 값을 대입하면, 클래스의 것인 static 변수가 바뀐다. 그러나 정식으로 접근하는 것은 아니다.***

 - static final의 형태로, 상수값 선언할 때 사용한다. (클래스의 단 하나의 것이면서, 안움직이게!)


public class Car{

Stirng color; // static 없으니 객체의 것(객체를 선언해서 거기서 사용) --> Car1.color, Car2.color

static String modelName; // static 있으니 클래스의 것(클래스 내부에서만 저장) --> Car.modelName / Car1.modelName도 가능하긴함

static int maxSpeed = 300;

}


..

public class Car {

public static int height;//static을 붙혔으니, 메인함수에서, 객체없이 [Car.변수명]으로 바로 쓸 수 있다.

}


public static void main(String[] args) {

Car.height = 100; // Car의 객체 car 생성 없이도, 바로 쓸 수 있는, 클래스의 것인 static 변수


...

//객체에서 height 값을 주지 않았으나, 클래스의 것인 static변수 height는 , 어느 객체에서든 --> 클래스의 static 변수로 접근이 가능하며, 클래스내부 1개의 값만 호출한다. 그러나 객체를 통한 접근은 정식접근이 아니다.

System.out.println(c1.height);

//c1에서 클래스의 것인 static변수  height에 값을 대입하면, c2에서 접근하더라도 클래스의 것인 height는 입력한 값이 출력된다.

c1.height=200;

System.out.println(c2.height);

System.out.println(Car.height);


}


---출력값--------------------

100

200

200

------------------------------


7. 객체 생성과 사용

 - new 라는 예약어생성자를 호출하여( new Object()) ---> ReferenceType변수(참조형 변수, 클래스명)에 대입을 하는 것이다.  

   Object o = new Object();

 - 한 클래스 안에 , 다른 클래스의 객체를 , 필드로 가지고 있는 경우 : has a 관계


public class Wheel{

int radius;  // 반지름을 필드로 가지는 Wheel클래스

}


public class Car{

Wheel wheel; // Wheel클래스의 객체를, 필드로 가지는 Car클래스

String meodel;

}


 - 이때, Car는 Wheel을 가지고 있는 has a 관계이다.

 - 이것을 메인함수에서 사용해보면,


Car c = new Car();

Wheel w = new Wheel(); //w에 객체를 생성함

c.wheel = w; // 생성된 객체를 같은 타입의 c.wheel에다가 대입해주니, c.wheel에는 Wheel객체인 w가 참조됨

c.wheel.radius = 100;


 > 객체지향의 특징으로, c는 Car의 객체로서, wheel이라는 Wheel의 참조형변수를 가지고 있다(아직 객체 생성은 안됬다). 거기다가 new생성자를 호출해서 객체를 생성한 w를 대입해주면, c.wheel에는 w객체를 참조하게된다.  c.wheel이라는 객체는 Wheel의 객체와 같으므로, radius라는 필드를 가지니, 거기다 100을 대입했다.

 >  이때, c.wheel.radius =100;과   w.radius=100;은 똑같다.  w 자체가 c.wheel에 담겨 있으므로, w에 대입해주나 c.wheel에 대입해주나 같이 c. 안에 들어가게 된다.    ( 객체지향으로, w는 c.wheel담겨져 참조된다.  w에 대입해도 c.wheel 안에 들어가게 된다 )


8. JVM메모리의 구조

 - Method area / Stack Area / Heap Area로 구분된다.

(1) Method Area : class에 관련된 정보들이 저장된다. (static 등..)

(2) Stack Area : 매쏘드가 실행이되는 부분(main())에서 사용되는 변수들이 저장된다.

(3) Heap Area : 각 객체가 new Car(); 으로 만들어 질 때, 각 객체들의 정보가 저장된다. 

Stack Area에서 Car a = new Car();로 변수에 참조를 할 때, 여기의 객체정보들이 쌓여서 참조된다.


객체HeapArea에서 hashCode를 가지고, StackArea의 각 변수들이 이 hashCode들을 참조하고 있다.


//객체를 출력해보면, 속한 패키지. 클래스명 @ 해쉬코드가 찍힌다.

System.out.println(c1);

System.out.println(c2);


//c2를 c1에 대입하면, heap area의 c2에 연결되던 new Car() 객체 정보가 -> Stack Area의 변수 c1과 연결되서 , 기존 c2와의 연결은 끊어진다.

c1 = c2;

System.out.println(c2);

----

classa.Car@7852e922

classa.Car@4e25154f

classa.Car@4e25154f

---------------------


9. 실습


public class Car {

private String owner;

String name; //접근제한자 default

protected String color;

public static int height;//static을 붙혔으니, 메인함수에서, 객체없이 [Car.변수명]으로 바로 쓸 수 있다.

//생성자 생성 [Ctrl + Space]로 default 생성자를 바로 생성할 수 있다.

//default 생성자. 클래스와 똑같은 public이라는 접근제한자를 가진다.

public Car() {

}

//직접 생성자 생성. 접근제한자는 클래스의 접근제한자와 동일하게 해주는 것이 좋다.

public Car(String owner) {

this.owner = owner; //클래스의 멤버변수(필드)에 대입하려면 this.멤버변수(필드) 에 대입한다.

//다른 방식으로서, 인자를 2개를 가지고 있지 않더라도,인자 1개의 생성자라도 임의의 값을 넣어서 인자 2개인 생성자를 호출할 수 있다.

//this("임의의색으로 다른 생성자 호출", owner);

}

//생성자 오버로딩을 이용해서, 파라미터를 더 추가했다. 

public Car(String color, String owner) {

this.color = color;

this.owner = owner;

}



public static void main(String[] args) {

Car.height = 100; // Car의 객체 car 생성 없이도, 바로 쓸 수 있는, 클래스의 것인 static 변수

Car c1 = new Car();

c1.name = "조재성 카";

//생성자를 이용한 객체 생성. ()안에 ctrl+space로 고를 수 있다.

Car c2 = new Car("조재성");

c2.name = "조재성 카2";

//syso + Ctrl+space를 하면 자동완성된다.!

//객체어서 height 값을 주지 않았으나, 클래스의 것인 static height는 , 어느 객체에서든 --> 클래스의 static 변수로 접근이 가능하다.

System.out.println(c1.height);

//c1에서 클래스의 것인 static변수  height에 값을 대입하면, c2에서 접근하더라도 클래스의 것인 height는 입력한 값이 출력된다.

c1.height=200;

System.out.println(c2.height);

System.out.println(Car.height);

//클래스의 것은, 객체 어디서든 접근가능하나

//객체의 것인, 필드들은, 각각 다르다.

System.out.println(c1.name);

System.out.println(c2.name);

System.out.println(c1.owner);

System.out.println(c2.owner); //c2는 생성자를 통해 각 객체의 것인 필드값에, 소유자를 적어서 생성했으니, null이 안뜬다.


//객체를 출력해보면, 속한 패키지. 클래스명 @ 해쉬코드가 찍힌다.

System.out.println(c1);

System.out.println(c2);


//c2를 c1에 대입하면, heap area의 c2에 연결되던 Car 객체 정보가 -> Stack Area의 변수 c1과 연결되서 , 기존 c2와의 연결은 끊어진다.

c1 = c2;

System.out.println(c2);

}


}

참고) [ Ctrl + Shift+ O ] : import 단축키


배열의 선언방법

int[] array  = new int[100]; 

 - 여기서 new라는 것은 어떠한 인스턴스를 만들 때 쓰는 약속 예약어이다.

 - 대괄호[]로 배열을 선언하고, 배열의 크기를 우항에 넣는다.

 - 변수 array에는 100개의 배열을 가진다.

 - index라는 것은 0부터 출발해서, 99까지 차지한다. (크기 -1까지)





[1] 원하는 개수만큼 배열을 생성 하고, 입력한 다음, 최대값을 구하는 프로그램을 작성해보자.


1. 최대값을 반환하는 max()매쏘드를 하나 만들어준다. 

public static int max(int a, int b) {

return a>b?a : b;

}

2. 메인함수 안에 Scanner 를 선언한다. sc를 이용해서 사용자에게 배열의 크기를 입력받을 것이다. print도 찍어준다.

3. sc를 이용해서 정수를 받고, int number에 입력 받는다. 입력받을 변수를 이용해서 배열을 만든다.

4. for문을 통해 0부터 number-1까지 1씩 증가시키면서 index값으로서 사용하며, for문 안에서는 배열을 입력받고 그것을 배열안에 넣어준다.

5. int result =-1;을 선언하고, for문을 돌리면서,  max()함수를 이용해 최대값이 들어가는 result 와  각 배열 index[0]부터 [number-1]까지 최대값을 비교해서 result에 집어넣어준다.

6. 최대값 result를 출력한다.


import java.util.Scanner;


public class Main {


public static int max(int a, int b) {

return a>b?a : b;

}

public static void main(String[] args) {


Scanner sc = new Scanner(System.in);

System.out.print("생성할 배열의 크기를 입력하세요 : ");

int number = sc.nextInt();

int[] array = new int[number];

for(int i = 0; i <number ;i++) {

System.out.print("index["+i+"]"+"번째 배열에 넣을 값을 입력해주세요(양수) : ");

array[i] = sc.nextInt();

}

int result = -1;

for (int i = 0; i<number ; i++) {

result=max(result, array[i]);

}

System.out.println("배열 중 최대값 : "+result);

}


}



7. 출력값

생성할 배열의 크기를 입력하세요 : 5

index[0]번째 배열에 넣을 값을 입력해주세요(양수) : 1

index[1]번째 배열에 넣을 값을 입력해주세요(양수) : 10

index[2]번째 배열에 넣을 값을 입력해주세요(양수) : 54

index[3]번째 배열에 넣을 값을 입력해주세요(양수) : 3

index[4]번째 배열에 넣을 값을 입력해주세요(양수) : 2

배열 중 최대값 : 54



[2] 100개의 랜덤 정수의 평균을 구하는 프로그램을 작성해보자.

1. 100개짜리 배열을 선언하고, for문에는 index만큼 0부터 99까지 돌린다.

2. 각 배열[index]마다, Math.random() * 100 + 1 을 넣어준다. 이 때 double이므로, int로 캐스팅 해야한다. 

   이때, Math.random() 0 <= x < 1 사이의 랜덤한 수를 가져오기 때문에, 100을 곱해서 0<= 100x< 100 가 되고, +1을 더해서 1<=x<101 이게 된다. 이제 형변환으로 정수가 나오게 된다.


3. for문을 돌려서 array[i] 100개를 모두 sum에 넣은 뒤에, 그 값을 출력해준다.


int[] array= new int[100];

for(int i = 0;i<100;i++) {

array[i] = (int) (Math.random() * 100 + 1);

}

int sum = 0;

for(int i = 0; i<100;i++) {

sum+=array[i];

}

System.out.println("100개의 랜덤 정수의 평균 : "+ sum/100);;

}


9. 반복함수와 재귀함수(팩토리얼/ 피보나치 수열) ( Tutorial10, 11)


반복함수는 while 혹은 for문법을 이용해서 문제를 해결하는 함수다.

재귀함수는 자신의 함수 내부에서 자기 자신을 스스로 호출함으로써 재귀적으로 문제를 해결하는 함수다.


(Tutorial10)


[1] 반복함수로 팩토리얼을 구현해보자


1. int를 하나 받아서 int를 반환하는 팩토리얼 함수를 만들자.

 -  로컬 변수 sum에 1을 넣어 초기화 한 다음, for문을 통해서 sum에다가 2부터 i를 받은 숫자까지 곱해서 넣어주자.


//5! = 5 * 4 * 3 * 2 * 1

public static int factorial(int number) {

int sum = 1;

for ( int i = 2; i<=number ; i++) {

sum *= i;

}

return sum;

}


2. 메인함수에서 출력시켜보자

public static void main(String[] args) {

System.out.println("10팩토리얼은 "+factorial(10)+ "입니다.");

}




[2] 재귀함수로 팩토리얼을 구현해보자.


1. 받은 값이 1일 때만 예외적으로, 1을 return해서 마무리 짓는다. 

   왜냐하면, 속에 똑같은 매쏘드()가 들어가는데, -1씩 줄여서 대입할 것이기 때문에, 마지막 1은 바로 1을 리턴하도록 한다

   재귀함수는 계속 자신을 호출하므로, 마지막에는 상수로 마무리대응 해야한다.


2. return할 때, 받은 수 * 매쏘드( 받은수 -1 ); 을 반환해서, 받은수 -1 이 또 한바퀴 돌도록 한다. 1이 되면 그냥 1이 return되서 끝난다.

 - 핵심은 -1 씩 줄여가다가 마지막 종점 1에서는 재귀함수를 호출 안하고, 값 1을 반환해서 끝낸다.

 - 핵심은 5!  =  5 * 4!로 같으며, 팩토리얼 속에 또 -1의 팩토리얼이 담겨져 있으니까, 재귀함수로 표현 가능하다.

   f(5) = 5 * f(4)


//5! = 5 * 4!

public static int factorial(int number) {


if(number ==1)

return 1;

else

return number * factorial(number-1);

}



(Tutorial11)


[3] 반복함수로 피보나치 수열을 구현해보자.

 - 피보나치 수열은 연속된 두 수를 더해서 다음 수가 나오는 수열을 말한다.(// 1, 1, 2, 3, 5, 8, ...)

 - k번 째 수가 무엇인지 알아내는 함수를 만들 것이다.



1. 첫째항 1과 둘째항 1을 미리 선언해준다. 잘못된 경우에 -1을 반환하도록 result도 만들어준다.

  (피보나치수열은 초기항 a1, a2는 기본적으로 주어진다)


2.  if /else if 에다가는 첫째항, 둘째항이 입력되면 바로 반환하도록 만들고 / 나머지 3번째항 이상인 경우 else에다가  아래와 같이 코드를 작성해야한다.

- for문 2 <=  i < number 까지 돌면서,

<2부터 시작하는 이유는, number가 3이라고 가정해보면, i=2일때만 for문이 작동하므로 a1 + a2 만 계산한 a3가 리턴된다

  만약 number가 4라면, i=2일 때 다음계산을 위해, a2가 one에 / a3가 two에 들어가고, 마지막 i=3이면 a2+ a3 가 result에 담겨서 리턴되기 때문>

      i = 2 일때, 초기항 2개를 더해서 result에 넣어준다. (one + two)

      다음계산을 위해서,  one에다가는 오른쪽으로 한칸 옮겨지므로, two를 대입해준다

        two에다가는 오른족으로 한칸 옮겨지므로, one+two값인 result를 넣어준다.


      i = 3 일때, 미리 옮겨진 one 과 two를 더해서 result에 더한다. 그리고 오른쪽으로 한칸씩 one과 two를 옮긴 값을 대입해 놓는다.

 ...

i=number-1 일때, number항 직전 2개의 항인 one과 two를 더해서 result에 넣는다. 그리고 다음계산을 위해 오른쪽으로 옮겨놓지만 사용되진 않음.


public static int fibonacci(int number) {

int one=1;

int two=1;

int result = -1;

if(number == 1)

{

return one;

}

else if(number == 2) {

return two;

}

else{

for(int i = 2; i < number ; i++) {

result = one + two; // number 직전까지 아래에서 one과 two를 옮겨놓았다.

one = two; // 수열 오른쪽으로 한칸씩 다음 계산을 위해, 옮겨놓는 작업.

two = result;

}

return result;

}

}



3. 출력해보자.

public static void main(String[] args) {


System.out.println("피보나치 수열의 10번째 원소는 "+fibonacci(10)+"입니다.");

}



[4] 재귀함수로 피보나치 수열을 구현해보자. 훨씬 간단해진다.

 - 핵심은 n-1씩 해가면서, 줄여가는 것이다. 그리고 마지막 종점지에는 상수를 이용해서 리턴해줘야한다. 

 - 팩토리얼 함수와 차이점은 n-1뿐만 아니라 n-2도 있으니, 2개의 초기항이 존재해야한다. 


1. 첫번째, 2번째 항에 대해서는 if문으로 바로 return1을 해주자.


2. 3번재 이상부터는, return값에 f(n-2) + f(n-1)만 해주면 된다.


public static int fibonacci(int number) {

if(number ==1)

{

return 1;

}else if(number==2) {

return 1;

}else {

return fibonacci(number-2) + fibonacci(number-1) ;

}

}


*** 반복함수와 달리 재귀함수의 피보나치 수열은 f(49) 계산시, f(48) + f(47)이 계산되지만, 

     f(48)계산시에도 f(47) + f(46)이 계산되므로, 반복되는 계산이 기하급수적으로 많아 진다.

     재귀함수를 사용할 때, 훨씬 비효율적인 계산을 하므로, 주의해서 계산해야한다. 실제로 f(50)을 물어보면, 계산값이 안나온다.

[1]변수(Variable)

변수의 분류 - 객체 변수/ 클래스변수 / 지역변수/ 인자형 변수 or 참조형 변수 / 기본형 변수




1. 객체형 변수 (Instance Variable) - non-static field

- 객체형 변수란 ? 클래스 안에 선언되어있는 변수로 [ 필드 혹은 멤버변수 ]라고 부른다. 

- 필드의 종류도 2가지가 있다. static이 붙어 있는 것과 static이 없는 것이다. 일반적으로 static이 안붙어 있는 것을 [ 필드 혹은 멤버변수 ]라고 한다.

- 클래스로 객체를 생성할 때마다, (객체.변수)로 사용할 수 있다.


2. 클래스 변수(Class Variable) - static field

 - 클래스 변수란 ? 클래스 안에 선언되어 있으면서 static이 붙어 있는 변수로 [ 스태틱 필드 ] 라고 부른다.

 - 클래스에만 하나가 존재하여 저장되는 변수로, 객체형변수와는 다르게, (클래스명.변수)로 사용하며,

   생성된 여러 객체에서도 호출이 가능하나 (객체.변수) but 클래스 안에 하나의 형태로 저장된다.


3. 지역변수(Local Variable)

 - 지역 변수란? 매쏘드()안에 존재하고 있기 때문에, 필드(클래스 안에 존재하는 변수)와 다르게, [반드시 초기화]를 해줘야한다.

 - 멤버변수라 불리는 필드는 초기화가 필요없다. 자동으로 초기화가 된다. 그러나 매쏘드()안에 있는 변수는 반드시 초기화를 해줘야한다


4. 인자형 변수(Parameter)

 - 인자형 변수란? 다른 언어에서는 argument라고도 불리며, 매쏘드()가 실행 될 때, 넘겨 받는 변수다. 


5. 변수의 이름 붙이기(naming) - 식별자(identifier) 규칙

 -  숫자로 시작할 수 없으나 영대 소문자나 숫자가 들어갈 수 있으며, 특수 문자 중 [ _ 와 $ ]를 넣을 수 있다.

 - 관례(convention) : 소문자로 시작하며, $는 사용하지 않으며, _를 쓸 경우에는 맨 앞에 잘 사용하지 않는다.

 ex> String name; (O) String 5name&;(X)  /  int powerPoint; (O) int _name;(세모)


6. 형태(Type)에 따른 구분

 (1) 참조형 변수(Reference Type Variable) : String  name; Test t; Object o; 등 앞글자가 대문자로 시작하여, 내부에 클래스를 가지고 있다.

 -> 필드와 매쏘드()가 사용 가능

 (2) 기본형 변수(Primitive Type Vairable) : int a; float f; char c; 등 소문자로 시작하며, 내부 클래스가 없다. 객체에 속하지 않는 것들임.


[2] 기본형 변수(8)와 참조형 변수

(1) 수치형 변수(6) : 기본형 변수 8가지 중 6가지는 수치를 나타내는 것으로, byte/ short/ int/ long 등 정수형 변수 와 

float/ double의 실수형 변수가 있다.

 - 순서대로 1/2/4/8 byte 와 4/8byte의 크기를 가진다.

 -  bit가 0,1로 이루어져있는데, 1byte는 8bit로 bit가 8개 있으므로, 0000 0000 ~ 1111 1111으로 구성 된다.

 -  byte의 8자리 중 첫번째 bit는 [부호비트]로 0은 양수, 1은 음수를 의미한다. 나머지 7자리의 bit가 숫자를 구성하므로  범위를 따지면 [ -2^7부터 ~ (2^7-1) ]로, 0을 양수에서 -1로 차지한다.

   ex> int는 4byte이므로, bit가 8 x 4 = 32 개 존재한다. 첫번재 부호비트를 제외하고 31자리의 bit가 숫자를 결정하므로, -2^31 ~ (2^31-1)의 범위를 가진다.


(2) 문자형 변수(char) : 문자 하나를 표현하는 것이다. 작은 따음표로 감싸서 문자 1개를 표현한다. ex>'가', 'a'

(3) 논리형 변수(boolean) : true or false를 의미한다.


(4)참조형 변수(String) : 문자의 집합로 큰 따옴표로 표시한다. "a가 b는 아니다"


- 기본형 변수들은 [기본값]을 가진다.

 byte, short, int 0 / long은 0L / float는 0.0f / double은 0.0d 가 기본값이다.

 char'\u0000'의 유니코드 값을 기본값으로 가진다.

 booleanfalse를 기본값으로 가진다.

- 모든 참조형 변수는 기본값이 null이다.


(5) 기본형 변수 표기법

 - 10진수 표기법 int a = 10;

 - 16진수 표기법(0x XXX형식으로 표기) : int a = 0xa; (a는 10을 의미한다)

    cf) 16진수는 0부터 9, A(10) ~ F(15)까지 총 16가지의 문자로 숫자를 표현하는 것을 말한다.

 - 2진수 표기법(0b XXXX형슥으로 표기) : int a = 0b1010;(1010은 2진수로 10을 의미한다.)

 - 실수 일반 표기법 : double d = 123.4;

   지수 일반 표기법 : double d = 1.234e2; (e2는 100을 곱하는 것을 의미한다. d에는 123.4가 들어간다)

 - 문자 표기법 : char 는 ''; / String은 "";

 - 유니코드(UTF-16) 표기법 : 모든 문자는 2byte로 표기가 가능하다. 한글 가 도 2byte이다. '가'의 유니코드 값은 AC00이라는 코드를 가진다. 이런 것들의 모임은 charSet이다.

    char c= '\uAC00';  String s= "\uAC00";

 - Escape Sequence(특수한 표기법, escape문자) : 

   \b (backspace), \t(tab), \n(line feed), \r(carriage return, 엔터키), \"(double quote, 쌍따옴표), \'(single quote,작은 따옴표), \\(back slash)

 - 언더바(_)문자 사용(se7부터 적용) : 숫자의 시작or끝에는 쓸 수 없고, 중간에 넣어서 구분을 위해서 넣어준다. ex> 전화번호, 카드번호 등등


[3] 배열(array)

 - 배열이란? 똑같은 형태의 변수들의 집합체로, 방번호가 붙은 호텔과 같은 개념이다.

 int[] a= new int[6];식으로 선언한다. 마지막의 6은 6개의 방을 만들어라는 의미이다. 

 - 방 번호를 index라 하는데 0부터 시작한다. 0부터 5번방까지 총 6개(length)의 배열이 만들어진 것이다.

 - int클래스x 대문자로시작x인 기본형 변수이므로, default값= 기본값을 0으로 다 가지고 있다. 만약 2번 방을 끄집어 내고 싶다면, 대괄호 a[2]로 끄집어 낸다.

 (1) 생성법은 3가지가 있다

int[] a = new int[6];  - int뒤에 바로 []를 넣어서, 우항에는 방의 번호를 집어넣는다.

int []a = {1, 3, 4, 5, 6, 3}; - 변수앞에 바로 []를 넣어서, 우항에는 값을 집어 넣어, 방번호를 간접적으로 만든다.

int a[] = new int[]{1,2,3,4,5,6}; - 변수뒤에 바로 []를 넣어서, 빈방과 값을 동시에 집어넣는다.


 (2) 2차원 배열 

int[][] a = new int[2][2]; - int뒤에 넣어서, 2차원 방번호를 집어넣는다.

int[][] a = { {1,2}, {3,4}}; - int뒤에 넣어서, 중괄호를 이중으로 해서 값을 집어넣는다.


  

[4] 실습

javase05 자바프로젝트를 만들고, 패키지명은 var, 클래스명은 TestVar, 메인함수까지 포함해서 만든다.


package var;


public class TestVar {

//클래스 안에 적었으니, static이 안붙은 [ 필드(field) 혹은 멤버변수 혹은 객체가 쓰는 객체형 변수 ] 혹은 static이 붙어 있는 [클래스 변수]가 될 수 있다.

String name; //static이 안붙어 있으면, 객체가 쓰는 변수로 [쓰는 곳에서는 클래스 객체가 필요하다! 메인함수에서 객체를 만들어서 써야한다] 

int height;

static int power=100;


public static void main(String[] args) {


//메인 함수 안에 적었으니, 지역변수(Local variable)이다.


byte b = 1;

short s = 4; //int를 제외하고 잘 안쓰는 byte, short는, 엄청 큰 배열일 경우 크기를 고려할 때 byte배열이나 short배열을 사용한다.

int i = 1000;

long l = 10000000000L; //int의 범위(20억)을 넘는 수를 짚어 넣을 수 있다. L을 안붙히면, int로 인식되서 오류가 뜬다.

float f =3.14f;

double d= 3.14;

char c = '가';

boolean boo  = true;

String str = "조재성";

TestVar t = new TestVar();

System.out.println(t.name); //클래스의 객체형 변수, 필드, 멤버변수는 초기화 안해두 null이라는 값으로 자동초기화 되어있다

String name;

System.out.println(name); //메쏘드 안의 지역변수는 , 초기화 하지 않으면, 오류가 뜬다. 지역변수는 반드시 초기화를 해야한다.

String name2="";

System.out.println(name2); //지역변수는, 문자형변수라면 "";로 초기화 해야한다.

}


}

+ Recent posts