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

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);
  
 }

}

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

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

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

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

//P.227 상속
//상속..그래 하도 많이 봐서 알겠는데..언제 써먹냐가 가장 중요한 문제지..
//간단히 줄이면 한군데만 수정할테니 니들이 가져다 써~..ㅋㅋ 뭐 이런식이겠지?
//예문으로 갑니다!

package JavaTest;

class Tv{                  //Tv 클래스 한개 만들고~

 boolean power;    // 전원 켰다 껐다..OK?
 int channel;          // 요건 채널이고~
 
 void power(){          // ①번 메서드 맹글고~ 얜 파워On/Off 메서드
  power =! power;
 }
 
 void channelUp(){    // ②번 메서드 얜 채널 올리고~
  ++channel;
 }
 
 void channelDown(){  // ③번 메서드 얜 채널 내리고~~
  --channel;
 }
 
 // 여기까지 하고 잠깐!! 나 밑에다가 이 Tv클래서 녀석 상속받는 클래스를 하나 설계할건데...
 // 책 열심히 본사람은 알거야~ 위에 메서드는 상속 된다? 안된다?  ....된다!!!
 // 잠깐 해깔리지 말자! 메서드까지는 상속되고, ..앞에서 공부한 '생성자'는 상속이 안된다.!!!^
 // 대충보고 넘어가지 말고, 외워라 임뫄~! 주입식 교육이 최고얌!
}

class CaptionTv extends Tv{      //상속 키워드 'extends'써주고.. Tv를 상속했숨돠~
 
 // Tv 클래스의 power 와 channel 은 상속됐으니 적지 않아도~~
 boolean caption;   //caption?? 뭐 자막을 키거나 끄는것 같당~ㅋ 쓸데없다~
 
 void displayCation(String text){
  if(caption==true){                      //자꾸 책은 삭제해도 된다..개념이 강해서 짜증나..난 true 를 써줬어!
   System.out.println(text);          //true 일때 출력하라 String text 값(매개변수값을~~)
  }
 }
}

public class CaptionTvTest {

 public static void main(String[] args) {

  // 클래스의 인스턴스 변수를 써먹자!
  CaptionTv ct = new CaptionTv();   //두개의 클래스중에서 Tv를 상속받은 CaptionTv클래스만 인스턴스시킴!
  
  ct.power = true;      //CaptionTv에 없는 power변수를 썼어~ 상속됐으니 지맘이겠지.ㅋ
  ct.channel = 11;       //채널도 썼어~(부모클래스(Tv클래스)에 있는놈)
  ct.channelUp();        //부모클래스에 있는 채널업! 메서드도 썼엉~
  System.out.println(ct.channel);    //Up시킨 다음 채널 값을 물어보는 거겠지?
  
  ct.caption = false;                //자식클래스(자기자신)에 있는 if 문 caption 값!~~ true 로 바꿔보셈!
  ct.displayCation("세현아 롤 그만해 죽여버릴거야!");
  
 }

}

//보다가 틀린것 있으면 말해~ 이제 생성자 시작일뿐~

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

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

//P.202 변수의 초기화
//이장을 쭉~읽으면서 생각한게..우리가 알고 있는 초기화 말고, 다른것을 쓸일이 있을까?라는 생각을 했다.
//답은...있으니깐 ...책에도 나왔겠지..ㅋㅋ하지만~ 예문빼고는 거의 쓸일은 없을것 같다.
//그래도 짚고 넘어가자.. 변수의 초기화만 이해가 안가서..'이게뭐야..'라고 생각하며..1시간동안 3~4번은
//정독한거 같다..ㅠ_ㅠ 스터디멤버들이여..열심히 해주세요..

package JavaTest;

//우선 클래스 하나 선언해주고~
class Product{
 static int count = 0;   //참 ~ 오랜만에 보는 클래스(static)변수..^^ 초기값을 0으로 선언했네요
 int serialNo;              //얜~ 인스턴스변수..얼래?초기값 없지? 앞에서 쭉~읽어본사람만 알수있다.
                                //인스턴스 변수는 자동으로 초기값을 0으로 갖게된다.
 
 {
  ++count;                       //아...바로 이아이다..{ } 괄호만 나와서 묶는게 인스턴스 초기화 블럭이란다.쩝~
  serialNo = count;            //괄호안에 내용을 보아하니 클래스변수는 1씩증가해라~ 그리고 그값을 serialNo에
 }                                      // 넣어랏!! 끝! 클래스 만 따로 초기화하는 방법이 있는데..
                                            //어?근데 이상하다..책을 본사람은 클래스 초기화는 static { } 이렇게 하는걸로
                                         //알고있을텐데... 안타깝게도.. 여기서는 클래스변수 count를 정적으로 쓰기보다는
                                            //유동적으로 쓰기 위해 저렇게 사용한것이다..understand??!!

 public Product(){
                                      //세현아 넌 왼쪽에 선언한 이것이 무엇이라고 생각하느냐? '생성자' 죠!
 }                                      //기본 생성자를 선언까지 해줬네~ 기본 생성자는 생략도 가능하다는거 알쥐?
                                           //이친구는 앞으로 저위에 있는 클래스 안에 있는 ★클래스변수는'지맘대로 쓸거고'
                                        //★인스턴스변수는 '인스턴스화'시켜서 쓸거야~~
}                                       

///////////자 ~ 여기까지 이상없으면 Pass~~~

public class ProductTest {

 public static void main(String[] args) {

  //본격적으로 변수들을 사용해보겠어!!
  
  Product p1 = new Product();
  System.out.println(p1.serialNo);         //0에서 1증가한 count를 serialNo에 넣어서 출력은 1이 나올테고
  
  Product p2 = new Product();              // <--요놈 밉상(또 인스턴스 생성했음)
  System.out.println(p2.serialNo);         //◆ 핵심은 요기!!! '인스턴스 초기화블럭'은 인스턴스를 생성할때마다
                                                       //실행이 되기 때문에 이전에 생성됐던 값에 또 1이 증가하는거임!
                                                       //이부분은 한 3분만 코드보고 생각해보렴~...난 머리가 나빠 10분걸림
  
  
  System.out.println(Product.count);    //참내~ 마지막 출력와서 클래스변수 답게 인스턴스도 생성안하고 막부르네.ㅋ
                                                      //최종 count 값을 자기맘대로 쓴다고하네~~~ 건방진..클래스변수들...
 }

}

//이상 여기까지가 '변수의 초기화' 부분이고 어차피 또 봐야하니 머리 싸매지 말고 집중해서 스피드하게 보고 지나가자!!

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

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

//클래스메서드(static 메서드) 와 인스턴스메서드

package JavaTest;

class MyMath2{
 
 long a, b;      //<--요놈 뭐게? 바로 인스턴스변수 ~~고유한 값인놈! 끝 외워~
 
 long add(){          //() 요건 멀까? 앞에서 했던건 들어간건 기억나남? 매개변수(a,b)를 위에서 선언해줘서
  return a+b;     // 사실 넣을 필요가 없지! 이런 구조가 싫다면 위에 변수 빼버리고 넣으면 끝
 }
 
 long substract(){
  return a-b;
 }
 
 long multiply(){
  return a*b;
 }
 
 long divide(){           //나누기니깐 쫌..소수점이 나올걸 고려해서..double 강츄! >_<
  return a/b;
 }
 
 ////////////////요기까지가 인스턴스 변수를 이용하여 인스턴스 메서드를 작성한거임
 
 static long add(long a, long b){                    // long a 하공 b 는 클래스변수양 따로 선언 안하고 그냥 메서드에 다해버렸네 그려..
  return a+b;
 }
 
 static long substract(long a, long b){
  return a-b;
 }                                                              //기억 났으면 좋겠어...앞전에 변수 앞에 static 붙이면 (new 어쩌구
                                                                    // 저쩌구) 안붙여도 사용할수 있다는거 기억나심?! 이아이들은 
 static long multiply(long a, long b){             // main 가서 그냥 인스턴스고 뭐고 그냥 막 써도됨..밑에서 잘보심!
  return a*b;
 }
 
 static long divide(long a, long b){
  return a/b;
 }
 
 /////////////여기는 클래스변수로 클래스 메서드를 만든부분~~
}

public class MyMathTest2 {

 public static void main(String[] args) {

  System.out.println(MyMath2.add(20L, 30L));   //봤냐?! 순서 기억하지? static변수나 static메서드나 똑같거든 둘다 불러오는 형식.....클래스명.메서드명(값들)
  System.out.println(MyMath2.substract(20L, 30L));
  System.out.println(MyMath2.multiply(20L, 30L));
  System.out.println(MyMath2.divide(20L, 30L));   //여기까지는 위에 static메서드를 인스턴스 따위도 하지 않고 마음대로 쓸수 있다는것을 보여준거임
  

  ///이제 맨위에서 했던 인스턴스변수와 인스턴스메서드를 쓸차례임...첫번째로 해야할것...기억나지?
  
  MyMath2 mm = new MyMath2();
  
  //인스턴스 메서드는 객체를 생성해야지만 호출이 가능함
  mm.a = 20L;
  mm.b = 30L;
  
  System.out.println(mm.add());
  System.out.println(mm.substract());
  System.out.println(mm.multiply());
  System.out.println(mm.divide());
  
  //System.out.println(mm.add(20L,30L));        이렇게 써도 실행은 됨..긍데 왜 이렇게 쓰면 안될까??
                                                                //인스턴스메서드는 a,b만으로도 충분히 작업이 가능하기 때문에 따로따로
                                                               //매개변수를 줄 필요가 없고,
                                                               //위에 클래스메서드는 인스턴스 변수 없이 매개변수만으로 작업을 수행하기
                                                               //때문에.. 말이 어렵다..?? 코드를 다시 봐봐
 }

}

package jungsuk;

class Card{
 String kind;
 int number;
 public static int width = 100;
 public static int height = 200;   //변수 앞에 static 을 붙이면 클래스 변수가 되며, 누구나 고정값을 가지고 사용
}

public class CardTest {

 public static void main(String[] args) {

  System.out.println(Card.width);  //인스턴스화를 안시켜도 사용이 되네~~
  System.out.println(Card.height);
  
  Card c1 = new Card();
  c1.kind = "heart";
  c1.number = 7;    //각 카드들은 값이 다 다를수 있으니 인스턴스 변수를 써주는구낭~
  
  Card c2 = new Card();
  c2.kind = "spade";
  c2.number = 8;
  
  System.out.println(c1.kind+","+c1.number+","+c1.height+","+c1.width);
  System.out.println(c2.kind+","+c2.number+","+c2.height+","+c2.width);
  
  c1.width = 300;
  c1.height = 400;
  
  System.out.println(c1.kind+","+c1.number+","+c1.height+","+c1.width);
  System.out.println(c2.kind+","+c2.number+","+c2.height+","+c2.width);  //얼래c2도 바뀌었네?ㅋ
  
  //Card.width 와 c1 ,c2는 같은 저장공간을 참조 혹은 공유를 하기때문에 항상 같은값을 같는다.
  //사실상 c1하고 c2로 각각 인스턴스화를 시켰다 뿐이지 클래스 안에 static 으로 하나의 저장 공간을 가지고 논다.
  
  
  
 }

}