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

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 으로 하나의 저장 공간을 가지고 논다.
  
  
  
 }

}

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

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

//오버로딩?! 메서드 오버로딩?!
//생각보다 쉽다..왜냐고? 진짜 별거 없거든~
//그냥 메서드에서 매개변수 -->  int add()   <--저 메서드에서 괄호안에 들어가는 매개변수만
//달리해주면 그게 오버로딩이래~ 예문을 보면 더 잘 알수 있쥐~~ㅎ
//자 ~ 달려주마! 잘 따라오숑

package JavaTest;

//우선 클래스 정의를 합죠! 앞에서 했던거 참조하장!
class MyMath3{
 int add(int a, int b){
  return a+b;
 }
 
 long add(int a, long b){                         //자~ 왼쪽 보면 메서드 add들이 여러개 있는데 이걸 오버로딩 같은 이름의
  return a+b;                                     //메서드로 처리한게 특징이라고 할 수 있지...요게 바로 오버로딩
 }                                                        //근데 원래는 메서드의 이름이 같으면 안되거든... 그럼 당연히
                                                          // 밑에서 처리할때 어떤 놈을 써줘야 할지 모르거든..그래서 자바에서는 저것들
 long add(long a, int b){                        //을 분리하는 방법으로 add 옆에 괄호 보이지 바로 매개변수의 형태만 전부
  return a+b;                                    //다르게 하면 그 형식에 맞는 놈들을 밑에서 불러다 쓸 수 있게 하는 방식인
 }                                                        //오버로딩을 만든것 같다.. 참으로 별거 아니지만 심오(?)한것 같다..ㅋㅋ
                                                           //아 참고로 리턴값은 오버로딩에는 아무런 영향을 끼치지 않는다고 열라게
 long  add(long a, long b){                     //강조하던데 참고만 하자!ㅋ
  return a+b;
 }
}

//////////자 그럼 밑에서 실제로 한번 써먹어보겠음돠~~~~!

public class OverloadingTest {

 public static void main(String[] args) {

  //클래스 안에 메서드..딱 저들을 보니 저건 '인스턴스 변수들이네...' 인스턴스를 먼저 시켜야 겠고만~~
  MyMath3 mm = new MyMath3();
  
  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));
  
 }

}

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

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만으로도 충분히 작업이 가능하기 때문에 따로따로
                                                               //매개변수를 줄 필요가 없고,
                                                               //위에 클래스메서드는 인스턴스 변수 없이 매개변수만으로 작업을 수행하기
                                                               //때문에.. 말이 어렵다..?? 코드를 다시 봐봐
 }

}

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

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

//재귀호출 (메서드가 나와서..리~~)

package JavaTest;

public class FactorialTest {

 public static void main(String[] args) {

  System.out.println(factorial(4));     //FactorialTest.factorial(4)  <--원래는 클래스 명을 앞에 써야한다는거 앞에서 했음~
 }

 private static long factorial(int n) {    //요놈은 위에서 선언해준 factorial()에 관한 메서드 click
                                                    // static 으로 선언해서 인스턴스 (new 어쩌구저쩌구) 안해도 그냥 쓸수있엉
  long result = 0;
  
 if(n==1){                                        // 조건은 factorial 원리를 간단하게 적은거고
  result = 1;
 }else{
  result = n*factorial(n-1);               //이건 앞으로 쓸수 있는 공식임 외워 주입식이야
 }
 return result;                                   //리턴 왜 썼냐고? result 어쩔거야? 그리고 메서드 앞에 void 있어?없어?
 }                                                    //당연히 써야 하는거고 리턴 factorial(4)로 보내서 출력하는거임 OK?!

}

//생성자 입니다.^^ 내용을 보아하니 '인스턴스 초기화 메서드'라고 하네..
//얼래?인스턴스 XX화?? 많이 듣던 놈인데...한번 보니..new 어쩌구 저쩌구에서 나왔던 놈이다..
//바로 '인스턴스 변수'를 사용하려면 사실 'new'를 이용하여 '인스턴스화'를 시키자너~~
//근데 글쎄.. 그동안 앞에서 썼던 클래스안에 자동으로(기본)으로 기본 생성자를 그동안 알아서 만들어 줬다네..
//예문을 보자!

package JavaTest;

class Data1{                        //Data1이라는 클래스를 하나 만들었어..그안에 int 로 value값을 만들었고..
 int value;
}

class Data2{                       //Data2라는 클래스를 하나 만들었고.. 똑같이 value를 하나 선언했어..
 int value;
 
 //Data2(){};               // ★<-- 이친구는 저 밑에서 설명할께 지금은 쌩까~!
 
 Data2(int x){                  //요놈이 바로 '생성자' ~~ 첨엔 메서드 처럼 보였는데...앞에 아무것도 없자나..void라든가
  value = x;                  // 형식이 없어서... 생성자 형식은 "클래스(){}" <--요거임 간단하네~ㅋ
 }                                   //근데 잘 봐야 하는게...Data2하고 그안에 매개변수 x라는 놈이 하나 있어...
}                                       // 매개변수 형식 하고 개수 요놈을 잘 기억해야해..

public class ConstructorTest {

 public static void main(String[] args) {

  //자 그럼~~ main에서 한번 사용해보자! 우선 클래스 안에 '인스턴스 변수'를 써먹어야 하니 인스턴스화 시키자!
  Data1 d1 = new Data1();
  //Data2 d2 = new Data2();    //<-- 썅~ 빨간줄 뜬다.....감이 오지? Data2클래스에서 생성자로 '초기화'를 어떤식으로
                                          // 시켰냐면  'int x'로 한개를 초기화해랏!!하고 시켰으면서 정작 밑에서는 () <-아무것도
                                          //없는 놈을 '인스턴스화' 시켜라 하니 빨갱이 줄이 떠버렸어.. 여기까지 이해됐으면 PASS
  
  Data2 d2 = new Data2(10);   // <--요게 바로 정답이쥐~!! int x 요값을 넣어주면 형식도 맞고 갯수도 맞고 딱이지.ㅋ  
  
                                            //★ 별표시된거 봤지? 위에거 안쓸려면 두개 똑같이 비워주면 된다는것! 에효 정신없다.ㅋ
 }

}

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

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

// 생성자를 이용한 인스턴스의 복사랍니다.
// 이건 보니깐 인스턴스의 복사보다는 클래스를 복사해서 쓰는것 같은데..
//공부를 쫌더 해보면서 이해를 해보자.. 만만치 않네..그려.ㅋ

package JavaTest;

class Car3{
 String color;                     //늘 그렇듯이 클래스잡고 매개변수 선언해주고~
 String gearType;
 int door;
 
 //메서드?ㅋ 생성자 들어갑니다.
 Car3(){                                 //매개변수가 아무것도 없는 Car 생성자
  this("white","auto",4);      //빨간줄 뜬다..아직 밑에 선언을 안해서~~ㅠ
 }
 
 Car3(String color,String gearType, int door){      //자~ 매개변수 3개짜리 앞에서 배운대로 업그레이드해서 선언
  this.color = color;
  this.gearType = gearType;
  this.door = door;
 }
 
 //생성자 하나 더 생성할껀데.. 바로 맨 처음에 있는 매개변수가 없는 Car3() 놈을 복사해서 써보겠어~이거 인스턴스복사와 관련있음
 Car3(Car3 c){            //매개변수가 들어갈 자리에 참조변수를 선언했어..참 웃기게 생겼지만 어쨋든 얘는 매개변수1개짜리임
  color = c.color;
  gearType = c.gearType;             //앞전이랑 쫌 많이 틀리다. 뒤에서 부터 해석들어가는거 기억하자!
  door = c.door;
 }
 
}

public class CarTest3 {

 public static void main(String[] args) {

  //자! 그럼 메인에서 한번 살펴보자!
  //인스턴스 생성
  Car3 c1 = new Car3();         //매개변수가 없는 생성자 인스턴스
  Car3 c2 = new Car3(c1);      //머야?? 여기있었자나 인스턴스 c1을 c2가 복사한게..이게 복사랍니다.헐..
                                       //그럼 저위에 Car3(Car3 c)는 복사가 아닌었던것이네....흠..생각생각
  
  System.out.println(c1.color+","+c1.gearType+","+c1.door);
  System.out.println(c2.color+","+c2.gearType+","+c2.door);
  // 결과 값은 똑같네...저런 방식으로 복사가 된다는것을 보여주는것 같아..결국...이것도 문법인가보다..
  //반복해서 자주 보는 수밖에..
  
  c1.door = 100;              //이건 c1의 door 만 바꿨엉~ 아래 결과를 보니..저장 공간이 다르다는것을 보여줌
  System.out.println(c1.color+","+c1.gearType+","+c1.door);
  System.out.println(c2.color+","+c2.gearType+","+c2.door);
  
 }

}

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

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

//생성자에서 다른 생성자 호출하기 this(), this
//생성자 끼리 서로 호출해서 쓰는거랍니다..굳이 그럴 필요가 있을까??싶다..한번 보기로 하지요~
//바로 예문입니다.

package JavaTest;

class Car2{
 String color;
 String gearType;
 int door;
 
 Car2(){
  this("white","Auto",4);       //헐..이게 머야..이렇게 바로 쓰면 빨간줄이..후덜덜..;; 근데 이놈은 코딩하는놈이 이런
 }                                        //생각을 하고 쓴거야.. "난 밑에다가 Car 생성자를 만들껀데..매개변수가 저렇게 3개 있는
                                          //놈을 쓸거야..그러니 3개 있는놈을 가져다 쓸거라서 this 하고 3개의 매개변수 지정한거야!"라고.
 
 Car2(String color, String gearType, int door){    //요거 앞에서 본거다.ㅋ 매개변수에 저렇게 주소값이 아닌 값을 정확히
  this.color = color;                                    //지정하면 여기서처럼 자기자신 값 color = color 다..라고 하는 불상사??
  this.gearType = gearType;                        //가 생기기 때문에..this.라고 명시를 해주는거였구나..이거 무슨 규칙같다.
  this.door = door;
 }
 
 Car2(String color){                     //넌 또 머니? 매개변수는 딸랑 하나...
  this(color,"stick",2);             //3개짜리 호출했는데..color 만큼은 자기 자신것을 쓴다고 하네..
 }
 
 
 
}

public class CarTest2 {

 public static void main(String[] args) {

  //결과를 한번 출력해보자~ 인스턴화~
  Car2 c1 = new Car2();            //매개변수가 아무것도 없는놈 하지만..3개짜리를 불러서 쓰기때문에..
  
  Car2 c2 = new Car2("black");   //이놈은 매개변수 한개짜리 생성자 인스턴스 시키네..
  
  //두개만 결과를 따지고 보면
  
  System.out.println(c1.color+","+c1.gearType+","+c1.door);
  System.out.println(c2.color+","+c2.gearType+","+c2.door);
  
  //그럼 두번째에 있는 생성자(3개짜리)도 시간되는데 한번 써먹어볼께~다이렉트로!
  
  Car2 c3 = new Car2("yellow","Auto",3);
  System.out.println(c3.color+","+c3.gearType+","+c3.door);  //괜찮네..그려~~ㅋㅋ
  
 }

}