은성이의 프로그램X파일

* 상속(Inheritance) : 기존의 class에 정의된 변수나 메소드를 재사용하여 새로운 class를 만드는것(물려받는것.- 확장성이 좋아짐)
->객체간의 상속

하나의 클래스에서 똑같은 코드를 물려 받아서 사용하는것.
부모-자식 관계

* 객체지향의 장점
1. 확장성
2. 재사용성
3. 유지보수

개 : 이름, 성별, 무게, 나이 , 색, 종, 키
      짖는다(),배설한다(),먹는다(),잔다()
고양이 :  이름, 성별, 무게, 나이, 종, 색, 키
  운다(), 배설한다(), 핱힌다(), 먹는다(), 잔다()
사람 : 이름, 나이, 성별, 무게, 키, 국적, 혈액형
          잔다(), 먹는다(), 말한다(), 일한다(),

동물 :  이름, 성별, 무게, 나이, 키
           먹는다(), 배설한다(), 잔다()

* 개, 고양이, 사람은 동물이기에 공통적인 속성을 동물에게 상속받는다.

물려주는 동물 class를 부모(super)class라 하고
물려받는 개, 사람, 고양이는 자식(sub)class라 한다.

* 상속 : is a 관계
-개(서브class) is a 동물(super class)
  개는 동물이다.
- 동물이면 개다.(x)

----------동물-----------
|                         -개 --           |
|                         |        |            |
|                         -----            |
-------------------------

- 동물의 type > 개의 type
   부모 type > 자식 type

* 상속 관계 일때만 type을 부모가 자식보다 type이 크다고 할수 있다.
(다형성에서 부모type이 자식type 보다 더 크다는 것을 사용한다.)
(부모는 추상적, 자식은 구체적)

* 추상화 :  공통점을 뽑아 내는것.(공통적인 것을 뽑아내서 새로운 것을 만들어 내는것.)
(고양이와, 개에 종과, 색이 공통적으로 있지만 사람에 없기때문에 동물로 빼낼 수 없다.)

* 다중 상속 : 부모class를 여러개 갖는것.
* 단일 상속 :  부모class를 하나만 갖는것.

* 자바는 단일 상속을 지원한다. ->class간의 상속을 할 시에는 단일 상속을 지원한다. (여러개의 상속을 하기 위해서는 interface를 지원한다)

동물                                                어류
키, 나이, 성별, 이름
먹는다(), 잔다()                          헤엄친다(), 먹는다()
           ^                                                   ^
           |                                                    |
           ---------------------------
   사람
   국적, 혈액형
   생각한다(), 말한다()

* 다중상속을 하면 상속에 상속을 갖는 구조가 되어 중복되는 메소드가 생겨 오류가 생길 수 있다.
(설계시 코드가 복잡하고 못쓰는 메소드가 생길 수 있어서 자바는 다중 상속을 지원하지 않는다. )

anmal(super class)
 ^
 | (상속)
Human(sub class)

- 코드구현

public class Animal {}
public class Human extends Animal{}

[제한자]class 식별자 extends 부모class이름{ 구현 }

* 상속되어 있는 부모 class가 없으면 object class(최상위 class)가 보이진 않지만 java.lang.Object가 상속되어 있다.
public class Animal extends Object{}

*사람으로 따지면 단군할아버지다.
-Object class에는 속성은 없고 메소드만 가지고 있다. ex :  toString(){}

*
Employee(직원)
-------------
+ id : String
+ name : String
+ salary : int
-------------
+getDetails() : String

Manager(관리자)
--------------
+ id : String
+ name : String
+ salary : int                                             //id,name,dalary,getDetails()는 직원의 것을 가져다 쓴다.
+department : String
---------------
+getDetails() : String

project : day15
package : inheritance.member
class : Employee
    Manager

//MemberTest.java

package inheritance.member;

/*public class MemberTest {
 public static void main(String[] args) {
  Employee emp = new Employee();
  emp.id = "emp-111";
  emp.name = "홍길동";
  emp.salary = 10000000;
  
  String str = emp.getDetails();
  System.out.println(str);
  
  
  Manager man = new Manager();
  man.id = "man-111";
  man.name = "이순신";
  man.salary = 2000000;
  man.department = "개발부";
   str = man.getDetails();
  System.out.println(str);
 }
}
*//*
public class MemberTest {
 public static void main(String[] args) {
  Employee emp = new Employee();
  emp.setId("emp-111");
  emp.setName("홍길동");
  emp.setSalary(10000000);
  
  String str = emp.getDetails();
  System.out.println(str);
  
  
  Manager man = new Manager();
  man.setId("man-111");
  man.setName("이순신");
  man.setSalary(2000000);
  man.department = "개발부";
  str = man.getDetails();
  System.out.println(str);
 }
}
*/
public class MemberTest {
 public static void main(String[] args) {
 Manager m = new Manager("m-111","이순신",200000,"영업부");
 String str = m.getDetails();
 System.out.println(str);
 }
}

//Manager.java

package inheritance.member;

public class Manager extends Employee{
 public String department;
 
 public Manager(){}
 public Manager(String id, String name, int salary, String department){
  
//  this.id = id;
//  this.name = name;
//  this.department = department;
  
  super(id,name,salary);
  this.department = department;
  
 }
 public String getDetails(){
  return  this.getClass().getSimpleName()+"[id=" + super.getId() + ", name=" + super.getName() + ", salary=" + super.getSalary()+" department = "+department+ "]";
  
 }
}

//Employee.java

package inheritance.member;

public class Employee {
 private String id;
 private String name;
 private int salary;
 
 //생성자
 public Employee(String id, String name, int salary){
  this.id = id;
  this.name = name;
  this.salary = salary;
 }
 public Employee(){}  //습관적으로 no-argument 생성자를 만들어라
 public String getDetails() {
  return this.getClass().getSimpleName()+"[id=" + id + ", name=" + name + ", salary=" + salary+ "]";
 }
 public String getId() {
  return id;
 }
 public void setId(String id) {
  this.id = id;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public int getSalary() {
  return salary;
 }
 public void setSalary(int salary) {
  this.salary = salary;
 }
 
}

* 싱글턴 패턴

package statictest;

public class TestSingleton {

 /**
  * @param args
  */
 public static void main(String[] args) {
  SingletonClass sc1 = SingletonClass.getInstance();
  sc1.setNum(100);
  SingletonClass sc2 = SingletonClass.getInstance();
  System.out.println(sc2.getNum());
  
  SingletonClass2 sc3 = SingletonClass2.getInstance();
  sc3.setNum(200);
  SingletonClass2 sc4 = SingletonClass2.getInstance();
  System.out.println(sc4.getNum());

 }

}

----------------------------------

package statictest;
/*싱클톤 패턴
1. 생성자의 접근 제한자를 private
2. private static 변수로 자신의 타입의 변수를 선언
3. public static 메소드를 통해 2번의 static 변수에 할당된 자신 타입의 객체를 return
*/
public class SingletonClass {
 private static SingletonClass instance = new SingletonClass();
 private int num;
 private SingletonClass(){}
 public static SingletonClass getInstance(){
  return instance;
 }
 public int getNum() {
  return num;
 }
 public void setNum(int num) {
  this.num = num;
 }
 
 
}

------------------------------------

package statictest;

public class SingletonClass2 {
 private static SingletonClass2 instance;
 private int num;
 private SingletonClass2(){}
 public int getNum() {
  return num;
 }
 public void setNum(int num) {
  this.num = num;
 }
 
 //처음 요청이 들어왔을때 객체를 생성하여 객체 생성을 늦추는 방식.
 public static SingletonClass2 getInstance() {
  if(instance == null){
   instance = new SingletonClass2();
  }
  return instance;
 }
 
}

* 정적 초기화영역

class A{
 static{

}
}

1. class loading
2. static block실행
3. main()

ex :  class A{
 private static CustomerDTO c;
 static{
  c = new CDTO();
 }
}

* static 블럭 실행 시점 예제

* class
package : staictest
Name : StaticBlockTest

package statictest;

public class StaticBlockTest {
  static{
   System.out.println("static 블럭 1");
  }
  public static void main(String[] args) {
   System.out.println("메인 메소드 실행");
  }
}

----------------
실행화면
static 블럭 1
메인 메소드 실행
(메인보다 static블럭1이 먼저 실행된 것을 볼 수 있다. )
-------------------------------------------

예제2

package statictest;

public class StaticBlockTest {
  static{
   System.out.println("static 블럭 1");
  }
  static{
   System.out.println("static 블럭 2");
  }
}
-------------------------------------------------

실행 화면

static 블럭 1
static 블럭 2
java.lang.NoSuchMethodError: main
Exception in thread "main"

static블럭 찍게 되면 순서 대로 나오고 메인이 없어서 메인이 없다는 에러를 내준다.
----------------------------------------------------

* instance 변수 - 객체마다 다른 값을 가지면 사용한다.
* static 변수 - 공통적인 값, 공통코드값(PI, 비율, 세율) : 비지니스 로직이 많다.

* 싱글턴 디자인 패턴 -> 일하는 객체를 정의하는 class(우리가 했던 것 중에는 productManagerService, ProductDTO(관리하는 사람은 한 사람만 필요하다.)) ->Business Service
- 클래스를 만들때 객체를 오직 하나만 만들수 있는 class(오직 하나의 객체를 공유한다)

ex :
DTO는 값을 표현하기 위해서 만들어진 객체기 때문에 객체를 하나만 부를수는 없다.