These days, one of the most common software engineering principle did dawn on me. The composition can be used to achieve code reuse without creating complex inheritance hierarchies. a single responsibility) and low coupling with other objects. g. In contrast, the composition provides a great level of freedom and reduces the inheritance hierarchies. The first one is the possibility of avoiding too nested components. Just to operate on a concrete example, let’s take a common. Why “Prefer Composition over Inheritance”?# In a recent post, I shared my frustration with the complexity of my project's codebase. One principle I heard many times is "Prefer Composition over Inheritance. But inheritance has. In many newer languages, inheritance is limited to one class, while you can compose as much as you want. Cars and trucks both have steering and acceleration, but a truck isn't a car, and shouldn't inherit behavior from it just because some of the implementation is shared. Prefer composition over mixins for complex behaviors: If the desired behavior involves complex composition or multiple interacting components, consider using composition (i. In short: Composition is about the relationship of class and object. attr_of_{a,b} gives you an attribute of A or B too (same caveat as with methods). Each design pattern will assemble simple classes, unburdened by inheritance, into an elegant runtime solution. In general, composition (which is implemented by Strategy) as a way of logic reuse is preferred over inheritance. I also give a nod to "prefer composition over inheritance. The common explanations of when to use inheritance and composition talk about “has a” and “is a” relationships: "If you have an. Field: a named property of some type, which may reference another object (see composition) Method: a named function or procedure, with or without parameters, that implements some behavior for a class. We mostly prefer composition over inheritance, because inheritance can result in too much functionality in the same object. Rather than having each widget provide a large number of parameters, Flutter embraces composition. That's all about the point. By programming, we represent knowledge which changes over time. single inheritance). This being said, and to satisfy your curiosity about inheritance: inheritance is a very special relationship that should mean is-a: a Dog is-an Animal, so it may inherit from it. Why you should favor composition over inheritance. The call C(). As the Gang of Four (probably) said: favor object composition over class inheritance. -- Why I mostly prefer composition over inheritance on inheritance problem on benefit of composition over inheritance. (Gang of Four 1995:20) Read the book. Almost everything else could change. There's also an efficiency reason to prefer inheritance over composition -- overriding costs nothing (assuming no super call), while composition costs an extra INVOKEVIRTUAL. Everything in React is a component, and it follows a strong component based model. 2. An interface (the C# keyword kind) is for giving common behavior to unrelated classes and then handle objects polymorphically. NET), introducing one inheritance hierarchy automatically excludes you from all other, alternative inheritance hierarchies. In general I prefer composition over inheritance. This violates one of the key design principles that says to prefer composition over inheritance. – jscs. Apply Now. Tagged with tutorial,. You can decide at runtime how you compose complex objects, if the parts have a polymorphic interface. Notice that composition is harder. What advantages does composition have over inheritance? Coupling and Cohesion Ideally, the objects in our system have high cohesion (i. Note that the phrase is to favor composition over inheritance. Composition: “has a. "X inherits Y" implies that "X is a Y", so it can be useful in cases where that statement is technically true (for example, "a square is a rectangle"). Let's say you have a screen where you're editing a list of Users. Consider this. Composition alone is less powerful than inheritance,. When people say prefer composition over inheritance, they are referring to class inheritance. However, this additional code is not useless: it informs the reader that a progress bar is used and how it is used. As for composition over inheritance, while this is a truism, I fail to see the relevance here. Let’s see some of the reasons that will help you in choosing composition vs inheritance. Premature Over-Engineering. 這篇是Effective Java - Favor composition over inheritance章節的讀書筆記 本篇的程式碼來自於原書內容. Favor Composition over Inheritance doesn't say never use inheritance. Same as before. Inheritance is more rigid as most languages do not allow you to derive from more than one type. And dealing with high inheritance trees is complexity. The composition is achieved by using an instance variable that refers to other objects. I am acquainted with the "prefer composition over inheritance" rule of thumb but at the beginning of the example it made sense to. At second, it has less implementation limitations like multi-class inheritance, etc. Composition and inheritance are two ways that you can use to build an object. However when we use composition in Python, we cannot access methods directly from the composed class, and we either re-define these methods from scratch, or access them using chaining. 3 Answers. So the goose is more or less. However, C# specifically does provide a nice out here. Use inheritance over composition in Python to model a clear is a relationship. but do not shoehorn composition where inheritance is the right answer. Inheritance in OOP is when we derive a new class from an existing base class. Much like other words of wisdom, they had gone in without being properly digested. What advantages does composition have over inheritance? Coupling and Cohesion Ideally, the objects in our system have high cohesion (i. By making the methods suitably granular, the base class can then make small tweaks to the shared behavior without causing code duplication. The composition can offer more explicit control and better organization in such scenarios. Prefer composition over inheritance? (35 answers) Closed 10 years ago. People will repeat it without even understanding it. It does not matter if you are using inheritance or composition, you still need to know about the performance hit to design around it. In many newer languages, inheritance is limited to one class, while you can compose as much as you want. เรา. 1. Prefer composition over inheritance as it is more malleable / easy to modify later, but do not use a compose-always approach. On the other hand, one thing that you’ll miss when not using classes is encapsulation. That extends even to further subclasses - and with Java's single-inheritance model, if we have two new bits of. Conclusion. We need to include the composed object and use it in every single class. Programming is as much an art as a science. Teach. Private inheritance means is-implemented-in-terms of. Default methods do not change this. In case of inheritance there are data that are present in form of the model field. Inheritance is powerful when used in the right situations. You can model anything as a hierarchy. So the goose is more or less. ) Flexibility : Another reason to favor composition over inheritance is its. Should composition be favoured over inheritance as rule - in all circumstances? I have read that inheritance is actually now being seen as an anti pattern. IObservable<T> and. " What benefits was it giving you in this case? I would avoid blindly following "prefer composition over inheritance" like it's gospel. 13 February, 2010. , if inheritance was implemented only to combine common code but not because the subclass is an extension of the superclass. Data models generally follow OOP more closely. "which has destroyed the benefits that the composition pattern was giving me. In object-oriented programming, we will often handle this with inheritance. And you can always refactor again later if you need to compose. Let's say I have the following IGameobject interface. Composition is a “has-a” relationship, used to design a class on what it does. Again, now it's clear where that Component is going. But again, virtually all of the major design patterns use composition, and modern design paradigms such as inversion of control and dependency injection also use composition. First declare interfaces that you want to implement on your target class: interface IBar { doBarThings (): void; } interface IBazz { doBazzThings (): void; } class Foo implements IBar, IBazz {}In OOP there’s this thing to prefer composition over inheritance. It should probably not be used before understanding how traits work normally. Mar 26, 2012 at 17:40. In languages without multiple inheritance (Java, C#, Visual Basic. Inheritance is more rigid as most languages do not allow you to derive from more than one type. Publish the abstraction interface in the separate inheritance hierarchy, and put the implementation in its own inheritance hierarchy. With composition, it's easy to change behavior on the fly with Dependency Injection / Setters. This has led many people to say, prefer composition over inheritance. Prefer using composition over inheritance when you need to reuse code and the types don’t have an “is a” relationship. That would make the treatment on "MessageReceiver" with pattern. Object-Oriented Programming (OOP) is a programming paradigm where objects representing real-world things are the main building blocks. Goを勉強している中で、「Composition over inheritance」という概念が出てきました。ちゃんと理解していなかったので、ここで改めて掘り下げます。 特に、普段 Ruby や Rails を書いている初中級者の方は、Go を勉強する前におさらいしておくことをオススメします。Communicating clearly with future programmers, including future you. This site requires JavaScript to be enabled. Interface inheritance is key to designing to interfaces, not implementations. You are dependent on base class to test derived class. If you're working in a language without multiple inheritance, you should always favour composition over inheritance. In general composition is the one you want to reach for if you don’t have a strong. First, justify the relationship between the derived class and its base. Using interfaces and composition not only makes our code more modular but. Composition has always had some advantages over inheritance. 5. You do composition by having an instance of another class C as a field of your class, instead of extending C. I prefer to opt-in things to expose as opposed to opt-out. In Python. The most basic way to deal with multiple inheritance issues in Java is to use interfaces and then delegate behavior using composition. Teach. composition in that It provides method calling. It should never be the first option you think of, but there are some design patterns which. George Gaskin. e. Actually, "Composition over inheritance" often ends up being "Composition + inheritance over inheritance" since you often want your composed dependency to be an abstract superclass rather than the concrete subclass itself. Unlike interfaces, you can reuse code from the parent class in the child class. In general, you should prefer composition over inheritance. Composition vs Inheritance in the Semantic Web. One score (minus five) years ago, in the age of yore and of our programming forefathers, there was written a little book. Changing a base class can cause unwanted side. We’ll introduce the pattern, a simplifying abstraction over data storage, allowing us to decouple our model layer from the data layer. 4. Erich Gamma lept onto the software world stage in 1995 as co-author of the best-selling. Academy. Prefer composition over inheritance; Dependency injection for objects that fullfill defined roles; Cautiously apply inheritance and polymorphism; Extracting classes or objects when appropriate; Tiny public interfaces; Make all member variables private; Avoid global variables at all times;composition นั้นไม่ได้ใช้หรือทำงานร่วมกับ inheritance. So you have an entity called User which is your persistence object. Here you will see why. You need to be precise: Java allows multiple inheritance of interface, but only single inheritance of implementation. Conclusion. Reference. Generally it is said, Favor Composition Over Inheritance, as it offers many advantages. About;Some people said - check whether there is “is-a” relationship. Sorted by: 15. Also, is it not possible to have the generic (isInteger etc) methods implemented in the interface Validator and marked finalGoogle "is a, has a" inheritance and composition for an overview on when to use each. Composition is still an OOP concept. Concerning;19. OOP: Inheritance vs. You really need to understand why you're doing it before you do it. . e. A lot of what rdfs provides has an analog in Object Oriented Programming (OOP). OOP allows objects to have relationships with each other, like inheritance and aggregation. The composition can be used to achieve code reuse without creating complex inheritance. This is where the age-old design pattern of composition over inheritance comes into the picture. Without knowing what both classes do or represent, it is impossible to decide whether one 'is a' subtype of the other, but let me remark that in "Effective Java", Joshua Bloch recommends to prefer composition over inheritance in most situations, since inheritance provides your new class with an interface that may be too large, or out of its. And in Ruby people constantly forget that modules == multiple inheritance -_solnic_. Favor object composition over class inheritance. Prefer composition over inheritance? Sep 10, 2008. It also gives the developer more power over how this progress bar works. “Prefer composition over inheritance and interfaces. It's not too hard to decide what should be used over each other, inheritance is an “Is a” relationship and composition is an “Has a” relationship, these are powerful assets in programming software so think about how they can benefit each other when you use them. We therefore suggest to prefer composition (=delegation) over inheritance where this is possible. prefer composition over inheritance ,and so on known articles about the abuse of inheritance. Favoring Composition Over Inheritance In Java With Examples. e. Overview. ”. แต่ในความเป็นจริง. THIS POST SERIES ISN’T ABOUT OOP BEING BAD – It’s getting you to realize THE TRUE POWER OF OOP –. " Composition is to favour over inheritance " is a guidance: When starting with OOP, it's tempting to see inheritance everywhere. After seeing the advantages of Composition and when to use it you can have a look at SOLID and Inversion Of Control it will help it all fit. So in this case, good practice is using inheritance and it allows also to respect the DRY principle. This is an idea that I’ve been thinking about a lot as I’ve been reading books on object-oriented programming and design patterns. Follow edited Jan 2, 2009 at 5:36. In both cases, do the classes have a strict "is-a" relationship? If you can say "Has-a" out loud and it doesn't sound stupid, you probably want composition. Stack, which currently extends java. When you use composition, you are (as the other answers note) making a "has-a" relationship. Taking a mantra like "favour composition over inheritance" out of context and using that as an unbending rule not only goes against that philosophy but highlights the dangers of reducing sound advice to the level of soundbites. Can composition sometimes be more flexible or easier to maintain than straight-up inheritance? Sure. For example, you can define a class called Animal, with attributes like name, age, and. An often-repeated piece of advice in OOP is “prefer composition over inheritance”. The popular advice is not "stick to composition" it's "prefer composition over inheritance". Prefer composition over inheritance; To start with, what we can be sure of is that our application needs to collect payment - both at present and in the future. This might mislead to think that there is a relation between these two different concepts: Inheritance is about a relation between classes. This isn't something you can follow without thinking about it. It wasn't. If you limit the usage of classes, then you’re getting rid of a whole class of design problems. private inheritance is typically used to represent "implemented-in-terms-of". inherit from) a Vehicle. In above scenario , it is better practice to make separate class for address because it contain multiple information like house no,city,country postal code etc. The setup method of the FramworkInterface will be called just after instance created by default Constructor so we can use it to initialize our RecordValidator attribute; This is kind of Mixing and Matching Composition and Inheritance together to me because I'm using Composition with Inheritance together. Item18: 復合優先於繼承. Finally, I told you that the Observable class and the Observer interface have been deprecated since Java 9. 1. If that is the situation I would prefer a Rust enum instead of a hiearchy (as some other poster already mentioned). . Your composition strategy still involves inheritance with virtual methods, so that really doesn't simplify over the (first) direct inheritance option. Prefer Composition Over Inheritance Out of Control Inheritance. If you want the object to use all the behavior of the base class unless explicitly overridden, then inheritance is the simplest, least verbose, most straightforward way to express it. So, the way I understand "prefer composition over inheritance" is that inheritance leaks an implementation detail. We create a base class. The client’s dependency on classes is replaced with interfaces. wizofaus 9 months ago | root | parent | next [–] The logging target may be a property that is part of the composition of the logger itself, but it would still need to support interface- or abstract-"inheritance" (even if via duck-typing) to be useful. Inheritance describes a "is a" relationship, composition describes a "has a" relationship. This idea of keeping internal/private state is nice and you’ll probably miss it if you entirely get. It becomes handy when you must subclass different times in ways that are orthogonal with one another. The tricky part is deciding which to use where. Pros: Maps well to non-oop scenarios like relational tables, structured programing, etc"prefer composition over inheritance" is not a braindead rule saying one should avoid inheritance under all circumstances - that would miss the point of that recommendation, and would be nothing but a form of cargo-cult programming. The Liskov Substitution Principle. Create a Person class. You should prefer inheritance when inheritance is more appropriate, but prefer composition when composition is more appropriate. Author’s Note: PLEASE DONT FORGET TO READ PART 2 – PREFER COMPOSITION OVER INHERITANCE! – It describes the alternative! It’s what the Gang of Four intended when they made Design Patterns. Publish abstraction interface in a separate inheritance hierarchy, and put the implementation in its own inheritance hierarchy. Go to react. As a very general rule, look no further than The Zen of Python (which you can also see by typing import this into the Python interpreter): Flat is better than nested. In the implementation of this pattern, we prefer composition over an inheritance – so that we can reduce the overhead of subclassing. Yes, we're now running the only sale of the year. Use inheritance. , combining multiple classes) instead of relying solely on mixins. That's why it exists. If it is there use inheritance. is-a relationships. Hello proggit, I've heard from quite a few places lately to prefer composition to inheritance (last time was from…Sử dụng Composition để thay thế Inheritance. For example, rdfs:subClassOf roughly corresponds to the OOP concept of a subclass. We can replace the CheckBox with a RadioButton. You should use interfaces instead of having a class hierarchy. The new class has now the original class as a member. 3K views 1 year ago C# - . If The new class is more or less as the original class. A common misunderstanding with the DRY principle is that it is somehow related to not repeating lines of code. There are still cases where inheritance makes the most sense. In most cases, you should prefer composition when you design plain Java classes. Prefer Composition Over Inheritance. My opinion is perhaps a little softer (or maybe just differently worded) than the others here; both inheritance and composition have their place in good code. This principle is a reaction to the excessive use of inheritance when Object Oriented design became popular and inheritance of 4 or more levels deep were used and without a proper, strong, "is-a" relationship between the levels. Now the Flutter language dev team has been pretty clear that composition should always be prefered to inheritance when extending widgets. That has several reasons: Humans are bad at dealing with complexity. Another one is the Composition over Inheritance Principle, which states that you should prefer composition over inheritance when possible, as it gives you more flexibility and modularity. This being said, and to satisfy your curiosity about inheritance: inheritance is a very special relationship that should mean is-a: a Dog is-an Animal, so it may inherit from it. . a single responsibility) and low coupling with other objects. prefer composition over inheritance, because inheritance is always a strong coupling (any change in the parent class might require a change in all the child classes) and furthermore, it's defined at compile time. Inheritance: a class may inherit - use by default - the fields and methods of its superclass. A Decorator pattern can be used to attach additional responsibilities to an object either statically or dynamically. That said, I definitely do also use. Perhaps it adds additional metadata relating to the entries in A. We prefer short functions focusing each on one task and for which the input and output types are clearly specified. This chapter introduces the 'prefer composition over inheritance' design principle, by explaining the 'Strategy-Pattern'. Inheritance is more rigid as most languages do not allow you to derive from more than one type. The main use I have seen is for mixins using private multiple inheritance to build up a child object with the proper functionality from the various mixin parents. I assert that the advice to prefer composition over inheritance is just fear mongering, pushed by those who failed to understand either where inheritance is best used, or how to properly refactor logic. e. Inheritance is used when there is a is-a relationship between your class and the other class. IMHO "prefer composition over inheritance" is such a misunderstood thing it's become a dogma. " But this is a guideline, not a hard and fast rule. The more instances of the same knowledge, the harder it is to change it. The first thing to remember is that inheritance tightly bounds you to the base class. [2] 1436. This comprehensive article navigates the complex discussion of composition vs inheritance in the context of ReactJS programming. " Composition is to favour over inheritance " is a guidance: When starting with OOP, it's tempting to see inheritance everywhere. I definitely prefer Composition over Inheritance after doing this exercise. Inheritance inherits the properties of other components, whereas composition merely inherits the behaviour of other components. On the other hand, there is the principle of "prefer composition over inheritance". See more1436. JimchaoTry reading through a few answers on Prefer composition over inheritance? As a rule of thumb try out this: if inheritance would result in more than 3 levels of hierarchy, use composition if you have something that matches the strategy pattern, use inheritance always prefer composition (try it first)As the saying goes: prefer composition over inheritance. Additionally, if your types don’t have an “is a” relationship but. Then, reverse the relationship and try to justify it. If you are in total control, you can build entire systems using interfaces and composition. Assume that you have started a project and you decided to use VIPER as project architecture. “has-a”). In OO, if something "is a" use inheritance. Conclusion. Usually it implies the opposite. How this method is implemented, whether by composition, generics or some other technique, is orthogonal. Composition versus Inheritance. Pretend you own a pizza shop. Consider the following example ECS from Evolve Your Hierarchy: Your components would correspond to classes: class Position. And you probably mostly should - "prefer composition over inheritance". It’s time to make good on our promise to use the dependency inversion principle as a way of decoupling our core logic from infrastructural concerns. As discussed in other answers multiple inheritance can be simulated using interfaces and composition, at the expense of having to write a lot of boilerplate code. There are two benefits of inheritance: subtyping and subclassing Subtyping means conforming to a type (interface) signature, ie a set of APIs, and one can override part of the signature to achieve subtyping polymorphism. Mỗi cách thiết kế đều có ưu nhược điểm riêng, chúng ta cần xác định rõ mục đich, và. Prefer composition over inheritance; To start with, what we can be sure of is that our application needs to collect payment - both at present and in the future. – Ben Cottrell. Is initially simple and convenient. Use bridge. The primary issue in composition vs inheritance is that the programming world has begun to think of these two concepts as competitors. In my opinion…Composition. Because of props. Inheritance: a class may inherit - use by default - the fields and methods of its superclass. Composition is used when there is a has-a relationship between your class and the other class. Share your knowledge with others, earn money, and help people with their career. Let’s take a single design problem and watch how this principle works itself out through several of the classic Gang of Four design patterns. Reasons to Favour Composition over Inheritance in Java and OOP: The fact that Java does not support multiple inheritances is one reason for favoring. You still get code reuse and polymorphism through it. In that respect, there is not necessarily a single best way to achieve a result, and it's up to you to compare the pros and cons. Widgets are built out of smaller widgets that you can reuse and combine in novel ways to make custom widgets. The major. It is best to prefer composition over inheritance when the relationship between classes is uncertain or likely to change in the future, as composition is more flexible and adaptable than inheritance. Example Problem Let’s say that as part of your language you need to describe an input for a certain transformation. Yet, I often hear programmers say they prefer “Composition over inheritance”. 1. Why prefer composition instead of heirship? What trade-offs are there required each approach? And the converse question: when ought I choose inheritance instead of composition? Stack Overflow. g 1. With classic (Java, C#, and C++ to some extent) OOP, one can model shared behavior and data between classes by making those classes inherit from some common (absctract) base class with the appropriate methods and data. Composition in JavaScript is implemented through concatenative. g. Creating deep inheritance hierarchies leads to brittle/inflexible code when you are trying to make changes deep in the hierarchy. class Car may have an Engine member (composition), but may be (i. Unlike composition, private inheritance can enable the empty base optimization. E. g. The car is a vehicle. But this brings certain challenges such as subclass adherence to base class implementations, difficulty in changing the base class over time, and increased coupling. Like you, I tend to favor composition over inheritance. The composition is a design technique in java to implement a has-a relationship. Inheritance is one of the four major concept of OOP, where a class known as sub/child class achieve the behavior of another class known as parent/super class by inheriting it. In this interview, Erich Gamma, co-author of the landmark book, Design Patterns, talks with Bill Venners about two design principles: program to an interface, not an implementation, and favor object composition over class inheritance. I’m not entirely sure this is going anywhere fruitful. Even more misleading: the "composition" used in the general OO. eg: Bathroom HAS-A Tub. They are absolutely different. 1969 Prefer composition over inheritance? 1242. E. A Decorator provides an enhanced interface to the original object. Follow. In the same way, the. For instance. I keep it as a huge object, but split related methods into separate classes from which I inherit (but I don't. Why you should favor composition over inheritance. answered Jan 2, 2009 at 5:18. 0. Yes, (novice) developers need to be urged away from overusing inheritance, but that does not invalidate that there are use cases for inheritance. composition over inheritance; Random bits. Inheritance vs. Be very careful when you use inheritance. Prefer Composition Over Inheritance. enum_dispatch is a crate that implements a very specific optimization, i. Let's say you wanted to avoid they use of abstract classes completely and only use concrete classes. By preferring composition over inheritance in Go, we can create flexible, maintainable, and reusable code. dead_alchemy • 14 hr. This is what you need. Another case is overriding/changing. – Blake. Antipattern: inheritance instead of composition. Prefer composition to inheritance. Makes a lot of sense there. We can overuse ‘inheritance’. Note that at least for this example, the CompositionRobot is usually considered to be the better approach, since inheritance implies an is-a relationship, and a robot isn't a particular kind of Arms and a robot isn't a particular kind of Legs (rather a robot has-arms and has-legs ). NET Prefer Composition Over Inheritance is an important tenet of Object oriented programming, but what's so bad about. Similarly, a property list is not a hash table, so. -- Why I mostly prefer composition over inheritance on inheritance problem on benefit of composition over inheritance. Here’s an example that illustrates the benefits of composition over. Composition vs. If you rely on composition over inheritance too heavily, you. When books and articles refer to "prefer composition over inheritance", they are specifically not talking about interfaces; they're talking about state and behaviour inherited from a base class. Give the Student class a list of roles, including athlete, band member and student union member. In that case, the following is possible (with Eclipse): Write a class skeleton as follows: class MyClass implements XXXInterface. Prefer using composition over inheritance when you need to reuse code and the types don’t have an “is a” relationship. Inheritance, by its very nature, tends to bind a subclass to its superclass. 2. I have yet to find any major downsides to this approach, works just as I would want multiple inheritance to do. But like all tools it can be abused! In fact, there is a popular quote from the original Design Patterns book that goes like this: “Prefer composition over inheritance. js and TypeScript. The car is a vehicle. Summary. This is what you need. BTW, You should always prefer Composition over Inheritance in Java, it not just me but even Joshua Bloch has suggested in his book Effective Java, which is a great resource to learn how to do things in the right way in Java. Kt. If The new class is more or less as the original class. Classes and objects created through composition are loosely coupled, which. Terry Wilcox. In that respect, there is not necessarily a single best way to achieve a result, and it's up to you to compare the pros and cons. Inheritance can get messy. Reply. Composition vs. My question isn't about the pattern, but rather about a more. So, here's when you want to use inheritance: when you need to instantiate both the parent and child classes. g. Inheritance and Composition are, in a vacuum, equally useful. 5 Reasons to Prefer Composition over Inheritance in Java On composition, a class, which desires to use the functionality of an existing class, doesn't inherit, instead it holds a reference of that class in a member variable, that’s why the name composition. Your first way using the inheritance makes sense. Inheritances use when. It's usually inferior to composition, but it makes sense when a derived class needs access to protected base class members or needs to redefine inherited virtual functions. Inheritance does not break encapsulation.