검수요청.png검수요청.png

"전략패턴"의 두 판 사이의 차이

위키원
이동: 둘러보기, 검색
잔글
 
(사용자 2명의 중간 판 45개는 보이지 않습니다)
1번째 줄: 1번째 줄:
−
'''전략 패턴'''(Strategy Pattern) 이란 전략을 쉽게 바꿀 수 있도록 해주는 디자인 패턴이다. 여기에서 전략이란 어떤 목적을 달성하기 위해 일을 수행하는 방식, 비즈니스 규칙, 문제를 해결하는 알고리즘 등으로 이해할 수 있다.<ref name = 'strategy01'> 정인상, 채흥석, <[https://www.hanbit.co.kr/store/books/look.php?p_code=B3400922670 자바 객체지향 디자인 패턴: UML과 GoF 디자인 패턴 핵심 10가지로 배우는]>, <<한빛 미디어>>, 2014-04-28</ref>
+
'''전략패턴'''<!--전략 패턴-->(strategy pattern)이란 전략을 쉽게 바꿀 수 있도록 해주는 [[디자인패턴]](design pattern)이다. 여기에서 전략이란 어떤 목적을 달성하기 위해 일을 수행하는 방식, 비즈니스 규칙, 문제를 해결하는 알고리즘 등으로 이해할 수 있다.<ref name = 'strategy01'>정인상, 채흥석, <[https://www.hanbit.co.kr/store/books/look.php?p_code=B3400922670 자바 객체지향 디자인 패턴: UML과 GoF 디자인 패턴 핵심 10가지로 배우는]>, <<한빛 미디어>>, 2014-04-28</ref>
  
 
== 개요 ==
 
== 개요 ==
−
디자인패턴에서 전략패턴(strategy pattern)을 따르는 클래스는 유연하고 재사용 가능한 객체 지향 소프트웨어를 설계하기 위해 반복되는 디자인 문제를 해결하는 방법, 즉 객체는 구현, 변경, 테스트, 재사용이 쉬워야 한다는것을 기술하는 23가지 GoF 디자인 패턴중 하나이다.<ref name = 'strategy02'>전략 패턴 위키백과 - https://ko.wikipedia.org/wiki/%EC%A0%84%EB%9E%B5_%ED%8C%A8%ED%84%B4</ref> 같은 문제를 해결하는 여러 알고리즘이 클래스별로 캡슐화되어 있고 이들이 필요할 때 교체할 수 있도록 함으로써 동일한 문제를 다른 알고리즘으로 해결할 수 있게하는 패턴이다.<ref name = 'strategy01'></ref>
+
[[디자인패턴]]에서 전략패턴(strategy pattern)을 따르는 클래스는 유연하고 재사용 가능한 객체 지향 소프트웨어를 설계하기 위해 반복되는 디자인 문제를 해결하는 방법, 즉 객체는 구현, 변경, 테스트, 재사용이 쉬워야 한다는것을 기술하는 23가지 GoF 디자인 패턴중 하나이다.<ref name = 'strategy02'>전략패턴 위키백과 - https://ko.wikipedia.org/wiki/%EC%A0%84%EB%9E%B5_%ED%8C%A8%ED%84%B4</ref> 같은 문제를 해결하는 여러 알고리즘이 클래스별로 캡슐화되어 있고 이들이 필요할 때 교체할 수 있도록 함으로써 동일한 문제를 다른 알고리즘으로 해결할 수 있게하는 패턴이다.<ref name = 'strategy01'></ref>
  
 
== 특징 ==
 
== 특징 ==
 
=== 목적 ===
 
=== 목적 ===
 +
하나의 결과를 만드는 목적([[메소드]])는 동일하나, 그 목적을 달성할 수 있는 방법(전략, 알고리즘)이 여러가지 존재할 경우에 사용하는 패턴이다. Context의 변경을 최소화하고, 인터페이스를 통해 다양한 타입을 만들어 코드를 변경할 수 있다.<ref name = 'strategy03'>문메이, <[https://meylady.tistory.com/53 전략패턴(Strategy Pattern)]>, <<개인 블로그>>, 2018-04-03</ref>
 +
 +
=== 장점 ===
 +
새로운 알고리즘이 개발되더라도 기존에 작성했던 클래스의 코드를 수정하지 않고도 이를 쉽게 추가 적용할 수 있게 한다. SOLID원칙에서 개방-폐쇄원칙(OCP)를 만족한다.<ref name = 'strategy04'>favxoe, <[https://fabxoe.tistory.com/62 전략패턴]>, <<개인 블로그>>, 2019-11-06</ref>
 +
 +
== 구조 <ref name = 'strategy01'></ref>==
 +
[[파일:전략패턴컬레보레이션.PNG|800픽셀|섬네일|가운데|'''전략패턴''' 컬레보레이션]]
 +
Strategy는 인터페이스나 추상클래스로 외부에서 동일한 방식으로 알고리즘을 호출하는 방법을 명시한다. ConcreteStrategy는 전략패턴(strategy pattern)에서 명시한 알고리즘을 실제로 구현한 클래스이다. Context는 전략패턴(strategy pattern)을 이용하는 역할을 수행한다. 필요에 따라 동적으로 구체적인 전략을 바꿀 수 있도록 setter 메소드를 제공한다.
 +
 +
== 활용 예제 ==
 +
=== 로봇 만들기 <ref name = 'strategy01'></ref>===
 +
이 클래스 다이어그램에서 Atom 클래스와 TaekwonV 클래스는 Robot이라는 추상 클래스의 자식 클래스로 설정했다. 이렇게 설계한 이유는 아톰과 태권V는 둘 다 attack과 move기능이 있는 로봇의 한 종류 이기 때문이다. 아톰과 태권V의 이동 기능과 공격기능이 서로 다르기 때문에 Robot 클래스에서 attack과 move메서드를 추상메서드로 설정해 자식 클래스에서 각각 정의하도록한다.     
 +
 +
==== 문제점 ====
 +
기존 로봇의 공격 또는 이동 방법을 수정하려면 기존에 작성했던 Atom 클래스나 TaekwonV 클래스의 직접적으로 메소드의 코드 수정이 필요하다. 또 만약 새로운 로봇을 만들어 기존의 공격 또는 이동 방법을 추가하거나 수정하려면 분명 기존에 있던 방법임에도 불구하고 어떤 기술도 참조할 수 없고 새로운 로봇에 똑같은 내용을 또 추가해줘야 하는 상황이 발생한다. 클래스의 직접적인 코드 수정은 로봇의 종류가 많아질수록 중복 코드를 일관성 있게 유지 관리하는 일은 매우 힘들고 대단한 집중력을 요구하고 또 새로운 로봇을 추가 했을 때 매번 기존 코드를 입력하면서 발생하는 중복코드는 나중에 심각한 문제를 일으킬 수 있다. 그리고 매번 새로운 방식이 개발될수록 새로운 방식을 로봇에게 제공하려면 현재 시스템에서 관련된 기존의 모든 코드를 수정해야한다. <ref name = 'strategy01></ref>
 +
[[파일:전략기존코드예제모델.PNG|500픽셀|섬네일|가운데|로봇 패턴의 클래스 다이어그램]]
 +
//Robot 클래스
 +
  public abstract class Robot
 +
  {
 +
    private String name;
 +
    public Robot(String name)
 +
    {
 +
      this.name = name;
 +
    }
 +
    public String getName()
 +
    {
 +
      return name;
 +
    }
 +
    public abstract void attack();
 +
    public abstract void move();
 +
  }
 +
 +
//TaekwonV 클래스
 +
  public class TaekwonV extends Robot
 +
  {
 +
    public TaekwonV(String name)
 +
    {
 +
      super(name);
 +
    }
 +
    public void attack()
 +
    {
 +
      System.out.println("미사일 공격");
 +
    }
 +
    public void move()
 +
    {
 +
      System.out.println("걷는다.");
 +
    }
 +
  }
 +
 +
//Atom 클래스
 +
  public class Atom extends Robot
 +
  {
 +
    public Atom(String name)
 +
    { 
 +
      super(name);
 +
    }
 +
    public void attack()
 +
    {
 +
      System.out.println("강펀치 공격");
 +
    }
 +
    public void move()
 +
    {
 +
      System.out.println("비행");
 +
    }
 +
  }
 +
 +
//Client 클래스
 +
  public class Client
 +
  {
 +
    public static void main(String[] args)
 +
    {
 +
      Robot r1 = new TaekwonV("태권브이");
 +
      Robot r2 =new Atom("아톰");
 +
      //r1의 이동 공격
 +
      System.out.println("내 이름은 " + r1.getName());
 +
      r1.move();
 +
      r1.attack();
 +
      System.out.println();
 +
      //r2의 이동 공격
 +
      System.out.println("내 이름은 " + r2.getName());
 +
      r2.move();
 +
      r2.attack();
 +
    }
 +
  }
 +
 +
<실행결과>
 +
  내 이름은 태권브이
 +
  걷는다.
 +
  미사일 공격
 +
               
 +
  내 이름은 아톰
 +
  비행
 +
  강펀치 공격   
 +
 +
==== 해결책 ====
 +
무엇이 변화할 수 있을지 파악한 후에 이를 클래스로 캡슐화해야한다. 우리가 제시했던 변화 방법중에 로봇이 추가되는 겨우는 이미 캡슐화가 되어 있으니 이동 기능과 공격기능이 변할 수 있다는 것을 인지한 후 캡슐화를 해야하는데 외부에서 구체적인 이동 방식과 공격 방식을 담은 구체적인 클래스들을 은닉해야 한다 이를 위해 공격과 이동을 위한 인터페이스를 각각 만들고 이들을 시제 구현할 클래스를 만들어야한다. 클라이언트에서는 연관 관계를 이용해 이동 기능과 공격 기능의 변화를 포함시킨다. 이 예에서는 Robot 클래스가 이동 기능과 공격 기능을 이용하는 클라이언트 역할을 수행하고, 이 클래스는 변화를 처리하기 위해 MovingStrategy와 AttackStrategy 인터페이스를 포함해야한다. 아래의 실행결과를 보면 결과자체는 전략패턴을 쓰지 않았을 때와 유사하지만 로봇이 다른 전략으로 바꾸는데 기존 클래스를 변경해야할 요소가 사라졌다.
 +
[[파일:전략패턴해결책.PNG|800픽셀|섬네일|가운데|전략패턴을 적용한 해결책]]
 +
 +
// Robot 클래스
 +
  public abstract class Robot
 +
  {
 +
    private String name;
 +
    private MovingStrategy movingstrategy;
 +
    private AttackStrategy attackstrategy;
 +
   
 +
    public Robot(String name)
 +
    {
 +
      this.name = name;
 +
    }
 +
    public String getName()
 +
    {
 +
      return name;
 +
    }
 +
    public void move()
 +
    {
 +
      movingstrategy.move();
 +
    }
 +
    public void attack()
 +
    {
 +
      attackstrategy.attack();
 +
    }
 +
    public void setMovingStrategy(MovingStrategy movingStrategy)
 +
    {
 +
      this.movingstrategy = movingStrategy;
 +
    }
 +
    public void setAttackStrategy(AttackStrategy attackStrategy)
 +
    {
 +
      this.attackstrategy = attackStrategy;
 +
    }
 +
  }
 +
 +
//Atom 클래스
 +
  public class Atom extends Robot
 +
  {
 +
    public Atom(String name)
 +
    {
 +
      super(name);
 +
    }
 +
  }
 +
 +
//TaekwonV 클래스
 +
  public class TaekwonV extends Robot
 +
  {
 +
    public TaekwonV(String name)
 +
    {
 +
      super(name);
 +
    }
 +
  }
 +
 +
//MovingStrategy 인터페이스
 +
  interface MovingStrategy
 +
  {
 +
    public void move();
 +
  }
 +
 +
//FlyingStrategy 클래스
 +
  public class FlyingStrategy implements MovingStrategy
 +
  {
 +
    public void move()
 +
  {
 +
    System.out.println("비행 이동");
 +
  }
 +
  }
 +
 +
//WalkingStrategy 클래스
 +
  public class WalkingStrategy implements MovingStrategy
 +
  {
 +
    public void move()
 +
    {
 +
      System.out.println("도보 이동");
 +
    }
 +
  }
 +
 +
//AttackStrategy 인터페이스
 +
  interface AttackStrategy
 +
  {
 +
    public void attack();
 +
  } 
 +
 +
//MissileStrategy 클래스
 +
  public class MissileStrategy implements AttackStrategy
 +
  {
 +
    public void attack()
 +
    {
 +
      System.out.println("미사일 공격");
 +
    }
 +
  }
 +
 +
//PunchStrategy 클래스
 +
  public class PunchStrategy implements AttackStrategy
 +
  {
 +
    public void attack()
 +
    {
 +
      System.out.println("강펀치 공격");
 +
    }
 +
  }
 +
 +
//Client 클래스
 +
  public class Client
 +
  {
 +
    public static void main(String[] args)
 +
    {
 +
      Robot r1 = new TaekwonV("태권브이");
 +
      Robot r2 = new Atom("아톰");
 +
     
 +
      r1.setMovingStrategy(new WalkingStrategy());
 +
      r1.setAttackStrategy(new MissileStrategy());
 +
     
 +
      r2.setMovingStrategy(new FlyingStrategy());
 +
      r2.setAttackStrategy(new PunchStrategy());
 +
     
 +
      System.out.println("내 이름은 " + r1.getName());
 +
      r1.move();
 +
      r1.attack();
 +
     
 +
      System.out.println();
 +
     
 +
      System.out.println("내 이름은 " + r2.getName());
 +
      r2.move();
 +
      r2.attack();
 +
    }
 +
  }
 +
 +
//실행결과
 +
  내 이름은 태권브이
 +
  도보 이동
 +
  미사일 공격
 +
 +
  내 이름은 아톰
 +
  비행 이동
 +
  강펀치 공격
 +
 +
[[파일:로봇만들기.PNG|800픽셀|섬네일|가운데|전략패턴을 적용한 로봇만들기의 설계]]
 +
     
 
{{각주}}
 
{{각주}}
  
 
== 참고자료 ==
 
== 참고자료 ==
 +
* 정인상, 채흥석, <[https://www.hanbit.co.kr/store/books/look.php?p_code=B3400922670 자바 객체지향 디자인 패턴: UML과 GoF 디자인 패턴 핵심 10가지로 배우는]>, <<한빛 미디어>>, 2014-04-28
 +
* 전략패턴 위키백과 - https://ko.wikipedia.org/wiki/%EC%A0%84%EB%9E%B5_%ED%8C%A8%ED%84%B4
 +
* 문메이, <[https://meylady.tistory.com/53 전략패턴(Strategy Pattern)]>, <<개인 블로그>>, 2018-04-03
 +
* favxoe, <[https://fabxoe.tistory.com/62 전략패턴]>, <<개인 블로그>>, 2019-11-06
 +
 
== 같이보기 ==
 
== 같이보기 ==
 
* [[디자인패턴]]
 
* [[디자인패턴]]
 
* [[모델-뷰-컨트롤러 패턴]]
 
* [[모델-뷰-컨트롤러 패턴]]
 +
* [[템플릿 메소드 패턴]]
 +
 +
{{프로그래밍|검토 필요}}

2020년 8월 19일 (수) 22:06 기준 최신판

전략패턴(strategy pattern)이란 전략을 쉽게 바꿀 수 있도록 해주는 디자인패턴(design pattern)이다. 여기에서 전략이란 어떤 목적을 달성하기 위해 일을 수행하는 방식, 비즈니스 규칙, 문제를 해결하는 알고리즘 등으로 이해할 수 있다.[1]

개요[편집]

디자인패턴에서 전략패턴(strategy pattern)을 따르는 클래스는 유연하고 재사용 가능한 객체 지향 소프트웨어를 설계하기 위해 반복되는 디자인 문제를 해결하는 방법, 즉 객체는 구현, 변경, 테스트, 재사용이 쉬워야 한다는것을 기술하는 23가지 GoF 디자인 패턴중 하나이다.[2] 같은 문제를 해결하는 여러 알고리즘이 클래스별로 캡슐화되어 있고 이들이 필요할 때 교체할 수 있도록 함으로써 동일한 문제를 다른 알고리즘으로 해결할 수 있게하는 패턴이다.[1]

특징[편집]

목적[편집]

하나의 결과를 만드는 목적(메소드)는 동일하나, 그 목적을 달성할 수 있는 방법(전략, 알고리즘)이 여러가지 존재할 경우에 사용하는 패턴이다. Context의 변경을 최소화하고, 인터페이스를 통해 다양한 타입을 만들어 코드를 변경할 수 있다.[3]

장점[편집]

새로운 알고리즘이 개발되더라도 기존에 작성했던 클래스의 코드를 수정하지 않고도 이를 쉽게 추가 적용할 수 있게 한다. SOLID원칙에서 개방-폐쇄원칙(OCP)를 만족한다.[4]

구조 [1][편집]

전략패턴 컬레보레이션

Strategy는 인터페이스나 추상클래스로 외부에서 동일한 방식으로 알고리즘을 호출하는 방법을 명시한다. ConcreteStrategy는 전략패턴(strategy pattern)에서 명시한 알고리즘을 실제로 구현한 클래스이다. Context는 전략패턴(strategy pattern)을 이용하는 역할을 수행한다. 필요에 따라 동적으로 구체적인 전략을 바꿀 수 있도록 setter 메소드를 제공한다.

활용 예제[편집]

로봇 만들기 [1][편집]

이 클래스 다이어그램에서 Atom 클래스와 TaekwonV 클래스는 Robot이라는 추상 클래스의 자식 클래스로 설정했다. 이렇게 설계한 이유는 아톰과 태권V는 둘 다 attack과 move기능이 있는 로봇의 한 종류 이기 때문이다. 아톰과 태권V의 이동 기능과 공격기능이 서로 다르기 때문에 Robot 클래스에서 attack과 move메서드를 추상메서드로 설정해 자식 클래스에서 각각 정의하도록한다.

문제점[편집]

기존 로봇의 공격 또는 이동 방법을 수정하려면 기존에 작성했던 Atom 클래스나 TaekwonV 클래스의 직접적으로 메소드의 코드 수정이 필요하다. 또 만약 새로운 로봇을 만들어 기존의 공격 또는 이동 방법을 추가하거나 수정하려면 분명 기존에 있던 방법임에도 불구하고 어떤 기술도 참조할 수 없고 새로운 로봇에 똑같은 내용을 또 추가해줘야 하는 상황이 발생한다. 클래스의 직접적인 코드 수정은 로봇의 종류가 많아질수록 중복 코드를 일관성 있게 유지 관리하는 일은 매우 힘들고 대단한 집중력을 요구하고 또 새로운 로봇을 추가 했을 때 매번 기존 코드를 입력하면서 발생하는 중복코드는 나중에 심각한 문제를 일으킬 수 있다. 그리고 매번 새로운 방식이 개발될수록 새로운 방식을 로봇에게 제공하려면 현재 시스템에서 관련된 기존의 모든 코드를 수정해야한다. [1]

로봇 패턴의 클래스 다이어그램
//Robot 클래스
 public abstract class Robot
 {
   private String name;
   public Robot(String name)
   {
     this.name = name;
   }
   public String getName()
   {
     return name;
   }
   public abstract void attack();
   public abstract void move();
 }

//TaekwonV 클래스
 public class TaekwonV extends Robot
 {
   public TaekwonV(String name) 
   {
     super(name);
   }
   public void attack()
   {
     System.out.println("미사일 공격");
   }
   public void move()
   {
     System.out.println("걷는다.");
   }
 }

//Atom 클래스
 public class Atom extends Robot
 {
   public Atom(String name)
   {   
     super(name);
   }
   public void attack()
   {
     System.out.println("강펀치 공격");
   }
   public void move()
   {
     System.out.println("비행");
   }
 }

//Client 클래스
 public class Client
 {
   public static void main(String[] args)
   {
     Robot r1 = new TaekwonV("태권브이");
     Robot r2 =new Atom("아톰");
     //r1의 이동 공격
     System.out.println("내 이름은 " + r1.getName());
     r1.move();
     r1.attack();
     System.out.println();
     //r2의 이동 공격
     System.out.println("내 이름은 " + r2.getName());
     r2.move();
     r2.attack();
   }
 }

<실행결과>
 내 이름은 태권브이
 걷는다. 
 미사일 공격
               
 내 이름은 아톰
 비행
 강펀치 공격

해결책[편집]

무엇이 변화할 수 있을지 파악한 후에 이를 클래스로 캡슐화해야한다. 우리가 제시했던 변화 방법중에 로봇이 추가되는 겨우는 이미 캡슐화가 되어 있으니 이동 기능과 공격기능이 변할 수 있다는 것을 인지한 후 캡슐화를 해야하는데 외부에서 구체적인 이동 방식과 공격 방식을 담은 구체적인 클래스들을 은닉해야 한다 이를 위해 공격과 이동을 위한 인터페이스를 각각 만들고 이들을 시제 구현할 클래스를 만들어야한다. 클라이언트에서는 연관 관계를 이용해 이동 기능과 공격 기능의 변화를 포함시킨다. 이 예에서는 Robot 클래스가 이동 기능과 공격 기능을 이용하는 클라이언트 역할을 수행하고, 이 클래스는 변화를 처리하기 위해 MovingStrategy와 AttackStrategy 인터페이스를 포함해야한다. 아래의 실행결과를 보면 결과자체는 전략패턴을 쓰지 않았을 때와 유사하지만 로봇이 다른 전략으로 바꾸는데 기존 클래스를 변경해야할 요소가 사라졌다.

전략패턴을 적용한 해결책
// Robot 클래스
 public abstract class Robot
 {
   private String name;
   private MovingStrategy movingstrategy;
   private AttackStrategy attackstrategy;
   
   public Robot(String name)
   {
     this.name = name;
   }
   public String getName()
   {
     return name;
   }
   public void move()
   {
     movingstrategy.move();
   }
   public void attack()
   {
     attackstrategy.attack();
   }
   public void setMovingStrategy(MovingStrategy movingStrategy)
   {
     this.movingstrategy = movingStrategy;
   }
   public void setAttackStrategy(AttackStrategy attackStrategy)
   {
     this.attackstrategy = attackStrategy;
   }
 }

//Atom 클래스
 public class Atom extends Robot 
 {
   public Atom(String name)
   {
     super(name);
   }
 }

//TaekwonV 클래스
 public class TaekwonV extends Robot
 {
   public TaekwonV(String name)
   {
     super(name);
   }
 }

//MovingStrategy 인터페이스
 interface MovingStrategy
 {
   public void move();
 }

//FlyingStrategy 클래스
 public class FlyingStrategy implements MovingStrategy
 {
   public void move()
  {
    System.out.println("비행 이동");
  }
 }

//WalkingStrategy 클래스
 public class WalkingStrategy implements MovingStrategy
 {
   public void move()
   {
     System.out.println("도보 이동");
   }
 }

//AttackStrategy 인터페이스
 interface AttackStrategy
 {
   public void attack();
 }  

//MissileStrategy 클래스
 public class MissileStrategy implements AttackStrategy
 {
   public void attack()
   {
     System.out.println("미사일 공격");
   }
 }

//PunchStrategy 클래스
 public class PunchStrategy implements AttackStrategy
 {
   public void attack()
   {
     System.out.println("강펀치 공격");
   }
 }

//Client 클래스
 public class Client
 {
   public static void main(String[] args)
   {
     Robot r1 = new TaekwonV("태권브이");
     Robot r2 = new Atom("아톰");
     
     r1.setMovingStrategy(new WalkingStrategy());
     r1.setAttackStrategy(new MissileStrategy());
     
     r2.setMovingStrategy(new FlyingStrategy());
     r2.setAttackStrategy(new PunchStrategy());
     
     System.out.println("내 이름은 " + r1.getName());
     r1.move();
     r1.attack();
     
     System.out.println();
     
     System.out.println("내 이름은 " + r2.getName());
     r2.move();
     r2.attack();
   }
 }

//실행결과
 내 이름은 태권브이
 도보 이동
 미사일 공격

 내 이름은 아톰
 비행 이동
 강펀치 공격
전략패턴을 적용한 로봇만들기의 설계

각주[편집]

  1. ↑ 1.0 1.1 1.2 1.3 1.4 정인상, 채흥석, <자바 객체지향 디자인 패턴: UML과 GoF 디자인 패턴 핵심 10가지로 배우는>, <<한빛 미디어>>, 2014-04-28
  2. ↑ 전략패턴 위키백과 - https://ko.wikipedia.org/wiki/%EC%A0%84%EB%9E%B5_%ED%8C%A8%ED%84%B4
  3. ↑ 문메이, <전략패턴(Strategy Pattern)>, <<개인 블로그>>, 2018-04-03
  4. ↑ favxoe, <전략패턴>, <<개인 블로그>>, 2019-11-06

참고자료[편집]

같이보기[편집]


  검수요청.png검수요청.png 이 전략패턴 문서는 프로그래밍에 관한 글로서 검토가 필요합니다. 위키 문서는 누구든지 자유롭게 편집할 수 있습니다. [편집]을 눌러 문서 내용을 검토·수정해 주세요.  

개발 : 프로그래밍 □■⊕, 소프트웨어, 데이터, 솔루션, 보안, 하드웨어, 컴퓨터, 사무자동화, 인터넷, 모바일, 사물인터넷, 게임, 메타버스, 디자인
프로그래밍 언어 ASP • C 언어 • C++ • C# • CSS • D 언어 • HTML • HTML5 • JSP • PHP • R • XHTML • XML • XSLT • 고(Go) • 고급언어 • 기계어 • 델파이 • 러스트 • 루비 • 루아 • 리액트 • 리퀴디티 • 무브 • 미켈슨 • 베이직 • 브이비스크립트 • 비주얼 C++ • 비주얼베이직(VB) • 비주얼베이직닷넷(VB.NET) • 솔리디티 • 스몰토크 • 스위프트 언어 • 스칼라 • 스크립트 언어 • 알골 • 어셈블리 • 언리얼스크립트 • 얼랭 • 에이잭스(Ajax) • 엠에프씨(MFC) • 오브젝티브-C • 오브젝트 파스칼 • 오카멜 • 웹어셈블리(WASM) • 이와즘(eWASM) • 자바 • 자바스크립트 • 저급언어 • 제이슨(JSON) • 제이쿼리(jQuery) • 카멜 • 코볼 • 코틀린 • 콜드퓨전 • 타입스크립트 • 파스칼 • 파워스크립트 • 파이썬 • 펄(Perl) • 포트란 • 프로씨(Pro-C) • 피엘에스큐엘(PL/SQL) • 피엘원(PL/I) • 하스켈
개발방법론 CBD 개발방법론 • EA • 구조적 개발방법론 • 객체지향 개발방법론 • 라이브러리 • 람다 아키텍처 • 모듈 • 모듈화 • 벤치마킹 • 소프트웨어 개발방법론 • 스크럼 • 스프린트 • 아키텍처 • 아키텍트 • 애자일 • 웹개발방법론 • 정보공학 개발방법론 • 컴포넌트 • 테일러링 • 템플릿 • 폭포수 모델 • 프로젝트 • 프로토타입 • 피드백
코딩 EUC-KR • UTF-8 • 값 • 글루웨어 • 노팔로우 링크 • 두팔로우 링크 • 디버깅 • 디코딩 • 마크업 • 버그 • 부트스트랩 • 세이브포인트 • 소스코드 • 시큐어코딩 • 아스키 • 액티브엑스 • 오픈소스 • 유니코드 • 인코딩 • 재컴파일 • 주석 • 컴파일 • 컴퓨터 프로그램 • 코드 • 코딩 • 태그 • 테스트 • 테이블 • 텍스트 • 파싱 • 퍼블리싱 • 퓨니코드 • 하드코딩 • 하이퍼링크 • 하이퍼텍스트
프로그래밍 C 명령어 • 객체 • 객체지향 • 객체지향 프로그래밍 • 거짓 • 관계연산자 • 기본형 변수 • 널 • 논리 • 논리연산 • 논리연산자 • 다중상속 • 다형성 • 대입 • 대입문 • 대입연산자 • 더블 • 도스 명령어 • 디폴트 • 레지스터변수 • 루프 • 리눅스 명령어 • 리턴 • 메모리 주소 • 메소드 • 멤버 • 명령문 • 명령어 • 무한루프 • 문자 • 문자열 • 바이트 • 반복문 • 배열 • 변수 • 분기 • 분기문 • 불린 • 브레이크 • 비교연산자 • 비트연산자 • 산술연산자 • 상속 • 상수 • 생성자 • 선언 • 선언문 • 설정자 • 속성 • 스위치 • 스태틱 • 시프트연산자 • 실행 • 실행문 • 어노테이션 • 에코 • 역참조 • 연산 • 연산문 • 연산자 • 오버로딩 • 오버라이딩 • 외부변수 • 윈도우 명령어 • 유닉스 명령어 • 인스턴스 • 인스트럭션 • 인클루드 • 인터페이스 • 임포트 • 입력 • 입력문 • 입출력 • 입출력문 • 자료형(데이터 타입) • 자바 명령어 • 자바 예약어 • 자바 컬렉션 • 전역변수 • 접근자 • 접근제어자 • 정보은닉 • 정수형 • 정적변수 • 제어 • 제어문 • 제어자 • 조건 • 조건문 • 조건연산자 • 주소 • 증감연산자 • 지역변수 • 참 • 참조 • 참조변수 • 초기화 • 추상메소드 • 추상클래스 • 추상화 • 출력 • 출력문 • 캡슐화 • 케이스 • 클래스 • 파라미터(매개변수) • 파이널 • 패키지 • 퍼블릭 • 포인터 • 프라이빗 • 프로텍티드 • 필드(멤버변수) • 함수 • 환경변수
명령어 abstract • array • boolean • break • byte • case • char • continue • default • double • do while • echo • elif • else • else if • false • final • float • for • gosub • goto • if • if else • import • include • int • join • long • long long • null • print • printf • println • private • protected • public • return • scanf • short • stdio.h • static • string • switch • temp • then • true • unsigned • void • while
디자인패턴 구조패턴 • 동시성패턴 • 동시실행패턴 • 모델-뷰-컨트롤러 패턴 • 상태패턴 • 생성패턴 • 싱글톤패턴 • 아키텍처패턴 • 전략패턴 • 커맨드패턴 • 행동패턴
프로그래밍 인물 귀도 반 로썸 • 그레이스 머레이 호퍼 • 니클라우스 비르트 • 댄 브릭클린 • 더그 커팅 • 데니스 리치 • 리누스 토르발스 • 리처드 그린블라트 • 마거릿 해밀턴 • 마크 앤드리슨 • 빈트 서프 • 빌 게이츠 • 빌 조이 • 스티브 잡스 • 에이다 러브레이스 • 제임스 고슬링 • 척 벤턴 • 켄 톰슨 • 팀 패터슨
위키 : 자동차, 교통, 지역, 지도, 산업, 기업, 단체, 업무, 생활, 쇼핑, 블록체인, 암호화폐, 인공지능, 개발, 인물, 행사, 일반
원본 주소 "http://wiki1.kr/index.php?title=전략패턴&oldid=347247"