[java] PECS (Producer Extends Consumer Super) 란 무엇입니까?

PECS (생산자 extends및 소비자 super)

니모닉 → Get and Put 원칙.

이 원칙은 다음과 같이 말합니다.

• 구조에서 값을 가져올 때만 확장 와일드 카드를 사용하십시오.
• 구조에 값만 넣을 때는 슈퍼 와일드 카드를 사용하십시오.
• 그리고 둘 다 넣을 때 와일드 카드를 사용하지 마십시오.

자바 예제 :

class Super {

    Object testCoVariance(){ return null;} //Covariance of return types in the subtype.
    void testContraVariance(Object parameter){} // Contravariance of method arguments in the subtype.
}

class Sub extends Super {

    @Override
    String testCoVariance(){ return null;} //compiles successfully i.e. return type is don't care(String is subtype of Object) 
    @Override
    void testContraVariance(String parameter){} //doesn't support even though String is subtype of Object

}

Liskov 대체 원리 : S가 T의 하위 유형 인 경우 T 유형의 오브젝트는 S 유형의 오브젝트로 대체 될 수 있습니다.

프로그래밍 언어의 타이핑 시스템 내에서 타이핑 규칙

• 유형의 순서를 유지하는 경우 공변량 (≤), 유형을보다 구체적에서 일반으로 정렬합니다.
• 이 순서를 바꾸면 반 변형 ;
• 이들 중 어느 것도 적용되지 않으면 불변 또는 비변이.

공분산 및 반공 분산

• 읽기 전용 데이터 유형 (소스)은 공변량 일 수 있습니다 .
• 쓰기 전용 데이터 형식 (싱크)은 반 변형 일 수 있습니다 .
• 소스와 싱크 역할을하는 가변 데이터 유형은 변하지 않아야합니다 .

이 일반적인 현상을 설명하기 위해 배열 유형을 고려하십시오. Animal 유형의 경우 Animal [] 유형을 만들 수 있습니다

• 공변량 : 고양이 []는 동물 []입니다.
• 반 변형 : 동물 []은 고양이 []입니다.
• 불변 : 동물 []은 고양이 []가 아니며 고양이 []는 동물 []이 아닙니다.

자바 예제 :

Object name= new String("prem"); //works
List<Number> numbers = new ArrayList<Integer>();//gets compile time error

Integer[] myInts = {1,2,3,4};
Number[] myNumber = myInts;
myNumber[0] = 3.14; //attempt of heap pollution i.e. at runtime gets java.lang.ArrayStoreException: java.lang.Double(we can fool compiler but not run-time)

List<String> list=new ArrayList<>();
list.add("prem");
List<Object> listObject=list; //Type mismatch: cannot convert from List<String> to List<Object> at Compiletime  

더 많은 예

경계 (예 : 어딘가로 향함) 와일드 카드 : 와일드 카드 에는 세 가지 맛이 있습니다.

• 인 – 분산 / 비 분산 : ?나 ? extends Object– 무제한으로 와일드 카드. 모든 유형의 가족을 나타냅니다. 둘 다 넣을 때 사용하십시오.
• 공분산 : ? extends T(하위 유형의 모든 유형의 패밀리 T)- 상한이 있는 와일드 카드 . T는 IS 상단 상속 계층 구조 – 대부분의 클래스는. 사용 extends만 할 때 와일드 카드를 얻기 구조에서 값을.
• 대조-분산 : ? super T(슈퍼 타입 인 모든 유형의 패밀리 T)- 하한이 있는 와일드 카드 . T는 IS 낮은 상속 계층 구조 – 대부분의 클래스는. 구조에 값을 넣을super 때만 와일드 카드를 사용하십시오 .

참고 : 와일드 카드 ?는 0 회 또는 1 회를 의미 하며 알 수없는 유형을 나타냅니다. 와일드 카드는 일반적인 메소드 호출, 제네릭 클래스의 인스턴스 생성에 대한 형식 인수로 사용되지 않는 매개 변수의 유형으로 사용할 수있다. (즉, 때 우리가 사용하는 같은 참조 프로그램의 다른 곳에서 사용하지 않는 것이 사용 와일드 카드 T)

class Shape { void draw() {}}

class Circle extends Shape {void draw() {}}

class Square extends Shape {void draw() {}}

class Rectangle extends Shape {void draw() {}}

public class Test {
 /*
   * Example for an upper bound wildcard (Get values i.e Producer `extends`)
   *
   * */

    public void testCoVariance(List<? extends Shape> list) {
        list.add(new Shape()); // Error:  is not applicable for the arguments (Shape) i.e. inheritance is not supporting
        list.add(new Circle()); // Error:  is not applicable for the arguments (Circle) i.e. inheritance is not supporting
        list.add(new Square()); // Error:  is not applicable for the arguments (Square) i.e. inheritance is not supporting
        list.add(new Rectangle()); // Error:  is not applicable for the arguments (Rectangle) i.e. inheritance is not supporting
        Shape shape= list.get(0);//compiles so list act as produces only

        /*You can't add a Shape,Circle,Square,Rectangle to a List<? extends Shape>
         * You can get an object and know that it will be an Shape
         */
    }
      /*
* Example for  a lower bound wildcard (Put values i.e Consumer`super`)
* */
    public void testContraVariance(List<? super Shape> list) {
        list.add(new Shape());//compiles i.e. inheritance is supporting
        list.add(new Circle());//compiles i.e. inheritance is  supporting
        list.add(new Square());//compiles i.e. inheritance is supporting
        list.add(new Rectangle());//compiles i.e. inheritance is supporting
        Shape shape= list.get(0); // Error: Type mismatch, so list acts only as consumer
        Object object= list.get(0); // gets an object, but we don't know what kind of Object it is.

        /*You can add a Shape,Circle,Square,Rectangle to a List<? super Shape>
        * You can't get an Shape(but can get Object) and don't know what kind of Shape it is.
        */
    }
}

제네릭 과 예제

답변

public class Test {

    public class A {}

    public class B extends A {}

    public class C extends B {}

    public void testCoVariance(List<? extends B> myBlist) {
        B b = new B();
        C c = new C();
        myBlist.add(b); // does not compile
        myBlist.add(c); // does not compile
        A a = myBlist.get(0);
    }

    public void testContraVariance(List<? super B> myBlist) {
        B b = new B();
        C c = new C();
        myBlist.add(b);
        myBlist.add(c);
        A a = myBlist.get(0); // does not compile
    }
}

class Creature{}// X
class Animal extends Creature{}// Y
class Fish extends Animal{}// Z
class Shark extends Fish{}// A
class HammerSkark extends Shark{}// B
class DeadHammerShark extends HammerSkark{}// C

List<? extends Shark> sharks = new ArrayList<>();

sharks.add(new HammerShark());//will result in compilation error

sharks.add(new HammerShark());

List<? super Shark> sharks = new ArrayList<>();

sharks.add(new Shark());
sharks.add(new DeadHammerShark());
sharks.add(new HammerSkark());

Object o;
o = sharks.get(2);// only assignment that works

Animal s;
s = sharks.get(2);//doen't work