08.21 문제 - interface CharSequence

package day12;

public interface CharSequence {
//문자열을 만들어 반환
@Override
public String toString();

//인덱스 i에서 시작 j까지의 문자열을 반환
public CharSequence subSequence(int i,int j);

// 인덱스 i 위치의 문자 반환
public char charAt(int i);

// 문자열의 길이를 반환
public int length();
}

http://blog.naver.com/PostView.nhn?blogId=sohyoun74&logNo=90155124194

08.14 접근레벨 지정자(접근제한자) / 상속 / Override / Object 클래스

접근레벨 지정자

- 클래스,인터페이스, 멤버에 대한 접근 영역을 제한 하기위해 사용

1. class 레벨
1. public (ex-public enum / public class)
1. 패키지 밖에서 접근가능
2. package-private(default)
1. 패키지 안에서만 접근가능
2. 멤버 레벨 (클래스 또는 인터페이스 내의 멤버에 대한 접근영역 제한)
1. public - 어디서든 접근
2. protected - 패키지내, 패키지외에서는 상속관계인 경우만 접근가능
3. package-private(default) - 해당패키지 내에서만 접근
4. private - 멤버가 선언된 클래스 내에서만 접근

                영역 - 패키지내, 패키지외, 멤버선언클래스, 상속관계클래스

                (빨간색- 접근불가) 

1.같은패키지 같은클래스

   all OK

2.같은패키지내(좌측하단)

   같은 패키지지만 private 변수엔 접근불가.(상속을 했는데도)

3.다른패키지 

   public만 접근가능

4.다른패키지 but 상속받은클래스

   public,protected →OK

   default,private → 접근불가

• 관계
• 사용관계 - import
• 상속관계 - extends

* 접근제한자

private - 해당 class 내에서만 접근가능

default - 접근제한자가 지정되지 않은경우.같은 package 내에서만 접근가능

protected - 같은 package 접근가능/다른package서는 자식class에서만 접근가능

public - 어디서든 접근가능.

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

상속

- 클래스를 다른 클래스로부터 파생하는것
- 클래스의 코드(필드와 메서드)를 재사용

수퍼클래스 → 서브클래스
Base클래스 → Extented클래스
부모클래스 → 자식클래스

- 자식클래스는 부모클래스로부터

1. 모든 public,protected멤버 상속(생성자 제외)
1. 같은 패키지내, 혹은 상속관계에 있는경우
2. 같은 패키지에 있으면
1.  package-private( = default) 멤버 상속

서브클래스 정의

- extends키워드와 부모클래스명을 사용
- 상속받은 멤버를 사용, 숨기거나, 대체가능
형식) [지시어]class 클래스명 extends 슈퍼클래스명 {
            ...
         }

상속받은 필드와 메서드 사용

- 상속받은 필드와 메서드를 사용

class Person {

  private String name;

  int age;

   public void setName(String name) {

      this.name;

   }

   public void getName() {

      return name;

   }

}

class Student extens Person {

   public void print() {

      System.out.println(getName());//부모의 메서드 사용.

      System.out.println(age); //부모의 age사용.

   }

}

서브클래스 정의2

- 서브클래스에서는 (아래 1~5)

1. 새로운 이름의 필드와 메서드 추가
1. class Person {
     private String name;
     int age;
      public void setName(String name) {
         this.name;
      }
      public void getName() {

         return name;

      }
   }
   class Student extens Person {
      Sting sid;//학번 추가
      //setter 추가
      public void setSid(String sid) {
         this.sid = sid;
      }
   }
2. 동일한 이름의 필드 선언.재정의(숨기기)
1. class A {
2.    int n = 10;
3. }
4. class B extends A {
5.    int n=20; //동일한 이름으로 변수 선언
6.    public void print() {
7.       System.out.println(n);
8.    }
9. }
10. new B.print(); //20
11. System.out.println(new B().n);//20 자식클래스에선 부모필드는 숨겨진다.
3. 동일한 이름의 static메서드 재정의(숨기기)
1. class A{
2.    static int a=1;
3.    public static void printStatic() {
4.       System.out.println("A:"+a);
5.    }
6. }
7. class B extends A {
8.    static int a=2;
9.    public static void printStatic() { //동일한 이름으로 static메서드 선언
10.       System.out.println("B:"+a);
11.    }
12. }
13. B.printStatic();//B:2
4. 동일한 이름의 instatce 메서드 재정의(override) => 자식을 통한 부모메서드 접근X
1. class Person {
2.    public void sayHi() {
3.        System.out.print("안녕하셈");
4.    }
5. }
6. class Student extends Person{ 
7.    public void sayHi(){ //override
8.       System.out.println("안녕~");
9.    }
10. }
11. new Student().sayHi(); //안녕~
5. super()를 이용한 생성자.(-- 부모로부터 상속받은 생성자 초기화에 사용)
1. class Person {
2.    String name;
3.    int age;
4.    Person(String name,int age) {//생성자
5.        this.name=name;
6.        this.age = age;
7.    }
8. }
9. class Student extends Person{ 
10.    int sid;
11.    int age = 20; //부모와 동일한 변수 선언.
12.    Student(String name,int age,int sid) {//생성자
13.        super(); //super() 생성자
14.        this.sid = sid;
15.    }
16.    public void print() {
17.       System.out.print(this.age+","+super.age);  //super reference
18.       // 자식age , 부모age 출력
19.    }
20. }

@@ 실습 p203

서브클래스 정의3

- private 멤버에 대한 간접 access만 가능.(getter)

1. 이 멤버에 접근하는 public or protected 메서드들을 통하여
2. 상속받은 nested class를 통하여(클래스내 클래스-중첩클래스)

Override

- 서브클래스에서 슈퍼클래스의 메서드를 재정의 하여 사용하는 방법
- 조건: (접근레벨지시자/Exception은 제외하고 상속)

1. 상속관계
2. 메서드 이름이 동일
3. 메서드 인자 리스트가 동일
4. 메서드 리턴타입이 동일
5. - 접근 지정자는 확대만 가능
6. - 더 많은 예외를 가질 수 없음.(동일하거나 더 적은 예외)

- static,final,private 지정자를 가진 메서드는 오버라이드 할 수 없다.
   (cf - static 메서드는 숨기기만 가능. 나머지는 다 안됨.)

Overriding 와 Overrloading 비교

1. 오버라이딩 :
1.  상속관계에서, 상속받은 메서드의 내용을 재정의 하는것.
2. 오버로딩 :
1.  같은 클래스내에서, 새로운 메서드(매개변수의 타입,갯수,순서가 다른)를 만드는 것.

@@ 실습 p188~

super()

- 슈퍼클래스의 생성자를 호출할 때 사용

- 슈퍼클래스 멤버의 생성과 초기화 작업이 수행되어야 하기 때문

- 생성자의 첫줄에서 super()를 호출해야. 그렇지 않은 경우, 컴파일러가 자동으로 super()를 추가함.

    ==> 부모클래스에 기본생성자가 없다면 super() 에러..

- 매개변수가 있는 super 생성자를 사용하는 경우, 컴파일러는 기본 super()생성자를 추가하지 않음.

   * 부모클래스의 생성자가 호출되어야

상속

subclass의 객체의 생성과 형변한

- new키워드를 이용한 생성
- 객체의 형변환과 상속을 이용하여 reference를 부모클래스 타입의 참조변수에 저장할 수 있음.

예) Person p = new Student();//자동형변환    (Up-casting)

     Student s = (Student)p;     //명시적 형변환(Down-casting)
*부모클래스 객체를 자식클래스로 형변환=> 대개 실행시에러(why? 자식은 확장되어 있거든)

- instanceof - reference를 특정타입으로 캐스팅 할수있는지 판단해주는 연산자
   - 예: 참조변수 instanceof 캐스팅할 타입
Person person1 = president1;
if(person1 instanceof President){
President president2 = (President)person1;
System.out.println("person1 을 President 타입으로 캐스팅 성공");
}

다형성 (Polymorphism)

- 하나의 interface를 사용해서 여러 데이터 타입을 다룰 수 있는 능력
- 상속 ,override를 이용해서 다형성 제공
예) Person p = new Student(); //부모형 자식객체 생성
     p.sayHi();//안녕~,override되었음 ==> 타입 폴리머피즘. 자식의 메서드 실행
     (Student)p.sayHi();//안녕~

- 파라미터의 다형성1
-         Person
-      ↙          ↘
- Student , Employee

class Person {
   public void test() {
       System.out.print("안녕하셈");
   }
}
class Student extends Person{
   public void test(){ //override
      System.out.println("안녕~");
   }
}

class Employee extends Person{
   public void test(){ //override
      System.out.println("안녕하십니까!");
   }
}

- 파라미터의 다형성2
class MikeTest{
   public void test(Person p) {
      p.sayHi();
   }
   public static void main(String args[])  {
      MikeTest mike = new Test();
      //Person 이 Student , Employee 등 여러개의 데이터형을 다룰수 있다=> 다형성
      mike.test(new Student()); //안녕~
      mike.test(new Employee()); //안녕하십니까!

   }

}

상속 - 배열의 다형성

class TestArray{
   public static void main(String args[]) {
      Person[] p = new Person[2];

      p[0] = new Student();
      p[1] = new Employee();

      for(int i=0;i<p.length;ㅑ++) {
           p[i].sayHi(); //안녕~,안녕하십니까! : 자식메서드 실행
      }
   }
}

@@ 실습 p215

Object 클래스

- java.lang 패키지의 Object클래스는 class hierarchy tree의 최상단에 위치함.
- 모든 클래스는 Object의 instance메서드(멤버)를 상속
  (notify,notifyAll,clone,equals,finalize,getClass,hashCode,toString)

final

- 더 이상 변경될 수 없다는 것을 선언한다.

- final 키워드가 사용가능한 곳 / 의미

1. 필드 - 변경불가
2. 메서드 - override 불가
3. 클래스 - 상속불가.

@실습 p211,212

[문제1] 패키지
package외부에서 public package멤버를 사용하기위한 3가지 방법?
http://blog.daum.net/sweetheev/3346269
답) 

1. import 패키기상세
2. import 패키지.*
3. fully qualified name 접근

[문제2] 접근제어자

접근범위가 넓은것에서 좁은 순서

public > protected > (default) > private

[문제3] 접근제어자 

1. 부모클래스의 private멤버는 접근할 수 있다. x

2. 같은 package내에서는, public과 protected멤버인 경우 접근가능하다. x

   - (default도 있다)

3. 다른 패키지의 클래스 상속인 경우는 default 멤버는 사용 할 수 없다. o

   - 디폴트는 같은 패키지 내에서만 접근가능.

4. public 메서드는 어디에서도 접근가능하다. o

[문제4]서브클래스의 메서드

3번째 x A:static B:인스턴스  허용불가
4번째 o .

[문제] override 조건으로 틀린것은? ( 4 )

1. 이름이 같아야한다 o
2. 매개변수의 수와 타입이 같아야 한다 o
3. 리턴타입이 같아야 한다 o
4. 접근제어자는 좁은 범위로만 변경할 수 있다 x
5. 더 많은 예외를 선언할 수 없다. o

[문제] 형변환 바른것은? a, b

a- up casting : 자동형변환 되지만 - 형변환 연산자 붙여도 무관.
b- up casting : 자동형변환 
c- 확장된 자식에 부모객체를 대입하면, 확장된 내용을 사용불가.


[문제6] instanceof
결과가 ture가 아닌 것? 3 (형변환이 가능한 경우 - upcasting)

            A a=new A();
            B b=new B();
            C c=new C();

1. c instanceof B //?
2. b instanceof C //?
3. a instanceof B //?
4. b instanceof A //?
5. c instanceof A //? 

UPCASTING 가능 -  2,4

3 - A의 객체 a를 B에 대입할수 있나? B는 확장됨 => 형변환불가

a instanceof C 도 마찬가지.


[문제7] 생성자
Student 클래스는 Person의 클래스를 상속받고 있다.
Student 의 생성자를 완성하기.

class Person {
 String name;
 int age;
 Person(String name, int age) {
  this.name = name;
  this.age = age;
 }
}

class Student extends Person
{
 int sid;
 Student(int sid,String name, int age) {
  //생성자 완성?
  super(name,age);

  this.sid = sid;
 }
}

[문제8] 상속과 다형성
override 해야될 메서드?

class SchoolNewsPaper {
public String getInfo(Object o) {
return (o==null)?null:o.toString();
}
...

}

sol) getInfo() 메서드-Student 클래스 객체 받을수 있어.
==> toString() 을 오버라이드 해야

08.20 예외처리 / 예외전가 throws

예외처리

개요

- 프로그램실행중 발생하는 예외적인 문제에대한 처리는
일반적으로 문제의 발생시 강제적으로 그 프로그램을 종료시킴.
- Java에서는 복구가 가능한 예외인 경우에
비정상 종료가 되지 않도록 프로그램이 예외에 대한 처리를 하도록 요구한다.

예외처리

1. 에러가 발생했다는 신호를 (java 가상머신 또는 throw문에 의해서) 실행중인 프로그램에게 던진다.
2. 이 신호는 에러가 발생한 지점으로부터 던져진 신호를 catch할 수 있는 try문을 찾아서 제어가 진행된다.
3. try문이 발견되었으면,catch절에서 match되는 예외클래스를 찾는다
4. 그 try문의 catch절 다음에 처리코드를 두어 예외(exception) 객체를 이용하여 예외처리를 한다.

try catch block

- 형식 :

try {

  ... //예외발생이 가능한 실행문들

} catch(예외클래스명 변수명) {

  ... //예외처리문들

} finally {

  ... //마지막에 반드시 실행되는 실행문들

}

- try문의 블럭내에는 예외발생이 가능한 문들을 넣고, catch절의 블록내에는 예외처리문을 정의.

- 다중catch블록이 가능. 첫번째 catch절부터 차례대로 해당하는 catch절을 찾게됨

- 보내온 예외클래스와 동일한 예외클래스가 catch절에 명시되어 있는지를 찾아서,

있으면 전달, 없으면 그 예외의 상위클래스가 명시된 catch절을 찾게된다.

- 예외처리문으로서 Exception클래스들의 printStackTrace 메서드가 일반적으로 호출됨.
(e.printStackTrace();  =>
에러메세지의 발생근원지를 찾아서 단계별로 에러를 출력한다.)

- finally절을 사용해서, (마지막에) 항상실행되는 문장을 추가할 수 있음. 일반적으로, 자원반납을 위해 사용됨.

@@실습 p276~282 5개 예제

예외전가

- 예외처리는 예외가 발생된 메서드에서 처리되지 않고, 호출한 메서드로 전가될 수 있음.

- 호출한 메서드로 전가시키기 위해서,메서드의 선언문에 키워드 throws를 사용하여 발생가능한 예외(CheckedException)를 선언.

- 형식:

... 메서드명(인자목록) throws 예외클래스명 {

... // 예외발생가능한 실행문

}

예)
public void readFile(String file) throws FileNotFoundException,IOException {
   FileOutputStream os = new FileOutputStream(file);
   while((char = os.read()) != -1) {
      ...
   }
}

- 호출한메서드에서 try catch블럭을 사용해서 선언된 예외클래스에 대한 예외처리를 하거나 상위호출메서드로 예외전가 할 수 있음.
- 최종적으로 main메서드까지 예외처리가 지연될 수 있음.
- 정상종료를 위해서 main에서는 반드시
....

메서드 선언문의  throws

- 메서드 선언문의 throws를 사용해서 명시적으로 선언하는 예외들은 CheckedException.

- 메서드 내에서 이 예외에 대한 예외처리가 없거나 throws 로 선언되지 않았으면 컴파일 에러발생.

- UnCheckedException(RealtimeException, 그 외 하위클래스들과 Error 클래스)은 선언하지 않음.

- 메서드에서 발생되는 예외가 여러개인 경우throws로 예외선언시 예외클래스를 나열함.

- 형식: 지정자 리턴타입 메서드명([인자]) throw 예외클래스1,예외클래스2,[...]{}

- 메서드가 오버라이딩 되 경우,예외클래스 타입의 축소(오버라이드 된 메서드의 예외클래스와 같거나 그것의 하위클래스만) 또는 적은 수만 가능함.

* Exception : 예외상황

* - 프로그램이 정상적으로 실행되는 과정에서 발생하는 예상치 못한 에러

* Throwable

* Exception의 유형

* 1. CheckedException

* - Compile시 Exception 처리

* 2. UnCheckedException

* - Runtime시 Exception 처리

* - RuntimeException의 Sub class

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

* Exception Handling

* 1. try~catch 구문

* try{

*     //예외가 발생할 만한 명령문

* }

* catch(Exception_type 레퍼런스명){

*     //예외처리 루틴 ex)printStackTrace/getMessage

* }...

* catch(Exception_type 레퍼런스명){

* //예외처리 루틴

* finally { ////try블럭 안에서 예외사항 발생을 하든 안하든 어떠한 로직을 처리해주기 위함[ex)close //Resource Release]

* }

ex) 상위 예외처리부터 하면 오류

 try{

     //예외가 발생할 만한 명령문

 }

 catch(FileNotFoundException 레퍼런스명){

     //예외처리 루틴

 }...

 catch(IoException 레퍼런스명){

 //예외처리 루틴

* 2. throws 구문

* ex) throws Exception타입,Exception타입,사용자정의Exception,...

08.12 클래스기초 - 객체의 필드(변수) 참조/GC

1.객체의 필드의 참조

- 객체의 필드들은 필드명에 의하여 접근된다.
- 외부의 코드는 반드시 객체레퍼런스(object reference), 필드명을 사용해야 한다.
- 예)
Class Rectangle {
   int width;
   public Rectangle(int w) {
      width=w; //내부에서 width필드의 접근.
   }
}

Class B {
   public static void main (String args[]) {
      Rectangle rect = new Rectangle(100);// width 초기화
      Int length = rect.width; // 외부에서 width 필드의 접근
   }
}

- 객체 참조를 통한  instance필드의 효출은, 특정한 객체의 필드 호출을 의미한다.
- 그밖에, 객체의 접근을 위하여, new 연산자가 반환하는 object reference값을 바로 사용할 수 있다.
이 경우, 프로그램은 객체의 reference를 갖지 않게 되므로, 이 객체는 Garbage Collection의 대상이 된다.
예) int width = new Rectangle(100).width;//

2.객체의 메서드 호출

- 객체의 instance 메서드를 호출하기 위해서
objectReference,메서드명(인수)을 사용해서 호출
- 예)
Class Rectangle {
   ...
   public Area getArea() {
      return area;
   }
}
Class B {
   public static void main (String args[]) {

   }
}

- 오브젝트레퍼런스를 통한 instance메서드의 호출을,특정한 object의 메서드의 호출을 의미한다.
- 이회에, 필드와 마찬가지로 객체의 접근을 위하여 new 연산자가 반환하는 object reference값을 바로 사용할 수 있다.
예) Int area = new Rectangle(100).getArea();//

3. Gargage Collection

- 객체가 더이상 사용되지 않고 있다는 것이 확정될때, JRE 가 그 객체를 삭제하는 프로세스.
- 객체는 자신을 가리키고 있는 어떠한 reference도 없을때 garbage collection에 대한 대상이 된다.
- 객체의 reference가 끊어지는 때는
1) reference를 보유하고 있던 참조변수가 자신의 scope을 벗어날때(지역변수)
2) 참조변수에 null값을 대입할때.

- JRE 의 Garbage collector는
reference가 없는 객체들을 메모리로부터 제거한다.

메서드로부터 값의 반환

- 메서드가 자신을 호출했던 곳으로 복귀하는 경우

1. 메서드에 있는 모든 문들의 실행을 완료했을때
2. return 문에 도달했을때.
3. 예외를 던질때

- 메서드 선언문에서 반환할 값이 있는 경우 반환할 자료형을 명시하였는데, 메서드의 body내에서 값을 반환하기 위하여  return문을 사용한다.

- void 로 선언된 메서드도, return문을 사용할 수 있다.

- return값의 자료형은 메서드에서 선언된 반환 자료형과 일치되어야 함

   (단, 자동형병환, subclass는 예외)

- 메서드가 참조데이터형을 반환하는 경우는, 반환되는 자료형의 class는 메서드의 반환자료형과 동일한 class이거나, 또는 subclass 일수 있다.(다형성)

메서드 또는 생성자에 정보전달 :참고

1) 기본형 자료의 전달.
2) 참조형 자료의 전달.

기본형 자료의 전달

- call by value 로 전달.
- 매개변수의 값에 대한 변경은,. 그 메서드의 scope에서만 유지되고, 메서드가 복귀할때 매개변수와 어떤 변경들도 모두 사라진다.
- 예)
class MyUtil {
   void swap(int a, int b) {
      int temp = a;
      a=b; b=temp; //a 와 b 의 swap 은 메서드의 복귀후에는 유효하지 않음.
      return;
   }
}

참조형 자료의 전달

- call by reference 로 전달.

- 전달되는 reference값은 동일한 객체를 참조.
- 그러므로, 매개변수의 reference 가 가리키는 객체의 필드에 대한 변경은, 메서드가 복귀한 후에도 유지된다.
- 예)
class MyUtil {
   void swap(MyNums num) {
      int temp = num.a;
      num.a=num.b; num.b=temp; //MyNum의 a 와 b 의 swap 은 메서드의 복귀후에도 유지됨.
      return;
   }
}

=======================================

가변인자

- 메서드를 호출할때 전달하는 인자의 갯수가 정해져 있지 않음.(sdk5 부터) -- 타입은 동일
- 일반적으로, 메서드의 매개변수의 갯수와 메서드 호출시 전달되는 인자의 갯수는 동일해야 함.
- 형식 : 반환자료형 메서드명(매개변수타입... 변수명) {
             ... // 매개변수를 배열로서 사용.
}
- 예)
//가변인자를 갖는 메서드의 정의
public static void foo(int ... nums)
{
    for(int num : nums)
    {
        System.out.print(num);
    }
    System.out.println();
    System.out.printf("The last number of list is %d\n", nums[nums.length - 1]);
}
public static void main(String [] args
{//메서드의 호출
    foo(1);  //1개의 숫자 전달
    foo(1, 2, 3);//3개의 숫자 전달
    foo(1, 2, 3, 4, 5);//5개의 숫자 전달
}

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

public static void print(String ... args) { //

   for(int i=0; i< args.length;i++) {

      System.out.println(args[i]);

   }

}

//메서드의 호출
print("a","b","c"); //3개의 문자열 전달.
print("a","b"); //2개의 문자열 전달.
print("a"); //1개의 문자열 전달.


@실습 : 인수전달방식 테스트 ArgsTest.java (p156)
@VariableArgument.java(p162)

08.14 실습 -- 카드

/*
# Card 클래스를 정의하고, main 메서드와 Console메뉴(1.저장,2.조회)를 생성하여 테스트
# Deck(묶음) 클래스를 아래와 같이 정의하고 ,초기화블록에서 카드 한벌을 생성하여 Cards배열에 저장한후,
# DisplayDeck클래스에서 Deck 갖고있는 모든카드를 출력.

suit (모양) :
Diamond - 1,Heart -2,Clover -3,Spade -4

rank (등급) : 카드의 숫자
Ace - 1,Deuce - 2,Three - 3,Four - 4,... Ten - 10,Jack - 11,Queen - 12,King - 13

Deck 클래스
필드 Card cards[][]//카드
메서드 Card getCard(int suit,int rank)
DisplayDeck
메서드 main
*/


상수를 적용?

08.08 클래스 기초

클래스 기초

객체란?(1)

- 상태와 행동, 이 두 특성으로 표현되는 모든 대상들.
- Software의 객체도 이와 유사함
- 객체생성을 위한 청사진(blueprint)이다.
- 클래스는 사용자 정의 타입이다.

객체란?(2)

- Software를 객체로 묶는 잇점

1. Modularity 모듈화 독립성 상승
2. Information Hiding
3. Code재사용
4. Plugability와 Debuging이 쉬워짐

Class란?(3)

- 클래스의 3요소

1. 필드 - 속성 또는 상태를 저장하는 곳.==> 변수!
2. 메서드 - 동작 또는 기능
3. 생성자 - 필드 초기화

- 형식:[지정자]class클래스명{
                         [필드선언] //클래스/인스턴스변수
                         [메서드 정의]
                         [생성자 정의]
}

필드(1)==> 변수!

- 속성 또는 상태
- 객체가 처리할 데이터를 저장하는 곳.

(1) 인스턴스변수
  변수선언시,static지시자 없이 선언된다.
  클래스를 객체화 할 때 마다 메모리에 새로 생성됨.

(2) 클래스변수 (또는 static변수)
  변수 선언시, static으로 선언된다.
  클래스가 업로드 될 때 메모리에 한 번 생성됨.
// 클래스 변수
// - 클래스에 static 으로 선언된 변수
// - 클래스가 메모리에 로딩될 때 준비된다.
// - 클래스의 모든 메서드가 접근 가능.
// - 만약 해당 변수가 public, (default), protected로 공개되었다면,
//   그 조건에 맞추어 다른 클래스에서 접근할 수 있다.

// static 블럭
// - 클래스가 로딩되고 난 후 사용되기 전에 필요한 값을 준비하는 블럭
// - 스태틱 블럭에서는 스태틱 변수와 스태틱 메서드만 사용가능. 인스턴스 변수/메서드 접근 불가!
// - 클래스가 로딩되고 난 후 즉시 딱 한 번 이 블럭을 수행한다.
static {
scanner = new Scanner(System.in);
}

public class CalculatorView02 {
public static void inputForm() {
// 로컬변수
// - 메서드 및 블럭 안에 선언된 변수
// - 해당 블럭 내에서만 사용 가능
// - 메서드의 변수는 메서드의 블럭 안에서는 사용가능
// - 메서드 안에 선언된 모든 로컬 변수는 다른 메서드에서 사용 불가능

int result = 0;
...
}

}

• 인스턴스변수
• static이 붙지않은 멤버변수
• 객체가 생성될때
• 객체마다 독립적인 공간에 존재
• 인스턴스 고유의 상태를 유지해야 되는 경우에 사용
• 객체를 생성한후, Object reference(객체의레퍼런스)를 통해서 접근
• 형식 - [접근 지정자] 데이터형 변수명;//초기값으로 자동으로 초기화
•           cf) 로컬변수는 자동 초기화 안됨
• 인스턴스화 : 개별적으로 관리되어야 할 값은 인스턴스 변수에 저장해야 한다.
     인스턴스 변수는 static 을 제외한다. static은 공유되는 영역으로 동시에 개별적으로 값을
      입력받거나 할 수 없다. 이럴 때는 인스턴스화 시켜야 한다.

• 클래스변수
• static으로 선언되며 모든 객체가 공유
• 클래스가 메모리에 올라갈때 
• 인스턴스를 생성하지 않고 사용가능.
• 공통적인 값을 유지해야 하는 속성의 경우에 사용
• 객체를 생성하지 않고도, 클래스명을 통해서 접근 => 공유(공통속성 저장유리)
• 형식 - [접근지정자] static데이터형 변수명;

• 로컬변수(지역변수)
• 메서드가 일시적인 상태를 저장하기 위해 선언된 변수
• 메서드의 블록내에서만 선언 및 접근가능.

객체의생성(1)

- 키워드 new와 함께 클래스의 생성자를 호출함
- 생성자가 호출되면,객체 인스턴스가 메모리에 생성되고,
- 참조형 변수에 생성된 객체의 위치정보가 저장됨.
- 형식 - 클래스형 변수명 = new 클래스생성자([인자]);

객체의생성

- 키워드 new와 함께 클래스의 생성자를 호출

- 생성자가 호출되면, 객체 인스턴스가 메모리에 생성되고,
- 참조형 변수에 생성된 객체의 위치정보가 저장됨.

- 형식 - 클래스형 변수명 = new 클래스명([값]);
            변수명.필드명;
            변수명.메소드명([값]);
- 객체의 멤버에 접근하기 위해서 변수명과 (.)을 사용함
(같은 클래스 내의 메소드 및 필드에 접근하기 위해서  this.(현재 객체를 의미)을 사용할 수 있음)

@교재실습.--P 145 147 148 151 AirCon/AirConUse/AirConUse2/VariableKind
   - 인스턴스,static,local변수 관련

메서드(1)

- 행동을 표현
- 작업을 수행하는 명령어들의 집합.
- 필드(멤버변수 또는 인스턴스 변수)에 저장된 데이터를 수정,조회하는 용도로 사용됨.
- 호출을 통해서 동작 -- 메소드는 호출. 필드(변수)는 정의.
- 모든 객체가 공유해서 사용.

메서드(2)

- 형식[지정자] 반환자료형 메서드명([매개변수선언]) {
          ...//메서드가 처리하는 실행문.
          [return 반환값]
}
- 메서드명은 동사형이며 소문자로 시작(규약)
- 호출시 전달받을 인자에 대한 매개변수의 선언은 변수 선언과 동일함
- 반환한 값이 있는 경우, 반환자료형을 지정.
반환자료형은, 기본자료형, 참조형(배열,클래스,인터페이스)이 모두 가능, 반환할 결과값이 없는 경우  void로 명명)

main 메서드

- 프로그램의 시작점인 메서드.JVM에 의해 가장 처음 호출된다.
- 어플리케이션은 반드시 한개의 main메서드를 갖는다.

- 형식 - public static void main(String[] args) {
                  ...
            } 규칙!!!

클래스 메서드와 인스턴스 메서드

메서드 앞에
- static이 붙으면 클래스메서드,
- static이 안붙으면 인스턴스 메서드.

1. 클래스 메서드
1. static으로 선언된 메서드
2. 객체를 생성하지 않고, 클래스 이름을 통해서 호출할 수 있음.
3. static변수만 사용 가능 (인스턴스 변수는 사용할 수 없다.)
2. 인스턴스 메서드
1. static이 붙지 않은 메서드
2. 객체를 생성한 후,Object reference를 사용해서 호출할 수 있음
3. static변수와 인스턴스 변수 모두 사용할 수 있다.

오버로딩(Overloading)

- 같은 이름의 메서드(또는 생성자)를 정의하는 것.
- 같은 이름으로 된 메서드 또는 생성자를
  '오버로딩메서드' 또는 '오버로딩생성자'라고 함.

- 오버로딩(Overloading) 규칙

1. 메서드(또는 생성자) 이름이 같아야 한다
2. 매개변수들의 갯수,타입 또는 순서가 달라야 한다.
3.                   (반환자료형은 영향을 주지 않는다.)

- 예) Overloading 메서드

   public class MyMath {

      public static short add(short a, short b) { return (short)(a+b); }
      public static int add(int a, int b) { return (a+b); }//오버로딩 메서드

   }

public int sum(int a, int b) {
return a+b;
}
public int sum(int a, int b, int c) {//갯수 다르게,(만약 같은 type의  같은이름  변수쓰면서 순서 바꾸면 동일하게 인식하여 err).
return a+b+c;
}
public short sum(short a, short b) {//type 다르게
return (short)(a+b);
}
//순서가 적용되는 경우
public int sum(int a,float f) {
return (int)(a+f);
}
public int sum(float f,int a) {//type이 다른경우 순서 변경시 다르게 인식.
return (int)(a+f);
}

@실습 - P166,164 : static과 instance메서드 관련

생성자

- 객체가 생성될때,멤버필드의 초기화 작업을 수행하는 메서드
- 클래스명과 동일한 이름을 가지며, 반환자료형 없음
- 형식-[접근지정자]생성자명([매개변수]) {
          ...
    }
- 매개변수를 이용해서 멤버필드를 초기화하거나 그밖에 필요한 작업을 위하여 사용.
- 예) public class Member{
   String namek
   int age;
   public Member(String name,int age) {
      this.name = name; //멤버필드 name 초기화
      this.name = age;    //멤버필드 age의 초기화
   }
}
this => 자신을 가리키는 레퍼런스 객체

기본생성자

- 매개변수가 없는 생성자
(컴파일러는 어떤 생성자도 존재하지 않는 경우에 empty인 기본생성자를 클래스에 자동으로 포함시킴)
- 형식-[접근지정자]생성자명() {}

- 예) public class Member{

             public  Member(){
                   ...

             }

        }

this() 생성자 

http://jeami.tistory.com/entry/This
http://blog.daum.net/gunsu0j/334

- 생성자 안에서 다른 생성자를 호출할때 this()사용!.
이때는 생성자 block 내의 첫번째 구문(라인)이어야 함.

- 예) public class Member{

             int id;

             String name;

             public  Member(){

                  this.name=name;

             }

             public  Member(int id,String name){

                  this(name);//this()이용해서 생성자 호출-블럭내 첫줄!

                  this.id = id;

             }
/*

             public  Member(int id,String name){ //같은내용

                  this.name=name;

                  this.id = id;

             }
*/

        }

[this]

-- 참조 변수 this

인스턴스 자신을 가리키는 참조변수로 해당 인스턴스의 주소값을 가지고 있음.

static에서 사용 불가.

-- 생성자 참조 함수 this()

같은 클래스 내의 다른 생성자를 참조할 때 사용.

초기화 블럭

- 복잡한 초기화 작업이 필요한 경우 초기화 블럭을  사용

1. 클래스 초기화 블럭
1. 클래스 초기화 블럭: 클래스변수의 초기화에 사용
   ( static을 블럭앞에 붙임 )
2. 클래스가 메모리에 처음 로드될때,한번만 수행됨.
2. 인스턴스 초기화 블럭
1. 인스턴스 변수의 초기화, 인스턴스 생성할 때마다 수행됨.
2. 생성자들 공통으로 수행되는 작업을 인스턴스 초기화 블럭 에 넣는다.

필드의 초기화

- 멤버필드는 자동적으로 디폴트값으로 초기화

- 알고있는 특정한 값으로 초기화 가능.

- 멤버변수의 초기화 순서

1. 클래스변수의 초기화 순서
1. 기본값 초기화
2. 명시적초기화
3. 클래스 초기화 블럭 수행
2. 인스턴스변수의 초기화 순서
1. 기본값 초기화
2. 명시적초기화
3. 인스턴스 초기화 블럭
4. 생성자(호출)

public class InitTest {
// private static int a;// default 0
// private        int b; //0
// private char c; // 0000
// private String s; //null

private static int a;
private        int b;
private static int [] static_arr;
private        int [] instance_arr;

private char c='A';
private String s="AAA";

//초기화블럭(static 클래스변수) : 로직이 필요한 초기화에 유용
static{
for (int i = 0; i < static_arr.length; i++) {
static_arr[i] = i*2;
}
}

//초기화블럭(인스턴스변수) : 로직이 필요한 초기화에 유용
{
for (int i = 0; i < static_arr.length; i++) {
static_arr[i] = i*2;
instance_arr[i] = i*10;
}
}
//생성자
public InitTest(int b){
this.b=b+instance_arr[0]+instance_arr[2];
}

}

@실습 - P169,171,174 

setter 메서드 와 getter 메서드

- 프로퍼티의 값을 설정하거나 읽기 위해서 사용.
(프로퍼티는 setter와 getter 메서드를 갖고있는 멤버필드)
- encapsulation 캡슐화에 유용
- setter와 getter 메서드의 이름은 다음같이 지정.
형식 : set + 프로퍼티명(또는 필드명)
         get + 프로퍼티명(또는 필드명)//프로퍼티명의 첫글자는 대문자
예) 프로퍼티 age 에 대해, setAge(), getAge()
public class Student {
   private String name;

   public void setName(String n){
      name = n;//프로퍼티네임의 setter
   }
   public String getName() {
      return name;//getter
   }
}

1.객체의 필드의 참조

- 객체의 필드들은 필드명에 의하여 접근된다.
- 외부의 코드는 반드시 객체레퍼런스, 필드명을 사용해야 한다.
- 예)
Class Rectangle {
   int width;
   public Rectangle(int w) {
      width=w; //내부에서 width필드의 접근.
   }
}

Class B {
   public static void main (String args[]) {
      Rectangle rect = new Rectangle(100);// width 초기화
      Int length = rect.width; // 외부에서 width 필드의 접근
   }
}

- 객체 참조를 통한  instance필드의 효출은, 특정한 객체의 필드 호출을 의미한다.
- 그밖에, 객체의 접근을 위하여, new 연산자가 반환하는 object reference값을 바로 사용할 수 있다.
이 경우, 프로그램은 객체의 reference를 갖지 않게 되므로, 이 객체는 Garbage Collection의 대상이 된다.
예) int width = new Rectangle(100).width;//

08.09 주말 숙제 - 가위바위보 게임

//------------------------------------------------------------
//주말숙제 = 실습4
/* 가위바위보 게임
 * 결과와 함께 게임전적 - 승 무 패 를 누적하여 보여주는 프로그램
 * 컴퓨터의 선택은 p117 에 있는  Math.ramdom 사용하여 랜덤 발생시킨다.
 * -----------------------------

 * 결과화면은 아래처럼 

 * -----------------------------
 * 가위바위보를 선택하세요(1:가위,2:바위,3:보)
 * 1
 * 당신은 가위,컴퓨터는 바위를 선택했습니다.
 * 당신이 졌습니다(0승 0무 1패)
 * 
 * 가위바위보를 선택하세요(1:가위,2:바위,3:보) 
 * 2
 * 당신은 바위,컴퓨터는 가위를 선택했습니다.
 * 당신이 이겼습니다(1승 0무 1패)
 * 
 * 가위바위보를 선택하세요(1:가위,2:바위,3:보)
 * */

08.09 배열 실습 및 연습문제

//[문제1]배열의 선언과 초기화 맞나?
int[] arr1[]; //OK 2차원배열: 배열기호는 떨어져있어도 무관.
int[] arr2 = {1,2,3};//OK 1차원 배열 초기화
int[] arr3 = new int[5];//OK

int[] arr4 = new int[5]{1,2,3,4,5};//Error
int arr5[5];//Error 길이지정은 new 선언 이후에

int arr6[] = new int[3][];//Error 전항:1차원 != 후항:2차원 => type mismatch


//문제2 배열을 사용하는 code넣기
int[] arr = new int[]{1,2,3};
//배열 arr의 길이 출력
System.out.println("배열 arr의 길이 : "+arr.length);

//for문을 사용하여 arr모든 원소 값을 출력
// for (int k = 0; k < arr.length; k++) {
// System.out.println(arr[k]);
// }
for (int j : arr) {
System.out.println(j);

}

//[실습1]
//반복문이용, 배열에 저장된 성적을 모두 합하고 평균과 총점을 출력하시오.
//성적 : 95,84,87,92,100,90,78,94
//==================
// 총점=720
// 평균=90 / f평균=90.0

// int jumsu[] = new int[]{95,84,87,92,100,90,78,94}; //표기법1

// int jumsu[] = {95,84,87,92,100,90,78,94}; //표기법2 

// int[] jumsu = {95,84,87,92,100,90,78,94}; //표기법3 

int jumsu[] = new int[8]; //표기법4
int idx = 0;
jumsu[idx++] = 95;
jumsu[idx++] = 84;
jumsu[idx++] = 87;
jumsu[idx++] = 92;
jumsu[idx++] = 100;
jumsu[idx++] = 90;
jumsu[idx++] = 78;
jumsu[idx++] = 94;

float favg = 0f;
int sum ,avg;
sum = avg = 0;

for (int i = 0; i < jumsu.length; i++) {
sum += jumsu[i];
}
avg = sum/jumsu.length;
                favg = sum/(jumsu.length*1f);
System.out.println("총점="+sum);
System.out.println("평균="+avg+" / f평균="+favg);


//[실습2]
//연도를 입력받고 지간 출력하는 프로그램.
// 10간: 갑 을 병 정 무 기 경 신 임 계(10년)
// 12지: 자 축 인 묘 진 사 오 미 신 유 술 해 (12년주기)
// 참고 : 서기 4년은 갑자년.1905 을사년.2013 계사년

import java.util.Scanner;
public class Day6 {
public static void main(String[] args) {

String gan[] = {"갑","을","병","정","무","기","경","신","임","계"};
String ji[] =  {"자","축","인","묘","진","사","오","미","신","유","술","해"};
Scanner sc = new Scanner(System.in);
int year = sc.nextInt();

//간= (year-4)%10
//지= (year-4)%12

String sel_gan,sel_ji;
sel_gan = sel_ji = "";

sel_gan = gan[(year-4)%10];
sel_ji = ji[(year-4)%12];

System.out.println("입력한 년도 "+year+"의 간지는? "+sel_gan+sel_ji);
}
}
//==================
public static void main(String args[]){
//실습3
// //2*3 2차원 배열에 담긴 두학생의총점과 평균 구하기
// 학생 국어 영어 수학
// A    90,85,92
// B    87,92,84
// 학생 국어 영어 수학 총점 평균 순으로 출력하기

int[][] stu = new int[][]{
{90,85,92},
{87,92,84}
};
char c = 'A';
int stu_len = stu.length; //학생수
int sum[]      = new int[stu_len];
float avg[]    = new float[stu_len];
int stu_nm[]   = new int[stu_len];
String title[] = {"학생","국어","영어","수학","총점","평균"};

//float avg[] = 0f;

for (int i = 0; i < stu_len; i++) {
for (int j = 0; j < stu[i].length; j++) {
sum[i] += stu[i][j];//학생별 전과목 합계
}
//평균구하기
//10f 곱하고 나누면 87.7, 100f곱하고 나누면 87.67
avg[i]= Math.round(sum[i]*10f/stu[0].length)/10f;
avg[i]= Math.round(sum[i]*100f/stu[0].length)/100f;
// avg[i]=(float)sum[i]/stu[0].length;//87.666664
}

for (int i = 0; i < sum.length; i++) {
stu_nm[i] = c++;//학생이름 A B
}

//화면출력
// System.out.println("학생|국어|영어|수학|총점|평균");
for (int i = 0; i < title.length; i++) {
System.out.print(title[i]);
if (i<title.length-1) {
System.out.print("\t");
}
}
System.out.println();
for (int i = 0; i < stu_len; i++) {
System.out.print((char)(stu_nm[i])+"\t");
for (int j = 0; j < stu[i].length; j++) {
System.out.print(stu[i][j]+"\t");
}
System.out.print(sum[i]+"\t");//학생별 전과목 합계
System.out.println(avg[i]);  //평균
}
//------------------------------------------------------------
//주말숙제 = 실습4
/* 가위바위보 게임
 * 결과와 함께 게임전적 - 승 무 패 를 누적하여 보여주는 프로그램
 * 컴퓨터의 선택은 p117 에 있는  Math.ramdom 사용하여 랜덤 발생시킨다.

 * -----------------------------
 * 가위바위보를 선택하세요(1:가위,2:바위,3:보)
 * 1
 * 당신은 가위,컴퓨터는 바위를 선택했습니다.
 * 당신이 졌습니다(0승 0무 1패)
 * 
 * 가위바위보를 선택하세요(1:가위,2:바위,3:보) 
 * 2
 * 당신은 바위,컴퓨터는 가위를 선택했습니다.
 * 당신이 이겼습니다(1승 0무 1패)
 * 
 * 가위바위보를 선택하세요(1:가위,2:바위,3:보)

 * */

//==================


//==================

08.08 - 오후 : 배열 Array

* 배열 Array

- 배열객체 : 동일한 자료형의 고정된 갯수의 공간(배열)을 갖고 있는 객체

- 유사한 여러변수들을 하나의 묶음(배열)으로 다루는 객체

- 배열의 원소는 기본형,참조형이 모두 가능.

# 배열의 선언

- 배열변수의 선언: 배역객체의 reference를 저장하라 수 있는 참조변수의 선언.

- 배열원소의 자료형과 배열기호[], 그리고 배열(참조) 변수명으로 구성.
(배열 원소의 자료형은 기본형과 참조형 둘다 가능)

- 형식 : 자료형[] 배열변수명
   예) int i[]; //int형 배열변수 i선언
        String st[]; // String형 배열변수 st선언

# 배열의 생성(1)

- 자료를 저장하기 위한 공간(배열)을 갖고 있는 객체의 생성과 그 객체의 reference를 배열(참조)변수에 대입하는 절차.

- 키워드 new와 함께 배열의 타입과 크기를 지정.

- 배열의 원소들은 초기값으로 초기화.

# 배열의 생성(2)

형식 - 배열변수명 = new 자료형[배열의길이]

예) i = new int[10];

/*

배열객체의 생성과 초기화, 그리고 참조변수 i에 대입

(이 배열객체는 int형의 

*/

// int jumsu[] = new int[]{95,84,87,92,100,90,78,94}; //표기법1

// int jumsu[] = {95,84,87,92,100,90,78,94}; //표기법2 

// int[] jumsu = {95,84,87,92,100,90,78,94}; //표기법3 

int jumsu[] = new int[8]; //표기법4
int idx = 0;
jumsu[idx++] = 95;
jumsu[idx++] = 84;
jumsu[idx++] = 87;
jumsu[idx++] = 92;
jumsu[idx++] = 100;
jumsu[idx++] = 90;
jumsu[idx++] = 78;
jumsu[idx++] = 94;

# 메모리상의 배열(1)

- 메모리에 배열이 생성되는 과정은 다음과 같음

예) int[] items;//배열객체의  regerence를 대입.

     items = items int[5];//배열객체의 생성및 초기화/ reference를 대입.

Heap 영역에 ,배열을 포함하는 (배열)객체가 생성되고 

배열은 4Byte의 연속된 메모리가 할당되고 초기화 됨.

<stack영역>                             < Heap영역>

                                                items[0] 

              reference값 : 0x100 ↗   items[1]

                                        /       items[2]

                                      /         items[3]

items(null)                     /           items[4]

# 배열의 특징

- 배열의 선언과생성을 한문장으로.

  형식 : 자료형[] 변수이름 = new 자료형[길이];

- 배열은 한번 생성되면 길이를 바꿀 수 없음.

- 각 배열원소들은 초기값으로 초기화 된다.

예) 논리형 → false 

     정수형 → 0

     실수형 → 0.0

     문자형 → \u0000

     참조데이터형 → null

# 배열의 초기화(1)

1. 개별적인 초기화
1. int[] items = new[5];
2. items[0] = 100;
3. items[1] = 90;
2. 집합적인 초기화
1. new 키워드를 사용하지 않는 방법
1. int[] items = {1,2,3}
2. new 키워드를 사용하는 방법
1. int[] items = new int[] {1,2,3}
3. 1,2 의 차이?
1. 1 처럼 하면 선언할때만 초기화 가능
2. 2 는 선언 따로 하고 초기화 별도로 가능함.

# 배열의 사용

- 배열의 각 원소는 배열참조변수와 인덱스를 사용해서 접근.

- 인덱스란? 

   배열의 저장공간에 순서대로 자동적으로 주어지는 번호, 0부터 연속적으로 증가하는 정수값.

예) 크가가 5인 배열의 index의 범위는 0~4

# 배열의 사용(2)

- 형식: 참조변수명[인덱스]

예1) ages[1] = 20;

//배열참조변수 ages가 가리키는 배열의 두번째 원소에 값 20 eodlq

예2) int ages = ages[1]

// 정수형 변수 age를 선언하고

// 배열참조변수 ages를 배열의 두번째 원소의 값으로 초기화.

# 배열의 사용(3)

- for 문으로 배열에 접근할때는 배열의길이(length)를 이용한다.

예)

for(int i=0;i<ages.length;++i) {

 ...

}

- (참고)배열도 객체이며,멤버필드와 메서드를 갖고있다.

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

- 실습(한시간 넘게)

교재 : p129~

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

# 그 밖의 배열

1. 다차원배열 : 2차원 이상의 배열을 말하며 ,이러한 배열을 갖고 있는 객체.

   - 2차원 배열

2. 가변배열 : 2차원 이상의 배열로서 각 행마다 열의 크기가 다른 배열.

   - 2차원 가변배열

먼저 배열을 선언하는 것과 동시에 초기화 하는 방법입니다.
int[ ][ ] a = new int[ ][ ] { 1, 2, 3 }, { 6, 7, 8 } ;

int[ ][ ] a = { { 1, 2, 3 }, { 6, 7, 8 } } ;

1. 다차원배열(1)
1. 선언:자료형,차원만큼의[],그리고 배열참조변수 이름으로 구성.
2. 형식:자료형[][]배열(참조) 변수명
1. 예-int[][] grades;
3. [] 위치는 자료형 다음 또는 변수 다음.
2. 다차원배열(2)
1. 생성 : 첫번째는 행 두번째는 열
2. 형식 : 배열변수명 = new자료형[행][열길이]
1. 예- int[][] grades = new int[2][3]; 행 열
3. 다차원배열(3)
1. 배열변수 grades를 위한 공간 생성과 초기화
2. reference를 담을 수 있는 길이가 2인 reference배열 객체의 생성과 초기화
3. 자료를 담을수 있는, 길이가 3인 int배열객체의 생성과 초기화, 그리고 이 배열객체의 reference를 먼저 생성된 ref 배열에  대입x(2회)
4. reference배열 객체의 reference를 배열변수 grades에 대입.
4. 다차원배열(4)
1. 초기화
1. 형식 : 배열변수 = new자료형[][]{{},{}}
2. 예) 배열변수 = new 자료형[][]{{}{}}
2. 초기화를 할때는 ,배열의 갯수를 명시하지 않는다.
5. 다차원배열(5)
1. 행과 열의 인덱스를 사용하여 원소에 접근하고,배열객체의 length필드를 활용.
2.   예) grades[1][0]=80;//1행1열에 80대입.
3.   예) int sum=grades[1][0]+grades[1][1]+grades[1][2];
4. 배열참조변수.length → 2차원배열의 행의길이(=reference배열길이)
5. 배열참조변수[행].length → 지정된 행의 열의길이.
6.   예) grades.length      //grades배열의 행의 길이
7.   예) grades[0].length //grades배열의 첫번째 행의 열의 길이
8.   예) grades[1].length //grades배열의 두번째 행의 열의 길이

가변배열(1)

1. 가변배열 선언 및 생성.
1. 배열의 열의 길이가 일정하지 않은 배열을 포함하는 객체
2. 배열의 마지막 차원의 크기를 나중에 지정.
3. 효율적인 배열의 구성을 허용
4. 예) int maps[][] = new int[4][];//마지막 차원이 지정되지 않음
1. maps[0] = new int[3]; //열의 길이지정 및 생성
2. maps[1] = new int[4]; //열의 길이지정 및 생성
3. maps[2] = new int[5]; //열의 길이지정 및 생성
4. maps[3] = new int[5]; //열의 길이지정 및 생성
2. 가변배열 초기화
1. 예)  int maps[][] = new int[][] {
1.     {1,2},
2.     {1,2,3},
3.     {1,2,3,4},
4.     {1,2,3,32}
5.  };
2. 생성과 초기화를 같이할때 => 배열의 갯수를 명시하지 않는다.

# 배열의복사

1. for 문을 이용한 직접복사 → deep copy
2. 배열의 clone 메서드 이용
1. 혹은 System.arraycopy() 이용
2. (1차원 배열 deep copy, 2차원배열 shallow copy)
3. 형식
1. System.arraycopy(source 배열,시작위치,타겟배열,시작위치,복사할  배열의길이)

* 용어정리 (A를 B에 카피할 때)

• deep copy     → A 변경시 B 불변
• (원본과 같은 데이터를 저장하고 있는 새로운 객체나  배열을 생성하는것)
• shallow copy → A변경시 B 변경.
• 배열이나 객체를 복사할 때, 단순히 참조만 복사하는 것.

Shallow Copy:  참조형 변수가 가지고 있는 참조값을 복제한다.

Deep Copy : 참조형 변수가 참조값에 의해 참조하고 있는 인스턴스 자체를 복제하여 새로운 인스턴스를 만든다.


다음은 참조형의 일종인 배열형 변수에 대한 Shallow Copy와 Deep Copy의 차이점을 보여주는 간단한 코드다.


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

  int array[] = new int[]{1,2,3,4,5};

  //array가 가리키는 배열 인스턴스에 대한 참조값만을 복사한다.
  int shallowCopy[] = array;

  //새로운 배열 인스턴스를 만들어 array가 가리크는 배열 인스턴스의 내용을 복사한다.
  int[] deepCopy = new int[array.length];
  System.arraycopy(array,0,deepCopy,0,array.length);

  array[2] = 123;
  System.out.println(shallowCopy[2]);
  System.out.println(deepCopy[2]);
 }

}

-------------------------------------------------------------------------------------
123
3
-----------------------------------------------------------------------------------



참조 값만을 복제한 shallowCopy는 결국 array와 같은 배열 인스턴스를 가리키고 있으므로 "array[2]=123" 을 통해 변경한 결과가 반영되어 shallowCopy[2]의 값 역시 "123"이 될 것이나 배열 인스턴스의 내용 자체를 복사하여 새로운 인스턴스를 가지고 있는 deepCopy는 array[2]의 변화에 상관없이 복제 당시의 값인 3을 출력하는 모습을 볼 수 잇다.

살펴본 바와 같이 참조형 변수를 복제한다고 할 때에 그 의미가 Shallow Copy인지 Deep Copy인지 구별하는 것은 중요하다. 하지만 참조형 변수라고 해서 항상 이러한 구별을 해야 하는것은 아니다. 생성된 후에는 그 값이 구별할 수 없는 특징을 가지는 이뮤터블 클래스의 인스턴스에 대해서는 Shallow Copy , Deep Copy와 같은 구별이 무의미하다.  이뮤터블 클래스의 인스턴스는 그 자체로서 값형 변수와 같은 특징을 갖기 때문이다. 그러한 이유로 이뮤터블 클래스의 인스턴스를 값 객체(Value Object)라고 부르기도 한다..

08.08 실습

# 실습
(main 메소드[p59]arg or scanner[p115] 로 입력)
[문제 4]
3개의 값을 입력받아 최대값과 최소값 출력.
입력 : 3,1,2
출력 : 최대 3/ 최소 1
//Scanner 이용
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();
int max,min;
min = max = a;

if(max < b) max = b;
else if(min>b) min=b;

if(max < c) max = c;
else if(min>c) min=c;

System.out.println("max:" + max);
System.out.println("min:" + min);

[문제 5]학점이
A+ 98 이상
A   95 이상
B+ 88 이상
B  85 이상
C 85 미만
출력하는 프로그램(반드시 중첩 if문 사용)
while(true) {// break 되기전까지 계속 입력가능.
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int start_num = 0;
if (a==1) start_num = 1;
else if(a==2) start_num = 2;
else {
System.out.println("you can select just 1or2!\n(will be close.recompile please!)");
// System.exit(1);
break;
}
if (a==1||a==2) {

// for (int i = start_num; i < 10; i+=2) {
// System.out.println("-----"+i+" 단-----");
// for (int j = 1; j < 10; j++) {
// System.out.println(i+"*"+j+"="+(i*j));
// }
// }

//continue 넣어서 만들기
for (int i = 1; i < 10; i++) {
if (a==1 && i%2==0) { //1인데 짝수단이면
continue;
}
if (a==2 && i%2==1) { //2인데 홀수단이면
continue;
}
System.out.println("-----"+i+" 단-----");
for (int j = 1; j < 10; j++) {
System.out.println(i+"*"+j+"="+(i*j));
}
}
}
}

08.07 4일차 expression, statement, block

식,문,블럭

1. 식(expression) - 변수,연산자,메서드 호출로 구성되며 단일값으로 평가된다.
2. 문(statement) - 실행이 완료되는 프로그램의 단위
1. (expression 문, 선언문, 흐름제어문 등)
3. 블럭(block) - {}안에서 0개이상의 그룹을 이루는 것.

문(statement)

조건문,반복문,그리고 변수선언문,대입문,호출문 등

프로그램을 구성하는 실행이 완료되는 가장 작은 단위의 코드.

프로그램은 한개 이상의 일련의 문(statement)들로 구성되어 있음.

- statement 의 종류

1. 실행문
1. 선언문 - 변수를 선언하는 문
2. expression문
1. 대입식,단일항연산자,메서드 호출,객체생성식 등,
2. 실행이 완료가능한 식으로 구성됨.
3. 제어문 - 프로그램의 실행흐름을 제어하는 문
2. 비실행문
1. 주석문,프로그램의 설명을 기술한  statement
1. Doc-comment : /** ..*/ javadoc 에서 사용
2. Block-comment : /* .. */ 
3. End-Of-line comment : //
3. 제어문
1. 프로그램의 실행순서를 제어하는 문
1. 의사결정문(조건문) - 조건에 따라서 실행할 문들을 결정.
1. if, switch
2. 반복문 - 반복해서 실행하게 하는 문
1. for, while, do-while
3. 분기문 - 진행순서를 바꾸는 문.
1. break, continue, return 문

[제어문]

1. 의사결정문(조건문), 조건에 따라서 실행할 문들을 결정.
1. if문
1. 단순if문 - if (조건식) {}
2. if else문 - if (조건식) {} else {}
3. 다중 if문 - 조건이 여러개인 경우 
1. if (조건식1) {} else if (조건식2) {} else if(조건식3) {} else {}
4. 중첩 if문 - if 문 안에 if 문
5. * dangling else 처리 - brace 없는 if문
   - 중첩 if문에서 사용된 else는 가장 안쪽에 있는 if문에 속한 것으로 약속한다.
   예) if ( a<10 )

   if ( b<10 ){...}

   else { ...} //else 는 안쪽 if문에 속한다.
2. switch문
1. 식의 결과에 따라 수행되는 실행경로를 가질수 있는 문 (# 아래 참조)
2. 반복문 - 반복해서 실행하게 하는 문
1. for, while, do-while
3. 분기문 - 진행순서를 바꾸는 문.(break, continue, return 문)
1. break 
1. 반복문(for,while,do-while)의 block을 벗어나기 위해 사용
2. if, switch 블럭을 빠져나오기 위해 사용.
3. 실행중인 statement의 블록이 종료되고,블록 바로 다음의 문이 실행.
4. 실행중인 문의 블록이 if 문인 경우, 상위 반복문의 블럭까지 빠져나옴.
2. continue
1. 반복문의 블럭내에서 다음 문들을 수행하지 않고 조건식으로 돌아가기 위해서 사용
2. while(조건식) {
3.    문장1; 
4.    if(조건식) { // if 조건식이 만족된 경우 문장2를 건너뜀.
5.       continue;
6.    }
7.    문장2;
8. }
3. return
1. 프로그램의 제어가, 호출된 메서드에서 호출한 메서드로 이동.
2. 반환값이 있는 경우 값이 전달됨.
3. 메서드의 일부를 실행하지 않고 빠져나오기 위해 사용.

====================================================

문자열의 비교(String 클래스의 사용)

1. 값의 비교

String a= args[0]; //args "나철수"

if(a.equals("나철수")) {...} // true

2. 인스턴스의 비교

String a= new String("나");//객체의생성

String b= new String("나");//또다른 객체의생성

String res = "다르다";

if (a==b) res = "같다";

System.out.println(" == 비교결과 :  " + res + "입니다.");

if (a.equals(b)) res = "같다";

System.out.println(" equals 비교결과 :  " + res + "입니다.");

==================================

 == 비교결과 :  다르다입니다.

 equals 비교결과 :  같다입니다.

* java는 문자열을 class로 생성한 객체처리

== 는 주소값 비교

equals는 값 value 비교

# switch문

식의 결과에 따라 수행되는 실행경로를 많이 가질 수 있는 문

switch식의 결과와 일치하는 case label문들을 실행

- 조건으로 사용할 수 있는 자료형으로 4가지 정수형(byte,short,int,char) enum타입, Wrapper클래스가 사용됨.

(jdk1.7 에서는 String형도 허용함.)

- case lable 은 literal만 가능.- (식이 아닌 데이터)

- 일단 switch블럭 내에서 실행되면 

  일치되는 case  label이 아니더라도 계속해서 끝까지 실행됨.

- 중간에 빠져나오기 위해9서, break문을 사용

- break와 default는 필요에 따라 삭제 가능.

# if문과 switch문의 비교

1. if문은 조건식의 결과값이  true/false 이고,
2. switch문의 조건식의 데이터 타입으로 4가지 정수 enum,Wrapper,그리고 String형을 허용
3. if 문은 값 또는 범위를 표현 가능
4. switch문은 값을 표현하는 식만 test 가능
5. 실행 경로가 많은 경우에는 switch문이 가독성이 좋음.

# 반복문

- 조건식의 결과에 따랄서 실행문(들)의 반복수행을 가능하게 하는 문

- 반복횟수의 지정 및 무한루프도 가능

1. for 문
1. 조건식이 만족되는 동안 블럭내의 문들을 실행
2. *단일 for (초기화식; 조건식; 증감식) { }
3. 실행순서 
1. 초기화식
2. 조건식<---ㄱ
3. 증감식  ____」
4. *중첩 for문도 가능
5. *향상된 for문 : Collection이나 배열과 함께 사용
1. for (변수선언 : Collection또는 배열명) {}
1. collection 또는 배열의 각 item이 그 변수에 대입되며 블록내에서 그 변수를 활용
2. 집합체로부터 원소를 얻어서 반복수행가능.
2. while 문
1. 조건식만 지정되 있고,초기식과 증감식은 별도 위치에 지정.
2. 초기식;
3. while(조건식) {
1. 증감식;
4. }
3. do while 문
1. 루프의 맨 아래에서 조건식을 평가
2. 반복되는 문장을 반드시 한번은 실행하고 조건을 검사
3. while문 마지막에는 반드시 ; 을 붙여야 함
4. 초기식;
5. do {...
6. }(조건식)

# for 와 while문의 비교

1. for - 반복횟수가 정해져 있거나,예측하기 쉬운경우
2. while 이나 do-while문은 반복횟수가 정해져 있지 않은 경우.

# 교재실습 test17~20
# test21 => Scanner 등장.

1. Scanner class - 사용자로부터의 입력
1. java.util.Scanner 를 import 한다.
1. import java.util.Scanner;
2. 표준입력으로부터 입력값을 전달받도록 객체생성
1. Scanner sc = new Scanner(System.in);
3. 생성된 Scanner로부터, 하나의 입력된 문자열을 얻기
1. String s = sc.next();
4. 입력된 문자열이 정수형태의 문자열이면, next() 사용해서 변환된 정수로 얻을수 있다.
1. int i = sc.nextInt(); //"100" → 10
5. Enter Key를 치기전까지 한 라인의 모든 문자열을 입력받음
1. String s = sc.nextLine();

1. 분기문
1. break 
1. 반복문(for,while,do-while)의 block을 벗어나기 위해 사용
2. if, switch 블럭을 빠져나오기 위해 사용.
3. 실행중인 statement의 블록이 종료되고,블록 바로 다음의 문이 실행.
4. 실행중인 문의 블록이 if 문인 경우, 상위 반복문의 블럭까지 빠져나옴.
2. continue
1. 반복문의 블럭내에서 다음 문들을 수행하지 않고 조건식으로 돌아가기 위해서 사용
1. while(조건식) {
2.    문장1; 
3.    if(조건식) { // if 조건식이 만족된 경우 문장2를 건너뜀.
4.       continue;
5.    }
6.    문장2;
7. }
3. return
1. 프로그램의 제어가, 호출된 메서드에서 호출한 메서드로 이동.
2. 반환값이 있는 경우 값이 전달됨.
3. 메서드의 일부를 실행하지 않고 빠져나오기 위해 사용.
2. Lable문
1. 어떤 문들은 label을 가질수도 있다.
2. - for, while, do-while, switch, if문, 블럭
3. labeled break문은 중첩된 labeled-반복문 또는 labeled-if문, labeled-블럭을 벗어나기 위해 사용.
4. labeled continue 문은 실행을 건너뛰고,labeled-반복문으로 가기위해 사용된다.
5. label은 scope내에 sub문장의 label명과 일치해서는 안된다.

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

[문제1] dangling else 문제
number=3, 아래 코드의결과?
int n = 3;
if (n >= 0)
if (n == 0)
System.out.println("A");

else
System.out.println("B");
System.out.println("C");
==> 결과
B
C

[문제2] mm=22 일때 결과?
int mm=22;
switch (mm/2) {
default: System.out.println("@1"); //break;
case 10: System.out.println("@2"); //break;
case 20: System.out.println("@3"); //break;
case 30: System.out.println("@4"); //break;
}

==>
@1 ---- 이거지만 break가 없어서 아래있는 모든 경우가 다 실행됨.
@2
@3
@4
[문제3] 실행문1은 각각 몇번 실행되는가?
public static void main(String[] args) {
int cnt = 0;
int i = 0;

//1 -- 100
for (i = 1; i <= 10; i++) {
for (int j = 1; j <=10; j++) {
cnt++;
}
}
System.out.println("@1_"+cnt);
//2 -- 1~10 합계  -- 55
cnt = 0;
for (i = 1; i <= 10; i++) {
for (int j = i; j <=10; j++) {
cnt++;
}
}
System.out.println("@2_"+cnt);

//3 --10*(5+4+3+2+1) / 5  ==> 30
cnt = 0;
for (i = 1; i <= 10; i++) {
for (int j = i; j <=10; j+=2) {
cnt++;
}
}
System.out.println("@3_"+cnt);

//4 -- 18
cnt = 0;
for (i = 1; i <= 10; i++) {
for (int j = i; j <=10; j*=2) {
cnt++;
}
}
System.out.println("@4_"+cnt);
}
==========================
@1_100
@2_55
@3_30
(i,j)=(1,1)
(i,j)=(1,2)
(i,j)=(1,4)
(i,j)=(1,8) ==> 1,10 이 안걸리는 이유? *2 이므로 1,2,4,8, (16)
(i,j)=(2,2)
(i,j)=(2,4)
(i,j)=(2,8)
(i,j)=(3,3)
(i,j)=(3,6)
(i,j)=(4,4)
(i,j)=(4,8)
(i,j)=(5,5)
(i,j)=(5,10)
(i,j)=(6,6)
(i,j)=(7,7)
(i,j)=(8,8)
(i,j)=(9,9)
(i,j)=(10,10)
@4_18