[Core Java. Volume I. Fundamentals, 8th Edition]-5

reflection

reflection, the ability to find out more about classes and their properties in a running program.it is of interest mainly to tool builders, not application programmers.

关于超类的构造函数调用

If the subclass constructor does not call a superclass constructor explicitly, then the default (no-parameter) constructor of the superclass is invoked. If the superclass hasno default constructor and the subclass
constructor does not call another superclass constructor explicitly, then the Java compilerreports an error.

关于子类的方法重写

NOTE: Recall that the name and parameter type list for a method is called themethod’s signature. The return type is not part of the signature. However, when you override a method, you
need to keep the return type compatible. However, it is now legal for the subclass tochange the return type of an overridden method to asubtype of the original type.

如果一个类被声明为final,那么其方法自动变为final，但是变量非此

If a method is not overridden, and it is short, then a compiler can optimize the method call away—a process calledinlining.

抽象类

if a class is declared as
abstract, no objects of that class can becreated.

错误的示范

new Person("Vince Vu")

以下语句可以成立

Person p = new Student("Vince Vu", "Economics");

关于hashCode

自定义equals方法的时候要记得重写哈希码方法

Object Wrappers and Autoboxing

Occasionally, you need to convert a primitive type likeint to an object. All primitive types have class counterparts. For example, a class Integer corresponds to the primitive type int. These kinds of
classes are usually called wrappers. The wrapper classes have obvious names:
Integer, Long, Float, Double, Short, Byte, Character, Void, and Boolean. (The first six inherit from the common superclass Number.) The wrapper classes are immutable—you cannot change a wrapped value after the
wrapper has been constructed. They are alsofinal, so you cannot subclass them.

Suppose we want an array list of integers. Unfortunately, the type parameter inside the angle brackets cannot be a primitive type. It isnot
possible to form an ArrayList<int>. Here, the Integer wrapper class comes in. It is ok to declare an array list of Integer objects.

ArrayList<Integer> list = new ArrayList<Integer>();

Enumeration Classes

public enum Size { SMALL, MEDIUM, LARGE, EXTRA_LARGE };

The type defined by this declaration is actually a class. The class has exactly four instances—it is not possible to construct new objects.

You can, if you like, add constructors, methods, and fields to an enumerated type. Of course, the constructors are only invoked when the enumerated constants are constructed. Here is an example.

enum Size 
                      { 
                         SMALL("S"), MEDIUM("M"), LARGE("L"), EXTRA_LARGE("XL"); 

                         private Size(String abbreviation) { this.abbreviation = abbreviation; } 
                         public String getAbbreviation() { return abbreviation; } 

                         private String abbreviation; 
                      }

All enumerated types
are subclasses of the class Enum.



关于Class类型

Class cl1 = Date.class; // if you import java.util.*; 
     Class cl2 = int.class; 
     Class cl3 = Double[].class;

Note that a Class object really describes a type, which may or may not be a class. For example,int
is not a class, but int.class is nevertheless an object of typeClass.

import java.lang.Class

e.getClass().newInstance();

creates a new instance of the same class type ase. ThenewInstance method calls the default constructor (the one that takes no parameters) to initialize the newly created object. An exception is thrown if
the class has no default constructor.

java.lang.reflect.Constructor 1.1

* Object newInstance(Object[] args) args为需要传入的参数

Don’t use protected fields.

Some programmers think it is a good idea to define most instance fields as protected, “just in case,” so that subclasses can access these fields if they need to. However, the protected mechanism doesn’t give much protection, for two reasons. First,
the set of subclasses is unbounded—anyone can form a subclass of your classes and then write code that directly accesses protected instance fields, thereby breaking encapsulation. And second,
in the Java programming language, all classes in the same package have access to protected fields, whether or not they are subclasses.
（真的假的）

However, protected methods can be useful to indicate methods that are not ready for general use and should be redefined in subclasses. The
clone method is a good example.