HighLight in your life~

 TestExceptions.java

1) String test = "예"

2) String test = "아니요"

1. 다형적인 catch 블록 하나로 모든 예외를 잡을 수 있다고 해서 꼭 그렇게 해야 하는 것은 아니다.

try {

laundry.doLaunry();

}     catch(Exception ex) {

      //복구 코드

}

2. 따로 처리해야 하는 예외에 대해서는 별도의 catch 블록을 만든다.

try {

  laundry.doLaundry();

} catch (TeeShirtException tex) {

     //TeeShirtException 처리

} catch (LingerieException lex) {

     //LingerieException 처리

} catch (ClothingException cex) {

     //기타 모든 ClothingException 처리

}

3. 예외 발생 여부와 상관없이 무조건 실행할 코드는 finally 블록에 넣으면 된다.
   try 또는 catch 블록에 return 선언문이 있어도 finally 블록은 실행된다. 일단 흐름 제어가 finally 블록으로 넘어갔다가 리턴된다.

 1) Good Code

 try {
   trunOvenOn();
   x.bake();
 } catch (BakingException ex) {
   ex.printStackTrace();
 } finally {
   turnOvenOff();
 }

 2) Bad Code 
 try {
   trunOvenOn();
   x.bake();
   turnOvenOff();
 } catch (BakingException ex) {
   ex.printStackTrace();
   turnOvenOff();
 }

4. 테스트 과정을 제외하면 Exception에 대한 catch 블록을 만드는 일은 거의 없을 것이다.

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

Exception은 처리하거나 선언하거나 해야 한다.

MathFun.java

 import java.text.*; //NumberFormat 클래스가 java.text 패키지에 들어 있다.

 import java.util.*; //Locale 클래스가 java.util에 들어 있다. 

1. 화폐 단위 포매팅(기본 통화)

2. 로케일을 지정하여 화폐 단위로 포매팅하는 방법

3. 숫자 포매팅(쉼표 집어넣기)

4. 숫자 포매팅(소수점 이하 자릿수 설정)

5. 날짜 포매팅(기본 설정 사용)

6. 로케일을 지정하여 날짜를 포매팅하는 방법

//p.314 - (10장 숫자와 정적 변수, 정적 메소드)
Math 메소드

1) Math.random() - 0.0 이상 1.0 미만의 double 값을 리턴한다.
   double r1 = Math.random();
   int r2 = (int) (Math.random()*5);

2) Math.abs() - 주어진 인자의 절대값을 나타내는 double값을 리턴한다.
             이 메소드는 오버로드되어있기 때문에 int를 전달하면 int가, double을 전달하면 double이 리턴된다.

   int x = Math.abs(-240); //240이 리턴된다.
   double d = Math.abs(240.45); //240.45가 리턴된다.

3) Math.round() - 주어진 수를 반올림하여 가장 가까운 int 혹은 long(인자가 float인지 double인지에 따라 결정됨)을 리턴한다.
   
   int x = Math.round(-24.8f) //-25가 리턴된다.
   int y = Math.round(24.45f); //24가 리턴된다.

4) Math.min() - 두 인자 중 더 작은 값을 리턴한다. 이 메소드는 오버로드되어있기 때문에 int, long, float, double을 모두 사용할 수 있다.

   int x = Math.min(24, 240); //24가 리턴된다.
   double y = Math.min(90876.5,90876.49); //90876.49가 리턴된다.

5) Math.max() - 두 인자 중 더 큰 값을 리턴한다. 이 메소드는 오버로드되어있기 때문에 int, long, float, double을 모두 사용할 수 있다.

   int x = Math.max(24,240); //240이 리턴된다.
   double y = Math.max(90876.5,90876.49); //90876.5가 리턴된다.

final 키워드의 특징

- 보통 클래스를 final로 지정하는 이유는 보안 문제 때문이다.

1. 변수를 final로 지정하면 값을 변경할 수 없다.

class Macdonarld {
 final int burgerCount = 2;
 final int cokeCount;

 Macdonarld() {
  cokeCount = 2;
                // cokeCount를 변경 할 수 없다.
 }

 void Mac_morning(final int coffee) {
  //coffee로 값을 바꿀 수 없다.
 }

 void Mac_lunch() {
  final int bigMaccount = 10;
  // bigMaccount 값을 변경 할 수 없다.
 }
}

2. 메소드를 final로 저정하면 메소드를 오버라이드할 수 없다.

class Burger {
 final int calcMacluch() {
 //절대로 오버라이드하면 안 되는 중요한 메소드
 }
}

3. 클래스를 final로 지정하면 그 클래스를 확장할 수 없다. (자식 클래스를 만들 수 없다.)

final class BeToDeluxe {
 //이 클래스는 확장할 수 없다.

}
 

cf. 정적 메소드만 들어있는 클래스가 있다면 그 클래스의 인스턴스를 만들 필요가 없기 때문에 그 생성자를 private로 지정하는 것이 좋다.

cf. 자바에서 상수를 만들 때는 변수에 static과 final로 지정하면 된다.

cf. 상수(static final)의 이름은 일반적으로 모두 대문자를 사용한다.

cf. final 인스턴스 변수 값은 선언 할 때 혹은 생성자에서 값을 넣어 주어야 한다.

Q)객체의 일생에서 상위클래스 생성자의 역할
 1. 추상 클래스에 대해 new 키워드를 사용할 수 없지만 추상 클래스도 상위클래스이기 때문에 구상 클래스의 인스턴스를 만들면 그 생성자가 실행된다.
 2. 생성자가 실행되면 바로 그 상위클래스 생성자를 호출하고, Object 클래스의 생성자에 다다를 때까지 상속의 사슬을 거슬러 올라가면서 각 상위클래스의 생성자를 호출한다.

class Duck {
 int pounds = 6;
 float floatability = 2.1F;
 String name = "Generic";
 long[] feathers = {1,2,3,4,5,6,7};
 boolean canFly = true;
 int maxSpeed = 25;

 public Duck() {
  System.out.println("type 1 duck");
 }

 public Duck(boolean fly) {
  canFly = fly;
  System.out.println("type 2 duck");
 }

 public Duck(String n, long[] f) {
  name = n;
  feathers = f;
  System.out.println("type 3 duck");
 }

 public Duck(int w, float f) {
  pounds = w;
  floatability = f;
  System.out.println("type 4 duck");
 }

 public Duck(float density, int max) {
  floatability = density;
  maxSpeed = max;
  System.out.println("type 5 duck");
 }
}

public class TestDuck {
 public static void main(String[] args) {
  int weight = 8;
  float density = 2.3F;
  String name = "Donald";
  long[] feathers = {1,2,3,4,5,6};
  boolean canFly = true;
  int airspeed = 22;

  Duck[] d = new Duck[7];

  d[0] = new Duck();
  d[1] = new Duck(density,weight);
  d[2] = new Duck(name,feathers);
  d[3] = new Duck(canFly);
  d[4] = new Duck(3.3F,airspeed);
  d[5] = new Duck(false);
  d[6] = new Duck(airspeed,density);
 }
}

interface Nose {
 public int iMethod();
}

abstract class Picasso implements Nose {
 public int iMethod() {
  return 7;
 }
}

class Clowns extends Picasso { }

class Acts extends Picasso {
 public int iMethod(){
  return 5;
 }
}

public class Of76 extends Clowns {
 public static void main(String[] args) {
  Nose[] i = new Nose[3];
  i[0] = new Acts();
  i[1] = new Clowns();
  i[2] = new Of76();
  for(int x = 0 ; x < 3 ; x++) {
   System.out.println(i[x].iMethod() + " " + i[x].getClass());
  }
 }
}

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

cf. 8장 내용 정리

//p.240 - (8장 인터페이스와 추상 클래스)

public void go() {
 ArrayList al = new ArrayList();
 Dog d = new Dog();
 al.add(d);
 int indext = al.indexOf(d);
 Object o = al.get(index);
}

//p.244 - (8장 인터페이스와 추상 클래스)

Object o = al.get(index);
Dog d = (Dog) o:
d.roam();

if ( d instanceOf Dog) {
 Dog d = (Dog) o;
}

//p.252 - (8장 인터페이스와 추상 클래스)
interface - 모든 메소드를 추상 메소드로 만드는 것

public interface Pet {
 public abstract void beFriendly();
 public abstract void play();
}

public calss Dog extends Canine implements Pet {
 
 //Dog도 Pet이므로 Pet의 메소드를 반드시 구현해야 한다.
 public void beFriendly(){
  System.out.println("beFriendly()");
 }
 public void play() {
  System.out.println("play()");
 }

 // 일반적으로 오버라이드 하는 메소드
 public void roam() {
  System.out.println("roam()");

 }
 public void eat() {
  System.out.println("eat()");
 }
}

//p.254 - (8장 인터페이스와 추상 클래스)
한 클래스에서 인터페이스 여러 개를 구현할 수도 있다.

public class Dog extends Animal implements Pet, Saveable, Paintable { ... }

//p.255 - (8장 인터페이스와 추상 클래스)
한 클래스에서 인터페이스 여러 개를 구현할 수도 있다.
1. 클래스를 만들 때 인스턴스를 만들 수 없게 하고 싶다면 abstract 키워드를 사용한다.
2. 상속 트리에서 처음으로 나오는 구상 구사 클래스에서는 반드시 모든 추상 메소드를 구현해야 한다.
3. interface의 모든 메소드는 자동으로 public 메소드, abstract 메소드가 되기 때문에 interface를 구현하는 클래스에서는 interface에 들어 있는 모든 메소드를 구현해야 한다.
4. 자바 클래스에서는 부모(상위클래스)가 하나밖에 있을 수 없고 그 부모 클래스나 자식 클래스가 어떠해야 하는지를 정의하게 된다.
   그러나 interface는 여러 개를 구현할 수 있다.

//p.256 - (8장 인터페이스와 추상 클래스)
Object 클래스는 다음 함수를 같고 있다.
 equals()
 getClass()
 hashCode()
 toString()

class Boat {
 
 private int length;
 
 public void setLength(int len) {
  length = len;
 }

 public int getLength() {
  return length;
 }

 public void move() {
  System.out.print("drif ");
 }
}

class Rowboat extends Boat {
 
 public void rowTheBoat() {
  System.out.println("stroke natasha");
 }
}

class Sailboat extends Boat {
 public void move() {
  System.out.println("hoist sail ");
 }
}

public class TestBoats {
 
 public static void main(String[] args) {
  Boat b1 = new Boat();
  Sailboat b2 = new Sailboat();
  Rowboat b3  = new Rowboat();

  b2.setLength(32);
  b1.move(); 
  b3.move();
  b2.move();
 }
};

// Head First Java p.191
import java.util.*;

class ArrayList6 {
  public static void main(String[] args) {
    ArrayList<String> a = new ArrayList<String>();
    a.add(0, "zero");
    a.add(1, "one");
    a.add(2, "two");
    a.add(3, "three");
    printAL(a);
    if (a.contains("three")) {
      a.add("four");
    }
    a.remove(2);
    printAL(a);
    if (a.indexOf("four") != 4) {
      a.add(4, "4.2");
    }
    printAL(a);
    if (a.contains("two")) {
      a.add("2.2");
    }
    printAL(a);
    }
   
    public static void printAL(ArrayList<String> al) {
      for(int z = 0; z < al.size(); z++) {
        System.out.print(z + "=" + al.get(z));
        System.out.print(", ");
      }
      System.out.println(" ");
    }
}