Thinking in Java——笔记(7)

Reusing Classes

---

• The first is composition，You’re simply reusing the functionality of the code, not its form.
• The second approach is inheritance，You literally take the form of the existing class and add code to it without modifying the existing class.

Composition syntax

• You simply place object references inside new classes.
• Every non-primitive object has a toString( ) method.

• If you want the references initialized, you can do it:

  1.At the point the objects are defined.
  2.In the constructor for that class.
  3.Right before you actually need to use the object(lazy initialization).
  4.Using instance initialization.

Inheritance syntax

• It turns out that you’re always doing inheritance when you create a class.
• You automatically get all the fields and methods in the base class.
• This technique of putting a main() in each class allows easy testing for each class.
• Even if a class has package access, a public main() is accessible.
• If a class from some other package were to inherit from base class, it could access only public members.
• To allow for inheritance, as a general rule make all fields private and all methods public.
• It’s possible to take a method that’s been defined in the base class and modify it.
• Java has the keyword super that refers to the “superclass” that the current class inherits.

Initializing the base class

• It can be a bit confusing to try to imagine the resulting object produced by a derived class.
• When you create an object of the derived class, it contains within it a subobject of the base class.
• Perform the initialization in the constructor by calling the base- class constructor
• Java automatically inserts calls to the base-class constructor in the derived-class constructor.
• The compiler will synthesize a default constructor for you that calls the base class constructor.

Constructors with arguments

• If your class doesn’t have default arguments, or if you want to call a base-class constructor that has an argument, you must explicitly write the calls to the base-class constructor using the super keyword and the appropriate argument list.
• The call to the base-class constructor must be the first thing you do in the derived-class constructor.

Delegation

• You place a member object in the class you’re building (like composition), but at the same time you expose all the methods from the member object in your new class (like inheritance).
  
• Although the Java language doesn’t support delegation, development tools often do.

Combining composition and inheritance

• The compiler doesn’t watch over you to make sure that you initialize the member objects, so you must remember to pay attention to that.
• You don’t even need the source code for the methods in order to reuse the code. At most, you just import a package.

Guaranteeing proper cleanup

• So if you want something cleaned up for a class, you must explicitly write a special method to do it, and make sure that the client programmer knows that they must call this method.
• First perform all of the cleanup work specific to your class, in the reverse order of creation. Then call the base-class cleanup method.
• when you must do cleanup explicitly, diligence and attention are required, because there’s not much you can rely on when it comes to garbage collection.

Name hiding

• Overloading works regardless of whether the method was defined at this level or in a base class.
• It’s far more common to override methods of the same name, using exactly the same signature and return type as in the base class.
• You can choose to add this annotation and the compiler will produce an error message if you accidentally overload instead of overriding.

Choosing composition vs. inheritance

• You embed an object so that you can use it to implement features in your new class, but the user of your new class sees the interface you’ve defined for the new class rather than the interface from the embedded object.
• When you inherit, you’re taking a general-purpose class and specializing it for a particular need.
• The is-a relationship is expressed with inheritance, and the has-a relationship is expressed with composition.

protected

• You want to make something hidden from the world at large and yet allow access for members of derived classes.

Upcasting

• The new class is a type of the existing class.
• Any message you can send to the base class can also be sent to the derived class.

Why “upcasting”?

• Casting from a derived type to a base type moves up on the inheritance diagram, so it’s commonly referred to as upcasting.
• Upcasting is always safe because you’re going from a more specific type to a more general type.
• It can lose methods, not gain them.
• The compiler allows upcasting without any explicit casts or other special notation.

Composition vs. inheritance revisited

• You should use it sparingly, only when it’s clear that inheritance is useful.
• Whether you’ll ever need to upcast from your new class to the base class.

The final keyword

• Java’s final keyword has slightly different meanings depending on the context

final data

• A value must be given at the time of definition of such a constant.
• With a primitive, final makes the value a constant, but with an object reference, final makes the reference a constant.
• However, the object itself can be modified.
• Java does not provide a way to make any arbitrary object a constant.
• Just because something is final doesn’t mean that its value is known at compile time.
• The difference between making a final value static or non-static.
• There is no way that I know of to make the array references themselves final.

Blank finals

• The blank final must be initialized before it is used, and the compiler ensures this.
• A final field inside a class can now be different for each object, and yet it retains its immutable quality.
• You’re forced to perform assignments to finals either with an expression at the point of definition of the field or in every constructor.

final arguments

• This means that inside the method you cannot change what the argument reference points to.
• You can read the argument, but you can’t change it.
• This feature is primarily used to pass data to anonymous inner classes.

final methods

• Final methods put a “lock” on the method to prevent any inheriting class from changing its meaning.
• You want to make sure that a method’s behavior is retained during inheritance and cannot be overridden.

final and private

• Any private methods in a class are implicitly final.
• If a method is private, it isn’t part of the base-class interface.
• You haven’t overridden the method; you’ve just created a new method.

final classes

• You don’t want to inherit from this class or allow anyone else to do so.
• Note that the fields of a final class can be final or not.
• Bnecause it prevents inheritance, all methods in a final class are implicitly final.

final caution

• If you define a method as final, you might prevent the possibility of reusing your class through inheritance in some other programmer’s project simply because you couldn’t imagine it being used that way.

Initialization and class loading

• The compiled code for each class exists in its own separate file. That file isn’t loaded until the code is needed.
• class code is loaded at the point of first use.
• Loading also occurs when a static field or static method is accessed.

Initialization with inheritance

• The static initialization in the root base class (in this case, Insect) is performed, and then the next derived class, and so on.
• First, all the primitives in this object are set to their default values and the object references are set to null.
• Then the base-class constructor will be called.
• The instance variables are initialized in textual order.
• Finally, the rest of the body of the constructor is executed.

转载于:https://www.cnblogs.com/apolloqq/p/6137833.html