/*내용을 복사 한 후 이클립스에서

ctrl + shift + F를 눌러주세요!!*/

//P.273 instanceof  연산자
//이놈은 뭔가 봤더니 참조변수..매개변수의 타입(?!)을 알아보기 위하여 만든 친구인것 같다.
//음.. 나름 쓸모가 있을듯 싶어서 정리 해보려고 합니다.
//형식은 : if ( 참조변수 instanceof 클래스명 ) 을 통하여 true/ false 를 반환한다고 한다.
//책의 예문은 약간 부족한것 같으니..car 클래스 작성한것을 이용해 비슷하게 한번 만들어 볼련다~~

package JavaTest;

class Car8{
 
 void drive(){
  
  System.out.println("출발~~부르릉!!");
 }
}

 
class FireEngine01 extends Car8{
 
 void water(){
  
  System.out.println("물 뿌리자!!");
 }
}

class Ambulance extends Car8{
 
 void sound(){
  
  System.out.println("삐뽀~삐뽀~");
 }
}

// 자~ 여기까지는 한번 쭉 보면 Car8 클래스를 부모로 놓고 FireEngine 과 Ambulance 클래스를 각각 상속받아서 만들었엉~

// 자! 여기서 집중!! 클래스를 하나더 만들었는데~ 바로 요기서 instanceof 를 쓸 예정이야~ 한줄 한줄  잘보셈!

class Test01{            //Test01 클래스
 
 void dowork(Car8 car){          //dowork 메서드 인데.. Car8 을 c 참조변수로 갖는 메서드 작성함!
  
  if(car instanceof FireEngine01){    //자~ 부모클래스인 car가 자식클래스 FireEngine01 로 형변환이 돼니?
                                            
   FireEngine01 fe = new FireEngine01(); //true 이면 인스턴스화 시켜서~
   fe.water();                                        //요렇게 해라~~ 라는거임..
   
  }else if(car instanceof Ambulance){        //아뉘면.. Ambulance 로 형변환이 돼니?
   Ambulance ab = new Ambulance();     //인스턴스화 시켜서~
   ab.sound();                                      //요렇게 해라~ 라는거지요...
  }
 }
 
}

public class instanceofTest {

 public static void main(String[] args) {

  
  Test01 t1 = new Test01();        //이건 Test01 을 쓸려고 인스턴스화 한거고~
  
  Car8 car = new FireEngine01();  //이건 자식클래스 FireEngine01 을 부모클래스 Car8 로 업캐스팅 했엉~
                                                //car 는 솔직히 자기 클래스 안에 있는것 밖에 못쓰는데.. 별...꼴....(-_-)ㅗ
  
  //Ambulance ab = (Ambulance)car; //이런식으로 업,다운 캐스팅은 불가해 CastingTest2 처럼 null 이 없어!
  
  t1.dowork(car);
  
  System.out.println(car instanceof Ambulance);  //부모클래스 car 는 자식클래스 Ambulance 로 형변환이 가능하니?
                                                                     //다시말해 다운캐스팅 가능하니? 당연히 안돼지.....
                                                                     //73번 줄때문에....쉬파...와...정말...
 }

}

//아...정말 할말이 없다...정말 돌아버리겠네... 이거 분석하느라 2시간 걸렸다.. 머리가 나쁜건지..ㅠ_ㅠ
//오늘 정말 캐스팅이 날 시험에 들게 한다... 그래 너죽고 나죽어라 캐스팅 한번 정복해보자!!

/*내용을 복사 한 후 이클립스에서

ctrl + shift + F를 눌러주세요!!*/

//P.272 다형성(polymorphism)/ 참조변수의 형변환 ②
// 예문 하나만 더 보고 넘어가겠숨돠~~
//머리에 팍~! 하고 들어오지 않아서..ㅋㅋ

package JavaTest;

public class CastingTest2 {

 public static void main(String[] args) {

  Car7 car = new Car7();    //인스턴스화 시키고,
  
  Car7 car2 = null;             //car2 로 null 값
  
     FireEngine fe = null;
    
     //자 여기도 집중해서 보자!
    
     car.drive();  //그렇지 가능하고,
    
     fe = (FireEngine)car2;   //null 을 가지고 있는 놈끼리.. 암튼.. 부모를 자식으로 다운캐스팅 했음!
     fe = (FireEngine)car;    //근데!!! 이놈이 문제야... 조상타입의 인스턴스는 자손타입의 인스턴스 참조로 허용이 되지 않아!!
    
     // 아...쫌 이해된다..슬슬... 밑에다가 나만의 공식처럼 써야겠어..ㅋㅋ 암튼 위에 놈은 주석처리해라~
    
     car2 = fe;  //자식을 부모로 업캐스팅!
     car2.drive(); //부모(자기) 인스턴스만 사용가능..ㅋ
  
 }

}

//앗! 정리하자 세현아~
//우선 캐스팅을 해서 쓸려면 클래스 참조형까지 쓰고 null 을 적어야해..
// Car car = null;
// Fire fe = null;
// 이렇게 하면 업캐스팅이던 다운캐스팅 이던 할 수 있어~~!
// 자식을 부모로 형변환 하면 업캐스팅 : 이때는 형변환을 생략이 가능하고,
// 부모를 자식으로 형변환 하면 다운캐스팅 : 이때는 형변환 생략 불가능, 복습삼아! 밑에
// car = fe();   정답은? ㅇㅋㅅㅌ
// fe = (FireEngine)car; 정답은? ㄷㅇㅋㅅㅌ
//오케바리! 이해했어!! 아.. 이게 눈에 쫌 숙달이 되야할터인데.ㅋㅋㅋㅋ

/*내용을 복사 한 후 이클립스에서

ctrl + shift + F를 눌러주세요!!*/

//P.265 다형성(polymorphism)/ 참조변수의 형변환
//와..이번 장은 정말로...대박이다.. 더럽게 어렵네..;;다형성은 대충이해가 가는데..
//형변환이 대박일세..ㅋㅋ
//우선 다형성 부터~ 객체지향개념의  2번째 중요사항! 조상클래스 타입의 참조변수로 자손클래스의 인스턴스를 참조할 수 있다.!
//예를 들자면... Tv t = new CaptionTv(); (Tv : 부모/ CaptionTv : 자식) 이거는 가능한데..반대는 X
//에잇! 장난하나?! ...어쨌든 이것의 확장 개념인 형변환을 예제로 보면서 익혀보자..ㅗ(-_-)ㅗ

package JavaTest;

class Car7{
 
 String color;
 int door;
 
 void drive(){
  
  System.out.println("출발~~부르릉!!");
 }
 
 void stop(){
  
  System.out.println("정지!!");
 }
}

class FireEngine extends Car7{
 
 void water(){
  
  System.out.println("물 뿌리자!!");
 }
}

//여기까지 클래스 설계~! FireEngine 은 Car7 를 상속받았다..^ 부모자식 관계는 눈에 들어오지 그럼 다음으로 넘어가자!

public class CastingTest1 {

 public static void main(String[] args) {

  //자! 여기서 부터 약간 집중해서 보자!! 많이 헷갈린다..ㅠ
  
  Car7 car = null;   // Car7 클래스를 변수 car 로 선언하고 null 값을 주었다..썅..이건 머야?! (-_-)a
  
  FireEngine fe = new FireEngine();  // FireEngine 을 인스턴스화 시켰다.. 좋아!
  
  FireEngine fe2 = null;  //얼래? FireEngine 을 변수 fe2로 선언하고 null 값...
  
  
  fe.water();       //FireEngine 클래스의 water() 메서드를 호출...
  
  car = fe;  //★★ 오늘의 하이라이트 납셨네요.. fe 그러니깐 FireEngine 인스턴스를 참조변수 car 로 업캐스팅을 했습니다.
  // 아놔~ 생긴것도 쫌 그런데....쩝~ 원래 이놈은 이렇게 생겼다네요...( car7 = (car7)fe; ) 근데 이렇게 안써도 되는 이유는
  // 자식클래스가 부모클래스로 형변환이 될때는 생략이 가능하다고 하네요..
  // ※결론 : 부모였던 car 는 자식인 FireEngine 의 인스턴스를 사용할 수 있다네...헐..이거 불가능 아닌가??? 근데 ... 더욱긴건
  // car 는 fe 의 멤버가 아닌 water() 는 사용할 수 없다네.. 아놔~ 지금 말장난하는건가...ㅠ 당연한거 아닌가..암튼 Pass~
  
  //car.water();   <-- 이렇게는 안된다 하네요.. 당연한 건데..(-_-)ㅗ
  
  fe2 = (FireEngine) car;  //★★ 두번째 하이라이트... car 인스턴스를 FireEngine 인스턴스인 fe2 로 다운 캐스팅을 했숨돠!
  // 이놈은 내가 알고 있는 형변환 형태라 쫌 친근하네그려~ㅋㅋ 근데 웃긴건 다운캐스팅은 생략이 불가능 하다는 것만 기억하면 될듯..
  // ※결론: 이놈은 car7 와 FireEngine 모두의 인스턴스를 사용이 가능하다는것.. 이것도 당연한건데..헐...
  
  fe2.water();  //Good~~
  
  
 }

}

//와..역시 대박이다..업캐스팅 다운캐스팅...알겠는데..이거..실제 코드로 보면 많이 헷갈릴듯.~~ㅠ

/*내용을 복사 한 후 이클립스에서

ctrl + shift + F를 눌러주세요!!*/

//P.371 toString 메서드,  toString()
//객체 지향 배우다~ 자주 나오고 해서... 뒤에서 배우는것이지만 미리 땡겨서 한번 보도록 할께!
//생각보다 내용은 쉽고 간단하다! ...카악~퉤~!
//예문을 보면서 살펴보자~

package JavaTest;

//전에 카드를 통해서 만든 클래스를 가져다 써보도록 하지요~

class Card7{                //여기는 설명 안합니다.ㅋ
 
 String kind;
 int number;
 
 Card7(){
  
  this("Clover",7);
 }
 
 Card7(String kind, int number){
  
  this.kind = kind;
  this.number = number;
 }
 
 /*자~ 여기가 오버라이딩!!! 밑에 먼저 읽고 올라오숑
  * 이 부분을 주석을 풀고 한번 출력해보면~ 변화를 알수 있을거얌!!(-_-)ㅗ
  * 참! 그리고 책에도 강조하던데..오버라이딩 할때는 접근제어자를 최대한 넓혀서~~OK?
  *
 public String toString(){
  
  return kind+"."+number;
 }*/
 
}

public class CardToString {

 public static void main(String[] args) {

  Card7 c1 = new Card7();
  
  System.out.println(c1);                  //출력을 두개 작성하였다.
  System.out.println(c1.toString());    //toString ??? 그래!! 바로 이놈이다.
                                                  //결과값도 똑같을거야~
  //toString 은 Object 클래스와 관계가 있다..얘기가 조금 길어 질거 같은데..그래도 들어!!!
  //현재 Card7 클래스 바로 위에~ 조상 클래스인 Object 클래스가 존재한다. toString 메서드
  //를 가지고 있는....왜? 거기에 있냐고?? Object 클래스 한번 읽어봐~ 저놈은 항상 클래스 상위에
  //에서 우리를 귀찮게 하지..ㅋㅋㅋ  현재 출력값은 문자열이 아닌 16진수 해시코드 값을 가지고 있다.
  //왜냐고?? Object 클래스에 있는 toString() 을 ★★★오버라이딩★★★ 하지 않았기 때문에...
  //정말 더러워서 못해먹겠다고?? 할수 없자나..먹고 살려면..ㅠ_ㅠ 썅~ 오버라이딩 해주자~ 
 }
}

//참 별것도 아닌 문장인데...많은 것을 생각하게 만든다.. 설명이 어렵다기 보다는 역시 실무에서 이놈을
//발견할려면 아무래도 숙달이 많이 필요하겠지?ㅋㅋㅋ 열공합시당!!!

/*내용을 복사 한 후 이클립스에서

ctrl + shift + F를 눌러주세요!!*/

//P.258~261 접근 제어자(Access modifier) / 캡슐화(encapsulation)
//다른 책에서는 맨 앞에 나왔있는데, 정석에서는 중간쯤에 나오네...암튼~~ 나왔으니 한번 더 집고 넘어가자!
//사실 public , default , private 는 자기의 영역이 확실하니 기억하기가 쉬운데...
// 이놈 protected 가 신경이 쫌 쓰인다... 이놈을 쓸일이 있을까?? 정도의 생각..
// 의미는 같은 패키지와 자손 클래스까지 허용이 된다는데.~~~ 아무래도 예문을 한번 보면서 확인이 제일 빠를듯!
// 시작합니다~~Start!!!

package JavaTest;

//시간에 관련하여 작성하겠슴돠~ 앞에서 한번 한것 같은데.ㅋ 늘 그렇듯이 클래스 생성

class Time{
 
 protected int hour;       //hour 변수만 protected 로 했어요! 밑에서 한번 콕 찝어서 한번 보구 갈려구! 기억하셈!
 private int minute;      
 private int second;       //분,초는 private 로 ~  "난 니들을 이 클래스 안에서만 쓰겠어! 딴데 갈 생각 꿈도 꾸지마랏!!"
 
 
 Time(int hour){            //한개짜리 매개변수 생성자 하나 만들었어요! protected 살펴볼려고 만든거랍니다....
  
  setHour(hour);
 }
 
 
 Time(int hour, int minute, int second){  //매개변수 3개짜리 생성자 하나 만들었어~ 왜냐고? 맨밑에서 출력할때
                                                      //시간좀 표시할때 초기값으로 써먹어야 해서..바로 앞에서 공부했자나.ㅠ
  //this.hour = hour;                 
  //this.minute = minute;                   //근데~이렇게 안쓰고 밑에 처럼 쓴건~ 시간에 대한 제약 조건을 메서드로
  //this.second = second;                   //만들려고 그런거야... 30시 머~ 막이런건 틀린거자나..그거 만들려고
  
  setHour(hour);
  setMinute(minute);                         //이렇게! 생성자 안에다가 결과물 메서드를 나열해 봤어~
  setSecond(second);
  
 }
 
 
 
 public int getHour(){               //시간값을 얻는 메서드를 만들었어
  
  return hour;
 }
 
 public void setHour(int hour){   //시간을 설정하는 매개변수를 1개 갖는 메서드 (여기서는 void 쓰는것) 조심!!!!
  
  if(hour<0 || hour>23){       //아~이거 앞에서 했었는데..열나 짜증났던..ㅋㅋ
   return ;                       //0보다 작거나 혹은 23시보다 크면(false / false)면 아무것도 돌려주지 마랏!! '0'이겠네..
  }else{
   this.hour = hour;           //하나라도 true 면 여기로~ hour 를 설정!
  }
 }
 
 public int getMinute(){
  
  return minute;
 }
 
 
 public void setMinute(int minute){
  
  if(minute<0 || minute>59){
   return;
  }else{
   this.minute = minute;
  }
 }
 
 public int getSecond(){
  
  return second;
 }
 
 public void setSecond(int second){
  
  if(second<0 || second>59){
   return;
  }else{
   this.second = second;
  }
 }
 
 ///여기까지 get, set 을 이용하여 시간,분,초를 각각 조건에 맞게 꾸민거야! 몇번 써보니 외워지네~그려~
 
 
 public String toString(){                  //넌 머니??!!! 안되겠다..요거 다음에 toString 메서드 한번 살펴볼께!
  
  return hour+":"+minute+":"+second;        //간단히 말하면 '문자열로 돌려줘라~~'
 }
 
}

class Time2 extends Time{        //자!!! 여기가 바로!!! 상속을 만들었어~ 원래는 다른 패키지에서 이런식으로 상속을
                                            //받아야 하지만~ 그냥 다른 패키지에서 상속받았다 생각하고 보면 돼!
 
 Time2(int hour) {                  
  super(hour);
 }

 void pt(){
  System.out.println(hour);    //간단히 시간만 출력~~
 }
 
}

public class TmieTest {

 public static void main(String[] args) {

  Time t = new Time(11, 30, 50);          //매개변수 3개짜리 생성자가 있어서..이렇게 인자값을 3개 써줬어~ㅋ
                                                        //시간,분,초~~ 테스트 삼아서 맨 앞 변수에 30,40 막 이렇게 넣어봐
                                                        //어디어디에 에러가 나는지 알게 될거야~ㅋ
  
  System.out.println(t.getHour()+":"+t.getMinute()+":"+t.getSecond());   //자 출력!!! 잘된다.!ㅋ
  System.out.println(t.toString());
  System.out.println(t);
  
  
  Time2 t2 = new Time2(17);       //욘석이 상속받은 메서드를 호출하는 인스턴스~
  System.out.println(t2);              //출력~~
  

//t.hour = 20;     //이녀석이 설명이 하나 나와있는데...private 는 클래스 안에서만!! 접근 허용 그러니깐
  //지금 코드에서는 메서드에서만 접근이 가능하다는 이야기~뷁! (-_-)ㅗ
 }
}

//와~ protected 는 곰곰히 생각해보면 나중에 회사 유지보수를 한다던가 할때 분석이 장난이 아닐듯 싶다..완전 기존 개발자가
// protected 를 많이 써놓았다면.................거미줄............처럼 되있을듯하다...물론.....이게 바로 자바의 3대 객체 지향의
//개념중.........캡슐화이기는 하지만...........아오~~~ 복습만이 살길인듯 싶다...내일이면 또 까먹겠지..ㅠ_ㅠ

/*내용을 복사 한 후 이클립스에서

ctrl + shift + F를 눌러주세요!!*/

//P.254 제어자,static,final
//제어자는 객체 지향형 초반에 배울때 열심히 했으니 Pass~~
//static 과 final 은 카드에 관한 예문을 통하여 콕콕! 찝어보자!

package JavaTest;

class Card6{                        //시작합니다.~~Card 클래스 하도 만들어서 Card6 로 하나 만들었습니다.Sorry~~
 
 final int number;            //시작하자 나오네요..이좌식! number 라는 인스턴스 변수를 만들었는데..앞에
 final String kind;            //final 이 붙었네요! 이놈의 특징은 : 변경될수 없는, 변수앞에 쓰이면 상수로 만드는 재주가 있음!ㅋ
                                       // 결론은 number 변수는 상수가 되었네요..긍데... number 에 대한 초기값이 없네요...
                                    // 아직 이 두친구는 값이 없는 왕따입니다. 밑에 어떤일이 일어나는지 보겠습니다.
 
 static int width = 100;    //static 은 여기서 나오네요~ '이것도 앞에서 했었는데..ㅋㅋ' static 은 인스턴스는 필요없이
 static int height = 200;   // 항상 같은 값을 갖는다..ㅋ 정도로만 알고있자! 아~ 그리고 책에보니.. 인스턴스 변수를 사용하지
                                        // 않는 메서드는 되도록이면 static 을 붙이는것을 추천하네..OK! 앞으로 그렇게 하지머~ㅋ
 
 //잠깐 짚고 넘어갈께 있는데..number, kind 두 왕따 변수가 초기값이 없을때는 초기화를 시킬수 있다고 하더군요~
   //책 내용대로라면~ 생성자를 이용하여 매개변수로부터 제공받으면 된다고 한다..(-_-)a ㅋㅋ 그래~ 나도 이해안돼! 직접 써보자!
 
 Card6(int number, String kind){     //이거야!! 이게 final 변수 초기화~~ 앗! 근데 어디서 많이 봤던거 같아!
                                             // 어이없네..그려.. 이거 생성자 할때~~
  this.number = number;           // 자기 자신의 변수값을 나타낼때 this 썼던거 그거네..ㅋㅋ 이게 또 여기서
  this.kind = kind;                    // 나타날줄이야..ㅋㅋ 암튼 ~ 기억해~~!
 }
 
 //초기화도 했겠다~ 한번 써먹어보자!
 
 Card6(){                 //매개변수 없는 생성자 만들었어~~ 바로 위 두개짜리 복사해서 써볼께!^^
  
  this(5,"heart");     //두개짜리 매개변수를 복사해서 초기값을 5와 heart 로 주었습니다.! 이게 인쟈 초기값임!
 }
 
 
 static int table(){               //아 이건 그냥 static 할때 인스턴스 변수 안쓰는 메서드는 static 붙이는것을 추천했자나~
                                     //그래서 한번 붙여서 적어봤어...심심해서..ㅋ
  return width+height;
 }
 
}

// 요기까지 클래스를 통하여 간단한 변수들을 만들었습니다.^

public class FinalCardTest {

 public static void main(String[] args) {

 
  Card6 c = new Card6();   //카드 클래스 인스턴스화 시켰엉!
  
  System.out.println(c.number+","+c.kind);  //오~ 잘나와~~
  
  System.out.println(c.width+","+c.height);  //static 도 출력해보았엉!! static 까먹진 않았겠지?!
                                                             //인스턴스 필요없이 쓸수있고, 항상 같은값을 가진다.ㅋ
 }

}

//쓰임새 정도는 쫌 잘 기억하자! 특히 static 은 습관을 들이고, final 은 종종 나오니 의미랑 초기화 시켜서 써먹는 정도 OK?!

/*내용을 복사 한 후 이클립스에서

ctrl + shift + F를 눌러주세요!!*/

//P.241~246 super,super() 조상클래스 생성자
//앞전까지 상속하고,오버라이딩 하는것까지 정리했는데..오버라이딩의 마지막 super 를 한번 보겠어~
//생각보다 내용은 쉽다! 역시 이런건 딱딱 지적하면서 정리하는게 최고당~!^
//책은 예문을 쫌 많이 쪼개 놨는데, 난 한꺼번에 적어서 이것저것 다 정리해보겠어!
//GoGo~~!!

package JavaTest;

class Point{                     //부모클래스
 
 int x, y;                      //Point 클래스에 인스턴스 변수 x,y 를 선언~
 
 Point(int x,int y){         //매개변수 2개를 갖는 생성자를 만들었음
  this.x = x;
  this.y = y;
 }
 
 String getLocation(){    //메서드도 하나 만들어줬엉~홍홍!
  return x+","+y;
 }
}

class Point3D extends Point{       //자~다음은 Point 를 상속받는 Point3D 자식클래스~~
 
 int z;                                    //z 인스턴스 변수 하나 추가해주고~
 
 Point3D(){                             //매개변수 없는 생성자를 하나 만들어 봤어~
  this(100,200,300);              //빨간줄 뜨지? 3개의 매개변수를 갖는 생성자를 호출하는거쥐~근데
 }                                          //3개짜리 생성자를 아직 만들지 않아서 빨갱이가 뜬다~~밑에 만들어보자
 
 Point3D(int x,int y,int z){
  super(x,y);                        //★★★  드디어~ 납셨다! super() 이놈은 바로 생성자 안에서 쓰이는 놈이다
  this.z = z;                         // 부모클래스에 있는 Point(int x,int y) 생성자를 상속 받아서 쓸려면 super를
 }                                          //사용해야 한다는 거지요~~(앞전에 생성자는 상속 안된다고 했엉~기억하지?
                                             // 생성자에서 상속을 받으려면 super를 사용해야한다는것 기억하자!!외워!!임뫄!(-_-)ㅗ
              
                                             //Tip : super 와 super() 는 사용용도가 엄연히 다르당! 멍충아! 맨밑에다 정리할께!
 
 String getLocation(){
  return super.getLocation()+","+z;   //★★★ 자 여기도! 부모 클래스의 메서드를 새롭게 정의하는것도
 }                                                      // super를 사용하여 명확히 구분 짖는것도 좋다는~
                                                        //밑에 주석 처리한것처럼 사용하여도 상관은 없다..같은 내용이니~
 /*String getLocation(){                        //단, 여기서는 super의 사용 용도에 대하여 정리해봤엉~
  return x+","+y+","+z;                     //문) 이렇게 **부모클래스의 메서드**를 새롭게 정의하는걸 머라고 하나요??    
 }*/                                                   //정답) 오X라X딩~~
}

public class SuperTest {

 public static void main(String[] args) {

  //그럼 잘 되는지 출력해보자!꾸낭!ㅋ
  
  Point3D p3 = new Point3D();       //인스턴스화 시키고,
  System.out.println(p3.x);             //출력!
  System.out.println(p3.y);
  System.out.println(p3.z);
  
  System.out.println(p3.getLocation());   //메서드도 잘 출력되네욤!
  
 }

}

// ① super 는 조상클래스로 부터 받은 멤버변수를 참조할때 사용하는 변수!
// ② super() 는 조상클래스의 생성자를 호출하는데 사용하는 생성자!                  까오~ 이거 !!외워!이해해!! ㅋ
// 다음주에 물어봐서 모르면 뒤짐!

/*내용을 복사 한 후 이클립스에서

ctrl + shift + F를 눌러주세요!!*/

//P.239 오버라이딩~(overriding)
//앞전에 오버로딩에 대하여 MyMath3 으로 만든것이 있었다. 똑같은 예문에 추가로
//오버라이딩에 대하여 정의 해볼께요~~~
//따라와랏!!!

package JavaTest;

//우선 클래스 정의를 합죠! 앞에서 했던거 복사했음 (-_-)v

class MyMath{
 
 int method = 0;
 
 int add(int a, int b) {           //메서드~
  return a + b;
 }

 long add(int a, long b) {      //메서드~
  return a + b;
 } 
  

 long add(long a, int b) {      //메서드~
  return a + b;
 } 
  

 long add(long a, long b) {    //메서드~
  return a + b;
 }
 
 int method(){
  
  return ++method;                       //오버라이딩 추가 설명을 위해 추가함!
 }
}

///////여기까지는 오버로딩인거 알쥐? 매개변수 값만 달리 해주는것!~~~ Pass~~~

class MyMath6 extends MyMath{      //자~ 위에 MyMath 를 상속 받아 보았습니다.
 
 //오버라이딩 시작하겠습니다. 위에 있는 첫번째 메서드를 변경하겠습니다.!
 
 int add(int a, int b){            //이거 오버라이딩이얌! 위에꺼 그대로 똑같이 써놓고 먼 말이냐고?
  return a + b;                 //상황상 왼쪽은 이렇게 써놓았지만 내용은 완전히 다르게 하는거쥐~
 }                                      // 아~ 이 예문은 아무래도 적절치 않은것으로 보인다 하나더 추가할께!
 
 int method(){                   //자 이 예문을 보면 이해가 되나?? 역시 자바의 세계는 헷갈려~~
  
  return --method;                       // (~_~)/
 }
 
}

public class MyMath4 {

 public static void main(String[] args) {

  MyMath6 mm = new MyMath6();

  System.out.println(mm.add(3, 3));
  System.out.println(mm.add(3, 3L));
  System.out.println(mm.add(3L, 3));
  System.out.println(mm.add(3L, 3L));
  System.out.println(mm.method());   //요놈이 바로 메서드 오버라이딩을 해서 나온값입뉘다!!!

 }

}

//전에 적어 놨던 예문 때문에 조금 헷갈리고 난잡해 보이지만 '오버로딩'도 기억할겸 같이 적어서 만들어 보았음!
//책의 예문은 너무 이론에만 충실해서리.. 참고하길 바래요~

/*내용을 복사 한 후 이클립스에서

ctrl + shift + F를 눌러주세요!!*/

//P.235 단일상속(single inheritance)
//결론인즉~~~ class TVCR extends TV,VCR 머 이런식으로 TV클래스와 VCR 클래스를 한꺼번에
//다중상속을 받을수 없다고 한다.. 그래 알았어..잘 기억할께! 근데!!!!!!!!!!!!!!!!!!!
//밑에 예문을 보아하니 얼래????????? 굳이 써야 한다면 다음 예문처럼도 가능은 하다는것을 보여주는듯하다.
//예문을 파헤쳐 보자!

package JavaTest;

class Tv1{         //Tv 클래스 맹글었엉~홍홍!
 
 boolean power;            //인스턴스 변수 선언~에효 지겹다..이쯤 됐으면 이제 이건 주석 처리 안해도
 int channel = 11;                  // 돼지??
 
 void power(){               //간지좀 나게 메서드 power,channelUp,channelDown 이렇게 세게 맹듬!
  power =! power;
 }
 
 void channelUp(){
  ++channel;
 }
 
 void channelDown(){
  --channel;
 }
}

class VCR{         //VCR 클래스 만듬~
 
 boolean power;           //앗! 클래스에 있는 파워랑 똑같은 놈이다..ㅋㅋ
 int channel = 12;
 int counter = 0;           //넌 뭐냐? (-_-)a
 
 void power(){
  power =! power;
 }
 
 void channelUp(){
  ++channel;
 }
 
 void play(){                 //책에 있는거 다 쓸 필요성 못느껴 한개만 쓴다.ㅋ봐주라~
 }
 
}

class TVCR1 extends Tv1{        //오~~ Tv 클래스 상속받았숨돠~~!! 잘보세용   (is-a)
 
 VCR vcr = new VCR();        //얼래?! VCR 클래스를 포함 관계로 또 받았숨돠~!    (has-a)  두개 다 이렇게 받아쓰면 된다!이거지!
 
 int channel = vcr.channel;   //Tv클래스에서 상속 받은 channel 대신에 VCR 클래스에서 포함관계로 받은
                                           //channel을 사용하겠다 라고 하네욤! 한번 진짜 그런지 main 가서 출력!
 void play(){
  vcr.play();
 }
 
 void channelUp(){
  vcr.channelUp();             //뭐~ 이런거지..위에꺼 하나 보면 전부다 보일거야!
 }                                     
 
}

public class TVCR {

 public static void main(String[] args) {

  TVCR1 tr = new TVCR1();             //우선 TVCR1 클래스 인스턴스 시키고!
  System.out.println(tr.channel);       // 역시 결과값은 포함관계를 명시해준 놈이 출력됐어...알겠지?!
  
 }

}

//뭐 ~ 나름 놓칠수 있는 부분이었기에 이렇게 한번 정리 하는거임! 잘 기억하자!!

/*내용을 복사 한 후 이클립스에서

ctrl + shift + F를 눌러주세요!!*/

//P.232 클래스 (포함관계)
//앞전은 상속을 공부했어~
//뒷장은 바로 포함관계지... 나누어 놨더군~
//예문은 쉽다~
//① 상속(inheritance) 는 '~은 ~ 이다'                 is-a 관계
//② 포함(composite) 은 '~은 ~ 을 가지고 있다'       has-a 관계
// 책을 쭉 읽어 봤으면 상속을 쓸건지 포함을 쓸건지 정도는 쉽게 알수 있을 것 같다.
//P.230쪽 예문보다는 P.232 예문이 더 길고 스릴이 넘치는 관계로 P.232 예문으로 정리해볼께!

package JavaTest;

//우선 클래스를 정의한당~ 책은 자꾸 클래스가 먼저 안나오는데..책을 때로는 무시도 해보자..ㅋㅋ

class Card{
 
 static final int kind_max = 4; // 세현이 씹탱 이거 무슨 변수냐?! 또 틀리면 죽인다!
 static final int num_max = 13; // 카드 종류 4개, 넘버는 13개 우선 이렇게 클래스 변수 선언!
 
 static final int spade = 4;
 static final int diamond = 3;
 static final int heart = 2;
 static final int clover = 1;
 
 int kind;
 int number;                        // 인스턴스 변수 각각 선언~
 
 Card(){                              // 카드 생성자 만들었엉~ 매개변수 하나도 없는...
  this(spade,1);                // 빨간줄 뜨지?! 이거 기억나면 좋을텐데.. this() 지금 매개변수가 하나도없는
 }                                      //Card() 생성자는 매개변수가 두개 있는 생성자를 복사해서 쓴다라는거 기억나지?
                                        // 코딩할때 이렇게 생각하고 쓴거얌! 밑에다가 그럼 두개짜리 만들어보자!
 
 Card(int kind,int number){     //자 여기서 매개변수 2개짜리 만들면 위에 빨갱이가 사라짐!
  this.kind = kind;               //kind 와 number를 각각 자기 자신을 표현해줌~~~
  this.number = number;
 }
 
 public String toString(){        //toString이라는 메서드 하나 만들께염~뒤에서 배울 Object 클래스-모든 클래스의 조상뉨!
  
  String kind = "";              //문자열 초기값 설정은 "" 표로 해주면 됩니당용!
  String number = "";
  
  switch(this.kind){                      //스위치문 그냥 싫어! 어저께 교수님이 문제 내줄때도 맘에 안들었음!
  case 4 : kind = "spade"; break;
  case 3 : kind = "diamond"; break;
  case 2 : kind = "heart"; break;
  case 1 : kind = "clover"; break;
  }
  
  switch(this.number){
  case 13 : number = "K"; break;
  case 12 : number = "Q"; break;
  case 11 : number = "J"; break;
  default : number = this.number + "";
  
  }
  
  return kind+","+number;      //    toString() 메서드의 리턴값을 한번 받아 보겠습니다.~~~
 }
 
}

//여기까지 Card 클래스 끝! 확실한건 책에 적혀 있는 순서대로 코딩하면 이해가 안돼..ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ

//여기서 부터는 Deck 이라는 클래스 코딩~

class Deck{   //잠깐!! 영어 공부!! deck 은 원래 '(배의)갑판',층 뭐 이런 뜻이다. 미쿡!에서는 숙어적인 의미로
                // '카드 한벌' or '카드 한통' 정도의 의미이더라~ 더럽게 난해한 단어 쓰고 X랄 이야.ㅠ
 final int card_num = 52;       //어라?! final 이 또 나타났네..이건 일단 패스~ 뒤에서 배울거임
                                         //우선은 최종값? 정도로 정리하자! 어쨌든 인스턴스 변수선언!
 
 Card c[] = new Card[card_num];    //자~ 요놈 위에 Card 클래스를 '포함관계(has-a)' 로 나타냈어!
                                                  //나름 이번 예문의 핵심이니 잘 보도록 하장! 배열은 짜증나지만...
 
 Deck(){                  //매개변수가 하나도 없는 생성자 만듬
  
  int i = 0;            // 넌 뭐니? 초기화? for 문 때문에 i 값 초기화를 해뒀음
  
  for (int k = Card.kind_max; k > 0 ; k--) {     
   for (int n = 1; n < Card.num_max+1; n++) {
    c[i++] = new Card(k,n);
   }
  }
  
  //썅~ 설명의 고비가 찾아왔다..ㅋㅋ;; 직설적 설명들어감..;; 카드 종류는 1씩 줄여라..(4,3,2,1)로..
  //카드 숫자는 1씩 증가해라.. 해당하는 값을 표현해라..와..이거 설명해주기 되게 힘드네..for 문은 이래서 짜증나.
 }
 
 Card pick(int index){    // 매개변수 한개 있는 pick 메서드 .....근데...Card가 왜 있는지 모르겠다...ㅠ_ㅠ알려줘
  
  if(index>=0 && index<card_num){
   return c[index];
  }else{
   return pick();       //매개변수 없는 pick() 메서드 호출 밑에서 또 만들어야 겠네
  }
 }
 
 Card pick(){
  
  int index = (int)Math.random()*card_num;  // 똑같이 형변환 시켜주고~
  return pick(index);            //리턴값으로 매개변수 한개있는 매서드를 호출 ..왔다갔다 하네..그려~
 }
 
 void shuffle(){    //메서드`
  
  for (int n = 0; n < 1000; n++) {
   int i = (int)(Math.random()*card_num);
   Card t = c[0];               
   c[0] = c[i];                   //이 친구들은 서로 값을 바꾸는것! 자주봤으니 설명은 pass~~!
   c[i] = t;
  }
 }
}

//여기까지 Deck 클래스 끝...Deck 클래스 정말 짜증난다.. 역시 카드는 변수가 너무 많아서 힘들어~~ㅠ

public class DeckTest {

 public static void main(String[] args) {

  //이제 신나게 한번 뽑아서 놀아봅시다!
  Deck d = new Deck();              //Deck 클래스 인스턴스~
  Card c = d.pick(0);                   //젤 위에꺼 일단 뽑아주시고~
  System.out.println(c);
  
  d.shuffle();                             //섞어 주시고~~
  c = d.pick(0);                          //또 젤 위에꺼 뽑아주시고~
  System.out.println(c);
  
 }

}

//아..코드 분석하는 중에 뛰쳐 나갈뻔했다..ㅠ_ㅠ 이 예문은 내일 또 보도록 해야지;;; 헷갈리는것도 많고....

//설명이 틀린것도 있지 않을까 싶다..;