im_joonchul.log

Design Pattern

Sun, 11 Apr 2021 08:06:49 GMT

디자인 패턴 (Design Patterns)

디자인 패턴이 어떤 것인지와 대표적으로 사용하는 패턴에 대한 사용법 정도만 정리했다.

디자인 패턴이란

자주 발생하는 문제를 쉽게 해결하기 위해 제시된 재사용 가능한 해결책
- Don't reinvent the Wheel (바퀴를 다시 발명하지 마라)
이미 해결된 방식은 해결된 방식대로 해결하고, 새롭게 맞딱드린 문제를 해결하자
소프트웨어 설계 문제를 쉽게 해결할 수 있도록 패턴화된 설계 방식
팀원들과의 소통을 위해 디자인 패턴 학습이 필요하다.
- 팀원들이 싱글톤 패턴으로 해결 해주세요 할 때 이 패턴에 대해서 알고 있어야 하겠지?

디자인 패턴의 구조

문맥(Context)
- 패턴이 적용될 수 있는 문제 상황을 기술
문제(Problem)
- 패턴이 적용되어 해결되어야 하는 여러 설계 이슈를 기술
해결(Solution)
- 문제를 해결하는 설계 구성 요소와 구성 요소 사이의 관계를 기술

디자인 패턴의 종류

Gang of four 패턴
- 생성 패턴 (Creational patterns)
  - 객체의 생성 방식에 관련된 패턴
  - Abstract Factory, Factory Method, Singleton ...
- 구조 패턴 (Structural patterns)
  - 클래스/객체를 조합한 구조를 가지는 패턴
  - Composite, Decorator ...
- 동작 패턴 (Behavioral patterns)
  - 클래스/객체 사이의 동작 분배에 관련된 패턴
  - Observer, State, Strategy, Template Method, Command ...
동시성 패턴 (Concurrency patterns)
- Scheduling, Monitor, Lock ...
아키텍처 패턴 (Architecture patterns)
- Model-View-Controller, Model-View-Presenter, Model-View-ViewModel ...
기타 패턴
- Dependency injection, Lazy loading, Mock object ...

대표적인 디자인 패턴

싱글톤 패턴

단 하나의 객체만 존재할 수 있는 클래스를 구현하는 패턴

class Singleton {
  private static Singleton instance;

  private Singleton() {}

  public static Singleton getInstance() {
      if(instance == null) {
          instance = new Singleton();
      }
      return instance;
  }
}

팩토리 패턴

구상 클래스 객체를 전담하여 생성하는 클래스를 구현하는 패턴
팩토리 메소드 패턴 (ref)

interface Shape {
    void draw();
}

class Rectangle implements Shape {
  @Override
  public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
    }
}

class Square implements Shape {
  @Override
  public void draw() {
      System.out.println("Inside Square::draw() method.");
  }
}

class Circle implements Shape {
  @Override
  public void draw() {
      System.out.println("Inside Circle::draw() method.");
  }
}

class ShapeFactory {


Shape getShape(String shapeType){
    if(shapeType == null){
      return null;
    }        
    if(shapeType.equalsIgnoreCase("CIRCLE")){
      return new Circle();

    } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
      return new Rectangle();

    } else if(shapeType.equalsIgnoreCase("SQUARE")){
      return new Square();
    }

    return null;
  }
}
class FactoryPatternDemo {
  public static void main(String[] args) {
    ShapeFactory shapeFactory = new ShapeFactory();

    Shape shape1 = shapeFactory.getShape("CIRCLE");
    shape1.draw();

    Shape shape2 = shapeFactory.getShape("RECTANGLE");

    shape2.draw();

    Shape shape3 = shapeFactory.getShape("SQUARE");

    shape3.draw();
  }
}

추상 팩토리 패턴

public interface Shape {
  void draw();
}

class RoundedRectangle implements Shape {
  @Override
  public void draw() {
      System.out.println("Inside RoundedRectangle::draw() method.");
  }
}

class RoundedSquare implements Shape {
  @Override
  public void draw() {
      System.out.println("Inside RoundedSquare::draw() method.");
  }
}

class Rectangle implements Shape {
  @Override
  public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
  }
}

abstract class AbstractFactory {
  abstract Shape getShape(String shapeType) ;
}

class ShapeFactory extends AbstractFactory {
  @Override
  public Shape getShape(String shapeType){    
      if(shapeType.equalsIgnoreCase("RECTANGLE")){
        return new Rectangle();         
      }else if(shapeType.equalsIgnoreCase("SQUARE")){
        return new Square();
      }     
      return null;
  }
}

class RoundedShapeFactory extends AbstractFactory {
  @Override
  public Shape getShape(String shapeType){    
      if(shapeType.equalsIgnoreCase("RECTANGLE")){
        return new RoundedRectangle();         
      }else if(shapeType.equalsIgnoreCase("SQUARE")){
        return new RoundedSquare();
      }     
      return null;
  }
}

class FactoryProducer {
  public static AbstractFactory getFactory(boolean rounded){   
      if(rounded){
        return new RoundedShapeFactory();         
      }else{
        return new ShapeFactory();
      }
  }
}

class AbstractFactoryPatternDemo {
  public static void main(String[] args) {
      AbstractFactory shapeFactory = FactoryProducer.getFactory(false);

      Shape shape1 = shapeFactory.getShape("RECTANGLE");
      shape1.draw();
      Shape shape2 = shapeFactory.getShape("SQUARE");
      shape2.draw();

      AbstractFactory shapeFactory1 = FactoryProducer.getFactory(true);

      Shape shape3 = shapeFactory1.getShape("RECTANGLE");
      shape3.draw();
      Shape shape4 = shapeFactory1.getShape("SQUARE");
      shape4.draw();
  }
}

데코레이터 패턴

생성자를 이용해 객체에 일정한 기능을 추가하는 패턴

interface Shape {
  void draw();
}

class Rectangle implements Shape {

  @Override
  public void draw() {
      System.out.println("Shape: Rectangle");
  }
}

class Circle implements Shape {

  @Override
  public void draw() {
      System.out.println("Shape: Circle");
  }
}

abstract class ShapeDecorator implements Shape {
  protected Shape decoratedShape;

  public ShapeDecorator(Shape decoratedShape){
      this.decoratedShape = decoratedShape;
  }

  public void draw(){
      decoratedShape.draw();
  }    
}

class RedShapeDecorator extends ShapeDecorator {

  public RedShapeDecorator(Shape decoratedShape) {
      super(decoratedShape);        
  }

  @Override
  public void draw() {
      decoratedShape.draw();           
      setRedBorder(decoratedShape);
  }

  private void setRedBorder(Shape decoratedShape){
      System.out.println("Border Color: Red");
  }
}

class DecoratorPatternDemo {
  public static void main(String[] args) {

      Shape circle = new Circle();

      Shape redCircle = new RedShapeDecorator(new Circle());

      Shape redRectangle = new RedShapeDecorator(new Rectangle());
      System.out.println("Circle with normal border");
      circle.draw();

      System.out.println("\nCircle of red border");
      redCircle.draw();

      System.out.println("\nRectangle of red border");
      redRectangle.draw();
  }
}

옵저버 패턴

Observable 객체의 변화를 Observer에서 알 수 있도록 하는 패턴

class Subject {
  private List observers = new ArrayList();
  private int state;

  public int getState() {
      return state;
  }

  public void setState(int state) {
      this.state = state;
      notifyAllObservers();
  }

  public void attach(Observer observer){
      observers.add(observer);        
  }

  public void notifyAllObservers(){
      for (Observer observer : observers) {
        observer.update();
      }
  }     
}

abstract class Observer {
  protected Subject subject;
  public abstract void update();
}

class BinaryObserver extends Observer{

  public BinaryObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
  }

  @Override
  public void update() {
      System.out.println( "Binary String: " + Integer.toBinaryString( subject.getState() ) ); 
  }
}

class OctalObserver extends Observer{

  public OctalObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
  }

  @Override
  public void update() {
    System.out.println( "Octal String: " + Integer.toOctalString( subject.getState() ) ); 
  }
}

class HexaObserver extends Observer{

  public HexaObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
  }

  @Override
  public void update() {
      System.out.println( "Hex String: " + Integer.toHexString( subject.getState() ).toUpperCase() ); 
  }
}

class ObserverPatternDemo {
  public static void main(String[] args) {
      Subject subject = new Subject();

      new HexaObserver(subject);
      new OctalObserver(subject);
      new BinaryObserver(subject);

      System.out.println("First state change: 15");    
      subject.setState(15);
      System.out.println("Second state change: 10");    
      subject.setState(10);
  }
}

인터페이스(Interface)

Sun, 11 Apr 2021 07:58:47 GMT

인터페이스란

클래스를 사용하는 방식, 접점만을 선언하는 클래스와 유사한 틀
아무런 구현이 되어 있지 않으며, 모든 메소드가 추상 메소드
이름 짓는 방법
1. interface IFOO <- class Foo 상속을 하는 자식에서 부모 방향으로 / 앞에 i로 쓴다.
2. interface Printable(형용사 형태로 많이 씀) <- Bar 사용 가능한 형용사 형태로 쓴다.

인터페이스의 특징

class가 아니고 interface 키워드를 사용한다.
- public 또는 default 접근 제어자만 사용 가능.
구현 코드가 들어가지 않아서 new(인스턴스화)될 수 없다.
생성자를 가질 수 없고, 객체 생성을 할 수 없다.
자식 객체는 참조할 수 있으나 메소드와 변수는 사용할 수 없다.
인터페이스명으로 클래스 메소드 호출이 가능하나, 자식클래스명으로 클래스 메소드 호출 불가능.
멤버 변수는 항상 public static final 이다. (생략 가능하다.)
멤버 메소드는 항상 public abstract 이며, 생략가능
(자바에서는) 클래스는 하나만 상속할 수 있으나, 인터페이스는 여러개 상속이 가능하다.
인터페이스의 상속은 implements 키워드 사용

인터페이스의 요소

상수: 선언된 모든 변수는 상수로 처리됨(static 멤버 변수는 가질 수 있지만, 인스턴스 멤버 변수는 가질 수 없다)
- 인터페이스명.클래스 멤버 변수 접근이 가능하다.
메소드 : 모든 메소드는 추상 메소드이다.
디폴트 메소드 : 기본 구현을 가지는 메소드 구현하는 클래스에서 재정의 할 수 있음(java 8)
- 만약 이미 운영중인 프로그램에 새로운 기능을 추가하려고 할 때, 추상메소드로 구현을 하면 구현한 클래스들은 강제적으로 추상메소드를 구현해야하니 구현하지 않았을 때 에러가 발생한다. 그래서 이미 운영되고 있는 시스템에서 추가 요건으로 인해 불가피하게 반영을 해야할 때 디폴트 메소드를 쓰면 효과적이다.
정적 메소드 : 인스턴스 생성과 상관없이 인터페이스 타입으로 호출하는 메소드(java 8)
private 메소드 : 인터페이스 내에서 사용하기 위해 구현한 메소드 구현하는 클래스에서 재정의 할 수 없음(java9)

인터페이스 선언과 구현

인터페이스에서 클래스로의 타입 상속

Calc calc = new CompleteCacl();

인터페이스를 구현한 클래스는 인터페이스 타입으로 변수를 선언하여 인스턴스를 생성할 수 있다.
인터페이스는 구현 코드가 없기 때문에 타입 상속이라고 한다.

또 다른 구현코드(예문)

interface IFoo{
    public static final int MEMBER_VAR = 10; //변하지 않는 상수는 대문자_ 형식으로 사용하기 때문에 여기도 사용한다.
    int MEMBER_VAR2 = 20 ; //이렇게 사용해도됨 public static final;

    public abstract void methodA(int param);
    void methodB(int param); //public abstract

}

class Foo implements IFoo{

    @Override
    public void methodA(int param) {
        System.out.println(param);
    }

    @Override
    public void methodB(int param) {
        System.out.println(param);

    }
}

인터페이스간의 상속

인터페이스 간에도 상속이 가능하데, 이 경우 extends 키워드를 사용한다. (구현하는 것이 아니라서 extends 사용)
- 클래스에서 인터페이스를 상속받는 경우에는 implements 키워드를 사용한다.
클래스간의 상속과 달리 인터페이스간의 상속은 다중 상속 가능하다.
```
interface  Walkable{
  void walk();
}
interface  Runable{
  void run();
}

interface Jumpable extends  Walkable, Runable{
  void jump();
  //  워크, 런이 다 포함되어 있음
}

class Jumper implements Jumpable{
// 3개다 구현해야함  -?
  @Override
  public void walk() {
      System.out.println("걷다");
  }

  @Override
  public void run() {
      System.out.println("달리다");
  }

  @Override
  public void jump() {
      System.out.println("뛰다");

  }
}
```
인터페이스를 활용한 다형성 구현

인터페이스의 역할은?
- 인터페이스는 클라이언트 프로그램에 어떤 메소드를 제공하는지 알려주는 명세 또는 약속이다.
- 한 객체가 어떤 인터페이스의 타입이라 함은 그 인터페이스의 메소드를 구현했다는 의미한다.
- 클라이언트 프로그램은 실제 구현 내용을 몰라도 인터페이스의 정의만 알면 그 객체를 사용할 수 있다.
- 인터페이스를 구현해 놓은 다양한 객체를 사용한다 - 다형성
- JDBC를 구현한 오라클, MSSQL라이브러리 등
ORACLE, MySQL, MsSQL 같은 DB회사들이 구현을해서 라이브러리(.jar)를 준다. 그러면 우리가 오라클로 연결해서 쿼리문을 수행 하겠다 하면 라이브러리를 import해서 라이브러리를 가져다가 커넥션을 연결을 할 때 오라클 소스를 뒤져보지 않는다 단지, 메소드들만 확인한다.(명세들만 확인을 한다.설계에서 중요하다.*)

다형성 구현 문제

고객센터에는 전화 상담을 하는 상담원들이 있습니다. 일단 고객 센터로 전화가 오면 대기열에 저장됩니다.
상담원이 지정되기 전까지 대기 상태가 됩니다. 각 전화가 상담원에게 배분되는 정책은 다음과 같이 여러 방식으로 구현될 수 있습니다.
- 상담원 순서대로 배분하기
- 대기가 짧은 상담원 먼저 배분하기
- 우선순위가 높은(숙련도가 높은) 상담원에게 먼저 배분하기
위와 같은 다양한 정책이 사용되는 경우 interface를 정의하고 다양한 정책을 구현하여 실행하세요.

구현 코드

Scheduler 인터페이스

public interface Scheduler {
  public void getNextCall();
  public void sendCallToAgent();
}

RoundRobin 클래스

public class RoundRobin implements Scheduler{
  @Override
  public void getNextCall() {
      System.out.println("상담 전화를 순서대로 대기열에서 가져옵니다.");
  }

  @Override
  public void sendCallToAgent() {
      System.out.println("다음 순서의 상담원에게 배분합니다.");
  }
}

PriorityAllocation 클래스

public class PriorityAllocation implements Scheduler{
  @Override
  public void getNextCall() {
      System.out.println("고객등급이 높은 고객의 call을 먼저 가져옵니다.");
  }

  @Override
  public void sendCallToAgent() {
      System.out.println("업무 숙련도가 높은 상담원에게 먼저 배분합니다.");
  }
}

LeastJob 클래스

public class LeastJob implements Scheduler{
  @Override
  public void getNextCall() {
      System.out.println("상담 전화를 순서대로 대기열에서 가져옵니다.");
  }

  @Override
  public void sendCallToAgent() {
      System.out.println("현재 상담업무가 없거나 상담대기가 가장 적은 상담원에게 할당합니다.");
  }
}

Test 클래스

public class SchedulerTest {
  public static void main(String[] args) throws IOException {
      System.out.println("전화 상담원 할당 방식을 선택하세요");
      System.out.println("R : 한명씩 차례대로");
      System.out.println("L : 대기가 적은 상담원 우선");
      System.out.println("P : 우선순위가 높은 고객우선 숙련도 높은 상담원");

    int ch = System.in.read(); //아스키코드 값이 입력된다.
    Scheduler scheduler = null;

    if(ch == 'R' || ch == 'r'){
        scheduler = new RoundRobin();
    }else if(ch == 'L' || ch=='l'){
        scheduler = new LeastJob();
    }else if(ch == 'P' || ch == 'p'){
        scheduler = new PriorityAllocation();
    }else{
        System.out.println("지원되지 않는 기능입니다.");
        return; // 왜 리턴을 넣지?
    /**
     * return을 사용하는 이유
     * return은 값을 반환하거나 메소드를 호출한 곳으로 되돌아갈 때 사용하는 예약어이다
     * 만약 메소드 내부에서 return값이 void일때 return을 하면 여기서 메소드를 끝내겠다는 의미
     * return을 호출하면 나머지 로직을 실행하지 않고 함수를 종료하는 의미이다.
     */
    }

    scheduler.getNextCall();
    scheduler.sendCallToAgent();
}

}

## 인터페이스와 strategy pattern

![strategypattern](https://images.velog.io/images/im_joonchul/post/626c9190-e6da-4262-a0df-ba82f3d72adc/strtegypattern.jpg)

* 인터페이스를 활용하면 다양한 정책이나 알고리즘을 프로그램의 큰 수정 없이 적용, 확장할 수 있음

## JDK 1.8 이후의 인터페이스
  * 인터페이스에도 default 메소드를 구현할 수 있다. 접근제어자는 항상 `public` 키워드를 사용해야 한다.
    * 인터페이스는 원래 메소드를 구현할 수 없었는데 1.8버전 이후에 defualt 메소드가 생기면서 메소드를 구현할 수 있게 되었다.
  * 인터페이스 철학과 맞지 않으나, 기존에 사용하던 인터페이스가 개선되어,
   모든 자식 메소드에 동일하게 구현되어야 하는 메소드가 생긴 경우에 쉽게 기능을 추가하기 위해 만들어졌다.
  * 많은 클래스들이 인터페이스를 상속하는 경우 선택적으로 오버라이드해서 사용할 수 있다.
   ````java
  interface IFoo2{
      void abstractMethod();
      default void defaultMethod(){ //디폴트 메소드
          System.out.println("default method");
      }
  }

  class FooTwo implements IFoo2{
      @Override
      public void abstractMethod() {
          System.out.println("abstract method implemented");
      }

  //    @Override // overriding not necessary 반드시 오버라이딩 해야 하는 것은 아님.
  //    public void defaultMethod() {
  //        System.out.println("overriden default method");
  //    }

  }
  //처음부터 디폴트메소드를 구현하고 시작하는 것은 철학적으로 맞지않음 원래 abstract 메소드만 있음

  class SuperFoo{ //인터페이스가 있는데 부족한 부분이 있어서 메소드를 생성해서 사용하고 있었다
      public void defaultMethod(){
          System.out.println("default method in super class");
      }
  }


  class Foo3 extends SuperFoo implements IFoo2 {

      @Override
      public void abstractMethod() {
          System.out.println("abstract metho implemented");
      }

  }

인터페이스의 static 메소드 : 클래스 메소드와 동일하게 사용 가능하다.
- 인터페이스 이름으로 호출 가능하다.
- 클래스 구현체의 이름으로도 호출 가능하다.
```
interface IFoo {
  static void staticMethod() {
      System.out.println("static method");
  }
}
```
public class Main {
```
public static void main(String[] args) {
    IFoo.staticMethod(); // static method
}
```
} ````

제네릭(Generic)

Sun, 11 Apr 2021 07:52:18 GMT

제네릭이란

타입을 파라미터화해서 컴파일시 구체적인 타입이 결정되도록 하는 것 컬렉션, 람다식(함수적 인터페이스), 스트림 ,NIO에서 널리 사용된다.
대상 객체의 타입을 입력받아서 사용하는 형식
실행시 타입에러가 나는 것보다 컴파일시에 미리 타입을 강하게 체크해서 에러를 사전에 방지할 수 있다, 타입 변환을 제거할 수 있다.
- 일부 타입을 제한할 수 있는 기능이 있음.
- 입력을 object 로 할 수 있으나, 런타임에 instanceof 로 객체를 체크해야 함.
  - 원하는 객체가 들어왔는지 계속 확인해야 한다.
제네릭을 사용할 경우 간결하게 코드 작성을 할 수 있다.
클래스를 선언할 때에는 타입이 알려지지 않으며, 타입 파라미터를 사용한다.
생성자도 갖을 수 있다, 객체 참조 가능. 인터페이스, 추상클래스 상속 가능, 프리미티브 타입 불가능.
타입의 상속시 부모와 자식클래스의 타입을 맞추어 줘야 한다. 타입 파라미터도 모두 채워 주어야 한다. 부모클래스/인터페이스의 동일한 타입 파라미터를 넘겨줄 수 있다.
static 멤버 변수, static 메소드는 타입 파라미터를 사용할 수 없다.
- static void staticMethod(T t)는 안되고 / static
  p staticMethod(P p) 는 가능하다.
- static 메소드도 사용이 가능하다. 다만, 클래스와 static 메소드의 타입 파라미터를 갖게 하면 안된다.
- 왜냐하면, static은 객체가 생성되기 전에 메모리에 할당되는데 메모리에 할당되려면 타입이 있어야 하고,
- 타입 파라미터는 객체를 생성할 때 값이 넘어오기 때문에
new 키워드를 사용하여 객체를 참조할 수 없다.
instanceof의 피연산자로 사용할 수 없다.

제네릭 타입을 사용할 경우의 효과

비 제네릭을 사용할 경우 Object 타입을 사용하므로 빈번한 타입 변환생성 -> 성능 저하
제네릭을 사용할 경우 클래스를 선언할 때 타입 파라미터를 기술한다. 컴파일시 타입 파라미터가 구체적인 클래스로 변경된다. 유연하게 타입을 선언하여 처리할 수 있다.

제네릭 클래스

제네릭 타입

제네릭 타입이란 타입을 파라미터로 가지는 클래스와 인터페이스를 말한다. 타입을 파라미터로 가진다 -> 선언시 클래스 또는 인터페이스 이름 뒤에 <> 부호가 붙는다.
- 타입 파라미터 - 개발코드(실행하는 곳)에서는 타입 파라미터 자리에 구체적인 타입을 지정해야 한다.
클래스와 인터페이스에 제네릭이 적용된 타입

클래스를 선언할 때에 타입이 알려지지 않으며, 타입 파라미터를 사용.

//일반 클래스
class Foo{

}

// 제네릭 클래스
// 클래스를 선언할 때에는 설정되지 않은 타입이 있으며, 이것을 타입 파라미터로 표현한다.
class GenericFoo { // T: 타입 파라미터
    String name;
    T memberVar; // T를 자료형으로 사용.

    public GenericFoo(String name, T memberVar) {
        //생성자 생성 어떤 타입의 자료형이 들어오는지 모르는데 구현 가능.
        this.name = name;
        this.memberVar = memberVar;
    }
}
//제네릭 인터페이스
interface GenericInterface{ //인터페이스도 제네릭이 가능

}
class HashMap{ // 여러 개의 타입 파라미터로 쓸 수 있다.

}

제네릭 타입은 실제로 사용될 때 타입 파라미터에 자료형을 입력받는다.

GenericFoo foo = new GenericFoo("name","var");
 //**생성할 때 자료형을 정해주게 되어 있음.**
 // <>안에 스트링으로 넣어줬기 때문에 T도 스트링으로 된다.

GenericFoo foo1 = new GenericFoo<>("name","var");//뒤에 <>생략가능

주의 해야할 문법들

메소드의 중괄호 {} 안에서 타입 파라미터 변수로 사용 가능한 것은 상위 타입의 멤버(필드,메소드)로 제한된다.
하위 타입에만 있는 필드와 메소드는 사용할 수 없다.
static은 객체가 생성 전에 자료형이 결정되어야 하는데,

class GenericBar의 타입 파라미터와 static 변수, 메소드는 같은 타입 파라미터를 갖고 있기 때문에 안됨!

class  GenericBar{

 // 제네릭은 객체를 생성할때 자료형을 입력받기 때문에
 // 스태틱은 객체 생성 전에 자료형이 결정되어야 하기때문에 
 // 클래스에 속하기 때문에 T를 사용하면 자료형 알 수 없음.
 // static은 클래스에 속하기 때문에 애초에 T가 쓸수 없음 문법적 문제

 static T classVar; 
 // 안된다.. 클래스의 스테틱변수는 객체와 관계없이 클래스에 속해있기 때문에
 // 스태틱 변수가 생겨야하는 생성시점에는 T 자료형이 없기 때문에
 static void method(T var){} //이것도 마찬가지로 불가능.

문법적으로 문제가 없을 것 같으나, 안정성 문제로 금지. 암기해야 하는 됨!
instanceof의 피연산자로 사용할 수 없다.

new 키워드를 사용하여 객체 생성을 할 수 없다.

// T memberVar = new T(); t는 new 키워드를 쓸 수 없음. 안정성 문제 때문에 불가능하다.
// T라는 자료형이 결정되지 않기때문에 생성자가 어떻게 정의될지 모르기 때문에 불가능 자바에서 막혀있음.
// 타입파라미터의 객체를 생성하는 것은 불가능 하다.
 {
     Object obj = new Object();
     if(obj instanceof T){ 
// 어떤 객체가 있을 때 T에 속하는지 확인하기 불가능. 안정성 문제 때문에 그냥 막혀있음.

  }
}

제네릭 타입의 상속

부모 클래스 또는 인터페이스에 선언한 타입 파라미터는 반드시 자식에서도 선언해야 된다.
자식 클래스에서 추가적인 타입 파라미터를 선언할 수 있다.

부모 클래스와 인터페이스의 타입 파라미터가 같을 경우 상속받는 클래스에서 다르게 넣어주면 된다.

class Product {
 private T kind;
 private M model;

 public T getKind() {
     return kind;
 }
 public void setKind(T kind) {
     this.kind = kind;
 }
 public M getModel() {
     return model;
 }
 public void setModel(M model) {
     this.model = model;
 }
}
class Tv{
}
class ChildProduct extends Product{
 private C company;

 public C getCompany() {
     return company;
 }

 public void setCompany(C company) {
     this.company = company;
 }
}
public class ChildProductAndStorageExam {

 public static void main(String[] args) {
     ChildProduct childProduct = new ChildProduct();
     childProduct.setKind(new Tv());
     childProduct.setModel("스마트티비");
     childProduct.setCompany("삼성");
 }
}

파라미터 타입의 제한

extends를 이용하여 파라미터 타입을 제한할 수 있다.
- 인터페이스의 경우에도 extends 키워드를 사용한다.
- 클래스와 인터페이스를 동시에 제약하려면 &로 연결한다.

제한한 자료형의 자식 클래스는 모두 사용할 수 있다.

//타입 제한을 하지 않으면 extends object와 동일하다.
class GenericNoTypeLimit{
}

//extends를 이용해서 부모클래스를 제한 할 수 있음, 추상클래스를 상속하면서 인터페이스를 추가로 구현할 수 있음 
// 추상클래스+인터페이스를 구현해야한다
class GenericTypeLimitation{

}

제네릭 메소드

매개변수 타입과 리턴타입으로 타입 파라미터를 갖는 메소드를 말한다. 실제 메소드를 호출할 때 매개변수와 리턴 타입을 지정해서 사용한다.

메소드에 선언된 제네릭

메소드의 리턴 타입 앞에 타입 파라미터 변수를 선언하여 사용

public <타입파라미터,...> 리턴타입 메소드명 (매개변수){ ... }

class GenericMethod{
  public  T method(T x){
  // 여기서  는 제네릭 타입으로 선언을 하겠다라는 의미이다.
      return x;
  }
}

메소드에 선언된 제네릭은 정적 메서드에도 사용 가능.

class GenericMethod {
public static void method(T t) { // Error
  ...
}

public static  P method (P p) { // Possible
  ...
}
}

제네릭 메소드를 호출하는 두가지 방법

리턴타입 변수 = <구체적인 타입> 메소드명(매개값);

리턴타입 변수 = 메소드명(매개값); // 주로 이방법을 더 많이 사용한다.

class Box {
  private T t;
  public void set(T t) {
      this.t = t;
  }
  public T get() {
      return t;
  }
}

class Util { public static Box boxing(T t){ Box box = new Box(); box.set(t); return box; } }

public class BoxingMethodExam {

public static void main(String[] args) {
    Box box = Util.boxing(123);
    Box box2 = Util.boxing("홍길동");

    System.out.println(box.get());
    System.out.println(box2.get());
}

}

### 와일드 카드
  * 이미 선언되어 있는 제네릭 타입을 매개변수나 리턴타입으로 사용할 때 타입 파라미터를 제한할 목적
      * 비교  는 제네릭 타입과 제네릭 메소드를 선언할 때 제한한다.
  * 와일드카드 ?는 메소드의 입력 타입에 제네릭이 쓰일 경우, 제네릭의 타입 변수를 제한할 수 있다.
  * `` => ``와 동일
  * `` => 와일드카드의 상한을 제한
  * `` => 와일드카드의 하한을 제한
 ````java
 // 와일드카드
class Person {
    private String name;
    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {

        return name;
    }
}
class Worker extends Person {

    public Worker(String name) {
        super(name);
    }
}
class Student extends Person{

    public Student(String name) {
        super(name);
    }
}
class HighStudent extends Student{

    public HighStudent(String name) {
        super(name);
    }
}
public class Course {
    private String name;
    private T[] students;

    public Course(String name, int capacity) {
        this.name = name;
        students = (T[])new Object[capacity];
        // T타입으로 new 로 생성을 못하니깐 오브젝트로 만든다음
        // 타입 변환을 해야 한다.
    }

    public String getName() {
        return name;
    }
    public T[] getStudents() {
        return students;
    }

    public void add(T t) {
        for(int i=0; i

`출력`


package sec02.exam06_generic_wildCard;

import java.util.Arrays;

public class WildCardExam {
    public static void registerCourse(Course course) {
        System.out.println(course.getName()+"수강생 : "+Arrays.toString(course.getStudents()));
    }
    // Student, HightStudent 클래스 타입만 가능, 상한을 제한한다
    public static void registerCourseStudent(Course course) {
        System.out.println(course.getName()+"수강생 : "+Arrays.toString(course.getStudents()));
    }

    // Person, Worker 클래스 타입만 가능, 하한을 제한한다.
    public static void registerCourseWorker(Course course) {
        System.out.println(course.getName()+"수강생 : "+Arrays.toString(course.getStudents()));
      }

    public static void main(String[] args) {
        Course personCourse = new Course("일반인 과정",5);
        personCourse.add(new Person("일반인"));
        personCourse.add(new Person("직장인"));
        personCourse.add(new Person("학생"));
        personCourse.add(new Person("고등학생"));

        Course workerCourse = new Course("직장인 과정",5);
        workerCourse.add(new Worker("직장인"));

        Course studentCourse = new Course("학생 과정",5);
        studentCourse.add(new Student("학생"));
        studentCourse.add(new HighStudent("고등학생"));


        Course highStudentCourse = new Course("고등학생 과정",5);
//        highStudentCourse.add(new Student("일반인")); //error
        highStudentCourse.add(new HighStudent("직장인"));

        registerCourse(personCourse); // 일반인 과정수강생 : [일반인, 직장인, 학생, 고등학생, null]
        registerCourse(workerCourse); // 직장인 과정수강생 : [직장인, null, null, null, null]
        registerCourse(studentCourse); // 학생 과정수강생 : [학생, 고등학생, null, null, null]
        registerCourse(highStudentCourse); // 고등학생 과정수강생 : [직장인, null, null, null, null]


        //registerCourseStudent(personCourse); error
        //registerCourseStudent(workerCourse); error
        registerCourseStudent(studentCourse); // 학생 과정수강생 : [학생, 고등학생, null, null, null]
        registerCourseStudent(highStudentCourse); // 고등학생 과정수강생 : [직장인, null, null, null, null]


        registerCourseWorker(personCourse); // 일반인 과정수강생 : [일반인, 직장인, 학생, 고등학생, null]
        registerCourseWorker(workerCourse); // 직장인 과정수강생 : [직장인, null, null, null, null]
        //registerCourseWorker(studentCourse); error
        //registerCourseWorker(highStudentCourse); error
    }
}

동적 바인딩

메소드가 생길 때 자료형이랑 정의되어 있어서 기계가 동작하게 만들어지게 정상적인데, 자료형이 정해져있지 않아서 들어오는거에 따라 동작이 달라짐.
실제로 런타임이 되지 않으면 컴파일 타임이 알 수 없음.( 컴파일 타임에는 동작이 완전히 정의가 되지 않음)



열거형(Enumeration)
Sun, 11 Apr 2021 07:40:28 GMT
열거형이란

반드시 하나의 값만 가지게 될 변수들을 모아놓은 요일, 직업등 정해진 값 외에 바뀌지 않는 것들의 집합을 말한다. 이런 것들을 열거해서 한꺼번에 묶어 놓은 형태를 열거형이라 한다.
enum 키워드로 표현하고, '이넘' 이라고 부른다.
내부적인 구현은 enum -> java.lang.Enum 클래스를 상속 하는 것
이미 상속하는 클래스(java.lang.Enum)가 있기 때문에 enum은 다른 클래스를 상속하지 못한다. 

열거형의 특징

열거형으로 선언된 순서에 따라 0부터 index 값을 가진다.(순차적으로 증가)
접근 제한자는 public과 default만 사용 가능하다.
열거형은 다른 클래스를 상속하지 못하지만, 인터페이스 구현은 가능하다.
클래스 변수와 마찬가지로 바로 사용이 가능하다.
열거형 타입에는 열거형 상수와 null 값 할당 가능.
일종의 클래스 자료형으로 쓸 수 있고, 열거형 상수도 객체로 사용 가능하다.
생성자가 있을 수 있는데 앞에 private만 쓸 수 있고 생략 가능하다.
생성자는 값을 입력 받게 되어 있는데, 만들 때 각 객체에 값을 넣어줘야 한다.

열거형의 구현

일반적인 구현
// 클래스의 일종 자료형으로 쓰일 수 있음.
enum Job{
//실제 값은 0인데 자바에서는 숫자 개념으로 사용하지 말라는 것이 권고이다. 각 상수는 0부터 숫자를 가지지만, 
// 심볼로만 사용하고 숫자는 사용하지 않음.

  STUDENT, MARKETING, DEVELOPER, CEO, CHIEF_EXECUTIONAL_OFFICER 
  // 열거형 상수 대문자 단어 구문은 _ 로 표현
}
public class Enumeration {
public static void main(String[] args) {
    Job job = Job.CHIEF_EXECUTIONAL_OFFICER; // 클래스 변수와 유사하게 사용

    if(job == Job.CHIEF_EXECUTIONAL_OFFICER){
        System.out.println("사장님 안녕하세요?");
    }

    char c = 'A';
    switch (c){
        case 'A':
            break;
        case 'B':
            break;
        case 'C':
            break;
        default:
            break;
    }

    switch (job){ // switch ~ case 문에는 열거형 자료형을 생략, 열거형 상수만 사용
        case STUDENT:
            System.out.println("you will be a great one");
            break;
        case MARKETING:
            System.out.println("you sells");
            break;
        case DEVELOPER:
            System.out.println("you make things");
            break;
        case CHIEF_EXECUTIONAL_OFFICER:
            System.out.println("you choose");
            break;
        default:
            System.out.println("who are you?");
    }

}
}

클래스 내부에서 열거형 구현
class Foo{
 enum Symbol{
     ONE,TWO,THREE;
 }
}
public class Enumeration {
public static void main(String[] args) {
    System.out.println(Foo.Symbol.ONE); 
    // 이넘이 그대로 출력됨 결과값 : ONE; 출력을하면 자동으로 toString()으로 변환되서 스트링으로 출력됨.
    // 숫자로서 사용되는게 굉장히 제한됨. 최대한 막혀 있음
}
}

열거형에 메소드 구현
enum Symbol{
ONE,TWO,THREE,FOUR;
public Symbol nextSymbol(){
   if(this.equals(ONE)){ // 클래스 멤버변수와 마찬가지로 바로 사용 가능
       //각자가 객체로 사용됨
       return TWO;
   }else if(this.equals(TWO)){
       return THREE;
   }else if(this.equals(THREE)){
       return FOUR;
   }else{
       return ONE;
   }
}
}
public class Enumeration {
public static void main(String[] args) {
   Symbol sym = Symbol.ONE; //애는 객체
   Symbol nextSym = sym.nextSymbol(); 
   // 객체는 메소드를 실행할 수 있어서 사용가능 열거형 상수는 객체이다.
   // 그래서 메소드를 실행할 수 있다.
   System.out.println(nextSym); //TWO
   nextSym = nextSym.nextSymbol();
   System.out.println(nextSym); //THREE
}
}





열거형에 생성자를 이용한 enum 초기화

열거형의 생성자는 항상 private이며 생략 가능
enum Family{
FATHER("아버지"), MATHER("어머니"), SON("아들"), DAUGHTER("딸"); 
//열거형 상수(객체)
// 여기서 객체가 생성되는 것임. 처음 한번만 생성되는 거임

private String koreanWord; // 멤버변수(객체에 속하는 변수)

public String getKoreanWord() {
    return koreanWord;
}

public void setKoreanWord(String koreanWord) {
    this.koreanWord = koreanWord;
}

//private는 생략 가능 public 안됨 강제 private  / 안에서 생성되기 때문에
//객체의 생성자는 string을 입력받게 되어있는데 만들때 각 객체에 값을 넣어줘야한다. FATHER("아버지")
// 생성자를 사용해서 ("아버지")처럼 ""안에 값을 변경할 수 있다.
private Family(String koreanWord){
    this.koreanWord = koreanWord;
}
}
public class Enumeration {
public static void main(String[] args) {
    Family fam = Family.SON;
   System.out.println(fam.getKoreanWord());
   fam.setKoreanWord("버린 자식");
   System.out.println(fam.getKoreanWord());
   System.out.println(Family.SON.getKoreanWord());
}
}







추상클래스(Abstract class)
Sun, 11 Apr 2021 07:32:02 GMT
추상 클래스란

일부 메소드가 구현되지 않고, 선언만 되어있는 클래스
자식 클래스에서 이것을 반드시 구현하게끔 강제하는 것
필요한 모든 클래스가 구현될 수 있도록 하여 안정성을 높이는 효과를 가져온다.


일반 클래스의 공통적인 부분을 추출해 어느정도 규격(틀)을 잡아 놓는 추상적인 클래스이다.
일반 클래스는 실제 객체를 생성할 정도의 구체성을 가지는 반면, 추상클래스는 아직 메서드와 내용이 추상적이기 때문에
객체를 생성할 수 없다.


추상클래스 특징

메소드와 클래스에 abstract 예약어를 사용한다.
추상클래스는 new(인스턴스화) 할 수 없다.
추상메소드가 없어도 abstract 키워드를 사용하면 추상클래스가 된다
생성자를 가질 수 있고, 일반 메소드도 가질 수 있다. 
생성자를 갖지만, 객체 생성이 불가능하다. 그런데 구현된 자식클래스의 객체는 받을 수 있다.
추상클래스의 변수를 초기화 할 수 있다.(자동 초기화도 된다.)
공통적으로 사용할 수 있는 필드와 메서드를 공통적으로 추출해 만들어진 클래스이다.
구현해야하는 메소드들은 상위 클래스에서 선언을 해놓고,구현의 책임을 하위클래스에 위임한다.
하나의 추상메소드라도 포함을 하면 추상 클래스가 되야 한다.
모든 메소드가 구현되있다고 해도 클래스에 abstract 키워드를 사용하면 추상 클래스가 된다.


자기 자신의 객체를 생성하지 못하는 거 외에는 일반클래스와 비슷하다.
인터페이스와의 차이점은 멤버 변수를 갖고 있느냐 없느냐의 차이.

추상클래스 사용하기

추상클래스는 단독으로 사용되는 것이 아니라 상위 클래스로서 사용된다.

추상 메소드는 하위 클래스가 구현해야하는 메소드이다.
구현된 메소드는 하위 클래스가 공통으로 사용하는 기능의 메소드
하위 클래스에 따라 재정의할 수 있다.


추상메소드는 하위클래스에서 강제적으로 구현을 해야하지만, 
구현된메소드(일반메소드)들은 하위 클래스에 따라 재정의할 수도 있고, 안해도 상관이 없다.


추상클래스의 사용 용도

공통된 필드와 메소드를 통일할 목적으로 사용한다.

추상클래스에서 미리 필드와 메서드를 정의해 놓는다면, 실체클래스(일반클래스)에서는
추상클래스의 필드와 메소드명을 변경할 수 없고 그대로 받아 사용해야 구현해야 한다.
따라서 필드와 메소드의 이름을 통일시켜주고 유지보수성을 높일 수 있다.


실체클래스 구현시, 시간 절약이 가능하다.

필드와 메소드를 정의해 놓은 추상클래스가 있다면, 예를 들어 자동차를 구현해야 할 때
추상클래스를 기반으로 필요한 부분은 추가해서 클래스를 구현할 수 있다.
(없다면 결국 내가 추상클래스를 구현해야 하는 것이 아니냐 하면 이미 회사에 이런 것들을 구현하는
아키텍쳐들이 설계를 해놓았을 것이다.)


규격에 맞는 실체 클래스 구현

추상클래스에서 사용해야 할 필드와 메소드들을 정의해 놓으니, 이것을 토대로 코드를 작성할 때,
통일성 있는 규격 안에서 실체 클래스를 구현할 수 있기 때문이다.



abstract class AbstractFoo{
    int x, y;

    public void method(){
        System.out.println("method");
    }
                                       //세미콜론을 잊지 말아야 합니다.
    public abstract void abstractMethod(); 
    // 선언만 하고 구현하지 않음. Virtual method call이여서 부모메소드는 비어있음.
}

class Foo extends AbstractFoo{

    @Override
    public void abstractMethod() {
        System.out.println("implemented abstractMethod");
    }
}

public class AbstractClass {
    public static void main(String[] args) {
       // AbstractFoo afoo = new AbstractFoo() 
       //추상 클래스는 객체 생성이 불가합니다. 구현이 안되있으니 인스턴스화가 안된다.
        Foo foo = new Foo();
        foo.abstractMethod();

        AbstractFoo afoo = (AbstractFoo)foo;
        afoo.abstractMethod(); // virtual method call
        //추상클래스는 객체 생성은 불가하지만, 구현된 자식클래스의 객체는 받을 수 있다.
    }
}
템플릿 메서드

템플릿 : 틀이나 견본을 의미
템플릿 메소드 : 추상메소드나 구현된 메소드를 활용하여 전체의 흐름(시나리오)를 정의 해 놓은 메소드 final로 선언하여 재정의 할 수 없게 한다.

템플릿 매서드 패턴

디자인 패턴의 일종으로 프레임워크에서 많이 사용되는 설계패턴이다
추상클래스로 선언된 상위클래스에서 추상메소드를 이용하여 전체 구현의 흐름을 정의하고
구체적인 각 메소드 구현은 하위클래스에 위임함 
하위클래스가 다른 구현을 했 다고 해서 템플릿 메소드에 정의된 시나리오대로 수행됨.

템플릿 메소드 예제

Car 클래스
public abstract class Car {
  public abstract void drive();
  public abstract void stop();

  public void startCar(){
      System.out.println("시동을 켭니다.");
  }
  public void turnOff(){
      System.out.println("시동을 끕니다.");
  }
  public void washCar(){ }
  //아무 기능이 없어 여기서는 수행을 하지 않고 하위 클래스에서 재정의해서 사용.
  // 모든 하위클래스에서 구현을해야하는 거라면 abstract를 사용하지만
  // 모든 하위클래에서 사용하지 않으면 이렇게 사용한다.
  // 기능의 확장이 가능함

  //템플릿 메소드
  final public void run(){ //재정의할 수 없게 final 키워드 사용.
      startCar();
      drive();
      stop();
      turnOff();
      washCar();
  }
}

AICar
public class AICar extends Car {
  @Override
  public void drive() {
      System.out.println("자율 주행합니다.");
      System.out.println("자동차가 스스로 방향을 바꿉니다.");
  }

  @Override
  public void stop() {
      System.out.println("스스로 멈춥니다.");
  }

  @Override
  public void washCar(){
      System.out.println("자동 세차합니다.");
  }
}

ManualCar
public class ManualCar extends Car {
  @Override
  public void drive() {
      System.out.println("운전자가 주행합니다..");
      System.out.println("운전자가 방향을 바꿉니다.");
  }

  @Override
  public void stop() {
      System.out.println("운전자가 멈춥니다.");
  }
}

CarTest 클래스
public class CarTest {
  public static void main(String[] args) {
      Car aiCar = new AICar();
      aiCar.run();
      System.out.println("============");
      Car manualCarnuCar = new ManualCar();
      manualCarnuCar.run();
  }
}
final 예약어

fianl 변수는 값이 변경될 수 없는 상수이다.

public static final double PI = 3.14;

오직 한번만 값을 할당 할 수 있음

final 메소드는 하위 클래스에서 재정의(overriding) 할 수 없음.
final 클래스는 더 이상 상속되지 않음

상속이 됬을 때 문제가 될 수 도 있고 고유한 기능이 있는 경우 상속할 일이 없다 하면 final을 붙이면 된다.
public static final 상수 값 정의하여 사용하기

프로젝트 구현 시 여러 파일에서 공유해야 하는 상수 값은 하나의 파일에 선언하여 사용하면 편리하다.







다형성(Polymorphism)
Sun, 11 Apr 2021 07:26:08 GMT
다형성이란?

하나의 객체가 여러가지 타입을 가질 수 있는 것을 말한다.
자바에서는 이러한 다형성을 부모 클래스 타입의 참조 변수로 자식 클래스 타입의 인스턴스를
참조할 수 있도록 하여 구현하고 있다.
다형성은 상속, 추상화와 더불어 객체지향 프로그래밍을 구성하는 중요한 특징 중 하나이다.
객체지향 프로그래밍의 유연성, 재활용성, 유지보수성에 기본이 되는 특징이다.다형성의 장점

다양한 여러 클래스를 하나의 자료형(상위 클래스)으로 선언하거나 형변환 하여
각 클래스가 동일한 메소드를 오버라이딩 한 경우, 하나의 코드가 다양한 구현을 실행 할 수 있다.
유사한 클래스가 추가되는 경우 유지보수에 용이하고, 각 자료형 마다 다른 메소드를 호출하지 않으므로 코드에서 많은 if문이 사라진다.

다형성의 다양한 특징

오버로딩에 의한 다형성, 오버라이딩에 의한 다형성(상속에 의한 다형성과 같다.)

부모 클래스 타입으로 자식 클래스 객체를 참조하는 특징

부모 클래스로 자식 클래스를 참조한 경우, 자식 클래스의 메소드는 사용할 수 없다.

반대로 자식 클래스 타입으로 부모 클래스 타입의 객체를 참조할 경우에는 문법적으로 오류는 나지 않지만, 런타임시 에러가 발생한다.
class Foo{
 public void methodA(){
 }
}
class Bar extends Foo{
 public void methodB(){
 }
}
public class Poly01 {
 public static void main(String[] args) {
     Bar bar = new Bar(); //new가 있어야 새로운 객체를 만듬 자식 객체를 생성한 것이다.
     Foo foo = (Foo)bar; // 부모 클래스 타입으로 자식 객체를 받음.
     // 여전히 힙영역에는 자식객체가 있는 것이다.

     foo.methodA(); // Foo객체로받아서 문법적으로 a만 사용 가능, b는 불가능
     //foo.methodB();//이 경우 자식 클래스 메소드는 사용이 불가능 문법적으로 불가능함. 문법적으로 제한을 한 것이다.

     Foo foo1 = new Foo();

     //Bar bar1 = (Bar)foo1; 
     // 자식 클래스 타입으로 부모 객체를 받음 이거 자체가 오류(문법 오류는 아님)
     // 문법 오류는 아니지만, 런타임 오류가 발생
     // 자식클래스 자료형으로 객체를 보려 하지만, 부모 객체 부분만 있기 때문에
     // 런타임에서 오류가 발생시킴.
     //bar1.methodA(); //문법오류x 성립하지 않음
    // bar1.methodB(); //문법오류x 성립하지 않음

     Bar bar1 = (Bar)foo; 
     // 원래 자식객체를 자식객체로 캐스팅함 자식클래스 타입으로 자식 객체를 받음
     // 힙 영역에는 계속 자식 객체가 있었던 것. 부모객체 자료형으로 있는것을 자료객체로 캐스팅할 때
     // foo변수에 자식객체가 담겨져있는지 부모객체가 담겨져있는지 문법적으로 알수없음
     bar1.methodA();
     bar1.methodB();
 }
}





자식클래스로 부모 클래스를 참조하려 하면 java.lan.ClassCastException 오류 발생

 public class Main {
     public static void main(String args[]) {
         Foo foo = new Foo();
         Bar bar;

         // bar = (Bar)foo; // error
         if (foo instanceof Bar) { // returns false
             bar = (Bar)foo;
         }
     }
 }
형변환과 오버라이딩 메소드 호출

멤버 변수의 재정의는선언된 객체의 타입을 따른다. (문법적으로 본다) 클래스 변수도 마찬가지 변수는 별도의 메모리에 저장됨.

메소드 오버라이딩은 메모리상의 객체 타입을 따른다. (실제 객체로 본다)

부모 와 자식 클래스가 같은 메소드를 가지고 있을 경우, 부모 타입으로 자식 객체를 생성하게 되면 메소드를 호출할 때 자식 클래스의 메소드로 호출되는 경우를 가상 메소드 호출이라고 한다. (Virtual Method Call)
class  Foo{
   static public String y = "super class";
   public String x = "Super";
   public  void methodA(){
       System.out.println("Super method"); 
       // (가상 메소드 호출, virtual method call) 실제로 콜이 이루어지지 않지만 만들어줌 실제로 호출되지않음
       // 없으면 안됨 문법을 맞춰주기 위한 것 뿐 구현된 것 자체는 중요하지 않음..
   }
}

class Bar extends Foo{
   static public String y = "sub class";
   public String x = "sub";
   @Override
   public void methodA(){
       System.out.println("sub method");
   }
}

public class Poly02 {
   public static void main(String[] args) {
       Bar bar = new Bar();
       Foo foo = (Foo)bar; // new Bar();

       System.out.println(bar.x); //sub
       bar.methodA(); //sub

       System.out.println(foo.x); //super
       foo.methodA(); //sub virtural method call

       System.out.println(Foo.y);
       System.out.println(Bar.y);

//        System.out.println(foo.y); //super
//        System.out.println(bar.y); //sub
   }
}

공변 변환 타입(Covariant return type)
class Foo{
  public Foo getInstance(){
      return this;
  }
}
class Bar extends Foo{
  @Override
  public Bar getInstance(){ 
  //오버라이딩이지만, 리턴 타입이 달라질 수 있다. 여기서는 예외적으로 반환값이 달라진다. 공변 반환 타입
      return this;
      //return (Foo)this; 이거와 같다.
  }
}





객체지향프로그래밍(OOP)
Sun, 11 Apr 2021 07:05:25 GMT
객체지향 프로그래밍(Object Oriented Programming, OOP)
객체지향 프로그래밍이란?
컴퓨터 프로그래밍 패러다임 중 하나로, 프로그램을 명령어의 목록으로 보는 시각에서 벗어나, 독립된 단위인 객체의 모임으로 파악하는 것이다. 
각각의 객체는 메세지를 주고받고, 데이터를 처리한다.
프로그래밍에서 필요한 데이터를 추상화시켜 상태와 행위를 가진 객체를 만들고,
그 객체들 간의 유기적인 상호작용을 통해 로직을 구성하는 프로그래밍 방법(객체 간의 협력을 구현)

객체지향 프로그래밍의 장점

코드의 재사용성이 용이하다.
유지보수가 쉽다.
대규모 프로젝트에 적합하다.

객체지향 프로그래밍의 단점

처리속도가 상대적으로 느리다.
객체가 많으면 용량이 커질 수 있다.
설계시 많은 시간과 노력이 필요하다.

객체지향의 기본 구성 요소

클래스(Class)

같은 종류의 집단에 속하는 속성과 행위를 정의한 것
클래스는 다른 클래스 또는 외부 요소와 독립적으로 디자인해야 함


객체(Object)

클래스의 인스턴스로, 실제로 메모리상에 할당된 것
자신 고유의 속성을 가지며, 클래스에 정의된 행위를 수행
ex) 사람, 자동차, 주문, 생산, 관리


메소드(Method)

클래스로부터 생성된 객체를 사용하는 방법
메소드는 속성(변수)을 변화시키는 데에 사용한다.
정적 메소드는 정적 변수들을 변화시키고, 인스턴스 메소드는 객체의 속성을 변화시킨다.


꼭 속성을 변화시키는 것은 아니고, 주요 기능이 속성을 변화시키는 것이다.



객체지향의 특징

추상화(Abstraction)

객체지향에서 추상화란 객체에서 공통된 속성과 행위를 추출하는 것을 의미한다.
예를 들어, 자동차의 종류 중에 소나타, 아반떼, 그랜져, 제네시스 등이 있을 때 
이것들을 자동차라는 클래스를 만들어 세부적인 기능들은 다 다르지만, 공통적인 속성과 행위에 대한 개념을 정의한 것이다.
객체를 클래스로 추상적인 개념으로 만드는 것 추상화, 클래스를 객체로 만드는 것이 인스턴스화라고 한다.


캡슐화(Encapsulation)

캡슐화는 연관 있는 변수와 메소드를 묶어주는 작업을 말한다.
접근 제어자(private)를 통해 외부로부터 접근을 제한하여 객체 내에서만 접근이 가능하도록 하며, 이를 정보은닉이라고 한다.
외부 클래스에서의 직접적인 접근으로 발생하는 변경이나 오류를 막음으로써 보안성이 높아진다.


상속(Inheritance)

현실에서 부모의 재산이나 특징들을 자식이 이어받는 상속의 개념을 프로그래밍적으로 적용한 개념으로, 
부모 클래스의 속성과 기능을 이어받아 자식 클래스에서 사용할 수 있는 것을 말한다.
코드의 중복성을 줄여주는 역할을 한다.


다형성(Polymorphism)

한 타입의 참조 자료로 여러 타입의 객체를 참조할 수 있도록 하는 것으로, 동일한 변수, 함수명 등이 다양한 형태로 정의되는 것을 말한다.

오버 로딩(Overloading)과 오버 라이딩(Overriding)이라는 형태로 다양하게 기능들을 정의할 수 있다.

오버로딩 : 같은 이름의 메소드 여러 개를 가지면서 매개 변수의 자료형과 개수를 다르게 구현한 것이다.
 class Anmimal{
    String name;
    int age;
    public Animal(){
         name = "홍길동";
         age = 14;
    }
    public Animal(String name, int age){
          this.name = name;
          this.age = age;
    }
 }

오버라이딩 : 부모 클래스가 가지고 있는 메소드를 하위 클래스가 재정의해서 사용하는 것을 말한다.
 class Anmimal{
    void move(){
      System.out.println("동물이 이동합니다");
    }
 }

 class Cat extends Anmimal{
     @Override
     void move(){
        System.out.println("고양이가 이동합니다.");
     }
 }







제어자(Modifier)
Sun, 11 Apr 2021 06:59:45 GMT
제어자(Modifier)
제어자란

클래스, 변수, 메소드에 부가 기능을 부여하는 키워드

접근 제어자 (Access modifiers)

변수, 메소드, 생성자에 대한 접근할 수 있는 범위를 정하는 키워드이다.
자바 파일명과 같은 public class 클래스명이 꼭 있어야 한다.
private – 같은 클래스에서만 사용가능, 내부 구현을 위해서만 사용한다.
default – package라고도 한다 제어자명은 생략하여 쓴다. (제어자명에 package,default를 사용하지 않는다.)       사용범위가 같은 패키지안에서 가능.
protected – private와 비슷하게 사용이 되나, 상속한 경우 구현 시 접근이 필요할 때 사용.      자식이면 다른 패키지여도 접근할 수가 있다, 부모의 부모는 건들 수 없다.
public – 모든 곳에서 사용가능.
클래스는 public 과 default만 사용 가능하다.


그 외 제어자 (Other modifiers)

특별한 기능을 부여하는 제어자
static, final, abstract, synchronized





이미지 출처
접근 제어자
package com.company.s04.p05.subp01;
public class ClassA {
  public  int x;
  protected  int y;
  int z; // default (=package)
  private int w;

  public void methodA(){} //
  protected void methodB(){} //
  void methodC(){}//default (=package)
  private void methodD(){} //private - 내부 구현을 위해서만 사용.

  public void methodTest(){ //같은 클래스
      System.out.println(x);
      System.out.println(y);
      System.out.println(z);
      System.out.println(w);

      methodA();
      methodB();
      methodC();
      methodD();
  }
}



class ClassATest{ // 같은 패키지인 경우.
    public static void main(String[] args) {
        ClassA obj = new ClassA();
        System.out.println(obj.x);
        System.out.println(obj.y);
        System.out.println(obj.z);
        //System.out.println(obj.w); 접근 불가
    obj.methodA();
    obj.methodB();
    obj.methodC();
    //obj.methodD(); private 검색도 안됨
}
}
* 다른 패키지
````java
package com.company.s04.p05.subp02;
import com.company.s04.p05.subp01.ClassA;

class ClassAA extends ClassA{
    public void methodTest(){
        System.out.println(x);
        System.out.println(y); 
       // protected 자식이면 다른 패키지여도 ok 실제로 많이 씀. 
       // 하나의 자식 외에는 못봄. 부모의 부모는 건들 수 없음.(자바특성)
       // protected는 private처럼 쓰지만, 상속한 경우 구현 시 접근이 필요 할 때 사용.
       // System.out.println(z);
       // System.out.println(w); private - 상속해도 못봄

        methodA();//public
        methodB();//protected
        //methodC();
        //methodD();
    }
}

// public default만 사용 가능, 
// private은 쓸 수 없음 같은 클래스만 볼 수 있기 때문에 다른 클래스라는 개념이 없기 때문에. 
// protected도 사용 불가.
public class ClassB {
    public static void main(String[] args) {
        ClassA obj = new ClassA();
        System.out.println(obj.x); //다됨 public
       // System.out.println(obj.y); //protected 다른 패키지인경우 자식만됨.
        //System.out.println(obj.z); //default 다른 패키지이면 안됨.
        //System.out.println(obj.w); 접근 불가

        obj.methodA();
        //obj.methodB();//protected 다른 패키지인경우 자식만됨.
        //obj.methodC();//default 다른 패키지이면 안됨.
        //obj.methodD(); private 검색도 안됨
    }
}
public으로 open한거랑 private으로 닫아놓고 public method를 제공하는것의 차이

2가지 차이점이 있다

getter를 할 수 있게하고, setter를 못하게(안하게) 하는 경우가 있다 (ReadOnly만 된다, 값을 넣을 수 없다, ID라던가 값이 변할 수 없는 고유한 값들)

메소드에서 유효한 데이터를 핸들링 할 수 있다.

boolean isValid 라는 멤버변수를 선언해주고 이것이 true일 때 올바른 날짜가 출력되게 하므로써 제한사항을 줄 수 있다

멤버변수이기 때문에 클래스 전체에서 사용이 가능하므로 (scope,범위가) 메소드에서 값을 변경하게 되면 멤버변수의 값이 변경되기 때문에
public class MyDate {
  private int day;
  private int month;
  private int year;

  private boolean isVaild = true;

  public  void setDay(int day){
      this.day = day;
  }
  public int getDay(){
      return day;
  }

  public int getMonth() {
      return month;
  }

  public void setMonth(int month) {
      if(month <1 || month > 12){
          isVaild = false; // 값이 유효범위에 해당하는지 체크를 해준다.
      }
      this.month = month;
  }

  public int getYear() {
      return year;
  }

  public void setYear(int year) {
      this.year = year;
  }

  public void showDate(){
      if (isVaild){
          System.out.println(this.year + "년" + this.month + "월" +this.day+"일");
      }else{
          System.out.println("유효하지 않은 범위 입니다.");
      }

  }








 }

### 그 외의 제어자
  * final 
  * 더 이상 바꿀 수 없음을 의미 상수.
  * 클래스, 메소드, 변수에 사용 가능
    * 클래스 : 더 이상 상속이 불가능해진다.
    * 메소드 : 자식 클래스에서 오버라이드 할 수 없다.
    * 멤버 변수 : 변수의 값이 초기화 이후에 변하지 않는다.
    * 생성자에서 초기화가 이루어지는 것을 blank final 변수라 한다.
   ````java
    public class Foo {
        final int x = 0; // final variable
        final int y; // blank finial variable

        public Foo(int y) {
          this.y = y; // blank final variable initialization
      }
    }

static

클래스 변수, 클래스 메소드 등을 선언하기 위해 사용
클래스의 또는 공통적인의 의미를 가지고 있다.
static이 붙은 멤버변수와 메소드, 초기화 블록은 인스턴스를 생성하지 않아도 사용할 수 있다.
멤버 변수 : 모든 인스턴스에 공통적으로 사용되는 클래스 변수가 된다, 클래스가 메모리에 로드될 때 생성된다.
메소드 : 인스턴스를 생성하지 않고도 호출이 가능한 static 메소드가 된다, static 메소드 내에서는 인스턴스 멤버들을 직접 사용할 수 없다.




abstract

추상 클래스, 추상 메소드 앞에 붙여지는 제어자이다.
'추상의' 또는 '미완성의' 의미를 가지고 있다.
메소드의 선언부만 작성하고 실제 수행 내용은 구현하지 않는 추상메소드를 선언하는데 사용
abstract 클래스 : 클래스 내에 추상메서드가 선언되어 있음을 의미한다.(추상메소드가 없어도 된다.)
abstract 메소드 : 선언부만 작성하고 구현부는 작성하지 않는 메소드 ';'으로 끝낸다.




synchronized

동시성 프로그래밍에 사용.



접근제어자를 이용한 정보은닉(information hiding)

외부에서 클래스 내부의 정보에 접근하지 못하도록 한다, private 키워드를 활용
private 변수를 외부에서 접근하게 하려면 public 메소드 제공한다.
클래스 내부 데이터를 잘못 사용하는 오류를 방지할 수 있다.

싱글톤 패턴(Singletone)

객체가 단 하나만 존재할 수 있는 클래스
private 생성자를 이용한다.

class SingletonClass {
  private static SingletoneClass instance = new SingletonClass();
  private SingletonClass() {}

  public static SingletonClass getInstance() {
      return instance;
  }
}



인스턴스와힙메모리
Sun, 11 Apr 2021 06:51:20 GMT
인스턴스와힙메모리
인스턴스란

클래스로부터 생성된 객체
힙 메모리에 멤버 변수의 크기에 따라 메모리가 생성
클래스를 기반으로 new 키워드를 이용하여 여러 개의 인스턴스를 생성



참조변수와 참조 값
ch05.classPart.Student@1ddc4ec2의 주소값은 실제 물리적인 주소값은 아니고
가상 jvm이 준 해시코드 값이다. student가 가리키는 메모리의 위치가 32비트를 나타내는 메모리를 가리킨다Student student  = new Student();
System.out.println(student);






문자열(String) - 한번 만든 문자열은 변하지 않는다. (Immutable) 그래서 새로운 문자열을 만들어서 값을 넣어 주는 것과 같다.

클래스는 문자열과 달리 mutable 변할 수 있다.

참조형 객체이기 때문에 new일때만 새로운 객체를 생성하고, 이렇게 하면 같은 객체를 가리킨다.

이처럼 carThree 에 carOne을 넣었을 때 Three에서 속성 값을 변경시켰을 때 one의 속성값도 변경됨.
Car carThree = carOne;

System.out.println(carThree.speed); //carThree.speed = 5;
System.out.println(carThree.speed);// 5
System.out.println(carOne.speed);// 5


메모리 할당 시점

변수가 메모리에 생성될 때는 초기화가 이루어지는 시점인데, 
초기화가 되는 시점은 클래스나 메소드에서 초기화 값을 준다고 해도 메모리에 생성이 되는게 아니다.
변수를 선언하는 것은 메모리를 자료형의 크기만큼 쓰겠다라고 하는 것이다.(메모리에 공간 확보)
변수 초기화는 메모리에 실제 값을 할당 하는 것이다.
메인 메소드안에 있는 변수들은 실행될 때 메모리에 생성됨.
정적 변수 - 클래스가 생성이 될 때 메모리에 할당이 된다.

클래스와 객체의 메모리 구조
메모리 영역

클래스 영역(class area, method area, code area, static area) 클래스의 공통된 부분이 들어감 어떤 필드가 있는지 어떤 타입을 갖는다던지

어떤 메소드가 있고 어떤동작을 하는 코드라던지. 프로그램이 돌아가면 계속 존재함.

field 정보, method 정보, type 정보, constant pool
ex) method의 정보라고 하면 접근 제어자와 자료형, 메소드명이 이러한 메소드가 있다, 어떤동작을 한다 라는 정보만 생성이 된다. 


스택 영역 메소드콜이 이뤄질때 메소드에 의해 이뤄지는 임시적인 영역

method 호출 시 선언된 로컬 변수(호출시 임시로 있는 공간 (사라짐))


힙 영역 new키워드로 발생함.

new 키워드로 생성된 객체
garbage collection이 동작하는 영역 : 더 이상 사용하지 않는 메모리를 알아서 반환하는  jvm의 기능을 의미한다.(GC)


클래스와 객체의 메모리 구조 예제
public class MemoryStructure { // 클래스 영역
   int x, y; 
   // 힙 영역 객체에 속하기 때문에 객체를 콜할 때는 힙 영역에 들어감. 객체에 속하는 속성들이므로.
   // 클래스가 아니기 때문에 값 자체가 담긴다.(32비트 값을 잡아서 쓰여져있음)

   String string = "String!!"; 
   // 힙영역, 상수풀에도 생성, 애는 상수풀에 생성됨. 클래스를 만드는 클래스는 힙영역에있고 내용은 상수풀에 들어감.

   public void method(int value){ // 클래스 영역에 만들어 짐 (메소드의 정의)
       // int value = > 스택 영역
       char c = 'w'; // 스택 영역
   }
   // 대부분의 주소값은 64비트 운영체제가 대부분 64비트이기때문에 거기에 맞춰지는 것.

}


String 타입의 메모리 구조

class, method 같은 것들은 클래스 영역에 만들어지고, 
method 안에 있는 값들은 스택영역에 만들어졌다가 method의 생명주기가 끝나면 사라짐.

class 안에 변수들은 힙영역에 생성이 되는데, 정수, 실수형 변수는 constant pool 안에 정의 되어있는 값들을 가져와서 사용하는 것이고, 
String은 정의할 때 힙 영역에 값이 생성됨.

처음에 young메모리(nursery)에 생성되었다가 오랫동안 사용하면 올드메모리로 옮겨짐.

new로 생성했을 때 기본적으로 young 메모리에 들어간다.
@org.junit.Test
public void testStringEquality (){
  final String literal = "Hello";
  final String object = new String("Hello");

  Assert.assertTrue(literal.equals(object));
  Assert.assertFalse(literal == object);
}

위에서 String의 equals은 true, ==는 false가 나오는 경우를 볼 수 있는데,

equals는 문자열을 비교하고, ==는 객체의 주소값을 비교하기 때문이다.
@org.junit.Test
public void testStringIntern(){
  final String literal = "Hello";
  final String object = new String("Hello");
  final String intern = literal.intern();

  Assert.assertTrue(literal.equals(object));
  Assert.assertFalse(literal == object);
  Assert.assertTrue(literal.equals(intern));
  Assert.assertTrue(literal == intern);
}



위의 코드를 보면 intern()메서드를 호출한 결과값을 intern 변수에 할당되는 것을 볼 수 있다. 
 그 후 literal과 object의 동일성(==)과 동등성(equals)를 비교해보면 둘다 true값이 나와 테스트에 성공하게 된다.
 리터럴로 "Hello"라는 문자열이 string constant pool에 저장되었고, 
 inter() 메서드를 호출하면서 string constant pool에서 Hello라는 문자열을 검색하고 
 이미 존재하기 때문에 "Hello" 의 동일한 주소값을 반환하게 되어 true가 나오게 된다.


String을 리터럴로 선언할 경우 내부적으로 String의 intern()메서드가 호출되게 된다. 
intern() 메서드는 주어진 문자열이 string constant pool에 존재하는지 검색하고 있다면 그 주소값을 반환 하고, 없다면 string constant pool에 넣고 새로운 주소값을 반환한다.




상속(Inheritance)
Sun, 11 Apr 2021 06:35:01 GMT
상속(Inheritence)

상속과 다형성을 이해를 잘하면 유지보수하기 쉽고 확장성있는 시스템을 설계할 수 있다.
객체지향의 큰 특징 중 하나이다.

상속이란

어떤 클래스의 모든 멤버 변수 및 메소드를 계승하여, 새로운 클래스를 생성하는 것
부모 클래스로부터 상속을 받은 자식 클래스는 부모의 것을 다 가지고 자기의 것을 추가로 더 가지고 만들어진다.
상속 관계를 흔히 'IS-A'관계라고 한다.



상속대상은 조상클래스, 부모클래스, 상위클래스, 슈퍼클래스 라고 한다.
상속결과는 자손클래스, 자식클래스, 하위클래스, 서브클래스 라고 한다.

상속을 사용하는 경우

상속은 좀 더 일반적인 클래스가 있고 이것보다 좀 더 기능이 구체적인 클래스를 설계 한다.
유사한 클래스를 만드는데 기존의 클래스를 가져다가 좀 더 확장된 클래스를 만들 때 상속을 사용 한다.



상속에서 접근 제한

이미지 출처



protected 예약어
클래스에서 멤버변수나 메소드를 private 예약어로 지정해 놨을 때 외부 클래스에서 접근을 하지 못한다. 
그래서 상속 관계에서도 접근을 못하게 되는데 protected 예약어를 사용하면 상위클래스에 protected로 선언된 변수나 메소드를 
다른 외부 클래스에서는 사용할 수 없게 하고 하위클래스에서 사용이 가능하다. 



상속에서 클래스 생성 과정과 형변환

Customer 상위클래스, VIPCustomer 하위클래스  


하위클래스가 생성되는 과정

상위 클래스의 생성자가 호출되고 하위 클래스의 생성자가 호출 된다.
하위 클래스의 생성자에서는 무조건 상위 클래스의 생성자가 먼저 호출되어야 한다.
하위 클래스에서 상위 클래스의 생성자를 호출하는 코드가 없는 경우 
컴파일러는 상위 클래스 기본 생성자를 호출하기 위한 super()를 추가한다.
super()로 호출되는 생성자는 상위 클래스의 기본 생성자이다.


만약 상위 클래스의 기본 생성자가 없는 경우(매개변수가 있는 생성자만 존재하는 경우) 하위 클래스는 명시적으로 상위 클래스의 생성자를 호출해야 한다.



상위 클래스의 묵시적 형 변환(업 캐스팅)

상위 클래스 형으로 변수를 선언하고 하위 클래스 인스턴스를 생성 할 수 있다.
하위 클래스는 상위 클래스의 타입을 내포하고 있으므로 상위 클래스로 묵시적 형 변환이 가능하다.
상속 관계에서 모든 하위 클래스는 상위 클래스로 묵시적 형 변환이 된다.
그 반대는 성립하지 않는다.



VIPCustomer() 생성자의 호출로 인스턴스는 모두 생성 되었지만,
타입이 Customer이므로 접근 할 수 있는 변수나 메소드는 Customer의 변수와 메소드이다.

하위 클래스로 명시적 형 변환(다운 캐스팅)

묵시적으로 상위 클래스로 형 변환된 인스턴스가 원래 자료형(하위 클래스)으로 반환되어야 할 때
다운 캐스팅이라고 한다.
하위 클래스로의 형 변환은 명시적으로 되어야 한다.
Customer vc = new VIPCustomer() // 묵시적
VIPCustomer vCustomer = (VIPCustomer)vc; //명시적

클래스의 관계
클래스의 상속

부모 클래스
class Person{
  String name;
  public void work(){
      System.out.println("일하기");
  }
  public void sleep(){
      System.out.println("잠자기");
  }
}

자식 클래스
// person을 상속하는 자식 클래스 extends 키워드를 이용하여 상속
class Developer extends Person{
  String mainLang;
  public  void  writeCode(){
      System.out.println("돈 받은 만큼 코딩하기");
  }
}
class Student extends Person{
  String major;

  public void writeCode(){
      System.out.println("밤새 코딩하기");
  }
}
클래스의 포함

관계 클래스를 조합해서 클래스를 만든다.

상속하고 유사하지만, 한 클래스가 다른 클래스의 객체를 포함하는 관계

내부에 포함하고 'HAS-A' 관계로 표현된다.

특별히 자바에선 'HAS-A' 관계가 포함된 경우는 많이 없다.

클래스 컴포지션 (Composition)이라 부른다.
// 메인머신 'HAS-A' String 이미 스트링을 컴포지션하고 있었다.
class MainMachine{
  String model;
  boolean isBroken = false;

  public MainMachine(String model){
      this.model = model;
  }
}
// developer 'HAS-A; MainMachine 개발자클래스가 메인머신의 객체 하나를 보유한다.
// 보유하고 있어서 메인머신의 속성을 건드릴 수 있다.
class Developer{
  String name;
  MainMachine mainMachine;

  public Developer(String name,MainMachine machine){
      this.name = name;
      this. mainMachine = machine;
  }

  public void writeCode(){
      if(mainMachine.isBroken) {
          System.out.println("코딩할 수 없습니다.");
      }else{
          System.out.println(mainMachine.model+ "으로 코딩하기");
      }

      if(Math.random() > 0.9){
          breakMachine();
      }
  }

  public void breakMachine(){
      mainMachine.isBroken = true;
  }
}



MainMachine mac = new MainMachine("MacBook Pro");
Developer dev = new Developer("나개발",mac); // 메인머신을
//  dev.mainMachine.model 가능
//  dev.model 불가능.
//  일치하냐 보유하냐의 차이 (상속과 컴포지션의 차이)
    for (int i =0; i<10; i++){
       dev.writeCode();
    }

## 메소드 재정의
### 메소드 재정의(Method Overriding)란?
* Override -> 덮어씌운다, 해킹해서 뭔가 달라지게 한다.
* 기존의 있던걸 덮어씌워서 다른걸로 변형시키는 것
* 다형성 (polymorphism)의 근간이 됩니다.
````java
class Person{
    public void writeCode(){
        System.out.println("아무 코드나 일단 적어 보았다.");
    }
}
class Student extends Person{
    @Override // 이렇게 적어주는 것이 관례 필수는 아님(문법 오류는 아님)   @ - 에노테이션
    public void writeCode(){
        System.out.println("능숙하게 코드를 작성해 보았다.");
        System.out.println("답은 틀렸다.");
        System.out.println("하지만 무언가 또 배웠다.");
    }
}

class Developer extends Person{
    @Override // 다양하게 오버라이드 될 수 있음.
    public void writeCode(){
        System.out.println("코드 작성이 하기 싫어서 하지 않았다.");
    }
}
@ 애노테이션(Annotation)

재정의된 메소드라는 의미로 선언부가 기존의 메소드와 다른 경우 에러가 발생한다.(같게 해줘야 함)
애노테이션은 컴파일러에게 특정한 정보를 제공해주는 역할을 한다
(컴파일 오류를 막아주고, 컴파일러에게 정보를 전달해줌.)


주로 사용되는 자바에서 제공되는 애노테이션


형변환과 오버라이딩 메소드 호출
Customer vc = new VIPCustomer();
vc.calcPrice(10000);
위 코드에서 calcPrice() 메소드는 어느 메소드에서 호출 될까?
자바에서 항상 인스턴스의 메소드가 호출이 된다. (메모리의 자료형을 따라서 메소드가 호출이된다.)
그 이유는 Virtual method Call이 이루어지기 때문이다.
가상 메소드(Virtual method)

메소드의 이름과 메소드 주소를 가진 메소드 테이블에서 호출될 메소드의 주소를 참조한다.



재정의된 메소드 호출 과정


public class Customer {
    protected int customerID;
    protected String customerName;
    protected String customerGrade;
    int bonusPoint; // 보너스 포인트
    double bonusRatio; //보너스 포인트 적립 비율

    public Customer(){ //생성자를 기본 초기값으로 설정해주듯이 사용하면 될 것 같다.
        customerGrade = "Silver";
        bonusRatio = 0.01; //1%로 적립

        System.out.println("customer 생성자 호출");
    }

    public Customer(int customerID,String customerName){
        this.customerID = customerID;
        this.customerName = customerName;
        customerGrade = "Silver";
        bonusRatio = 0.01; //1%로 적립
        System.out.println("customer 파라미터 생성자 호출");

    }

    public String showCustomerInfo(){
        return customerName+"님의 등급은 "+customerGrade+"이며, 적립된 보너스 포인트는 "+bonusPoint+"점 입니다.";
    }

    public int calcPrice(int price){ //지불할 가격 반환.
        bonusPoint += price * bonusRatio;
        return price;
    }
}
Customer customerLee = new Customer(10010,"이순신");
customerLee.bonusPoint=1000;

VIPCustomer customerKim = new VIPCustomer(10020,"김유신");
customerKim.bonusPoint = 10000;

int priceLee = customerLee.calcPrice(10000);
int priceKim = customerKim.calcPrice(10000);
System.out.println(customerLee.showCustomerInfo() +"지불금액은 "+priceLee);
//이순신님의 등급은 Silver이며, 적립된 보너스 포인트는 1100점 입니다. 지불금액은 10000

System.out.println(customerKim.showCustomerInfo()+"지불금액은 "+priceKim);
//김유신님의 등급은 VIP이며, 적립된 보너스 포인트는 10500점 입니다. 지불금액은 9000

Customer customerNo = new VIPCustomer(10030,"나몰라");
customerNo.bonusPoint=10000;
System.out.println(customerNo.showCustomerInfo()+"지불금액은 "+customerNo.calcPrice(10000));
// 나몰라님의 등급은 VIP이며, 적립된 보너스 포인트는 10000점 입니다. 지불금액은 9000
// 지불금액이 예상하기로 10000이 나와야하지만 결과는 9000이나옴 
// 이유는 vipcustomer의 calcPrice()메소드가 호출되었기 때문에 
// 이것을 가상메소드호출이라 한다.
super 키워드

this 가 자신의 객체를 참조하듯, super 는 부모 객체를 참조한다.
다만 super.super 라는 식으로 부모의 부모는 참조할 수 없다. 바로 윗 부모만 가능하다.
자식 객체를 생성을 하면, 부모 객체를 먼저 생성하고, 그 다음에 자식 객체를 생성하게 된다.
자식 객체를 생성할 때마다 부모 객체를 따로따로 만들어서 가지고 있다.
호출할 때 this와 마찬가지로 첫줄에 써야한다.
멤버 변수명이 부모와 겹치면 재정의 하지만, 부모가 사라지는 것은 아니다.
부모클래스에 기본 생성자를 사용하는 경우에는 호출 안해줘도 된다. 파라미터 생성자일 때만
호출해주면 된다.
부모클래스 생성자와 다르게 파라미터 변수명을 해줘야 한다.
자식클래스 생성자를 만들 때 부모 클래스 생성자도 같이 호출해줘야한다.

class Foo {
    String x = "Foo";

    public Foo(String x) {
        this.x = x;
    }
}
class Bar extends Foo {
    String x = "Bar"; 
    // 멤버 변수명이 부모와 겹치면 재정의 하지만 부모가 사라지는 것은 아님.

    // 부모클래스에 기본 생성자를 사용하는 경우에는 호출 안해주어도 된다.
    // 부모클래스에 파라미터 생성자가 있으면 호출해 줘야 한다. super 사용.
    public Bar(String x, String x1) { 
    // 부모클래스 생성자와 다르게 파라미터 변수명을 다르게 해줘야 한다. x,x1
        super(x); //this와 마찬가지로 첫줄에 써야한다. 부모클래스 생성자 호출.
        //부모 객체를 먼저 생성하고, 그 다음에 자식 객체를 생성.
        this.x = x1; //자식클래스 생성자를 만들때 부모클래스 생성자도 같이 호출해줘야한다.
    }

    public void method(){
        //로컬변수명과 멤버변수명은 같을 수 있다.
    // String x = "method"; 로컬변수가 없어지면 멤버변수를 참조, 
    // 멤버변수도 없어지면 super클래스의 변수사용.
        System.out.println(x);
        // 로컬변수 -> 멤버변수 -> 부모의 멤버변수 순으로 접근
        System.out.println(this.x); 
        // 자기 자신의 객체에 접근가능 멤버변수 - > 부모의 멤버변수
        System.out.println(super.x); // 부모 객체에 접근 가능 부모의 멤버변수
    }
}



클래스와 객체
Sun, 11 Apr 2021 05:58:48 GMT
클래스(Classes)와 객체(Object)
클래스 와 객체 개념
클래스

객체를 만들어내기 위한 설계 혹은 틀 또는 객체를 정의해 놓은 것, 코드로 구현한 것을 말한다.

문자열(String)도 클래스 형태로 클래스는 한 번 만든 문자열은 변하지 않는데(Immutable), 클래스는 변할 수 있다.(mutable)

클래스 이름은 PascalCase로 적는다.

변수(attribute, filed, 멤버변수) 와 메소드(method,함수)로 구성된다.

클래스의 로딩되는 시점 

객체가 생성이 될 때 - 클래스가 먼저 클래스 영역에 생성이 되고 그 정보를 가지고 객체가 생성이 되는 것이다. 
초기화 블록을 사용해서 확인해보면 확실히 이해가 간다.

import 할 때 - 클래스가 로딩이 되서 클래스 영역에 생성이 된다.

정적 변수를 사용할 때 - 클래스명.정적 변수 형태로 사용이 가능하기 때문에 클래스의 정보가 먼저 있어야 한다. 
class Car{ 
  int speed = 0; // 속성, 멤버 변수

  void move(){ //  메소드 (method), 멤버 함수
      speed = 10; //행위를 구현, 속성을 변경
  }
}




객체

클래스가 구체화하여 값으로 생성된 것(실체화 된 것) 클래스의 인스턴스라고도 부른다.

하나의 클래스로 여러 개의 객체들을 생성할 수 있다. 같은 타입의 독립적인 객체가 된다.

new 키워드로 생성된 객체는 힙 영역에 생성이 된다.

new 키워드로 생성된 객체는 객체의 주소를 리턴하도록 되어있다.
 Car carOne = new Car(); // new 키워드로 클래스에서 객체 생성
 System.out.println(carOne.speed); // 객체명.으로 속성 접근 가능
 carOne.move(); // 메소드 호출(method call) 이라고 부름.
 System.out.println(carOne.speed);

 Car carTwo = new Car();
 System.out.println(carTwo.speed); // speed=0 독립적인 객체를 의미.

 // STRING은 Immutable이기 때문에 값이 변하지 않지만,
 // 클래스는 대부분 muttable이기 때문에 객체 참조에 대한 문제가 발생한다. 중요**

 Car carThree = carOne; 
 // 참조형 객체이기 때문에 new일때만 새로운 객체를 생성하고,
 // 이렇게하면 같은 객체를 가리킨다.
 System.out.println(carThree.speed);
 carThree.speed = 5;
 System.out.println(carThree.speed);// 5
 System.out.println(carOne.speed); // 5


클래스의 구성요소
필드(속성, 멤버 변수)

필드는 객체의 고유 데이터, 부품 객체, 상태 정보를 저장하는 곳이다.
필드는 생성자와 메소드 전체에서 사용되며 객체가 소멸되지 않는 한 객체와 함께 존재한다.

메소드

메소드는 객체의 동작을 담당한다. 메소드를 호출하면 중괄호 내의 코드들이 일괄적으로 실행된다.
메소드는 객체 간의 데이터 전달의 수단으로 사용되며, 외부로부터 매개 값을 받을 수도 있고, 실행 후 어떤 값을 리턴할 수도 있다.

생성자

객체 생성시에 초기화를 담당하는 역할을 하고, 필드를 초기화하거나 메소드를 호출해서 객체를 사용할 준비를 한다.
생성자는 메소드와 비슷하게 생겼지만, 클래스 이름으로 되어 있고 리턴 타입이 없다.

애노테이션(Annotation)

재정의된 메소드라는 의미로 선언부가 기존의 메소드와 다른 경우 에러가 발생한다.(같게 해줘야 함)
애노테이션은 컴파일러에게 특정한 정보를 제공해주는 역할을 한다.
컴파일 오류를 막아 주고, 컴파일러에게 정보를 전달해 준다.
주로 사용되는 자바에서 제공되는 애노테이션




애노테이션
설명



@Override
재정의된 메소드라는 정보 제공


@FuctionalInterface
함수형 인터페이스라는 정보 제공


@Deprecated
이후 버전에서 사용되지 않을 수 있는 변수, 메서드에 사용됨


@SupperessWarnings
특정 경고가 나타나지 않도록 함 ex) @SupperessWarnings("deprecations")는 @Depreacted가 나타나지 않도록 함.


Getter와 Setter

클래스의 멤버 변수를 간접적으로 다룰 수 있게 하는 메소드

멤버 변수의 캡슐화를 구현하기 위해 사용. -> 정보은닉 / 보호

멤버 변수의 값을 제한해야 할 때 유용.
public class Main {
   int x,y;

   // 멤버변수를 만들어야 생성가능.
   public int getX() { 
   // 경우에 따라 구현되지 않을 수 있다. 출력하지 않으면 사용 안하는 것.
       return x;
   }

   // 들어오는 값에 대해 조건을 걸 수 있다.
   public void setX(int x) {
       if(x > 0 && x <= 1000){
           this.x = x;
       }else{
           System.out.println("x should be 1 < x <= 1000!");
           System.out.println("however, you put in x = "+x);
       }
       this.x = x;
   }

   public int getY() {
       return y;
   }

   public void setY(int y) {
       this.y = y;
   }
}

class MainTest{
   public static void main(String[] args) {
       Main m = new Main();
       m.x=10; // x에 private를 넣으면 직접 값을 변경할 수 없음.
       System.out.println(m.x);

       m.setX(20);
       System.out.println(m.getX()); //권장된 처리 방식.

       m.x = 20; // 권장하지 않는 멤버 변수 처리 방식

       m.setX(11111);
       System.out.println(m.getX());
   }
}


초기화 블록(Initializer)

클래스 또는 인스턴스를 생성할 때 단 한번 실행되는 코드 블록
public class Main {
 static int classVar;
 static  int instanceCount;
 int instanceVar;

 // static initializer
 static { // 객체가 생성되지 않은 상태 객체에서 접근 불가
     System.out.println("static block1");
     classVar = 20;
 }
 // object initialzer 객체를 만들어서 접근.
 {
   System.out.println("block1");
   instanceVar = 30;
   classVar = 50; 
   // 추천되지 않는다. 
   // 객체를 생성하는데 클래스에 대해 변하는것은 권장하지 않음.
   instanceCount++; // 이러한 패턴은 사용된다.
 }
// 여러개 사용 가능. 스태틱은 스태틱끼리 출력되고, 값은 나중에 선언된 값이 삽입됨.
 static {
     System.out.println("static block2");
     classVar = 5;
 }
 {
     System.out.println("block2");
     instanceVar = 5;
 }
}

class MainTest{
 public static void main(String[] args) {
     System.out.println(Main.classVar);
     Main m = new Main();
     System.out.println(Main.instanceCount
     System.out.println(m.instanceVar);
     System.out.println(Main.classVar);

     Main m2 = new Main();
     System.out.println(Main.instanceCount);

     Main m3 = new Main();
     System.out.println(Main.instanceCount
  }
}  





Wrapper Class
Sun, 14 Mar 2021 07:16:29 GMT
Wrapper 클래스(Wrapper Class)
Wrapper Class란

기본형 타입을 객체로 쓰기 위해 있은 클래스
기본형 타입이 허용되지 않는 문법에 기본형 타입을 쓰기 위해서 제공 하는 클래스

Wrapper Class의 종류



기본형
WrapperClass



byte
Byte


char
Character


short
Short


int
Integer


flaot
Float


double
Double


boolean
Boolean


Wrapper 객체 생성

생성자를 이용한 객체 생성Integer integer = new Integer(10);
Character character = new Character('v');

valueOf를 이용한 객체 생성Integer integer1 = Integer.valueOf(10);
Character character1 = Character.valueOf('v');
Autoboxing & Unboxing

기본형을 객체로 사용할 수 있게 하는 것을 - > Autoboxing
객체를 기본형으로 바꾸는 것을 -> Unboxing

Autoboxing

Java1.5부터 추가된 기능으로, 객체로 다루어야 할 때 자동으로 Wrapper 클래스로 변경하는 기능
public static  T bypass (T x){
  return x;
}

Integer integer2 = 4;
System.out.println(add(4,2));
bypass(5); // 원래는 프리미티브 타입을t에 넣을 수 없는데 autoboxing이 이뤄져서 가능.
// T: wrapper class인 integer로 결정됨
// 5 -> new Integer(5) autoboxing 1.5버전 이후로 가능해짐.
Unboxing

Wrapper 객체를 기본형으로 자동으로 변경하는 기능
int m = new Integer(10); 

int i = 10;
Integer wrapped = i;
int b = 20 + wrapped;


Wrapper 타입의 값 비교

Wrapper 타입은 객체이므로, ==를 이용하여 값을 비교할 수 없다.Integer intOne = new Integer(100);
Integer intTwo = new Integer(100);



System.out.println(intOne == intTwo); // false
System.out.println(intOne.equals(intTwo)) // true
System.out.println(intOne == 100) // true (Unboxing)

## 문자열의 기본 자료형 반환
* Parsing 정적 메소드를 이용한 반환
````java
int x = Integer.parseInt("100");
long y = Long.parseLong("512345124");

Wrapper 객체로의 반환Integer intObj = Integer.valueOf("1000");
Integer intObjTwo = new Integer("1234");





Variable
Sun, 14 Mar 2021 07:15:14 GMT
변수 (Variable,필드, 속성, 멤버 변수)

변수의 자료형은 기본 자료형, 참조 자료형으로 나눠진다.
변수에 대한 생성은 생성자에서 주로하는데 사용하기 전에만 하면 된다.
생성하기 전 상태에서 값을 넣으면 NullPointException이 발생할 수 밖에 없다.
메모리가 없는데 값을 넣으면 에러가 날 수 밖에 없다.



선언된 위치에 따라 구분되는 변수는 생성 및 소멸 시기, 저장되는 메모리 공간과 사용 방법까지 서로 다르다.



변수
생성 시기
소멸 시기
저장 메모리
사용 방법



클래스 변수
클래스가 메모리에 올라갈 때(클래스가 사용이 될 때)
프로그램이 종료될 때
메소드 영역
클래스 이름, 변수 이름


인스턴스 변수
인스턴스가 생성될 때
인스턴스가 소멸할 때
힙 영역
인스턴스 이름, 변수 이름


지역 변수
블록 내에서 변수의 선언문이 실행될 때
블록을 벗어날 때
스택 영역
변수 이름


public class Variables{
   int instanceVar; // 인스턴스 멤버 변수
   static int classVar; // 클래스 멤버 변수

   public void method(int parameterVar){ //파라미터 변수
         int localVar = 0; //로컬 변수
   }
}
클래스 멤버 변수(static variable, class variable)

처음 프로그래밍에 로드될 때 클래스 영역에 생긴다, 메모리에 할당된다.
static을 이용하여 정의하는 변수, 클래스에서 바로 접근이 가능한 변수를 의미한다.
인스턴스(객체)들이 공통으로 사용하는 변수, 외부에서 접근하지 못하게 접근제어자를 private을 사용하는 것이 좋다.
초기화를 해주지 않았을 경우, 자동으로 자료형의 기본값으로 초기화가 된다.(static int num; 이라 했을 때 static int num = 0;과 같음)   
객체명으로도 접근이 가능하지만 권장하지 않는다.



모든 인스턴스에 공통적으로 사용되는 클래스 변수가 된다, 클래스가 메모리에 로드될 때 생성된다.

처음 프로그램이 로드될 때 데이터 영역(static 영역, 클래스 영역)에 생성이 된다.

인스턴스의 생성과 상관 없이 사용할 수 있으므로 클래스 이름으로 참조한다.(ex- 클래스명.static변수명,Student.name = "홍길동")
       static int classVar; 

       System.out.println("클래스 변수");
       System.out.println(Variable.classVar); // 0으로 초기화가 된다. 
인스턴스 멤버 변수

객체를 생성해서 사용하는 변수로 클래스명으로 접근이 불가능하다.   

초기화를 해주지 않았을 경우, 자동으로 자료형의 기본값으로 초기화가 된다.
      int instanceVar; // 인스턴스 멤버 변수, 필드, 속성
      System.out.println("인스턴스 멤버 변수");
      Variable var = new Variable();
      // 인스턴스를 만들어야 실체가 있기 때문에
      System.out.println(var.instanceVar);  
      //0으로 초기화가 됨.외워야됨.

각 자료형의 초기화값



변수의 타입
초기값



char
'\u0000'


byte,short,int
0


long
0L


float
0.0f


double
0.0


boolean
false


배열,인스턴스 등
null


### 클래스 변수와 인스턴스 변수







각각의 객체들은 데이터 영역에 위치한 동일한 메모리를 참조한다.

로컬 변수

메소드 또는 중괄호 블록 내부에서 생성되는 변수
스택 영역에 생성되며, 초기화가 자동으로 이루어지지 않는다.
생명 주기(Life cycle)은 생성된 중괄호 블록이 종료될 때 까지이다.

파라미터 변수

메소드에서 값을 호출할 때 넣어 주는 변수. 메소드 내부에서만 사용 가능.

    public void method(int paramVar){ //로컬 파라미터 변수
    System.out.println(paramVar);
    int localVar; //로컬 변수
    System.out.println(localVar); //error 로컬변수는 초기화가 자동으로 안됨. 
    localVar = 10;
    System.out.println(localVar); //이렇게 값을 대입해서 사용해야 한다.
    {
      localVar = 30;
    }
    int localVar2 = 20;
    }
    System.out.println(localVar); //블록 내에서 수정한 것도 반영됨.     
    localVar2 = 40; // 접근 불가. 생명주기가 끝났다. Life-Cycle이 끝났다.



UnitTest And TDD
Sun, 14 Mar 2021 06:57:00 GMT
UnitTest
유닛 테스트(Unit Test)

단위 테스트라고도 불리며, 최소 단위의 테스트를 말한다.
최소 단위는 메소드 단위를 말하는데 어느 정도의 객체 단위라는 것을 포함하고 있다.
객체 단위를 포함하고 있다는 의미는 메소드는 객체의 속성을 변화시키는 side-effect를 가지고 있기 때문이다.


환경 셋업과 환경 정리를 반드시 같이 해줘야 한다.

통합 테스트(Integration Test)

유닛 테스트는 가장 작은 단위로 테스트를 하고 통합 테스트는 시스템 전체적인 테스트를 진행한다.
전체 시스템의 동작을 확인하는 테스트 
내가 작업한 것을 git에 merge해서 전체 시스템이 잘 동작하는지 체크한다.



기존 임시적인 테스트 방식

임시적인 테스트의 문제점!

여러 개의 테스트를 작성하기 어렵고, 여러 개의 테스트를 넣어야 하는데 테스트 내용의 구분이 안간다.

여러가지 테스트를 할 때 '부작용(side-effect)'이 발생하기 쉽다.

밑의 Test2 처럼 Test1의 결과에 영향을 받아서 기대했던 값이 아닌 다른 값이 출력되는 등의 부작용이 발생한다.


테스트 결과가 성공적인지 여부를 파악하기 어렵다

일일이 예상 값을 두고 눈으로 파악해야 하는데, 실제로 테스트를 할 때는 수천 개가 넘는 테스트를 눈으로 파악하기 어렵다.


Production 코드와 Test 코드가 섞이게 된다.
public class ScoreCollection {
private final List scoreList = new ArrayList<>();

public void add(Scorable item){
   scoreList.add(item);

}
public int arithmeticMean(){
   int total = scoreList.stream().mapToInt(Scorable::getScore).sum();
   return total / scoreList.size();
}
}





class Main{
    public static void main(String[] args) {
        ScoreCollection collection = new ScoreCollection();
        // Test1. 5와 7의 평균 6
        collection.add(() -> 5);
        collection.add(() -> 7);
        System.out.println(collection.arithmeticMean());
        // Test2. 10 20 의 평균 15
        // 그런데 Test1의 영향을 받아서 원하는 테스트 출력을 얻지 못했다.
        // Test1과 Test2의 순서가 달라지면, 또 결과가 달라진다.
        collection = new ScoreCollection(); // 초기화해서 원하는 값을 얻을 수 있다.
        collection.add(() -> 10);
        collection.add(() -> 20);
        System.out.println(collection.arithmeticMean());
}
}

## JUnit
* 위의 임시적인 테스트 방법의 문제점을 해결하기 위한 테스트 프레임워크가 있다.
* 인텔리제이, 이클립스에도 다 포함되어 있는 프레임워크로, Production 코드와 Test 코드를 분리하여 테스트 할 수 있다.

* JUnit 설정방법!
  * 왼쪽 상단에 file -> Project Structure -> moudles에 간다.
  * 테스트를 만들 디렉토리 선택하면 그 디렉토리의 하위 디렉토리들이 나오는데 Test할 디렉토리를 선택하고
  Mark as 부분에 Test를 클릭 해주면 테스트 폴더로 변화한다.
  * 원래 Production 코드의 화면에서 마우스 우클릭을 해서 Generate -> Test를 누르고 확인을 누르면 테스트 클래스로 자동으로 만들어준다.

### JUnit을 사용한 테스트 1번
* Test라는 Annotation을 달아줘서 테스트라는걸 인식하게 하고 assert에 값을 넣어줘서 기대값에 맞는지 테스트한다.
* assert 반드시 이렇다 단언하는 것, 결과가 같다고 해주는 것
```java
package com.company.p01;

import org.junit.Test;

import static org.junit.Assert.*;

public class ScoreCollectionTest {
    @Test
    public void arithmeticMeanOfFiveAndSevenResultsInSIx(){
        ScoreCollection collection = new ScoreCollection();
        collection.add(() -> 5);
        collection.add(() -> 7);
        int actualResult = collection.arithmeticMean();
        assertEquals(6,actualResult);

    }
    @Test
    public void arithmeticMeanOfTenAndTwentyResultsInFifteen(){
        ScoreCollection collection = new ScoreCollection();
        collection.add(() -> 10);
        collection.add(() -> 20);
        int actualResult = collection.arithmeticMean();
        assertEquals(15,actualResult);
    }
}
POJO

POJO : Plain Old Java Object 자바 클래스를 의미하는 것인데 클래스 파일 하나가 이런 자바만으로 이루어진 파일이 있을 수 있고 스프링이 묻어 있는 애들이 있을 수 있어서 순수 자바만 이용된걸 포조라고 부른다.
이렇게 불러야 사람들이 그럴듯해 보여서 자바 클래스를 쓰는 것이다.
프로그래밍 언어들은 사람들의 인지적인 관점을 적용하려 애쓴다. 그래서 이러한 용어들을 만들어내고 하는 것이다. 어이없지만 생각보다 중요한 것들이다.
실무에서 사용하는 언어이다 어떤 것인지 알고 있으면 될 것 같다!



JUnit을 사용한 테스트 2번
AAA (Triple-A)

Arrange(준비) - 테스트를 하기 위해서 시스템이 적절한 상태에 있는지 확인,
객체 생성, 객체와의 소통, API 호출


Act (실행) - 실제로 테스트 코드를 실행하는 과정
Assert (단언) - 실행한 코드의 결과를 기대하는 값과 비교
+@ After (사후) - 중간 과정에서 자원을 할당한 경우에는 이를 해제 특수한 경우에만 사용.

package com.company.p02;

public class Account {
    private  int balance;

    public Account(int balance) {
        this.balance = balance;
    }

    public int getBalance() {
        return balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }

    public void withdraw(int value){
        balance -= value;
    }

    public void deposit(int value){
        balance += value;
    }

    public boolean isMinus(){
        return balance < 0;
    }

    public void throwExcept(){
        throw new ArithmeticException();
    }
}

실행 순서
before -> test1 -> before -> test2
beforeClass -> before -> Test1 ->(After) -> before -> test2 -> (After) -> (AfterClass)


import static org.hamcrest.CoreMatchers.* - EqualTo 이런 메소드들을 사용할 수 있게 import 해줘야한다.
@Ignore("This will be tested later") - 테스트를 무시한 채 다른 테스트를 하는것 테스트를 안할 것을 따로 빼놀 때 사용.
fail() - 익셉션이 발생하지 않아도 통과되서 익셉션이 발생하지 않은 경우에 강제로 fail 시켜버리는 것이다
assertThat(actualResult,equalTo(true));
기대값과 출력하려고 하는 값에 대한 정보를 표현할 수 있다. (확인할 수 있음)
단, 실패했을 때 정보를 잘 표현하기 위해서는
hamcrest의 CoreMatchers에 구현된 Matcher를 쓰는 것이 좋다.package com.company.p02;





import org.junit.*;
import org.junit.rules.ExpectedException;
import static org.hamcrest.CoreMatchers.*;
import static org.junit.Assert.*;
public class AccountTest {
    private Account account;
@BeforeClass
public static void classSetUp(){ 
// static으로 만들어야한다 맨 처음 한번 실행 오래되고 
// 딱 한번만 하면 되는 것들 여기다 작성

}

@Before
public void setUpBySetBalanceOneHundred(){ 
//setUp()메소드라고 부른다.
    account = new Account(100); // 1. Arrange
// 각 테스트를 실행할 때마다 매번 다시 실행된다. 초기화가 된다는 의미인듯
}
@Test
public void answerIsMinusWithNegativeBalance(){
// 어렌지와 액트를 구분해줄 필요가 있다 구분하지 않을 때 
// 테스트에 어렌지를 다 구현해줘야하는 문제가 생긴다 그래서 따로 만들어 줄 수있다.
// setUp() 메소드를 만든다.
//        Account account = new Account(100); // 1. Arrange
    account.withdraw(150); // 2. Act
    boolean actualResult = account.isMinus();
    // boolean에 대한 assertion은 assertTure, assertFalse를 쓰면 좋다.
//        assertFalse(actualResult);
        // 이건 실패 성공에 대한 것만 나오고 내용이 나오지 않는데 
        // assertThat()은 틀렸을 때 정보를 볼 수 있음
        // assertTure, False가 있다.
    assertThat(actualResult,is(equalTo(true))); // 3. Assert
    // 인지적으로 일기 좋게 actualResult is equalTo false로 문장처럼 읽히게 해준다.

    assertThat(actualResult,not(equalTo(false))); // is <-> not
    // not에 경우엔 not일 때 동작을 하게 된다. 이때 테스트가 통과됨.
}
@Test
public void answerIsNotMinusWithPositiveBalance(){
    account.withdraw(50);
    boolean actualResult = account.isMinus();

    assertThat(actualResult,is(not(equalTo(true))));
}

// 가능하면 모든 메소드르 테스트하되 우선순위를 정해서 하는 것이 좋다.

@Test
public void checkPositiveBalanceAfterWithdrawal(){
    account.withdraw(80);
    int actualResult = account.getBalance();
    assertThat(actualResult,is(equalTo(20)));
}

@Test
@Ignore("This will be tested later") 
// 테스트를 무시한 채 다른 테스트를 하는것 테스트를 안할 것을 따로 빼놀 때 사용, 
// 이것을 남겨두고 커밋하지마세요
// 임시로만 사용해야 한다.
public void checkNegativeBalanceAfterWithdrawal(){
    account.withdraw(130);
    int actualResult = account.getBalance();
    assertThat(actualResult,is(equalTo(20)));
}

// ArithmeticException이 발생하는지 assert하는 테스트

// 간단하다는 장점이 있지만, 인지적으로는 별로 좋지 않음 
// 테스트 메소드 내부에 assert가 드러나지 않는다.
@Test(expected = ArithmeticException.class) 
// ArithmeticException을 넣어줘서 ArithmeticException인지 확인
public void checkExceptionByAnnotation(){
    account.throwExcept();
}

// 인지적으로 더 개선되나, 코드가 매우 복잡해진다.
@Test
public void checkExceptionByTryCatch(){
    try{
//            account.throwExcept();
            fail(); 
            // 익셉션이 발생하지 않아도 통과되서 익셉션이 발생하지 않은 경우에 강제로 fail시켜버리는 것이다
        } catch (ArithmeticException e){
            assertThat(e.getClass(), equalTo(ArithmeticException.class));
//  아리스메틱 클래스의 클래스 클래스(클래스의 정보를 가지고 있는)를 가져온다. 
//  그래서 그것이 맞는지 비교.
//            e.getClass() == ArithmeticException.class
        }
    }
// Rule을 이용하면 메소드 코드에 excepted exception이 드러나서
// 인지적으로 개선 가장 추천함.
@Rule
public ExpectedException thrown = ExpectedException.none();

@Test
public void checkExceptionByRule(){
    thrown.expect(ArithmeticException.class); 
    // ArithmeticException을 기대한다고 써놔서 인지적으로 더 잘 이해가능
    // 이렇게 해줬을 때 프레임워크에 가서 이 익셉션이 
    // 프레임워크에 올라가서 메소드가 동작할 때 익셉션이 발생했을 때 캐치해준다.
    account.throwExcept();
}
}

### 좋은 테스트의 조건(FIRST)
#### Fast
* 전형적인 자바 시스템의 테스트 케이스는 수천 단위 (유닛테스트 기준)
* 평균 200ms가 걸린다 했을 때 (느린 경우를 예로), 5000개를 수행한다 했을 때  16분이 소요된다.
   * 우리가 코드를 1번 수행할 때 마다 매번 16분의 테스트를 수행해야 한다.(굉장히 안좋음)
   * 메소드에 테스트용 우회 코드를 넣거나, stub 객체를 활용

#### Isolated : 고립된
* 테스트는 순서와 시간에 영향을 받지 않아야 한다.
* 고립되지 않은 테스트는 실패했을 때 원인을 찾기 어렵다.(고립되지 않은 경우를 다봐야하므로 어렵다 후폭풍이 엄청난다 외부환경과 격리를 시켜야한다)
* 테스트를 하면서 다른 테스트에 영향을 받지 않아야 한다.

#### Repeatable : 반복 가능한
* 테스트를 반복하면 결과가 같아야 한다.
* 테스트 코드 자체만으로 그 내용을 설명할 수 있어야 한다.
   * 외부 환경에 영향을 받지 않아야 한다.
* 코드 내에서 코드가 작동한 시간, 이런 것에 따라 동작이 달라지는 것에 영향을 받지 않아야 한다.
#### Self-vlidating : 스스로 검증 가능한(굉장히 중요함)
* 테스트는 반드시 기대하는 바를 단언해야 한다.
   * ex) main 메소드에서 이것 저것 프린트해보고 동작시켜보기
* 테스트는 스스로 검증하며, 테스트를 준비하는 것도 스스로 한다. arranged와 assert를 스스로한다
* Continuous Integration(CI) 도구를 활용하기 위해 이것이 꼭 이루어져야 한다
   * 코드가 통합될 때마다 자동으로 모든 테스트를 수행하고, 상태를 점검하는 프레임워크를 CI도구라고 한다.
#### Timely : 적시의, 제때
* 변화하는 코드는 테스트 코드를 항상, 꾸준히 작성해야 한다.(변화하는 코드이니깐 테스트를 작성해야 한다.)
* 리뷰 시스템을 통해서 , 혹은 CI도구를 이용해서 테스트 코드 작성을 강제하기도 한다.
   -> peer Pressure 동료에게 드러내야 하기 때문에 압박감을 받음 테스트가 없으면 커밋이 안됨
* 큰 결함 없이 기존의 잘 동작하는(변경 예정이 없는) 코드 보다는
  말썽을 일으키는, 계속해서 변하고 있는 동적인 코드에 대한 테스트를 먼저 작성해야한다.
  (현실적으로 힘들어서 이렇게 명시를 하는 것이다.)

### JUnit을 사용한 테스트 3번 - Stub 이용
* Stub : 실제 코드나 아직 준비되지 못한 코드를 미리 정해진 답변으로 가장하는 것
   * dummy 객체가 마치 실제로 동작하는 것처럼 보이도록 만들어 놓은 것
````java
package com.company.p04;

import java.io.IOException;
import java.net.MalformedURLException;

public interface Http {
    String get(String targetUrl) throws IOException;
}
package com.company.p04;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;

public class HttpImpl implements Http{
    @Override
    public String get(String targetUrl) throws IOException {
        URL url = new URL(targetUrl);
        HttpURLConnection con = (HttpURLConnection) url.openConnection();
        con.setRequestMethod("GET");

        int responseCode = con.getResponseCode();
        BufferedReader in = 
             new BufferedReader(new InputStreamReader(con.getInputStream()));

        String inputLine;
        StringBuilder response = new StringBuilder();

        while ((inputLine = in.readLine()) != null){
            response.append(inputLine);
        }
        in.close();
        System.out.println("Response code : " + responseCode);

        return response.toString();
    }
}

dependency injection
테스트 케이스로 인해서 더 테스트하기 좋은 코드로 리팩토링했다. 이부분이 중요함!!!!package com.company.p04;





import java.io.IOException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class WebParser {
    private Http http;
// dependency injection di를하기위해 리팩토링을함
// 테스트 케이스로 인해서 더 테스트하기  좋은 코드로 수정하였다. 이부분이 중요함!!!!
public WebParser(Http http) {
    this.http = http;
}

public int countImageFromWebPage(String url) throws IOException {
    String text = http.get(url); // DI 적용
//        String text = new HttpImpl.get(url); 원래 코드
    Pattern pattern = Pattern.compile("(\\w+.(png|jpg|gif))");
    Matcher matcher = pattern.matcher(text);

    int count = 0;
    while (matcher.find()){
        count++;
    }

    System.out.println(text);
    return count;
}
}
```java
package com.company.p04;

import org.junit.Before;
import org.junit.Test;

import java.io.IOException;

import static org.hamcrest.CoreMatchers.*;
import static org.junit.Assert.*;

public class WebParserTest {
    // 이렇게 테스트하면 문제점
    // 1. Fast에 맞지 않는다 느리다. 구글에 요청을 보내서 받아오는데 
    // http 반응 속도가 느려서 그런 것이다. 인터넷 연결이 순간 안될 수도 있다.
    // 2. 웹페이지 내용이 변할 수 있다. (기대값이 변할 수 있다.)

//    @Test
//    public void countImageFromGoogleDotCom() throws IOException {
//        WebParser parser = new WebParser();
//        int actualResult =parser.countImageFromWebPage("http://google.com");
//
//        assertThat(actualResult, equalTo(5));
//    }

    private WebParser parser;
    @Before
    public void setUpUsingPageWithThreeImages(){
        // DI를 이용해 Http 객체의 stub을 구현하여 넣어준다. 
        // 실제로 웹파서를 이용할 때 HttpImpl을 만들어서 넣어주면 된다.
        parser = new WebParser((targetUrl) -> {
            return " 
               "; 
            // 테스트 하고자하는 상황을 더 넣으면 더 의미가 있어짐
        }); 
        // 이미지가 3개 나온다는걸 설정을 해줬다. 테스트가 많아질수록 의미가 있어진다.

    }
    @Test
    public void countImageFromThreeImagePageStub() throws IOException {
        int actualResult = parser.countImageFromWebPage("http://google.com");
        assertThat(actualResult, is(equalTo(3)));
    }

}
TDD(Test-Driven-Development) - 테스트 주도 개발

'실패하는' 테스트 케이스를 먼저 작성하고, 이것을 통과시키는 방식으로 코드를 구현하는 방식
테스트 케이스 작성 -> 코드 구현 -> (커밋) -> (리팩토링) -> 테스트 케이스 작성 .. 을 빠르게 반복
1~2분 간격으로 매우 빠른 호흡으로 진행
매번 커밋을 해줘서 돌아갈 수 있는 때를 확보를 하는 것이다.


도메인 지식이 없어도 테스트 케이스를 작성할 수 있다는 관점에서 시작.
도메인 지식이란 : 프로그래밍하고 상관없이 서비스할 분야에 대한 전반적인 지식을 의미한다.package com.company.p05;





/**

I-> 1
II -> 2
III -> 3
IV -> 4...
/

public class RomanConverter {
    private String roman = "";
public void setRoman(String roman) {
    this.roman = roman;
}

// 들여쓰기가 2번넘게 들어가면 리팩토링을 하는게 맞다.
public int transform() {
    if (roman.equals("")){
        throw new ArithmeticException();
    }
    if (roman.contains("X")){
        return 10;
    }
    int count = 0;
    boolean beforeV = roman.contains("V") ? true : false;
    for (char c: roman.toCharArray()){
        if (c == 'I'){
            count += beforeV ? -1 : 1;
        }
        // 4
        if (c == 'V'){
            beforeV = false;
            count += 5;

        }
        // 6을 했을때 I가 앞에나오는지 뒤에나오는지 구별을해야하는 상황이 됐다.
    }
    return count;
}
}
```java
package com.company.p05;

import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import static org.hamcrest.CoreMatchers.*;
import static org.junit.Assert.*;

public class RomanConverterTest {
    RomanConverter converter;

    @Before
    public void setUp() throws Exception {
        converter = new RomanConverter();
    }

    @Rule
    public ExpectedException thrown = ExpectedException.none();

    @Test
    public void exceptionWhenRomanNotSet(){
        thrown.expect(ArithmeticException.class);
        int actualResult =  converter.transform();
    }

    @Test
    public void convertI(){
        converter.setRoman("I");
        int actualResult = converter.transform();
        assertThat(actualResult, is(equalTo(1)));
    }

    @Test
    public void convertX(){
        converter.setRoman("X");
        int actualResult = converter.transform();
        assertThat(actualResult, is(equalTo(10)));

    }

    @Test
    public void convertIII(){
        converter.setRoman("III");
        int actualResult = converter.transform();
        assertThat(actualResult, is(equalTo(3)));
    }

    @Test
    public void convertIV(){
        converter.setRoman("IV");
        int actualResult = converter.transform();
        assertThat(actualResult, is(equalTo(4)));
    }

    @Test
    public void convertVI(){
        converter.setRoman("VI");
        int actualResult = converter.transform();
        assertThat(actualResult, is(equalTo(6)));
    }
}


This
Sun, 14 Mar 2021 06:35:20 GMT
This 키워드

객체가 스스로를 가르키는 참조, 자신의 메모리를 가리킨다.
인스턴스 자신의 주소를 반환한다.
멤버 변수와 로컬 변수의 이름이 같을 때, 멤버 변수임을 명시

생성자에서 다른 생성자를 호출하는 예제

생성자를 호출하는 데에도 사용할 수 있다.

생성자 오버로딩에서 한 클래스 안에 생성자가 여러개 있을 수 있는데
한 생성자에서 다른 생성자를 호출하는 경우가 종종있다.


this() 호출시에 반드시 생성자의 첫 줄에서만 사용해야 한다.

생성자는 인스턴스의 값들을 초기화하는 인스턴스 생성을 초기화하는 역할을 한다.
this()로 다른 생성자를 호출할 때, 호출한 생성자가 무슨일을 할 줄 모르는 상태인데 this() 호출 보다 먼저 값들을 초기화한다고 하면,
다른 생성자를 호출할 때 다른 스테이트가 올라가는 것을 허용하지 않는다. 그래서 호출은 가장 첫줄에 써야 한다.

public class Constructor {
    int x;
    int y;
    String z;

    public Constructor(){ // 기본 생성자, 구현하지 않아도 알아서 생긴다.
        this(0,0);
//        x = 1;
//        y = 2;
//        z = "자동 초기화 값이 들어간다.";
    }





  // 파라미터 생성자
   public Constructor(int x, int y, String z){ //오버로딩
       this.x = x; // this는 멤버 변수를 표기하기 위해 사용될 수 있다.
       this.y = y;
       this.z = z;
   }

   public Constructor(int a, int b){
       this(a,b,""); 
    // 자기 자신을 가르키는 애 위에 함수가 호출됨.
    // this는 무조건 첫줄에만 쓰일 수 있다.(단한번) 규칙입니다.
   //        x = a;
   //        y = b;
   //        z = "";
       }
   }
 ````
자기 자신의 메모리를 가리키는 this 예제

public class MyDate {
    private int day;
    private int month;
    private int year;

    private boolean isVaild = true;

    public  void setDay(int day){
        this.day = day;
    }
    public int getDay(){
        return day;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        if(month <1 || month > 12){
            isVaild = false;
        }
        this.month = month;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public void showDate(){
        if (isVaild){
            System.out.println(this.year + "년" + this.month + "월" +this.day+"일");
        }else{
            System.out.println("유효하지 않은 범위 입니다.");
        }
    }
}

public class MyDateTest {
    public static void main(String[] args) {
        MyDate date = new MyDate();

        date.setYear(2019);
        date.setMonth(13);
        date.setDay(10);

        date.showDate();

    }
}

인스턴스 자신의 주소를 반환할 일이 있으면 this를 반환 하면 된다.

day로부터 setYear라는 메소드를 호출하게 되면 setYear는 BirthDay에 대한 메소드이니깐

setYear의 세그멘테이션이 stack영역에 만들어지고 만약 setYear 안에서 this를 썼다하면 힙영역의 BirthDay에 대한  메모리를 가리킨다.
인스턴스 내부에서(객체 내부에서) 자기 자신이 생성된 메모리 주소를 가리킨다.
인스턴스가 여러 개 생성 됬다 하면 각각의 this는 다 다름 코드상에서 this하나만 쓰지만 각각은 다 다르다

여기서 stack 영역에 this가 들어가게 되는데 왜 this가 들어가는지 이해가 안 갔는데

메인에서 this가 date.setYear() 이런식으로 호출이 되어있다면 this는 date변수 대신이라고 생각해도 될까?

로컬변수에 this는 참조변수로 생성된다. 그런의미로 이해하면 될 것 같다.


자기 자신을 반환하는 this
public Person getPerson(){
     return this;
}



Stream API
Sun, 14 Mar 2021 06:19:34 GMT
스트림 API(Stream API)

여기서 말하는 스트림과 나중에 자바 io에서 말하는 스트림은 다른 것이다.
여기서의 스트림은 자료의 연산을 위해서 사용하는 객체를 말한다.
자바 io에서의 스트림은 입출력을 위한 스트림이다.스트림 API



Java 8에서 추가된 Java.util.stream 패키지
컬렉션의 요소를 람다식으로 처리할 수 있도록 하는 함수형 프로그래밍 도구
스트림 API는 데이터를 추상화하여 다루므로, 다양한 방식으로 저장된 데이터를 읽고 쓰기 위한 공통된 방법을 제공한다.
따라서 스트림 API를 이용하면 배열이나 컬렉션뿐만 아니라 파일에 저장된 데이터도 모두 같은 방법으로 다룰 수 있게 된다.
중간 연산과 최종 연산으로 구분 된다,최종 연산이 수행되어야 모든 연산이 적용되는 지연 연산이다.

스트림의 특징
1. 스트림은 한 번 밖에 사용 못한다.

내부적으로 몇번째 동작을 하고 있는지 체크하는 것이 들어가 있다. 그래서 사용할 때마다 다시 정의해주고 사용해야 한다.2. 간결한 코드로 작성할 수 있다.
// 기존의 Java 7방식의 작성 방법
List list = Arrays.asList("fast","campus","rocks");
List newList = new ArrayList<>();



for (String s : list){
    newList.add(s.toUpperCase());
}
for (String s : newList){
    System.out.println(s);
}
```java
// java 8 - Stream API -> 훨씬 더 간결한 코드로 작성할 수 있다.
List list1 = Arrays.asList("fast","campus","rocks");
Stream stream = list1.stream(); //스트림으로 변환해준다.

// 스트링에서 스트림으로 매핑해준다.
//uppercase를 string에 매핑, 각각의 요소에 적용해라
stream.map(String::toUpperCase).forEach(System.out::println); // foreach는 Consumer를 받는다,각각의 요소를 하나씩 출력한다.
3. 데이터 소스에 대한 공통된 접근 방식 제공.

Stream으로 변경해주고 나면, List, Set, Map 모두 동일한(표준화된) 방식으로 데이터를 접근 가능.
컬렉션 프레임워크는 각각을 다른 방식으로 데이터를 처리 해줘야 한다.
특히 Stream::sorted() 메소드는 공통된 정렬 방식을 제공한다.

4.중간 처리와 최종 처리를 지원한다.

Mapping, Filtering, Sorting 등 중간 처리 지원(여러 개 사용이 가능하다.)
Iteration, Count, Average, Summation, Reduce 등 최종 처리 지원(마지막에 하나 사용 가능하다.)

5.데이터 소스와 처리 결과를 분리

원본 데이터를 유지하여 처리하는 것에 의한 부작용을 방지한다.
처리 결과를 새로운 컬렉션으로 저장이 가능하다.

6. 람다식으로 요소 처리 코드를 제공한다.

스트림이 제공하는 대부분의 요소처리 메소드는 함수적 인터페이스 매개타입을 가진다.   
매개값으로 람다식 또는 메소드 참조를 대입할 수 있다.
(함수적 인터페이스 매개타입을 가지기 때문에 람다식,메소드 참조로 매개값을 제공할 수 있음)

7. 내부 반복자를 사용하므로 병렬 처리가 쉽다.

외부 반복자 - 개발자가 코드로 직접 컬렉션 요소를 반복해서 요청하고 가져오는 코드패턴
(Iterator를 생각하면 될 것 같다. Iterator을 사용해서 반복문을 구현해서 하나씩 값을 출력하게
코드를 구현해야 하는 것을 말하는 것 같다.)

내부 반복자 - 컬렉션 내부에서 요소들을 반복시키고 개발자는 요소당 처리해야할 코드만 제공하는 코드 패턴
 (forEach메소드 처럼 내부가 어떻게 구현되어있는지 모르지만 이것을 사용하면 요소들 하나씩 가져오라는 코드가 없지만 
 알아서 반복해서  반환시켜 처리해준다. 이런 것을 의미하는 것 같다)

내부 반복자의 이점 - 개발자는 요소 처리 코드에만 집중, 멀티 코어 cpu를 활용하기 위해 요소들을 분배시켜 병렬 처리 작업을 수 있다.

컬렉션의 요소가 많을 경우에 요소를 나눠서 별도의 스트림으로 만들어서 각각의 코어에서 병렬적으로 처리할 수 있다.



스트림 API를 이용한 자료 처리
스트림 API의 종류



종류
처리 대상



Stream
일반적인 객체를 처리


IntStream
기본 자료형 int를 처리


LongStream
기본 자료형 long을 처리


DoubleStream
기본 자료형 double을 처리


스트림 객체 생성 메소드

데이터 소스(인터페이스, 클래스)로부터 스트림 생성




데이터 소스
메소드



Collection
default Stream stream()


Collection
default Stream parallelStream()


Arrays
public static  Stream stream(T[] array)


Arrays
public static  Stream of(T ... values)


Arrays
public static IntStream stream(int[] array)


Arrays
public static IntStream of(int ... values)


Arrays
public static LongStream stream(long[] array)


Arrays
public static LongStream of(long ... values)


Arrays
public static DoubleStream stream(double[] array)


Arrays
public static DoubleStream of(double ... values)



정수 범위와 java.util.Random으로부터 생성




구분
메소드



int형 범위
public static IntStream range(int startInclusive, int endExclusive)


int형 범위
public static IntStream rangeClosed(int startInclusive, int endInclusive)


long형 범위
public static LongStream range(long startInclusive, long endExclusive)


long형 범위
public static LongStream rangeClosed(long startInclusive, long endInclusive)


Random p형 값
public PStream ps()


Random p형 값
public PStream ps(long streamSize)


Random p형 값
public PStream ps(long streamSize, p origin, p bound)


스트림 생성 방식 예제

컬렉션의 인스턴스 메소드 stream()
Stream stream1 = list1.stream();

Arrays 클래스의 클래스 메소드 stream() 을 이용
// 함수형 인터페이스랑 비슷함 P Type
// LongStream, DoubleStream 도 있다.
int[] ints = {4, 6, 2, 19, 2, 58, 4, 6, 5};
IntStream intStream = Arrays.stream(ints);
intStream.forEach(System.out::println);

위의 두 개의 다른점

Stream로 할 경우, Primitive Type이 들어올 때 오토박싱으로 변경되고 다시 출력할 때 언방식이 되는데 이럴 때 오버헤드가 발생한다.
IntStream을 사용 할 경우, 오버헤드 필요 없이, WrapperClass없이 사용 가능하다. 그래서 효율적이다.


Stream 클래스의 클래스 메소드 of()를 이용해서 Collection을 걸치지 않고도 스트림을 생성 가능
DoubleStream doubleStream = DoubleStream.of(0.4, 0.6, 0.2, 1.2, 0.94);
doubleStream.forEach(System.out::println);

range()를 이용한 스트림 -> for i문 (for(int i=0...))을 대체하는 스트림

rangeClosed() : 0~10까지 10을 포함한다.

순서대로 값을 출력한다.
IntStream intStream1 = IntStream.range(0,10); // 0~9까지 10은 포함되지 않는다.
intStream1.forEach(System.out::println);



IntStream intStream2 = IntStream.rangeClosed(0,10); // 0~10까지 10포함된다.
intStream2.forEach(System.out::println);
// LongStream도 range, rangeClosed 가 있다.

* Random 객체를 이용한 스트림이 있다. Java.util 패키지 안에 있다.
```java
Random random = new Random();
// LongStream longStream =  random.longs();
// longStream.forEach(System.out::println); // 개수 제한 없이 무한히 출력

// 개수 제한 가능
LongStream longStream1 =  random.longs(100);
longStream1.forEach(System.out::println); // 개수를 정해질 수있다 100개

// 개수제한 + 범위 제한 가능 젤 많이 사용함
LongStream longStream2 =  random.longs(100,0,1000);
longStream2.forEach(System.out::println); // 개수를 정해질 수있다 0~1000까지 100개를 출력
중간 처리 메소드

https://velog.io/@im_joonchul/Java-Stream%EC%A4%91%EA%B0%84%EC%B2%98%EB%A6%AC%EB%A9%94%EC%86%8C%EB%93%9C최종 처리 메소드

https://velog.io/@im_joonchul/Java-Stream%EC%B5%9C%EC%A2%85%EC%B2%98%EB%A6%AC%EB%A9%94%EC%86%8C%EB%93%9C

병렬 스트림
병렬 처리

한가지 작업을 서브 작업으로 나누고, 서브 작업들을 분리된 스레드에서 병렬 적으로 처리한 후,
서브 작업들의 결과들을 최종 결합하는 방법, 자바는 ForkJoinPool 프레임워크를 이용해서 병렬 처리를 한다.

병렬 스트림의 생성

stream() 대신 parallelStream()으로 변경

stream 생성 후 parallel()으로 병렬화

combiner를 이용해 병렬 스트림으로 생성된 컬렉션을 결합


BiConsumer combiner : T 객체에 K 객체를 결합 



인터페이스
리턴타입
메소드(매개변수)



java.util.Collection
Stream
parallelStream()


java.util.Stream
Stream
parallel()


java.util.Intstream
IntStream



java.util.Longstream
Longstream



java.util.Doublestream
Doublestream




parallelStream()
컬렉션으로부터 병렬 스트림을 바로 리턴


parallel()
순차 처리 스트림을 병렬 스트림으로 변환해서 리턴





병렬성 구분

데이터 병렬성

데이터 병렬성은 한 작업 내에 있는 전체 데이터를 쪼개어 서브 데이터들로 만들고
 이 서브 데이터들을 병럴 처리해서 작업을 빨리 끝내는 것을 말한다.


작업 병렬성
작업 병렬성은 서로 다른 작업을 병렬 처리하는 것을 말한다.
작업 병렬성은 대표적인 예는 웹서버이다.
웹 서버는 각각의 브라우저에서 요청한 내용을 개별 스레드에서 병렬로 처리한다.




병렬 스트림은 데이터 병렬성을 구현한 것이다.

멀티 코어의 수만큼 대용량 요소를 서브 요소들로 나누고,
 각각의 서브 요소들을 분리된 스레드에서 병렬 처리시킨다.
예를 들어 쿼드 코어cpu일 경우 4개의 서브 요소들로 나누고,
4개의 스레드가 각가의 서브 요소들을 병렬처리한다.
병렬 스트림은 포크조인 프레임워크를 이용한다.



Stream parStream = Arrays.stream(arr).parallel(); //  스트림을 parallel로 바꿔줌
System.out.println(parStream.map(String::length).count());
// parallelStream을 사용하면 연산 순서가 달라질 수 있다.

List list4 = List.of("atwe","bff","cqqqw","dtwer");
Stream stream6 = list4.parallelStream(); // 어떤 요소가 먼저 수행되는지 알 수 없음
// Stream stream6 = list4.stream();

stream6.map(String::length).peek(s->System.out.println("A: "+ s))
              .filter(value->value >=3)
              .peek(s-> System.out.println("B :"+ s))
              .forEach(System.out::println);
포크조인 프레임워크(ForkJoin Framework)

포크조인 프레임워크 동작 방식

포크 단계

데이터를 서브 데이터로 반복적으로 분리한다.
서브 데이터를 멀티 코어에서 병렬로 처리한다.


조인 단계

서브 결과를 결합해서 최종 결과를 만들어 낸다.


실제로 병렬 처리 스트림은 포크 단게에서 차례대로 요소를 4등분 하지 않는다.내부적으로 서브 요소를 나누는 알고리즘이 있기 때문에 개발자는 신경 쓸 필요가 없다.



포크조인풀(포크조인프레임워크는 내부적으로 스레드를 포크조인풀에서 관리한다.)
각각의 코어에서 서브요소를 처리하는 것은 개별 스레드가 해야하므로 스레드 관리가 필요
코어에서 작업을 할려면 코어별로 각각의 스레드가 존재해야한다.


포크조인 프레임워크는 ExcutorService의 구현 객체인 ForkJoinPool을 사용
4개의 코어를 가진 cpu일 경우





병렬 처리 성능

병렬 처리는 항상 빠르다?

스트림 병렬 처리가 스트림 순차 처리보다 항상 실행 성능이 좋다고 판단해서는 안된다.


병렬 처리에 영향을 미치는 3가지 요인

요소의 수와 요소당 처리 시간 - 요소우의 수가 적고 요소당 처리시간이 짧으면 순차 처리가 오히려 병렬처리보다
빠를 수 있다 병렬처리는 스레드풀 생성, 스레드 생성이라는 추가적인 비용이 발생하기 때문이다.

스트림 소스의 종류

ArrayList, 배열은 램덤 액세스를 지원(인덱스로 접근)하기 때문에 포크 단계에서 쉽게 요소를
분리할 수 있어 병렬 처리 시간이 절약된다, 반면 HashSet, TreeSet은 요소를 분리하기가 쉽지않고,
LinkedList는 램덤 액세스를 지원하지 않아서 요소를 분리하기가 쉽지 않다.
또한, BufferedReader.lines()은 전체 요소의 수를 알기 어렵기 때문에 포크 단계에서 부분 요소로
나누기 어렵다. 따라서 이들 소스들은 ArrayList, 배열 보다는 상대적으로 병럴처리가 늦다.


코어의 수 
 *싱글코어 cpu일 경우 순차처리가 빠르다. 코어의 수가 많으면 병렬처리 속도가 빨라진다.




패럴레 스트림을 사용한다는 것이 어떤 의미인가

원래 스트림(페럴레아닌 상태)은 [0,0,0,0,0,0] 이런게 있다로 시작, 스트림을 정하고 맵이 있으면 맵을 한 결과가 나와야함[0,0,0,0,0,0]
그런다음 맵을 한 번 더 실행하고 [0,0,0,0,0,0] foreach가 실행이 된다. 하나하나가 함수로 소비가 되는 상태가 된다
하나씩 처리가 된다 각 요소 가 모든 연산이 쭉되고 다음 요소가 모든 연산이 실행이 됨
그 중간에 peek(),peek(),foreach()의 결과가 출력이 된다 이것이 우리가 생각하는 기본적인 스트림

병렬 스트림 동작

자바에서 스레드가 기본적인건 모르겠으나 여기서 7개의 스레드가 각각있다고 가정하고 동시에 동작을한다

스레드는 프로그램을 동작할 때 한줄씩 실행되는데 이 한 줄씩 실행되는 것이 여러개 있는 것이다.각각 독립적으로 한줄을 실행한다.

한줄 한줄 계산하는게 동시에 계산해도 된다 각각을 순수함수로 되어있어야 하니깐

여기서 한줄이란 세로로 한줄이 시작되고 그옆에 세로가 시작되는건데 병렬처리면 스레드의 개수에 따라
이 세로줄의 실행이 스레드 개수에 따라서 한번에 실행된다는 의미이다 4개스레드이면 4개의 세로줄이 동시에 실행됨.
한줄 계산되는 동안 다른 한줄이 같이 계산되고 몇개가 같이 연산이 진행되는진 모르지만 스레드의 개수에 따라 한줄이 같이 진행됨


[0,0,0,0,0,0]

[0,0,0,0,0,0]

[0,0,0,0,0,0]

[0,0,0,0,0,0]

명령형/ 순차처리 <-> 함수형/병렬처리 큰 간극을 보인다






Java Stream_최종처리메소드
Sun, 14 Mar 2021 06:05:06 GMT
최종 처리 메소드



동작
메소드



루핑
forEach()


매칭
allMatch(), anyMatch(), noneMatch()


집계
count(), max(), min(), average(), sum(), reduce()


조사
findFirst(), findAny()


수집
collect()


루핑
forEach() 메소드로 스트림 요소를 순차적으로 Consumer를 이용해 소비

forEach() - 요소들을 계속해서 반복해서 가져와라라는 의미이다.
stream.forEach(name -> System.out.println(name))으로 되어있을 때
스트림에 가져온 요소를 name에 넣어서 하나씩 출력되게 하는 것이다.
매개값의 형태는 Consumer 함수형 인터페이스 타입을 갖는다.


void forEach(Comsumer action) : 스트림의 각 요소를 action으로 소비  

매칭
Predicate 계열을 이용해 스트림 요소들이 특정 조건에 만족하는지 조사하는 메소드

boolean allMatch(Predicate predicate) : 스트림의 모든 요소가 Predicate를 만족하면 true를 반환

boolean anyMatch(Predicate predicate) : 스트림의 요소 중 하나라도 Predicate를 만족하면 true를 반환

boolean noneMatch(Predicate predicate) : 스트림의 요소 중 하나라도 Predicate를 만족하지 않으면 true를 반환
Stream st0 = Stream.of("abc","cde","efg");
System.out.println(st0.allMatch(s -> s.equals("abc"))); //false
st0 = Stream.of("abc","cde","efg");
System.out.println(st0.anyMatch(s -> s.equals("cde"))); //true
st0 = Stream.of("abc","cde","efg");
System.out.println(st0.noneMatch(s -> s.equals("abcde")));//true
조사
첫번째 요소 또는 아무 요소를 조사하는 최종 처리 메소드. 필터링 등으로 인해 스트림에 요소가 남아있는지 확인할 수 있다.

Optional findFirst() : 스트림의 첫 요소 또는 empty Optional 객체를 반환

Optional findAny() : 스트림의 아무 요소나 가지는 Optional 객체를 반환 (병렬 스트림일 때 사용한다.)
int firstValue = Arrays.stream(new int[]{1,2,3,4,5})
                .filter(n -> n%3 ==0)
                .findFirst()
                .getAsInt();


집계 (통계)

최종 처리 기능

카운팅, 합계, 평균값, 최대값, 최소값 등과 같이 하나의 값으로 산출한다.
대량의 데이터를 가공해서 축소하는 리덕션이라고 볼 수 있다.


기본 집계 메소드

기본형 스트림의 통계 : count(), sum(), average(), min(), max()
T 타입 스트림의 통계 : count(), min(), max() (min, max의 경우 Comparator 필요)



reduce() 메소드 : 사용자 정의 집계 메소드

모든 자료형에서 사용할 수 있는 집계 메소드이다!
개발자가 프로그램화해서 다양한 집계(리덕션) 결과물을 만들 수 있다.
특정한 값을 집계 할 수 있게 하기 위해서 reduce를 제공한다.

세가지 인자를 받아서 처리

accmulator : 각 요소를 처리하는 계산 로직이다. 각 요소가 올 때마다 중간 결과를 생성한다. Optional reduce(BinaryOperator accumulator) 
 //accumulator를 수행하고 Optional 타입 반환

identity : 계산을 위한 초기값이다. stream이 비어서 계산할 값이 없더라도 이 값은 반한된다. T reduce(T identity, BinaryOperator accumulator) 
 // identity를 초기값으로 하여, accumulator를 이용해 집계 연산

combiner : 병럴 stream에서 나눠 계산한 결과를 하나로 합쳐 반환한다.  U reduce(U identity, BiFunction accumulator, BinaryOperator combiner) 
 // combiner를 이용해 병렬 스트림 결합



메소드 형태 및 사용코드



인터페이스
리턴 타입
메소드



Stream
Optional
reduce(BinaryOperator accumulator



T
reduce(T identitiy, BianryOperator accmulator)


IntStream
OptionalInt
reduce(IntBinaryOperator  op)



int
reduce(int indentity, IntBinaryOperator  op)


LongStream
OptionalLong
reduce(LongBinaryOperator  op)



long
reduce(long indentity, LongBinaryOperator  op)


DoubleStream
OptionalDouble
reduce(DoubleBinaryOperator  op)



double
reduce(double indentitiy, DoubleBinaryOperator  op)



reduce(BinaryOperator accumulator)

이건 연산의 결과가 없으면 예외가 발생한다. NotSuchElementException 요소가 있어야 동작한다.


reduce(T identitiy, BianryOperator accmulator) 

연산의 결과가 없다면, 디폴트로 identity 사용  요소가 없어도 동작한다.
연산의 결과가 없는 것은 요소가 없는 것이다. 그래서 연산의 결과로 디폴트 값으로 identity를 하는 것이다.


매개변수

XXXBinaryOperator : 두 개의 매개 값을 받아 연산 후 리턴하는 함수적 인터페이스
identity : 스트림에 요소가 전혀 없을 경우 리턴될 디폴트 값   

System.out.println(IntStream.range(0,10).reduce(0,(value1,value2)->value1+value2)); //sum()
// 1,2와 더한걸 3이랑 더하고 12 와 3을 더한걸 4 와 더함 .. 누적해서 더하는 것이다.
// identity가 사용이 되는 이유는 처음 identitiy와 1을 더한값과 2를계산하기위해서
// 0 [0,1,2,3,4,5,6,7,8,9] 0+0 =0 -> 0+1->1 1+2-> 3 과같은 연산 0~9까지 더한 연산
// sum()으로도 나타낼 수 있다 sum,min,max등등 도 reduce로 구현되어 있다

System.out.println(IntStream.range(0,10).reduce(Integer.MAX_VALUE,(value1,value2)->value1



Optional 클래스

T 타입 객체의 null 여부에 따라 다르게 동작하는 Wrapper 클래스

자바 8부터 추가된 값을 저장하는 값 기반 클래스

java.util 패키지의 Optional, OptionalDouble, OptionalInt, OptionLong 클래스를 말한다.

집계 메소드의 리턴 타입으로 사용되어 집계 값을 가지고 있다. 이게 핵심이다!!

저장된 값을 얻으려면 get(), getAsDouble(), getAsInt(), getAsLong()를 호출한다. 

Optional 클래스의 정적 메소드를 이용해 Optional 객체 생성

public static  Optional of(T value) : value가 null인 경우 NullPointerException을 발생시키는 Wrapping 메소드
public static  Optional ofNullable(T value) : value가 null인 경우 empty()의 결과를 리턴하는 Wrapping 메소드
public static  Optional empty() : 값이 비어있는 Optional 객체를 리턴


Optional 객체를 처리하는 메소드

public T get() : Optional의 값을 리턴하며, null일 경우 NullPointerException 발생
public void ifPresent(Consumer consumer) : Optional 값이 null이 아닐 경우 consumer를 이용해 소비한다, 값이 저장되어 있지 않을 경우 디폴트 값(매개변수가 디폴트 값이 된다)
consumer로 집계 값을 받아서 처리하는 코드를 람다식으로 작성한다


public T orElse(T other) : Optional의 값이 null일 경우 other를 반환한다, 값이 저장되어 있을 경우 Consumer 에서 처리
public T orElseGet(Supplier other) : Optional의 값이 null일 경우 Supplier를 통해 공급받은 값을 반환한다.
public  T orElseThrow(Supplier exceptionSupplier) throws X : Optional의 값이 null일 경우 exceptionSupplier에서 공급받은 예외를 throw



    double avg = list.stream()
            .mapToInt(Integer::intValue)
            .average()
            .getAsDouble();
    System.out.println(avg); //NotSuchElementException

    // isPresent()
    OptionalDouble optionalDouble = list.stream()
            .mapToInt(Integer::intValue)
            .average()

    if (optionalDouble.isPresent()){
        System.out.println("값이 있는 경우 : " + optionalDouble.getAsDouble());
    }else{
        System.out.println("방법 1-값이 없는 경우 : " + 0.0);

    // orElse()
    double avg = list.stream()
            .mapToInt(Integer::intValue)
            .average()
            .orElse(0.0;
    System.out.println("방법 2 : " + avg);

    // ifPresent()
    list.add(2);
    list.add(4);
    list.stream()
            .mapToInt(Integer::intValue)
            .average()
            .ifPresent(i-> System.out.println("방법 3 : "+ i));
    // 값이 없을 경우 false가 되서 종료가 된다. consumer로 했기 때문에 바로 값 출력
수집
필요한 요소를 수집하여 새로운 Collection으로 구성하여 반환하는 메소드

최종 처리 기능으로 요소들을 수집 또는 그룹핑한다.
필터링 또는 매핑된 요소들로 최종적으로 얻은요소들로 새로운 컬렉션 생성하는 것.
요소들을 그룹핑하고, 집계를 할 수 있다. 


Stream API는  JCF-> STREAM -> 처리 -> 결과
결과가 출력일 수도 있고 값일 수도 있고, 다시 컬렉션으로 만들고 싶을 수 있다.
요소가 여러개 있는 프레임워크 혹은 Arrays에서 스트림을 생성한 다음에 스트림에서 중간 처리를 쭉쭉한 다음에 마지막에 출력이나 값을 낼 수 있지만
다음 중 3가지중 하나의 조건은 꼭 선택해야 한다.
조건1. foreach()를 사용하거나
조건2. 특정한 값을 리턴을 받거나(reduce())
조건3. count,min,max 스트림을 간추려서 통계를 낼 수 있는 값들을 가져오던지 다시 컬렉션으로 만들어 주던지 해야한다.



보통 수집을 하기 위해서 필터링을 한다.

스트림에서 필요한 요소만 필터링해서 별도의 컬렉션으로 만든다

collect라는 메소드 사용 collect(Collector  collector)

collect가  요소를 어떤 컬렉션에 수집할 것인지를 결정한다.

collect()메소드

 R collect(Collector : collector를 이용해 새로운 Collection R에 담아 반환


Collectors의 정적 메소드 : toList(), toSet(), toCollection(), toMap(), toConcurrentMap()


 R collect(Supplier supplier, BiConsumer accumulator, BiConsumer combiner) 
: supplier를 통해 공급된 컨테이너 R에 accumulator를 이용해 T값을 저장. 병렬처리 스트림에 사용될 경우 combiner를 이용해 스레드별 컨테이너 R을 통합



Collector의 타입 파라미터

T : 요소                                
A : 누적기(accumulator) 요소를 컬렉션에 수집하는 역할을한다.
R : 요소가 저장될 새로운 컬렉션 
T 요소를 A 누적기가 R에 저장한다.








리턴 타입
메소드
설명



Collector>
Collectors.toCollection{Supplier}
Supplier가 제공한 Collection에 저장


Collector>
Collectors.toConcurrentMap(...)
ConcurrentMap에 저장한다.


Collector>
Collectors.toList()
List에 저장


Collector>
Collectors.toMap()
Map에 저장


Collecotr>
Collectors.toSet()
Set에 저장



Collectors.toConcurrentMap(...) - 멀티쓰레드 환경에서 쓰레드의 안전한 concurrentmap을 만들어서 거기에 요소를 수집하는 Collector를 얻는다. 

A가 ? 인 이유

List, Set, Map 컬렉션에 누적할 경우 별도의 누적기가 필요 없다. 
컬렉터내부에서 이들 컬렉션에 저장하는 방법을 알고 있기 때문에 별도의 누적기가 필요 없음.

  String[] array = {"Java", "Is", "Fun", "Isn't", "It", "?"};
  List list = Arrays.stream(array)
          .filter(s -> s.length() >= 3)
          .collect(Collectors.toList()); // ArrayList
          // .collect(Collectors.toCollection(LinkedList::new))
  System.out.println(list.getClass().getName() + ":" + list);

  Set set = Arrays.stream(array)
          .filter(s -> s.length() >= 3)
          .collect(Collectors.toSet()); // HashSet
          // .collect(Collectors.toCollection(HashSet::new))
  System.out.println(set.getClass().getName() + ":" + set);

  Map map = Arrays.stream(array)
          .filter(s -> s.length() >= 3)
          .collect(Collectors.toMap(s -> s, String::length)); // HashMap
          // .collect(Collectors.toCollection(s -> s, String::length, (oldVal, newVal) -> newVal, TreeMap::new))
  System.out.println(map.getClass().getName() + map);

Collectors의 정적 메소드를 이용한 그룹화와 분리

partitioningBy는 어떤 기준으로 무더기로 나누는 것 (2가지 true or false)

groupingBy는 어떤 기준으로 여러개 묶어 내는 것  (여러개)

public static  Collector>> groupingBy(Function classifier)
: classifier를 key값으로, 해당하는 값의 목록을 List인 value로 가지는 Map으로 스트림을 수집하는 Collector를 반환

public static  Collector> groupingBy(Function classifier, Collector downstream) : List 대신 downstream collector로 수집
groupingBy(R Function) - Map>입력받은게 function으로 출력됨 R타입에 따라 그룹이 됨 그래서 R이 키가 된다.
T를 String..length 로 해주면 R은 Integer
결과 - 1: [...........], 2: [...........], 3: [...........]
키를 기준으로 그룹화 하는 것이다 다 대 다 형태 n:m이면 m이 조금 작을 것이다


public static  Collector>> partitioningBy(Predicate predicate) : predicate 결과를 key로, 해당하는 값의 목록을 List value로 가지는 Map으로 스트림을 수집하는 Collector를 반환

public static  Collector> partitioningBy(Predicate predicate, Collector downstream)) : List 대신 downstream collector로 수집
partitionBy(predciate)- Map> 왜냐하면 이건 두가지로 나누는 것이기 때문에 predicate 계열을 가지고 참인지 거짓인지 판단을 해야 해서
결과 - true :[......] , false: [......]  String[] array = {"Java", "Is", "Fun", "Isn't", "It", "?"};



Map> map1 = Arrays.stream(array)
   .collect(Collectors.groupingBy(s -> s.charAt(0)));
System.out.println(map1);
Map> map2 = Arrays.stream(array)
   .collect(Collectors.partitioningBy(s -> s.length() >= 3));
System.out.println(map2);



집계를 위한 Collector

Downstream collector로 집계를 위한 Collector를 사용할 경우 유용하다.
counting(), summingP(), averagingP(), maxBy(), minBy(), reducing()

String[] array = {"Java", "Is", "Fun", "Isn't", "It", "?"};

  Map map = Arrays.stream(array)
          .collect(Collectors.groupingBy(s -> s.charAt(0),
                                         Collectors.counting()));
  System.out.println(map);





Java Stream_중간처리메소드
Sun, 14 Mar 2021 05:55:25 GMT
중간 처리 메소드(중간 연산자)

중간 처리 메소드 이후에 최종 처리 메소드를 붙여서 사용한다.
값을 원하는 형태로 처리하기 위한 연산자이다. 중간 연산자들은 lazy하게 실행되고 결과로 stream을 반환한다.
lazy한 처리는 최종처리메소드가 실행되기전까지 연산이 실행되지 않음,결과가 필요하기 전까지 실행되지 않는다, 연산의 시점을 최대한 늦춘다는 의미이다.


그렇기 때문에 중간연산자는 연쇄적으로 연결하여 연산을 처리할 수 있다. (Ex - list.stream().filter(...).map(...))




동작
메소드



필터링
dinstict(), filter()


자르기
skip(), limit()


정렬
sorted()


매핑
flatMap(), flatMapToP(), map(), mapToP(), asDoubleStream(), asLongStream()


조회
peek()


필터링
필터링은 스트림의 일부 요소를 제거하는 역할을 한다.
Stream stringStream = Stream.of("Java","Is","Fun","Isn't","It","?","Java");
stringStream.forEach(System.out::println); // 기본형 중복이 포함되서 출력됨.

distinct() : 스트림에 같은 요소가 있을 경우 하나만 남기고 삭제하는 메소드(중복 제거)stringStream.distinct().forEach(System.out::println);
// stringStream.distinct() 여기까지 중간처리메소드, foreach는 최종처리 메소드

filter() : Predicate 계열을 입력을 받아, true인 요소만 남긴다.stringStream = Stream.of("Java","Is","Fun","Isn't","It","?");
stringStream.filter(s- >s.length()>=3).forEach(System.out::println);


자르기
자르기는 스트림의 일부 요소를 한번에 생략한다.

skip(long n) : 스트림의 처음부터 n개의 요소를 생략하는 메소드, n개 자른다. n+1부터 끝까지 반환
List list = Arrays.asList(1,2,3,4,5,6,7,8,9);
Stream stream = list.stream().skip(5).forEach(n-> System.out.println(s));

limit(long maxsize) : 스트림의 최대 요소 개수를 maxsize를 제한한다, maxsize의 요소보다 뒤에 있는 값들은 짤린다. 0부터 n개까지 반환


List list = Arrays.asList(1,2,3,4,5,6,7,8,9);
Stream stream = list.stream().limit(5).forEach(n-> System.out.println(s));

정렬
스트림 요소의 compareTo() 또는 입력받은 Comparator를 이용해 정렬한다.
// Comparable 객체를 정렬한 스트림 반환
stringStream = Stream.of("abc","fwf","twtie","dnmov","work");
stringStream.sorted().forEach(System.out::println); // 사전순으로 정렬됨
// Comparator 인터페이스를 람다식으로 구현하여 정렬한다.
// Comparator를 이용하여 정렬된 스트림 반환
stringStream = Stream.of("abc","fwf","twtie","dnmov","work");
stringStream.sorted((o1, o2) -> o1.length() - o2.length())
                                        .forEach(System.out::println); 
//compreator를 람다식으로 작성해줄 수 있다, 길이가 짧은 것부터 나온다.
매핑
Function 인터페이스를 이용해 요소의 값을 변환한다.

map 계열 - 입력 1 : 1 출력

 Stream map(Function mapper) : 기존 스트림의 T 타입 요소를 R 타입으로 변환하여 새로운 스트림 반환
// Function 계열의 인터페이스를 사용하여 스트림의 각 요소를 매핑(Operator 계열도 사용)
stringStream = Stream.of("abc","fwf","twtie","dnmov","work");
// Function 계열로 string -> integer 로 변환하는 매핑 
// Function와 같은 형식을 람다식에 넣어준 것이다.
Stream stream2 = stringStream.map(s->s.length()) ;
//입력은 string 출력은 원하는대로 할수 있다
stream2.forEach(System.out::println);

PStream mapToP(ToPFunction mapper) : R(return)이 기본형 타입으로 제한된 map()
// PStream (기본형 타입의 스트림)은 Operator 계열로 처리(자료형 반환x)
// 입출력 값이 똑같기 때문에
IntStream intStream3 = IntStream.of(5,2,30,8,0,2,-34);
IntStream intStream4 = intStream3.map(value -> value * 10); 
// 형 변환이 되지 않고 입력이 출력이 된다.
intStream4.forEach(System.out::println);



flatMap 계열 - 입력 1 : n 출력(스트림 형태로 출력한다.)(Function 계열만 사용)

 Stream flatMap(Function> mapper) : 스트림의 T 타입 요소가 n개의 R 타입 요소로 매핑된 새로운 스트림을 반환
PStream flatMapToP(Function mapper) : R이 기본형 타입으로 제한된 flatMap() // s.split("") : "java" -> {"j","a","v","a"}
 List list2 = Arrays.asList("java","backend","best","course");
 list2.stream().flatMap(s -> {
     return Arrays.stream(s.split(""));
 }).forEach(System.out::println); 
 //foreach를 사용하면 스트림이 끝나게 된다.




조회
스트림 처리 과정에 영향을 미치지 않으며, 중간 결과를 확인할 수 있으며 입력받은 스트림과 동일한 스트림을 반환한다.

Stream peek(Consumer action)
peek() -> Consumer 계열의 람다식 입력을 받아 입력 요소를 소비
peek()는 입력받아 스트림과 동일한 스트림을 다시 출력System.out.println(list2.stream().flatMap(s -> {
 return Arrays.stream(s.split(""));
}).peek(s-> System.out.println("flatMap():"+s))
       .distinct().peek(s-> System.out.println("distinct():"+s))
       .count()); // 함수형 프로그래밍은 선언형이어서 어떻게 해라라고 말해야한다.
// flatmap은 모든 요소를 다 나타내고 distinct는 중복된것을 없애고 하나만 출력됨.







정규표현식
Sun, 14 Mar 2021 05:43:55 GMT
정규표현식(Regular Expression)
정규표현식이란?

문자열을 다루는 패턴화된 작업을 정의하는 수식
문자열 매칭, 템플릿 일치 여부 확인, 템플릿 매칭 검색(문서가 있을 때 이메일만 뽑는 작업을 할 때 등등)
정규표현식은 느리기 때문에 남용하면 안된다. 많은 동작을 돌리면 안된다. 알고리즘 문제를 정규표현식을 푸는건 적합하지 않음
특정 조건에 맞는 문자열을 검색(search) / 치환(Replace)를 하는 패턴 기반의 식( 패턴: 전화번호 같은 것, 이메일)
이메일, 전화 번호 등 특정한 형식에 맞게 적혀 있는지 Validation 하는데 사용 가능
Crawling(자료를 긁어 모으는 것) 등 날 것의 자료를 긁어 모았을 때 정리 하는데 유용
튜브 댓글이 있으면 형식에 따라 분석을 하고 구분을 할 수 있다.

정규표현식 표현 방법

정규 표현식의 기본 작성 방식
"/패턴/[플래그(Opt.)]"

기본 메타 문자



메타 문자
의미



^x
x로 시작


x$
x로 끝


.x
x앞에 하나의 문자가 있다.


x+
x가 1번 이상 반복


x?
x가 있거나 없다.


x*
x가 0번 이상 반복


.
아무 문자 하나를 의미





괄호의 활용



regexp
의미



(xy)
괄호 안의 내용을 그룹화


x{n}
n번 반복됨


x{n,}
n번 이상 반복됨


x{n, m}
n번 이상, m번 이하 반복됨


[xy]
x 또는 y


[a-z]
알파벳 소문자 (a~z)


[0-9]
숫자


[가-힣]
한글


[^x]
x가 아닌 것


[^0-9]
숫자가 아닌 것



\... 축약 문자



regexp
의미



\^,\....
\ 뒤에 나오는 문자를 문자로 처리


\b
단어의 경계를 찾는다.


\B
단어의 경계가 아닌 것을 찾는다.


\d
숫자를 찾는다.


\D
숫자가 아닌 것을 찾는다.


\s
공백 문자를 찾는다.


\S
공백 문자가 아닌 것을 찾는다.


\w
[a-zA-Z0-9_]


\W
[^a-zA-Z0-9_]



유용한 정규식 예

한글 이름 : ^[가-힣]{2,5}$
핸드폰 번호: ^01(0|1|2|6|9)[-\s]?\d{3,4}[-\s]?\d{4}$
이메일 주소: ^[\w\.-]{1,64}@[\w\.-]{1,252}\.\w{2,4}$



Flag



Flag
기능



g
문자열 내 모든 패턴을 찾음


i
대소문자를 구분하지 않음


m
문자열의 모든 줄에서 찾음


정규표현식을 사용하는 클래스
Pattern 클래스



메소드
설명



public
static Pattern compile(String regex)    Pattern 객체를 생성


public
Matcher matcher(CharSequence input)    입력을 분석하는 Matcher 객체 생성


public
static boolean matches(String regex, CharSequence input)    입력이 regexp에 해당하는지 판단


Matcher 클래스



메소드
설명



find()
정규표현식에 부합되는 내용이 문자열에 포함되어 있는지 반환. 이전 검색 위치부터 이어서 검색.


start()
패턴에 부합되는 요소의 시작 인덱스 반환


end()
패턴에 부합되는 요소가 끝나는 위치 + 1을 반환


matches()
문자열 전체가 정규표현식에 일치하는지 반환


lookingAt()
비교하려는 문자열이 정규표현식으로 시작하는지 반환. 0번 인덱스부터 검색.


replaceFirst()
일치하는 첫 패턴을 문자열로 대체


replaceAll()
일치하는 모든 패턴을 문자열로 대체


reset()
Matcher의 정보를 리셋하여 0번 인덱스부터 다시 검색


참고

정규표현식을 이미지로 보여주 사이트
정규표현식 연습문제 사이트




참조 자료형
Sun, 14 Mar 2021 05:40:52 GMT
참조 자료형(ReferenceDataType)
변수의 자료형


기본 자료형은 사용하는 메모리가 정해져 있지만, 참조 자료형은 클래스에 따라 다르다.

참조 자료형 직접 만들어 사용하기

학생 클래스에 있는 과목 이름, 과목 성적 속성을 학생클래스와 과목 클래스로 분리하고,
과목 참조 자료형 멤버 변수를 학생에 정의하여 사용한다.



예제


// Subject 클래스
public class Student {
    int stuID;
    String stuName;
    Subject korSub;
    Subject matSub;
public Student(int stuID,String stuName){
    this.stuID = stuID;
    this.stuName = stuName;

    korSub = new Subject();
    matSub = new Subject();
}

public void setKoreaSubject(String subName, int subScore) {
    korSub.subName = subName;
    korSub.subScore = subScore;
}

public void setMathSubject(String subName, int subScore) {
    matSub.subName = subName;
    matSub.subScore = subScore;
}

public void getKoreaSubject(String subName,int subScore){
    korSub.setSubject(subName,subScore);
}

public void getMathSubject(String subName,int subScore){
    matSub.setSubject(subName,subScore);
}

public void showStudentScore() {
    int total = korSub.subScore + matSub.subScore;
    System.out.println(stuName+"학생의 총점은 "+total+"입니다.");
}
}
// Subject 클래스
public class Subject {
    String subName;
    int subScore;
public void setSubject(String subName,int subScore){
    this.subName = subName;
    this.subScore = subScore;
}
}
// Test클래스
public class StudentTest {
    public static void main(String[] args) {
        Student studentLee = new Student(123,"lee");
        Student studentKim = new Student(456,"kim");
//        studentLee.setKoreaSubject("국어",100);
//        studentLee.setMathSubject("수학",95);
//        studentKim.setKoreaSubject("국어",99);
//        studentKim.setMathSubject("수학",80);
    studentLee.getKoreaSubject("국어",95);
    studentLee.getMathSubject("수학",100);
    studentKim.getKoreaSubject("국어",99);
    studentKim.getMathSubject("수학",80);

    studentLee.showStudentScore();
    studentKim.showStudentScore();

}
}
```

종류	처리 대상
`Stream`	일반적인 객체를 처리
`IntStream`	기본 자료형 `int`를 처리
`LongStream`	기본 자료형 `long`을 처리
`DoubleStream`	기본 자료형 `double`을 처리

애노테이션	설명
@Override	재정의된 메소드라는 정보 제공
@FuctionalInterface	함수형 인터페이스라는 정보 제공
@Deprecated	이후 버전에서 사용되지 않을 수 있는 변수, 메서드에 사용됨
@SupperessWarnings	특정 경고가 나타나지 않도록 함 ex) @SupperessWarnings("deprecations")는 @Depreacted가 나타나지 않도록 함.

기본형	WrapperClass
byte	Byte
char	Character
short	Short
int	Integer
flaot	Float
double	Double
boolean	Boolean

변수	생성 시기	소멸 시기	저장 메모리	사용 방법
클래스 변수	클래스가 메모리에 올라갈 때(클래스가 사용이 될 때)	프로그램이 종료될 때	메소드 영역	클래스 이름, 변수 이름
인스턴스 변수	인스턴스가 생성될 때	인스턴스가 소멸할 때	힙 영역	인스턴스 이름, 변수 이름
지역 변수	블록 내에서 변수의 선언문이 실행될 때	블록을 벗어날 때	스택 영역	변수 이름

변수의 타입	초기값
char	'\u0000'
byte,short,int	0
long	0L
float	0.0f
double	0.0
boolean	false
배열,인스턴스 등	null
### 클래스 변수와 인스턴스 변수

데이터 소스	메소드
Collection	default Stream stream()
Collection	default Stream parallelStream()
Arrays	public static Stream stream(T[] array)
Arrays	public static Stream of(T ... values)
Arrays	public static IntStream stream(int[] array)
Arrays	public static IntStream of(int ... values)
Arrays	public static LongStream stream(long[] array)
Arrays	public static LongStream of(long ... values)
Arrays	public static DoubleStream stream(double[] array)
Arrays	public static DoubleStream of(double ... values)

구분	메소드
int형 범위	public static IntStream range(int startInclusive, int endExclusive)
int형 범위	public static IntStream rangeClosed(int startInclusive, int endInclusive)
long형 범위	public static LongStream range(long startInclusive, long endExclusive)
long형 범위	public static LongStream rangeClosed(long startInclusive, long endInclusive)
Random p형 값	public PStream ps()
Random p형 값	public PStream ps(long streamSize)
Random p형 값	public PStream ps(long streamSize, p origin, p bound)

인터페이스	리턴타입	메소드(매개변수)
java.util.Collection	Stream	parallelStream()
java.util.Stream	Stream	parallel()
java.util.Intstream	IntStream
java.util.Longstream	Longstream
java.util.Doublestream	Doublestream

동작	메소드
루핑	forEach()
매칭	allMatch(), anyMatch(), noneMatch()
집계	count(), max(), min(), average(), sum(), reduce()
조사	findFirst(), findAny()
수집	collect()

인터페이스	리턴 타입	메소드
Stream	Optional	reduce(BinaryOperator accumulator
	T	reduce(T identitiy, BianryOperator accmulator)
IntStream	OptionalInt	reduce(IntBinaryOperator op)
	int	reduce(int indentity, IntBinaryOperator op)
LongStream	OptionalLong	reduce(LongBinaryOperator op)
	long	reduce(long indentity, LongBinaryOperator op)
DoubleStream	OptionalDouble	reduce(DoubleBinaryOperator op)
	double	reduce(double indentitiy, DoubleBinaryOperator op)

리턴 타입	메소드	설명
Collector>	Collectors.toCollection{Supplier}	Supplier가 제공한 Collection에 저장
Collector>	Collectors.toConcurrentMap(...)	ConcurrentMap에 저장한다.
Collector>	Collectors.toList()	List에 저장
Collector>	Collectors.toMap()	Map에 저장
Collecotr>	Collectors.toSet()	Set에 저장

동작	메소드
필터링	dinstict(), filter()
자르기	skip(), limit()
정렬	sorted()
매핑	flatMap(), flatMapToP(), map(), mapToP(), asDoubleStream(), asLongStream()
조회	peek()

메타 문자	의미
`^x`	x로 시작
`x$`	x로 끝
`.x`	x앞에 하나의 문자가 있다.
`x+`	x가 1번 이상 반복
`x?`	x가 있거나 없다.
`x*`	x가 0번 이상 반복
`.`	아무 문자 하나를 의미

regexp	의미
`(xy)`	괄호 안의 내용을 그룹화
`x{n}`	n번 반복됨
`x{n,}`	n번 이상 반복됨
`x{n, m}`	n번 이상, m번 이하 반복됨
`[xy]`	x 또는 y
`[a-z]`	알파벳 소문자 (a~z)
`[0-9]`	숫자
`[가-힣]`	한글
`[^x]`	x가 아닌 것
`[^0-9]`	숫자가 아닌 것

regexp	의미
`\^`,`\.`...	`\` 뒤에 나오는 문자를 문자로 처리
`\b`	단어의 경계를 찾는다.
`\B`	단어의 경계가 아닌 것을 찾는다.
`\d`	숫자를 찾는다.
`\D`	숫자가 아닌 것을 찾는다.
`\s`	공백 문자를 찾는다.
`\S`	공백 문자가 아닌 것을 찾는다.
`\w`	[a-zA-Z0-9_]
`\W`	[^a-zA-Z0-9_]

Flag	기능
`g`	문자열 내 모든 패턴을 찾음
`i`	대소문자를 구분하지 않음
`m`	문자열의 모든 줄에서 찾음

메소드	설명
public	static Pattern compile(String regex) Pattern 객체를 생성
public	Matcher matcher(CharSequence input) 입력을 분석하는 Matcher 객체 생성
public	static boolean matches(String regex, CharSequence input) 입력이 regexp에 해당하는지 판단

메소드	설명
find()	정규표현식에 부합되는 내용이 문자열에 포함되어 있는지 반환. 이전 검색 위치부터 이어서 검색.
start()	패턴에 부합되는 요소의 시작 인덱스 반환
end()	패턴에 부합되는 요소가 끝나는 위치 + 1을 반환
matches()	문자열 전체가 정규표현식에 일치하는지 반환
lookingAt()	비교하려는 문자열이 정규표현식으로 시작하는지 반환. 0번 인덱스부터 검색.
replaceFirst()	일치하는 첫 패턴을 문자열로 대체
replaceAll()	일치하는 모든 패턴을 문자열로 대체
reset()	Matcher의 정보를 리셋하여 0번 인덱스부터 다시 검색

im_joonchul.log

Design Pattern

디자인 패턴 (Design Patterns)

디자인 패턴이란

디자인 패턴의 구조

디자인 패턴의 종류

대표적인 디자인 패턴

싱글톤 패턴

팩토리 패턴

추상 팩토리 패턴

데코레이터 패턴

옵저버 패턴

인터페이스(Interface)

인터페이스란

인터페이스의 특징

인터페이스의 요소

인터페이스 선언과 구현

인터페이스에서 클래스로의 타입 상속

인터페이스간의 상속

인터페이스를 활용한 다형성 구현

인터페이스의 역할은?

다형성 구현 문제

구현 코드

제네릭(Generic)

제네릭이란

제네릭 타입을 사용할 경우의 효과

제네릭 클래스

제네릭 타입

주의 해야할 문법들

제네릭 타입의 상속

파라미터 타입의 제한

제네릭 메소드

메소드에 선언된 제네릭

제네릭 메소드를 호출하는 두가지 방법

출력

동적 바인딩

열거형(Enumeration)

열거형이란

열거형의 특징

열거형의 구현

추상클래스(Abstract class)

추상 클래스란

추상클래스 특징

추상클래스 사용하기

추상클래스의 사용 용도

템플릿 메서드

템플릿 매서드 패턴

템플릿 메소드 예제

final 예약어

다형성(Polymorphism)

다형성이란?

다형성의 장점

다형성의 다양한 특징

형변환과 오버라이딩 메소드 호출

객체지향프로그래밍(OOP)

객체지향 프로그래밍(Object Oriented Programming, OOP)

객체지향 프로그래밍이란?

객체지향 프로그래밍의 장점

객체지향 프로그래밍의 단점

객체지향의 기본 구성 요소

객체지향의 특징

제어자(Modifier)

제어자(Modifier)

제어자란

접근 제어자

public으로 open한거랑 private으로 닫아놓고 public method를 제공하는것의 차이

접근제어자를 이용한 정보은닉(information hiding)

싱글톤 패턴(Singletone)

인스턴스와힙메모리

인스턴스와힙메모리

인스턴스란

메모리 할당 시점

클래스와 객체의 메모리 구조

메모리 영역

String 타입의 메모리 구조

상속(Inheritance)

상속(Inheritence)

상속이란

상속을 사용하는 경우

상속에서 접근 제한

`출력`