C와 동일하다

동적할당 프로그램 실행 시간중 메모리 할당

즉, Runtime(실행중)에 할당 되는 것

정적할당 프로그램 실행 전에 미리 할당 받는것

Java의 경우 static이 정적에 해당됨

컴파일 시 stack과 Data영역에 할당 되어야 할 메모리 들

즉, 지역변수 전역변수 이런애들이 다 정적에 해당 된다.

package chap7;

import java.io.IOException;
import java.nio.CharBuffer;

// 인터페이스 예제 : 허용의 의미로 사용 됨
interface Repairable{}

class Unit2{
 int hitPoint;
 final int MAX_HP;
 Unit2( int hp ){
  MAX_HP = hp;
 }
}

class GroundUnit extends Unit2{
 GroundUnit( int hp ){ super(hp); }
}

class AirUnit extends Unit2{
 AirUnit( int hp ){ super(hp); }
}

class Tank2 extends GroundUnit implements Repairable{
 Tank2(){
  super( 150 );
  hitPoint = MAX_HP;
 }
 
 public String toString(){ return "Tank"; }
}

class DropShip extends AirUnit implements Repairable{
 DropShip(){
  super( 125 );
  hitPoint = MAX_HP;
 }
 
 public String toString(){ return "DropShip"; }
}

class Marine extends GroundUnit{
 public Marine() {
  super( 40 );
  hitPoint = MAX_HP;
 }
 
 public String toString(){ return "Marine"; }
}

class SCV extends GroundUnit implements Repairable{
 SCV(){
  super( 60 );
  hitPoint = MAX_HP;
 }
 
 void repair( Repairable r ){
  if( r instanceof Unit2 ){
   Unit2 u = (Unit2)r;
   u.hitPoint = u.MAX_HP;
   System.out.println( u + "의 수리 완료");
  }
 }
 
 public String toString(){ return "SCV"; }
}

public class RepairableEx {
 public static void main(String[] args) {
  Tank2 t = new Tank2();
  DropShip d = new DropShip();
  Marine m = new Marine();
  SCV s = new SCV();
  s.repair(t);
  s.repair(d);
//  s.repair(m); // implements로 Repairable을 받지 않은 상태.
 }
}

package chap7;

interface Parseable{
 void parse( String fileName );
}

class ParserManager{
 public static Parseable getParser( String type ){
  if( type.equals("XML") )
   return new XMLParser();
  else
   return new HTMLParser();
 }
}

class XMLParser implements Parseable{
 @Override
 public void parse( String fileName ){
  System.out.println( fileName + "XML parsing !");
 }
}

class HTMLParser implements Parseable{
 @Override
 public void parse( String fileName ){
  System.out.println( fileName + "HTML parsing !");
 }
}

public class ParserEx {
 public static void main(String[] args) {
  Parseable parser = ParserManager.getParser("XML");
  parser.parse("doc.xml");
  parser = ParserManager.getParser("HTML");
  parser.parse("doc2.html");
 }
}

f = Food의 객체 이다.

넘어온 객체가 A의 객체인지, B의 객체인지 확인가능함!!

instanceof 유용할듯.

저게 아니였다면 string 비교를 해야 했을 수도.

class abc{
 int x;
 int y;
 abc(int x, int y){
  this.x = x;
  this.y = y;
 }
}

class def extends abc{
 int z;
 def(int x, int y, int z){
  super(x, y);
  this.z = z;
 }
}

abc를 상속받는 def 의 생성자 에서 3개의 매개변수를 받을때

x,y를 부모에 셋팅할 때의 생성자 모양.

부모 클래스에서 멤버 변수를 생성자로 셋팅을 했다면

상속받는 자식 클래스 에서도 부모클래스( super을 호출 해 줘야 한다. )

이클립스에서 자동 지원도 해준다 클릭클릭

-> 우클릭 -> source -> generate construct using feild ( 알트시프트s )

class Employee{
 Employee(String kubun, String name, String address, String dept) {
  super();
  this.kubun = kubun;
  this.name = name;
  this.address = address;
  this.dept = dept;
 }

 String kubun; // 직원구분
 // 생성자 제너레이트로 생성 -> source -> 제네레이트 컨스트럭트 유징 필드(알트+시프트+s)
 String name; // 이름
 String address; // 주소
 String dept; // 부서
 
 int getPay(){
  return 0;
 }

 @Override
 public String toString() { // toString도 기본 제공 -> alt+shift+s -> tostring 끝.
  return "Employee [kubun=" + kubun + ", name=" + name + ", address="
    + address + ", dept=" + dept + "]";
 }
}

// 정규직원
class formalEmployee extends Employee{
 formalEmployee(String kubun, String name, String address, String dept,
   int empNo, String position, int salary, int bonusRate) {
  super(kubun, name, address, dept);
  this.empNo = empNo;
  this.position = position;
  this.salary = salary;
  this.bonusRate = bonusRate;
 }

 int empNo;   // 직원번호
 String position; // 직급
 int salary;   // 연봉
 int bonusRate; // 보너스 지급율
 
// 정규직원의 봉급 : 연봉/12 + (연봉/12*보너스 지급율/100)이다
 @Override
 int getPay(){
  return salary/12 + (salary/12*bonusRate/100);
 }

 @Override
 public String toString() {
  return super.toString() + "formalEmployee [empNo=" + empNo + ", position=" + position
    + ", salary=" + salary + ", bonusRate=" + bonusRate + "]";
 }
}

// 비정규직
class InfomalEmployee extends Employee{
 InfomalEmployee(String kubun, String name, String address, String dept,
   Date expireDate, int kibonPay) {
  super(kubun, name, address, dept);
  this.expireDate = expireDate;
  this.kibonPay = kibonPay;
 }

 Date expireDate; // 계약만료일
 int kibonPay;  // 기본임금
 
// 비정규직원의 봉급은 기본 임금이다.
 @Override
 int getPay(){
  return kibonPay;
 }

 @Override
 public String toString() {
  return super.toString() + "InfomalEmployee [expireDate=" + expireDate + ", kibonPay="
    + kibonPay + "]";
 }
}

Math.random()*5;

-> 0,1,2,3,4 -> 이렇게 5개가 나온다.

배열을 사용 했다면 인덱스로 바로 사용 하면 되고

1,2,3,4,5 가 필요하면 + 1 을 해서 사용 하면 된다.

C++는 여러개 다중상속 가능하지만

자바는 하나만 상속 가능.

자바는 기본 default 상속으로 object 라는 클래스를 상속 받는다

그 안에 뭐 여러기능이 있겠지.

class Single{
 public int x = 100;
 static Single single = new Single();
 private Single(){} // private으로 생성자.
 public static Single getInstance(){
  return single;
 }
}

public class SingleEx {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  // Single s1 = new Single(); 오류.
  Single s1 = Single.getInstance();
  System.out.println(s1);
  
  Single s2 = Single.getInstance();
  System.out.println(s2);
  
  System.out.println(s1.x);
  System.out.println(s2.x);
  
  s1.x = 200;
  System.out.println(s1.x);
  System.out.println(s2.x);
 }
}

동일한 메모리 주소

100

100

200

200

객체는 처음 한번만 new로 생성이 된다.

그 다음 객체들은 처음 생성된 객체의 참조자를 따라 간다.

그래서, 두번 세번 객체를 만들고 값을 변경해도 그 이전의 객체들의 값도 모두 변경이 된다.

다른 패키지 및 파일에서도 동일하게 변경 된다.

C++의 개념과 살짝 다르다.

사용예가 DB커넥션 데이터들의 동기화시에 사용하면 편리하다.

여러개 만들어 두고 동일한 값을 사용 해야 할 경우 !

package Class;
import java.sql.Struct;
import java.util.*;

public class FactorialEx{
 public static void main( String[] args ){
  System.out.println( factorial(4) );
 }

 private static int factorial(int i) {
  return ( i == 0)?1:i*factorial(i-1);
 }
}