상속
\n합성
\n코드 재사용을 위해서는 객체 합성이 클래스 상속보다 더 좋은 방법이다.
\n상속을 남용할 때 직면하는 세 가지 문제
\npublic class Properties {\n private Hashtable<String, String> properties = new Hashtable<>();\n\n public String setProperty(String key, String value) {\n return properties.put(key, value);\n }\n\n public String getProperty(String key) {\n return properties.get(key);\n }\n}\n Hashtable의 오퍼레이션들이 퍼블릭 인터페이스를 오염시키지 않는다.Stack 또한 Vector의 인스턴스 변수를 Stack 클래스의 인스턴스 변수로 선언함으로써 합성 관계로 변경할 수 있다.@RequiredArgsConstructor\npublic class InstrumentedHashSet<E> implements Set<E> {\n \n private static final int addCount = 0;\n \n private final Set<E> set;\n\n ... // Overriding\n}\n HashSet에 대한 구현 결합도는 제거하면서 퍼블릭 인터페이스는 그대로 상속포워딩
\nSet의 오버레이션을 오버라이딩한 인스턴스 메서드에서 내부의 HashSet 인스턴스에게 동일한 메서드 호출을 그대로 전달public class PersonalPlaylist {\n\n private Playlist playlist = new Playlist();\n\n public void append(Song song) {\n playlist.append(song);\n }\n\n public void remove(Song song) {\n playlist.getTracks().remove(song);\n playlist.getSingers().remove(song.getSinger());\n }\n}\n Playlist의 내부 구현을 변경하더라도 파급효과를 최대한 PersonalPlaylist 내부로 캡슐화할 수 있다.몽키 패치
\n기본 정책
\n부가 정책
\n@RequiredArgsConstructor\npublic abstract class Phone {\n\n private List<Call> calls = new ArrayList<>();\n\n public Money calculateFee() {\n Money result = Money.ZERO;\n\n for (Call call : calls) {\n result = result.plus(calculateCallFee(call));\n }\n\n return result;\n }\n\n protected abstract Money calculateCallFee(Call call);\n}\n @RequiredArgsConstructor\npublic class RegularPhone extends Phone {\n\n private final Money amount;\n\n private final Duration seconds;\n\n @Override\n protected Money calculateCallFee(Call call) {\n return amount.times((double) call.getDuration().getSeconds() / seconds.getSeconds());\n }\n}\n @RequiredArgsConstructor\npublic class NightlyDiscountPhone extends Phone {\n\n private static final int LATE_NIGHT_HOUR = 22;\n\n private final Money nightlyAmount;\n\n private final Money regularAmount;\n\n private final Duration seconds;\n\n @Override\n protected Money calculateCallFee(Call call) {\n if (call.getFrom().getHour() >= LATE_NIGHT_HOUR) {\n return nightlyAmount.times((double) call.getDuration().getSeconds() / seconds.getSeconds());\n }\n return regularAmount.times((double) call.getDuration().getSeconds() / seconds.getSeconds());\n }\n}\n public class TaxableRegularPhone extends RegularPhone {\n\n private final double taxRate;\n\n public TaxableRegularPhone(Money amount, Duration seconds, double taxRate) {\n super(amount, seconds);\n this.taxRate = taxRate;\n }\n\n @Override\n public Money calculateFee() {\n Money fee = super.calculateFee();\n return fee.plus(fee.times(taxRate));\n }\n}\n @RequiredArgsConstructor\npublic abstract class Phone {\n\n private List<Call> calls = new ArrayList<>();\n\n public Money calculateFee() {\n Money result = Money.ZERO;\n\n for (Call call : calls) {\n result = result.plus(calculateCallFee(call));\n }\n\n return afterCalculated(result);\n }\n\n protected abstract Money calculateCallFee(Call call);\n \n protected abstract Money afterCalculated(Money fee);\n}\n\n @RequiredArgsConstructor\npublic class RegularPhone extends Phone {\n\n private final Money amount;\n\n private final Duration seconds;\n\n @Override\n protected Money calculateCallFee(Call call) {\n return amount.times((double) call.getDuration().getSeconds() / seconds.getSeconds());\n }\n\n @Override\n protected Money afterCalculated(Money fee) {\n return fee;\n }\n}\n @RequiredArgsConstructor\npublic class NightlyDiscountPhone extends Phone {\n\n private static final int LATE_NIGHT_HOUR = 22;\n\n private final Money nightlyAmount;\n\n private final Money regularAmount;\n\n private final Duration seconds;\n\n @Override\n protected Money calculateCallFee(Call call) {\n if (call.getFrom().getHour() >= LATE_NIGHT_HOUR) {\n return nightlyAmount.times((double) call.getDuration().getSeconds() / seconds.getSeconds());\n }\n return regularAmount.times((double) call.getDuration().getSeconds() / seconds.getSeconds());\n }\n\n @Override\n protected Money afterCalculated(Money fee) {\n return fee;\n }\n}\n @RequiredArgsConstructor\npublic abstract class Phone {\n\n private List<Call> calls = new ArrayList<>();\n\n public Money calculateFee() {\n Money result = Money.ZERO;\n\n for (Call call : calls) {\n result = result.plus(calculateCallFee(call));\n }\n\n return afterCalculated(result);\n }\n\n protected Money afterCalculated(Money fee) {\n return fee;\n }\n\n protected abstract Money calculateCallFee(Call call);\n}\n public class TaxableRegularPhone extends RegularPhone {\n\n private final double taxRate;\n\n public TaxableRegularPhone(Money amount, Duration seconds, double taxRate) {\n super(amount, seconds);\n this.taxRate = taxRate;\n }\n\n @Override\n protected Money afterCalculated(Money fee) {\n return fee.plus(fee.times(taxRate));\n }\n}\n public class TaxableNightlyDiscountPhone extends NightlyDiscountPhone {\n\n private final double taxRate;\n\n public TaxableNightlyDiscountPhone(Money nightlyAmount, Money regularAmount, Duration seconds, double taxRate) {\n super(nightlyAmount, regularAmount, seconds);\n this.taxRate = taxRate;\n }\n\n @Override\n protected Money afterCalculated(Money fee) {\n return fee.plus(fee.times(taxRate));\n }\n}\n public class RateDiscountableRegularPhone extends RegularPhone {\n\n private final Money discountAmount;\n\n public RateDiscountableRegularPhone(Money amount, Duration seconds, Money discountAmount) {\n super(amount, seconds);\n this.discountAmount = discountAmount;\n }\n\n @Override\n protected Money afterCalculated(Money fee) {\n return fee.minus(discountAmount);\n }\n}\n public class RateDiscountableNightlyDiscountPhone extends NightlyDiscountPhone {\n\n private final Money discountAmount;\n\n public RateDiscountableNightlyDiscountPhone(Money nightlyAmount, Money regularAmount, Duration seconds, Money discountAmount) {\n super(nightlyAmount, regularAmount, seconds);\n this.discountAmount = discountAmount;\n }\n\n @Override\n protected Money afterCalculated(Money fee) {\n return fee.minus(discountAmount);\n }\n}\n 상속을 이용한 해결 방법은 모든 가능한 조합별로 자식 클래스를 하나씩 추가하는 것이다.
\npublic class TaxableAndRateDiscountableRegularPhone extends TaxableRegularPhone {\n\n private final Money discountAmount;\n\n public TaxableAndRateDiscountableRegularPhone(Money amount, Duration seconds, double taxRate, Money discountAmount) {\n super(amount, seconds, taxRate);\n this.discountAmount = discountAmount;\n }\n\n @Override\n protected Money afterCalculated(Money fee) {\n return super.afterCalculated(fee).minus(discountAmount);\n }\n}\n public class RateDiscountableAndTaxableRegularPhone extends RateDiscountableRegularPhone {\n\n private final double taxRate;\n\n public RateDiscountableAndTaxableRegularPhone(Money amount, Duration seconds, Money discountAmount, double taxRate) {\n super(amount, seconds, discountAmount);\n this.taxRate = taxRate;\n }\n\n @Override\n protected Money afterCalculated(Money fee) {\n return super.afterCalculated(fee).plus(fee.times(taxRate));\n }\n}\n public class TaxableAndDiscountableNightlyDiscountPhone extends TaxableNightlyDiscountPhone {\n\n private final Money discountAmount;\n\n public TaxableAndDiscountableNightlyDiscountPhone(Money nightlyAmount, Money regularAmount, Duration seconds, double taxRate, Money discountAmount) {\n super(nightlyAmount, regularAmount, seconds, taxRate);\n this.discountAmount = discountAmount;\n }\n\n @Override\n protected Money afterCalculated(Money fee) {\n return super.afterCalculated(fee).minus(discountAmount);\n }\n}\n public class RateDiscountableAndTaxableNightlyDiscountPhone extends RateDiscountableNightlyDiscountPhone {\n\n private final double taxRate;\n\n public RateDiscountableAndTaxableNightlyDiscountPhone(Money nightlyAmount, Money regularAmount, Duration seconds, Money discountAmount, double taxRate) {\n super(nightlyAmount, regularAmount, seconds, discountAmount);\n this.taxRate = taxRate;\n }\n\n @Override\n protected Money afterCalculated(Money fee) {\n return super.afterCalculated(fee).plus(fee.times(taxRate));\n }\n}\n\n 합성을 사용하면 구현이 아닌 퍼블릭 인터페이스에 대해서만 의존할 수 있기 때문에 런타임에 객체의 관계를 변경할 수 있다.
\npublic interface RatePolicy {\n Money calculateFee(Phone phone);\n}\n public abstract class BasicRatePolicy implements RatePolicy{\n\n @Override\n public Money calculateFee(Phone phone) {\n Money result = Money.ZERO;\n\n for (Call call : phone.getCalls()) {\n result.plus(calculateCallFee(call));\n }\n\n return result;\n }\n\n protected abstract Money calculateCallFee(Call call);\n}\n @RequiredArgsConstructor\npublic class RegularPolicy extends BasicRatePolicy {\n\n private final Money amount;\n private final Duration seconds;\n\n @Override\n protected Money calculateCallFee(Call call) {\n return amount.times((double) call.getDuration().getSeconds() / seconds.getSeconds());\n }\n}\n @RequiredArgsConstructor\npublic class NightlyDiscountPolicy extends BasicRatePolicy {\n\n private static final int LATE_NIGHT_HOUR = 22;\n\n private final Money nightlyAmount;\n private final Money regularAmount;\n private final Duration seconds;\n\n @Override\n protected Money calculateCallFee(Call call) {\n if (call.getFrom().getHour() >= LATE_NIGHT_HOUR) {\n return nightlyAmount.times((double) call.getDuration().getSeconds() / seconds.getSeconds());\n }\n return regularAmount.times((double) call.getDuration().getSeconds() / seconds.getSeconds());\n }\n}\n @RequiredArgsConstructor\npublic class Phone {\n\n private final RatePolicy ratePolicy;\n\n @Getter\n private List<Call> calls = new ArrayList<>();\n\n public Money calculateFee() {\n return ratePolicy.calculateFee(this);\n }\n}\n @RequiredArgsConstructor\npublic abstract class AdditionalRatePolicy implements RatePolicy {\n\n private final RatePolicy next;\n\n @Override\n public Money calculateFee(Phone phone) {\n Money fee = next.calculateFee(phone);\n return afterCalculated(fee);\n }\n\n protected abstract Money afterCalculated(Money fee);\n}\n public class TaxablePolicy extends AdditionalRatePolicy {\n \n private final double taxRatio;\n\n public TaxablePolicy(RatePolicy next, double taxRatio) {\n super(next);\n this.taxRatio = taxRatio;\n }\n\n @Override\n protected Money afterCalculated(Money fee) {\n return fee.plus(fee.times(taxRatio));\n }\n}\n public class RateDiscountablePolicy extends AdditionalRatePolicy {\n\n private final Money discountAmount;\n\n public RateDiscountablePolicy(RatePolicy next, Money discountAmount) {\n super(next);\n this.discountAmount = discountAmount;\n }\n\n @Override\n protected Money afterCalculated(Money fee) {\n return fee.minus(discountAmount);\n }\n}\n Phone phone = new Phone(new taxablePolicy(0.05, new RegularPolicy(...)))
상속의 용도
\n프로그래밍 언어 관점에서의 타입과 개념 관점에서의 타입
\n개념 관점에서 타입이란 우리가 인지하는 세상의 사물의 종류를 의미한다.
\n어떤 대상이 타입으로 분류될 때 그 대상을 타입의 인스턴스(instance)**라고 부른다.
\n프로그래밍 언어 관점에서 타입은 연속적인 비트에 의미와 제약을 부여하기 위해 사용하며 두 가지 목적이 있다.
\n타입은 적용 가능한 오퍼레이션의 종류와 의미를 정의함으로써 코드의 의미를 명확하게 전달하고 개발자의 실수를 방지하기 위해 사용
\n객체의 타입이란 객체가 수신할 수 있는 메시지의 종류를 정의하는 것
\n타입이 다른 타입에 포함될 수 있기 때문에 동일한 인스턴스가 하나 이상의 타입으로 분류되는 것도 가능
\n타입 계층을 구성하는 두 타입 관계에서 더 일반적인 타입을 **슈퍼타입(supertype)**이라고 부르고 더 특수한 타입을 **서브타입(subtype)**이라고 부른다.
\n내연 관점
\n외연 관점
\n서브타입의 인스턴스는 슈퍼타입의 인스턴스로 간주될 수 있다.
\n아래 두 질문에 모두 '예'라고 답할 수 있는 경우에만 상속을 사용
\n어떤 타입 S가 다른 타입 T의 일종이라면 당연히 타입 S는 타입 T다라고 답할 수 있어야 한다.
타입 계층의 의미는 행동이라는 문맥에 따라 달라질 수 있다.
\n타입의 이름 사이에 개념적으로 어떤 연관성이 있다고 하더라도 행동에 연관성이 없다면 is-a 관계를 사용하지 말아야 한다.
\npublic void flyBird(Bird bird) {\n\n // 인자로 전달된 모든 bird들은 날 수 있어야 한다.\n bird.fly();\n}\n public class Penguin extends Bird {\n\n ...\n\n @Override\n public void fly() {}\n}\n public class Penguin extends Bird {\n\n ...\n\n @Override\n public void fly() {\n throw new UnsupportedOperationException();\n }\n}\n UnsupportedOperationException 예외가 던져질 것이라고는 기대하지 않았을 것이다.public void flyBird(Bird bird) {\n\n // 인자로 전달된 모든 birtd가 Penguin의 인스턴스가 아닐 경우에만 fly() 메시지를 전송한다.\n if (!(bird instanceof Penguin)) {\n bird.fly();\n }\n}\n public class Bird {\n ...\n}\n\npublic class FlyingBird extends Bird {\n \n public void fly() { ... }\n \n ...\n}\n\npublic class Penguin extends Bird {\n ...\n}\n 이 문제를 해결하는 다른 방법은 클라이언트에 따라 인터페이스를 분리하는 것이지만 더 좋은 방법은 합성을 사용하는 것이다.
\n\n\n자연어에 현혹되지 말고 요구사항 속에서 클라이언트가 기대하는 행동에 집중
\n
상속을 사용하는 두 가지 목적
\n**서브클래싱(subclassing)
\n**서브 타이핑(subtyping)
\n어떤 타입이 다른 타입의 서브타입이 되기 위해서는 행동 호환성을 만족시켜야 한다. 자식 클래스와 부모 클래스 사이의 행동 호환성은 부모 클래스에 대한 자식 클래스의 **대체 가능성(substitutability)**을 포함한다.
\n\n\n서브타입은 그것의 기반 타입에 대해 대체 가능해야 한다.
\n
@AllArgsConstructor\npublic class Rectangle {\n \n private final int x;\n \n private final int y;\n \n @Getter\n @Setter\n private int width;\n \n @Getter\n @Setter\n private int height;\n \n public int getArea() {\n return width * height;\n }\n}\n public class Square extends Rectangle {\n\n public Square(int x, int y, int width, int height) {\n super(x, y, width, height);\n }\n\n @Override\n public void setWidth(int width) {\n super.setWidth(width);\n super.setHeight(width);\n }\n\n @Override\n public void setHeight(int height) {\n super.setWidth(height);\n super.setHeight(height);\n }\n}\n \n\n클라이언트와 격리한 채로 본 모델은 의미 있게 검증하는 것이 불가능하다.
\n
클라이언트 관점에서 자식 클래스의 행동이 부모 클래스의 행동과 호환되지 않고 그로 인해 대체가 불가능하다면 어휘적으로 is-a라고 말할 수 있다고 하더라도 그 관계를 is-a 관계라고 할 수 없다.
\n리스코프 치환 원칙은 개방-폐쇄 원칙을 만족하는 설계를 위한 전제 조건이다.
\n클래스 상속은 타입 계층을 구현할 수 있는 다양한 방법 중 하나일 뿐이다.
\n계약에 의한 설계(Design By Contract, DBC)
\n\n\n서브타입이 리스코프 치환 원칙을 만족시키기 위해서는 클라이언트와 슈퍼타입 간에 체결된 '계약'을 준수해야 한다.
\n
어떤 타입이 슈퍼타입에서 정의한 사전조건보다 더 약한 사전조건을 정의하고 있다면 그 타입은 서브타입이 될 수 있지만 더 강한 사전조건을 정의한다면 서브타입이 될 수 없다.
\n계약에 의한 설계는 클라이언트 관점에서의 대체 가능성을 계약으로 설명할 수 있다는 사실을 잘 보여준다.
","excerpt":"상속의 용도 타입 계층 구현 코드 재사용 📖 13.1 타입 프로그래밍 언어 관점에서의 타입과 개념 관점에서의 타입 🔖 13.1.1 개념 관점의 타입 개념 관점에서 타입이란 우리가 인지하는 세상의 사물의 종류를 의미한다. 어떤 대상이 타입으로 분류될 때 그 대상을 타입의 인스턴스(instance)**라고 부른다. 타입의 인스턴스를 객체라고 부름. 심볼(symbol): 타입에 이름을 붙인 것 내연(intension…","fields":{"slug":"/backend/object/chapter13/서브클래싱과_서브타이핑/"},"frontmatter":{"title":"Object - 13장 서브클래싱과 서브타이핑","thumbnail":{"childImageSharp":{"fluid":{"src":"/static/dd0e1990925e942697544e2bdcd9332e/9b73b/object.png"}}},"draft":false,"category":"Back-End","tags":["java"],"date":"November 19, 2023"}},"node":{"id":"1020f854-93fe-54be-b1d8-bb9f82d9c3a4","html":"상속의 목적이 코드 재사용이라면 사용하지 말아야 한다. 다형성이 런타임에 메시지를 처리하기에 적합한 메서드를 동적으로 탐색하는 과정을 통해 구현되며, 상속이 이런 메서드를 찾기 위한 일종의 탐색 경로를 클래스 계층의 형태로 구현된다.
\n+ 연산자객체지향 프로그램을 작성하기 위해서는 항상 데이터와 행동이라는 두 가지 관점을 함께 고려해야 한다.
\n@RequiredArgsConstructor\npublic class Lecture {\n\n /**\n * 이수 여부를 판단할 기준 점수\n */\n private final int pass;\n\n /**\n * 과목명\n */\n private final String title;\n\n /**\n * 학생들의 성적\n */\n private final List<Integer> scores;\n\n public double average() {\n return scores.stream()\n .mapToInt(Integer::intValue)\n .average().orElse(0);\n }\n\n public List<Integer> getScores() {\n return Collections.unmodifiableList(scores);\n }\n\n public String evaluate() {\n return String.format("Pass:%d Fail:%d", passCount(), failCount());\n }\n\n private long passCount() {\n return scores.stream().filter(score -> score >= pass).count();\n }\n\n private long failCount() {\n return scores.size() - passCount();\n }\n}\n @RequiredArgsConstructor\npublic class Grade {\n\n /**\n * 등급 이름\n */\n @Getter\n private final String name;\n\n /**\n * 최대 성적, 최소 성적\n */\n private final int upper, lower;\n\n public boolean isName(String name) {\n return this.name.equals(name);\n }\n\n public boolean include(int score) {\n return score >= lower && score <= upper;\n }\n}\n public class GradeLecture extends Lecture {\n\n private final List<Grade> grades;\n\n public GradeLecture(int pass, String title, List<Integer> scores, List<Grade> grades) {\n super(pass, title, scores);\n this.grades = grades;\n }\n\n @Override\n public String evaluate() {\n return super.evaluate() + ", " + gradesStatistics();\n }\n\n private String gradesStatistics() {\n return grades.stream()\n .map(this::format)\n .collect(joining(" "));\n }\n\n private String format(Grade grade) {\n return String.format("%s:%d", grade.getName(), gradeCount(grade));\n }\n\n private long gradeCount(Grade grade) {\n return getScores().stream()\n .filter(grade::include)\n .count();\n }\n\n public double average(String gradeName) {\n return grades.stream()\n .filter(each -> each.isName(gradeName))\n .findFirst()\n .map(this::gradeAverage)\n .orElse(0d);\n }\n \n private double gradeAverage(Grade grade) {\n return getScores().stream()\n .filter(grade::include)\n .mapToInt(Integer::intValue)\n .average()\n .orElse(0);\n }\n}\n 데이터 관점에서 상속은 자식 클래스의 인스턴스 안에 부모 클래스의 인스턴스를 포함하는 것으로 볼 수 있다.
\n부모 클래스의 모든 퍼블릭 메서드는 자식 클래스의 퍼블릭 인터페이스에 포함된다.
\n@RequiredArgsConstructor\npublic class Professor {\n\n private final String name;\n\n private final Lecture lecture;\n\n public String compileStatistics() {\n return String.format("[%s] %s - Avg: %.1f", name, lecture.evaluate(), lecture.average());\n }\n}\n Lecture lecture = new GradeLecture(...);\n public class Professor {\n public Professor(String name, Lecture lecture) {...}\n}\n\nProfessor professor = new Professor("다익스트라", new GradeLecture(...));\n Lecture lecture = new GradeLecture(...);\nGradeLecture gradeLecture = (GradeLecture)lecture;\n Professor는 Lecture를 상속받는 어떤 자식 클래스와도 협력할 수 있는 무한한 확장 가능성을 지닌다.\n컴파일타임에 호출할 함수를 결정하는 방식
\n런타임에 실행될 메서드를 결정하는 방식
\n객체지향 시스템은 다음 규칙에 따라 실행할 메서드를 선택
\n객체가 메시지를 수신하면 컴파일러는 **self 참조(self reference)**라는 임시 변수를 자동으로 생성한 후 메시지를 수신한 객체를 가리키도록 설정
\nthis동적 메서드 탐색은 두 가지 원리로 구성
\nLecture lecture = new Lecture(...);\nlecture.evaluate();\n Lecture 클래스 안에 evaluate 메서드가 존재하기 때문에 시스템은 메서드를 실행한 후 메서드 탐색을 종료Lecture lecture = new GradeLecture(...);\nlecture.evaluate();\n GradeLecture 클래스 안에 evaluate 메서드가 존재하기 때문에 먼저 발견된 메서드가 실행GradeLecture lecture = new GradeLecture(...);\nlecture.average("A");\n GradeLecture에서 종료Lecture lecture = new GradeLecture(...);\nlecture.average();\n Lecture에서 종료대부분의 사람들은 하나의 클래스 안에서 같은 이름을 가진 메서드들을 정의하는 것은 메서드 오버로딩으로 생각하고 상속 계층 사이에서 같은 이름을 가진 메서드를 정의하는 것은 메서드 오버로딩으로 생각하지 않는 경향이 있다.
\n동적인 문맥을 결정하는 것은 바로 메시지를 수신한 객체를 가리키는 self 참조
\npublic class Lecture {\n\n public String stats() {\n return String.format("Title: %s, Evaluation Method: %s", title, getEvaluationMethod());\n }\n\n public String getEvaluationMethod() {\n return "Pass or Fail";\n }\n}\n getEvaluationMethod()라는 구문은 현재 클래스의 메서드를 호출하는 것이 아니라 현재 객체에게 getEvaluationMethod 메시지를 전송하는 것이다.\npublic class GradeLecture extends Lecture {\n\n @Override\n public String getEvaluationMethod() {\n return "Grade";\n }\n}\n GradeLecture에 stats 메시지를 전송\nLecture 클래스의 stats 메서드와 GradeLecture 클래스의 getEvaluationMethod 메서드의 실행 결과를 조합한 문자열이 반환객체가 메시지를 이해할 수 없다면 어떻게 할까❓
\n정적 타입 언어에서는 코드를 컴파일할 때 상속 계층 안의 클래스들이 메시지를 이해할 수 있는지 여부를 판단
\nLecture lecture = new GradeLecture(...);\nlecture.unknownMessage(); // 컴파일 에러!\n 동적 타입 언어에는 컴파일 단계가 존재하지 않기 때문에 실제로 코드를 실행해보기 전에는 메시지 처리 가능 여부를 판단할 수 없다.
\n좀 더 순수한 관점에서 객체지향 패러다임을 구현한다.
\npublic class GradeLecture extends Lecture {\n\n @Override\n public String evaluate() {\n return super.evaluate() + ", " + gradesStatistics();\n }\n}\n public class FormattedGradeLecture extends GradeLecture {\n\n public FormattedGradeLecture(int pass, String title, List<Integer> scores, List<Grade> grades) {\n super(pass, title, scores, grades);\n }\n\n public String formatAverage() {\n return String.format("Avg: %1.1f", super.average());\n }\n}\n super.average()에 의해 실행되는 메서드는 GradeLecture의 부모 클래스인 Lecture의 average 메서드이다.super 참조의 정확한 의도는 '지금 이 클래스의 부모 클래스에서부터 메서드 탐색을 시작하세요'다.
\nself 전송이 메시지를 수신하는 객체의 클래스에 따라 메서드를 탐색할 시작 위치를 동적으로 결정하는 데 비해 super 전송은 항상 메시지를 전송하는 클래스의 부모 클래스에서부터 시작된다.
\nself 참조는 항상 메시지를 수신한 객체를 가리킨다.
\n위임(delegation)
\n클래스가 존재하지 않고 오직 객체만 존재하는 프로토타입 기반의 객체지향 언어에서 상속을 구현하는 유일한 방법은 객체 사이의 위임을 이용하는 것이다.
\n중요한 것은 클래스 기반의 상속과 객체 기반의 위임 사이에 기본 개념과 메커니즘을 공유한다는 점
","excerpt":"상속의 목적이 코드 재사용이라면 사용하지 말아야 한다. 다형성이 런타임에 메시지를 처리하기에 적합한 메서드를 동적으로 탐색하는 과정을 통해 구현되며, 상속이 이런 메서드를 찾기 위한 일종의 탐색 경로를 클래스 계층의 형태로 구현된다. 📖 12.1 다형성 많은 형태를 가질 수 있는 능력 Universal 다형성 Parametric 다형성 클래스의 인스턴스 변수나 메서드의 매개변수 타입을 임의의 타입으로 선언한 후 사용하는 시점에 구체적인 타입으로 지정하는 방식 제네릭 프로그래밍 Inclustion…","fields":{"slug":"/backend/object/chapter12/다형성/"},"frontmatter":{"title":"Object - 12장 다형성","thumbnail":{"childImageSharp":{"fluid":{"src":"/static/dd0e1990925e942697544e2bdcd9332e/9b73b/object.png"}}},"draft":false,"category":"Back-End","tags":["java"],"date":"November 12, 2023"}}}},"staticQueryHashes":["2374173507","2996537568","3691437124"]}