* * Never equal to null: for any non-null value `x`, `x.equals(null)` should return false. With the help of the inner class, we can access the outer class property inside the inner class. * * Consistent: for any non-null values `x` and `y`, multiple invocations of `x.equals(y)` consistently return true or consistently return false, provided no information used in `equals` comparisons on the objects is modified. Kotlin Inner Class When we can declare a class inside another class using the keyword inner then it is called inner class. * * Transitive: for any non-null values `x`, `y`, and `z`, if `x.equals(y)` returns true and `y.equals(z)` returns true, then `x.equals(z)` should return true. * * Symmetric: for any non-null values `x` and `y`, `x.equals(y)` should return true if and only if `y.equals(x)` returns true. Implementations must fulfil the following * requirements: * * * Reflexive: for any non-null value `x`, `x.equals(x)` should return true. ** * Indicates whether some other object is "equal to" this one. These words cannot be used as an identifier. As we can see this design is more flexible as new implementations of Moving and Eating can be created without affecting the Animal class.ĭelegation over inheritance is therefore a way to achieve the Open-Closed principle of the SOLID design patterns.All three functions are well-known functions which can be overridden in any class. Keywords are predefined, reserved words used in Kotlin programming that have special meanings to the compiler. However it has no actual code of the implementation, it delegates the calls to the concrete implementations of Walking and MeatEating. The Animal class implements the interfaces IMoving and IEating. The right picture on the other hand favors composition over inheritance.
A naive way of doing that would be to implement it as shown in the left picture. We want to create “animals” and implement how they move and eat. As an over-exaggerated example consider the following class setup. long inheritance chains were used to add incremental functionality to objects. In the past, this way of modeling was abused which caused bad design. As a textbook example, we can imagine a Shape class (base) and rectangles, circles, etc as derived classes. Other classes can inherit from the base class and get therefore the functionality inherited. It means that you can put some functionality and abstraction in a base class. It is known that in object-oriented languages inheritance is one of the key features.
0 kommentar(er)
