No, you don’t have to. Assume you have the following classes. class a { let name: String init() { name = “james” } } class b: a { let title: String override init() { title = “supervisor” } } If you instantiate a variable with let myVar = b() Then, override init() in b will … Read more
Another solution I eventually came up with, in addition to the ones provided by @iberbeu and @Nypan, is to add and intermediary initProps() method right before the call to scream(): class Person { public firstName: string; constructor(firstName: string, props?: any) { this.firstName = firstName; this.initProps(props); this.scream(); } protected initProps(props: any): void { } protected scream(): … Read more
I believe that the more you start to develop using design patterns, you’ll find more and more often where composition is going to be favored over inheritance. I actually believe in the Head First: Design Patterns book that “Favor Composition Over Inheritance” is one of the primary design principles. Your example of being able to … Read more
I solved it myself by creating a MappedSuperclass @MappedSuperclass public abstract class EntityBase{ @Id @GeneratedValue private int id; …setter/getter } All entities are inheriting from this class. I am still wondering why the tutorials dont mention this, but maybe it gets better with the JPA 2 implementations.
This is not the exact answer to your question but we can do something like this to share common parameters. message Child1 { required int c1 = 2; required string c2 = 3; } message Child2 { required int c1 = 2; required string c2 = 3; } message Request { required string common1 = … Read more
Interfaces are named collections of method signatures: see: https://gobyexample.com/interfaces and: http://www.golangbootcamp.com/book/interfaces so it is better not to use in such OOP way. what you asking is not Golang idiomatic but possible (2 ways): this is what you need (working sample code): package main import “fmt” type Base struct { } func (base *Base) Get() string … Read more
I like the Stream hierarchy. The idea is that anything can use a stream without usually caring what kind of stream it is, and individual subclasses handle the storage differently (e.g. NetworkStream, MemoryStream and FileStream in .NET). If you’re interested in interfaces, then IEnumerable<T> in .NET is a great one – you can iterate over … Read more
As mentioned in people’s comments, Go encourages composition over inheritance. To address your question about reducing code duplication, you would want to use embedding. Using the example from Effective Go linked above, you start with very narrow interfaces that only do a few things: type Reader interface { Read(p []byte) (n int, err error) } … Read more
Mark, This is an interesting question. You will find as many opinions on this. I don’t believe there is a ‘right’ answer. This is a great example of where a rigid heirarchial object design can really cause problems after a system is built. For example, lets say you went with the “Customer” and “Staff” classes. … Read more
Take this class for example: class MyClass { public num: number; public str: string; public constructor(num: number, str: string) { this.num = num; this.str = str; } public fn(arr: any[]): boolean { // do something } } You can create an instance like so: let a1 = new MyClass(4, “hey”); But you can also create … Read more