말없제이™'

package ch07;

public class Ch0709
{
 public static void main(String[] args)
 {
  Father f= new Father();
  f.giveMoney();
  System.out.println(f.money);
 }
}

***** Farmer.java ******
package ch07;

public class Farmer //옆집에 사는 농부 ..
{
 public Father father;
 
 public Farmer()
 {
  // TODO 자동 생성된 생성자 스텁
 }
 
 public Farmer(Father father) //로컬변수 -> 멤버변수로 선언하고 대입하는 절차 걸쳐야함.
 {
  // TODO 자동 생성된 생성자 스텁
  //멤버변수에 대입(이유 : 매개변수는 로컬변수이므로 아래의 receiveMoney에서 인식못함.
  this.father = father;
 }
 
 //외부사람이 아버지돈 가져갈때.
 public void receiveMoney()
 {
  father.money -= 10000;
 }
}

**** Father.java *****
package ch07;

public /* final */ class Father //final 상속시키지 않겠다고 명시한것.
{
 //0604추가
 public int money = 50000;
 
 //Farmer에게 줄때는 계승관계가 아니니 소유..
 public void giveMoney()
 {
  Farmer farmer = new Farmer(this);
  farmer.receiveMoney();
  }
 
// 내부클래스 : 클래스안의 클래스의 형태로 본질은 외부에 클래스가 존재하는것과 다르지 않다.
// 멤버변수도 둘수 있으며, 멤버함수도 사용 가능하다.
// (다만 이너클래스가 존재하는 메인클래스에서만 사용이 가능하므로
// 모듈화 용도에는 적합하지 않다.)
//장점은 메인클래스의 멤버변수를 내것처럼 자유로이 참조하여 쓸 수 있다.
 
 public /* final */ void work()  // final 하위클래스에서 오버라이딩 허용안함.
 {
  System.out.println("아버지께서 일하셔"); //상속과 클래스 레퍼런스 관계 위해...  
 }
 
 class Uncle
 {
//  public int a; //자유롭게 쓸수 있다.
//  public void print()
//  {
//  
//  }
  public void receiveMoney()
  {
   money = money-20000;
  }
 }
 
 
}

package ch07;

public class Ch0708
{
 public static void main(String[] args)
 {
  //인터페이스 예제.. Terran.java, Zerg.java, Protoss.java 포함.
  //Unit unit = new Unit(); //안될경우 2가지 : 추상클래스거나 인터페이스
 
//  Unit marin = new Terran();
//  marin.attackUpgrade();
//  marin.print();
 
  Unit unit[] = new Unit[] {new Terran(), new Zerg(), new Protoss()};
  for(int i=0;i<unit.length;i++)
  {
   unit[i].attackUpgrade();
   unit[i].defenseUpgrade();
   unit[i].shieldUpgrade();
   unit[i].print();
  }
 }
}
**** Unit.java ******
package ch07;

public interface Unit
{
//인터페이스 : 오로지 추상메서드만 가질 수 있으며
// 멤버변수, 멤버함수는 가질 수 없다.
// 그러나 클래스처럼 계승시킬 수 있는 성격을
// 가지며 인터페이스의 계승은 클래스의 상속과
// 다르게 다중상속이 허용된다.
 
// public int attack; //안됨..
// public int defence; //안됨..
 
 //public void sayHello(){} //안됨
 //public abstract void sayHello(); //작동됨.
 
 //public void sayHello(); //abstract이 자동으로 작동되어.
 //final int a=10;
 
 //가상으로 starcraft라 생각하고.
 public void attackUpgrade();
 public void defenseUpgrade();
 public void shieldUpgrade();
 
 public void print();
}


**** Terran.java *****
package ch07;

//인터페이스의 상속은 implements를 사용한다.
public class Terran implements Unit
{
 public int attack;
 public int defense;
 
 public void attackUpgrade()
 {
  // TODO 자동 생성된 메소드 스텁
  attack+=2;
 }
 
 public void defenseUpgrade()
 {
  // TODO 자동 생성된 메소드 스텁
  defense+=1;
 }
 
 public void shieldUpgrade()
 {
  // TODO 자동 생성된 메소드 스텁
 
 }
 
 public void print()
 {
  // TODO 자동 생성된 메소드 스텁
  System.out.println("태란유닛의 공격력 : "+attack+", 방어력 : "+defense);
 }
}

***** Zerg.java ******
package ch07;

public class Zerg implements Unit
{
 
 public int attack;
 public int defense;
 //공격력 +1, 방어력 +1;
 
 public void attackUpgrade()
 {
  // TODO 자동 생성된 메소드 스텁
  attack+=1;
 }
 public void defenseUpgrade()
 {
  // TODO 자동 생성된 메소드 스텁
  defense+=1;
 }
 public void shieldUpgrade()
 {
  // TODO 자동 생성된 메소드 스텁
 
 }
 
 public void print()
 {
  // TODO 자동 생성된 메소드 스텁
  System.out.println("저그유닛의 공격력 : "+attack+", 방어력 : "+defense);
 }
}

****** Protoss.java ******
package ch07;

public class Protoss implements Unit
{
 public int attack;
 public int defense;
 public int shield;
 //공격력 +1, 방어력 +1, 쉴드 1;
 
 public void attackUpgrade() {
  // TODO 자동 생성된 메소드 스텁
  attack+=1;
 }

 public void defenseUpgrade() {
  // TODO 자동 생성된 메소드 스텁
  defense+=1;
 }

 public void shieldUpgrade() {
  // TODO 자동 생성된 메소드 스텁
  shield+=1;
 }
 
 public void print()
 {
  // TODO 자동 생성된 메소드 스텁
  System.out.println("프로토스 유닛의 공격력 : "+attack+", 방어력 : "+defense+", 쉴드 : "+shield);
 }

}

package ch07;

public class Ch0707
{
 public static void main(String[] args)
 {
//  Car car[] = new Car[3]; //인스턴스의 생성이 아니라, 배열의 선언.
//  car[0] = new RacingCar();
//  car[1] = new Truck();
//  car[2] = new Taxi();
 
  //아래 방법이 abstract..
  Car car[] = new Car[] {new RacingCar(), new Truck(), new Taxi() };
  for(int i=0;i<car.length;i++)
  {
   car[i].SpeedUp();
   car[i].print();
  } 
 }
}

package ch07;

public class Ch0706
{
 public static void main(String[] args)
 {
  // Car car = new Car(); -> X
  Car car = new RacingCar(); //하위클래스를 통한 생성가능. 왜 abstract를 통해서
  car.SpeedUp();
  car.print();
  //car.sayhello(); -> X //상위클래스에 있는 abstract만 가능.
 
 
 }
}

***** Car.java *****
package ch07;

public abstract class Car
{
// 추상클래스 : 추상메서드가 하나라도 존재하념 그것이 추상클래스이다.
// 추상클래스를 두게되었을 경우 추상클래스를 계승받는 하위클래스에서
// 선언한 추상메서드를 전부 구현해주어야한다.
// 추상메서드 : 함수의 선언만 존재하되 실체는 없는 메서드.
// 형식>public abstract 반환형 멤버변수(...);

//추상클래스는 멤버변수, 멤버함수를 정상적인 클래스처럼 가질수 있지만,
//중요한것은 직접적인 개체생성이 불가능하다.
 public int speed = 0;
 
 public abstract void SpeedUp(); //class도 바꿔줘야함.
 //인터페이스랑 차이점 : 추상클래스는 멤버변수를 가질수 있다.
 
 public void print()
 {
  System.out.println("현재속도 : "+speed);
 }
 
}

***** Taxi.java ****
package ch07;

public class Taxi extends Car
{
 public void SpeedUp()
 {
  // TODO 자동 생성된 메소드 스텁
  speed+=30;
 }
}

**** Truck.java *****
package ch07;

public class Truck extends Car
{
 public void SpeedUp()
 {
  // TODO 자동 생성된 메소드 스텁
  speed+=10;
 }
 
}

**** RacingCar.java *****
package ch07;

public class RacingCar extends Car
{
 public void SpeedUp()
 {
  // TODO 자동 생성된 메소드 스텁
  speed+=50;
 }
 
 public void sayHello()
 {
  System.out.println("sayHello()");
 }
}

package ch07;

public class Ch0705
{
 //상속과 클래스 래퍼런스의 관계 (중요) -> object -> 컬렉션 -> 제너릭
 public static void main(String[] args)
 {
  Son son = new Son();
  son.playing(); //형변환전 son에서 새로 추가된함수
 
  Father father; //인스턴스화(초기화)되지 않은..
  //★ 클래스간의 형변황 되려면 반드시 해당클래스간의 계승관계가 있어야 함.
  //1) 서로 계승관계를 가지고 있는 두개의 레퍼런스간의
  //대입실험, 상위클래스 레퍼런스에 하위클래스 래퍼런스를 대입(형변환 필요없다)
  father = son;
 
  //father.playing(); -> X : 하위클래스의 멤버변수는
  //상위클래스의 레퍼런스에서 호출이 불가능 하다.

  //2) 하위클래스의 레퍼런스에 상위클래스 레퍼런스를 대입하는 경우
  //계승관계가 있을 경우.
  //반드시 형변환을 해야 가능.
  //반대상황.. 상위클래스를 하위클래스로 넣을려고 할때..
  Son son1; //초기화되지 않은 레퍼런스 변수
  son1 = (Son)father;
  son1.playing();
 }
}

****** Father.java ******
package ch07;

public /* final */ class Father //final 상속시키지 않겠다고 명시한것.
{
 public /* final */ void work()  // final 하위클래스에서 오버라이딩 허용안함.
 {
  System.out.println("아버지께서 일하셔"); //상속과 클래스 레퍼런스 관계 위해...  
 }
}

****** Son.java ******
package ch07;

public class Son extends Father
{
 //son에서 새로 추가된 함수
 public void playing()
 {
  System.out.println("놀고먹는 거 좋아해");  
 }
 
 public static void main(String[] args)
 {
   
 }
}

package ch07;

public class Ch0704
{
 public static void main(String[] args)
 {
//  기본자료형 : boolean,int,double,float, ...
//  클래스자료형 : String,Object, 나머지 자바에서 제공하는 내장클래스 들.
 
  byte a=1;
  int b;
  //표현범위가 작은 자료형에서 큰자료형으로 변수값 넣을시
  //형변환이 필요없다.
  b=a;
 
  int c=10;
  byte d;
  //표현범위가 큰 자료형에서 자은 자료형으로 변수값 넣을시
  //형변환이 필요.
  //d=c;
  d=(byte)c;
 
  //java는 관련없는 자료형간의 형변환은 안된다.
  boolean e=true;
  int f;
  //f=(int)e;
 }
}

package ch07;

public class Ch0703 extends Father
{
//father.java에서 final.. 사용시..
//class에 사용될 경우 : 하위클래스를 가질 수 없다.
//멤버함수에 사용할 경우 : 하위클래스에서 오버라이딩 불가.
//멤버/로컬변수 사용시 : 값을 변경 허락하지 않겠다는 의미.
//(완벽하지 않은상수 : new .. new.. 같지 않음 -> 해결방법 : static붙여서사용)
 
 //public int a;
 public final int a = 100;
 
 //상수의 형태를 취하려면 아래와 같이 static을 붙이면
 //인스턴스에 관계없이 참조가능한 상수가 된다.
 public final static double pi=3.14;
 public void work()
 {
  // TODO 자동 생성된 메소드 스텁
  super.work();
  //a=100; //public final int a = 100; 로 변경되지 안음
 }
 
}

****** Father.java ******
package ch07;

public /* final */ class Father //final 상속시키지 않겠다고 명시한것.
{
 public /* final */ void work()  // final 하위클래스에서 오버라이딩 허용안함.
 {
  System.out.println("아버지께서 일하셔"); //상속과 클래스 레퍼런스 관계 위해...  
 }
}

package ch07;

public class Ch0702
{
 public static String message;
 
 //static 멤버함수에는 멤버변수에 직접 접근할수 없다.
 //그러나 static멤버변수에는 아래와 같이 접근가능함
 public static void print()
 {
  message ="Message";
  System.out.println(message);
 
  //sayHello();
  //static 멤버함수에서는 멤버함수를 호출 할 수 없다.
 }

 public void sayHello() {}
 
 public static void main(String[] args)
 {
  //static 멤버변수와 마찬가지로 클래스이름.멤버함수로 호출 가능
   Ch0702.print();
   //main 또한 같은 static 멤버함수이므로
   //위의 static 멤버함수호출을 직접 호출할수 있다.
   print();
 
  //sayHello();
 }
}

package ch07;

public class Ch0701
{
 //static으로 선언된 멤버변수는 공유해서 사용.
 public static String x;
 public static int y;
 //static 없음..  a.x => Hello a.y=10
 //static 없음..  a.c => null c.y=0
 
 //public
 
 public static void main(String[] args)
 {
//  static으로 선언ㅇ된 멤버변수나 멤버함수는
//  아래의 경우처럼 생성된 개별인스턴스개체변수에 관계없이
//  그 값을 서로 공유하는 형태가 된다.
//  (모든 자동차의 교통바송은 95.1주파수이다.)
 
//  특징: static으로 선언된 멤버변수나 멤버함수는
//  인스턴스를 생성하지 않고 클래스이름.멤버변수나
//  클래스이름.멤버함수() 형태로 직접 참조 및 호출 가능
 
  Ch0701 a = new Ch0701();
  a.x = "Hello";
  a.y = 10;
 
  Ch0701 b = new Ch0701();
  b.x = "Message";
  b.y = 100;
 
  System.out.println("x : "+a.x+", y : "+a.y);
  Ch0701 c = new Ch0701();
  System.out.println("x : "+c.x+", y : "+c.y);
  Ch0701.x = "static 놀랍지??";
  Ch0701.y = 1004;
  System.out.println("x : "+a.x+", y : "+a.y);
  System.out.println("x : "+b.x+", y : "+b.y);
  System.out.println("x : "+c.x+", y : "+c.y);
 }
}

package ch06;

import ch05.sub.*;

public class Ch0608 //extends Car
{
// this() : 현재 클래스의 생성자함수를 호출할때 사용.
// super() : 상위클래스의 생성자함수를 호출할때 사용.
 public Ch0608()
 {
  // TODO 자동 생성된 생성자 스텁
  this("hello");
  System.out.println("인자없는 생성자~");
 }
 
 public Ch0608(String s)
 {
  //this()는 생성자 오버로딩시 생성자에서
  //오버로딩된 다른 생성자를 호출 할때 사용.
  //지켜야할 규칙 : 반드시 생성자 의 첫줄에서 사용.
  //this();
  System.out.println(s);
 }
 
 public void run()
 {
  //1상황.
  //this();
 }
 
 public static void main(String[] args)
 {
  //1상황.
  //new Ch0608("Hello");
  new Ch0608();
 }
}

***** ColorCar.java ******
package ch06;

import ch05.sub.*;

public class ColorCar extends Car
{
 /*
  * 메서드 오버라이딩 : 오버로딩과 다르다
  * 계승에서 상위클래스의 멤버함수의 이름,인자의 수까지
  * 완벽히 똑같은 이름을 하위클래스에서 구현할 경우
  * 상위클래스의 멤버함수는 은닉화되어 힘을 읽어버리며,
  * 하위클래스의 멤버함수가 그 함수를 대신하게 된다.
  * (상위클래스의 멤버함수의 재정의)
  * */
 
 public ColorCar()
 {
  // TODO 자동 생성된 생성자 스텁
  //1.기존..
  //super();
  //0603수정
  super("a","b"); //이미 오버로딩되어있으므로,
  //결론 : 상위클래스의 생성자가 오버로딩되어 있어서
  //하위클래스의 생성자에서 상위클래스의 생성자중 하나를 선택하여
  //실행하고자 하는 경우에 super()는 사용된다.
 }
 
 //아래의 print는 상위클래스의 print와 이름은 같지만,
 //인자의 수가 다르므로 멤버함수의 오버로딩에 해당.
 public void print(String message)
 {
  System.out.println(message);
 }
 
 //상위클래스의 print메서드의 오버라이딩
 public void print()
 {
  // TODO 자동 생성된 메소드 스텁
  //super는 상위클래스를 가르키는 지시어이다.
  //따라서 아래와 같이 super.print()를 지정하면,
  //상위 클ㄹ래스의 print()가 호출된다.
  //super는 보통 지금처럼 오버라이딩시
  //하위에서 상위클래스의 오버라이딩된 원본 메서드를 호출할때 사용.
  super.print();
  System.out.println("Hello Color Car()");
 }
 
 public static void main(String[] args)
 {
  ColorCar colorCar = new ColorCar();
  //colorCar.print("aa");
  colorCar.print();  
 }
}