The 5 keyword is used in class declarations or class expressions to create a class that is a child of another class.
6An expression that evaluates to a constructor function (including a class) or 7.The 5 keyword can be used to subclass custom classes as well as built-in objects.Any constructor that can be called with 9 and has the 0 property can be the candidate for the parent class. The two conditions must both hold — for example, bound functions and 1 can be constructed, but they don't have a 0 property, so they cannot be subclassed.
The 0 property of the 6 must be an 5 or 7, but you would rarely worry about this in practice, because a non-object 0 doesn't behave as it should anyway. (It's ignored by the 9 operator.)
5 sets the prototype for both 0 and 1.Prototype of 0Prototype of 1 5 clause absent 5 6 7 5 7 0 6 2
The right-hand side of 5 does not have to be an identifier. You can use any expression that evaluates to a constructor. This is often useful to create .
While the base class may return anything from its constructor, the derived class must return an object or 4, or a 5 will be thrown.
If the parent class constructor returns an object, that object will be used as the 6 value for the derived class when further initializing class fields. This trick is called , which allows a derived class's fields (including private ones) to be defined on unrelated objects.Warning: The standard committee now holds the position that the built-in subclassing mechanism in previous spec versions is over-engineered and causes non-negligible performance and security impacts. New built-in methods consider less about subclasses, and engine implementers are investigating whether to remove certain subclassing mechanisms. Consider using composition instead of inheritance when enhancing built-ins. Here are some things you may expect when extending a class:
However, the above expectations take non-trivial efforts to implement properly.
These problems are not unique to built-in classes. For your own classes, you will likely have to make the same decisions. However, for built-in classes, optimizability and security are a much bigger concern. New built-in methods always construct the base class and call as few custom methods as possible. If you want to subclass built-ins while achieving the above expectations, you need to override all methods that have the default behavior baked into them. Any addition of new methods on the base class may also break the semantics of your subclass because they are inherited by default. Therefore, a better way to extend built-ins is to use . The first example creates a class called 2 from a class called 3. This example is extracted from this live demo (source).
Classes cannot extend regular (non-constructible) objects. If you want to inherit from a regular object by making all properties of this object available on inherited instances, you can instead use 4:
This example extends the built-in 5 object. This example is extracted from this live demo (source).
You might want to return 6 objects in your derived array class 7. The species pattern lets you override default constructors.For example, when using methods such as 0 that return the default constructor, you want these methods to return a parent 6 object, instead of the 7 object. The 1 symbol lets you do this:
This behavior is implemented by many built-in copying methods. For caveats of this feature, see the discussion. Abstract subclasses or mix-ins are templates for classes. A class can only have a single superclass, so multiple inheritance from tooling classes, for example, is not possible. The functionality must be provided by the superclass. A function with a superclass as input and a subclass extending that superclass as output can be used to implement mix-ins: 0A class that uses these mix-ins can then be written like this: 1Inheritance is a very strong coupling relationship in object-oriented programming. It means all behaviors of the base class are inherited by the subclass by default, which may not always be what you want. For example, consider the implementation of a 2: 2It turns out that 2 is not constructible, because the 6 constructor calls the instance's 5 method. 3We may get around this by using a private flag to indicate whether the instance is being constructed. However, a more significant problem with this design is that it breaks the Liskov substitution principle, which states that a subclass should be substitutable for its superclass. If a function expects a 4 object, it should be able to use a 2 object as well, which will break here.Inheritance often leads to the circle-ellipse problem, because neither type perfectly entails the behavior of the other, although they share a lot of common traits. In general, unless there's a very good reason to use inheritance, it's better to use composition instead. Composition means that a class has a reference to an object of another class, and only uses that object as an implementation detail. 4In this case, the 2 class is not a subclass of 4, but it still implements most of the same methods. This means more code duplication, but it also means that the 2 class is not strongly coupled to the 4 class, and does not easily break if the 4 class is changed, avoiding the . For example, if the 4 class adds an 4 method that does not call 5, it would cause the 2 class to no longer be read-only unless the latter is updated accordingly to override 4 as well. Moreover, 2 objects do not have the 9 method at all, which is more accurate than throwing an error at runtime.
Apa yang dimaksud dengan parent class dan child class?Suatu class yang mempunyai class turunan dinamakan parent class atau base class. Sedangkan class turunan itu sendiri seringkali disebut subclass atau child class.
Apa itu child class?Class yang akan 'diturunkan' bisa disebut sebagai class induk (parent class), super class, atau base class. Sedangkan class yang 'menerima penurunan' bisa disebut sebagai class anak (child class), sub class, derived class atauheir class.
|