Java复习3-类的继承
前言
本次学习面向对象设计的另外一个基本概念：继承（inheritance）。这是Java程序设计中的一项核心技术。另外，还要学习反射(reflection)的概念。
继承
类、超类、子类
public class Manager extends Employee{
//...
}
关键字extends表明正在构造的新类派生于一个已存在的类。已存在的类称为超类(superclass)、基类(base class)或父类(parent class); 新类称为子类(sbclass)、派生类(derived class)、孩子类(childe class).
覆盖方法
子类继承父类的字段和方法，但有些方法子类想要修改，可以使用覆盖(override)。
public class Employee {
private String name;
private int salary;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
}
public class Manager extends Employee {
private int bonus;
public int getBonus() {
return bonus;
}
public void setBonus(int bonus) {
this.bonus = bonus;
}
@Override
public String getName() {
return "manager: " + super.getName();
}
@Override
public int getSalary() {
return super.getSalary() + bonus;
}
}
- extends关键字记得带s
- 超类的private字段是不能直接在子类中调用的，子类只能调用父类的protected和默认方法
- 覆盖的要求是完全一致，即子类的方法名，参数类型和顺序，返回值要完全一致
- 对于要覆盖的方法要添加注解
@Overide - 想要调用父类的同名方法，使用
supper - 子类覆盖父类的方法的权限不可以比父类小，父类是public的，子类也只能是public，父类是protected，子类不能是private
值得关注的是子类不能继承父类的private相关字段和方法。
多态
Employee manager = new Manager();
可以将子类赋值给父类。那么，我们创建多个子类，都可以赋值给Employee，employee在运行时可以知道具体是哪个子类的实例，但只能执行父类已有的方法。即子类新加的方法不能执行。子类覆盖的方法可以执行。
一个对象变量可以指示多种实际类型的现象被称为多态(polymorphism)。在运行时能够自动地选择调用哪个方法的现象称为动态绑定(dynamic binding).
Java不支持多继承，一个类只能继承一个类，而不是多个。要想要实现多个，可以使用接口。
所有的类都继承Object对象。
多态可以用关系is-a来描述，表明程序中出现超类的任何地方都可以用子类对象置换。
理解方法调用
假设要调用x.f(args), 隐式参数x声明为类C的一个对象。下面是调用过程的详细描述:
1)编译器查看对象的声明类型和方法名。假设调用x.f(args),且隐士参数x声明为C类对象。需要注意的是：有可能存在多个名字为f，但参数类型不一样的方法。例如，可能存在多个名字为f，但参数类型不一样的方法。例如，可能存在方法f(int)和方法f(String). 编译器会一一列举所有C类中名为f的方法和其超类中访问属性为public且名为f的方法(超类的私有方法不可访问)。
至此，编译器已获得所有可能被调用的候选方法。
2)接下来，编译器将查看调用方法时提供的参数类型。如果在所有名为f的方法中存在一个与提供的参数类型完全匹配，将选择这个方法。这个过程被称为重载解析(overloading resolution)。例如，对于调用x.f("Hello")，编译器将会挑选f(String), 而不是f(int). 由于允许类型转换(int可以转double，Manager可以转Employee), 所以这个过程可能很复杂。如果编译器找不到与参数匹配的方法，或发现经过类型转换后有多个方法与之匹配，将会报告一个错误。
至此，编译已获得需要调用的方法名字和参数类型。
3)如果是private方法、static方法、final方法或者构造器，那么编译器将可以准确地知道应该调用哪个方法，我们将这种调用方式成为静态绑定(static binding)。与之对应，调用的方法依赖于隐士参数的实际类型，并且在运行时实现动态绑定。
4)当程序运行，并且采用动态绑定调用方法时，虚拟机一定调用与x所引用对象的实际类型最合适的那个类的方法。假设x的实际类型是D, 它是C类的子类。如果D类定义了方法f(String), 就直接调用它，否则，将在D类的超类中寻找f(String)，以此类推。
每次调用方法都要进行搜索，时间开销相当大。因此，虚拟机预先为每个类创建了一个方法表(method table)，其中列出了所有方法的签名和实际调用的方法。这样一来，在真正调用方法的时候，虚拟机仅查找这个表就行了。
动态绑定有一个非常重要的特性：无需对现存程序进行扩展。
阻止继承：final类和方法
有时候，可能希望阻止人们利用某个类定义的子类。不允许扩展的类被成为final类。如果在定义类的时候使用了final修饰符就表明这个类是final类。
类的特定方法也可以声明为final的。这样，子类就不能覆盖这个方法(final类中的所有方法自动成为final方法)。
我们将方法声明为final的主要目的是：确保他们不会在子类中改变语义。
强制转换
只能在继承层次内进行类型转换。
在将超类转换成子类之前，应该使用instanceof进行检查。
抽象类
用abstract修饰的类是抽象类。用abstract修饰的方法是抽象方法。
抽象类不能实例化。抽象方法没有方法体。
受保护访问
- 仅本类可见--private
- 所有类可见--public
- 对本包和所有子类可见--protected
- 对本包可见--默认，不需要修饰符
equals方法
java.util.Objects#equals
public static boolean equals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
}
java.util.Arrays#equals(long[], long[])
public static boolean equals(long[] a, long[] a2) {
if (a==a2)
return true;
if (a==null || a2==null)
return false;
int length = a.length;
if (a2.length != length)
return false;
for (int i=0; i<length; i++)
if (a[i] != a2[i])
return false;
return true;
}
hashcode
java.util.Objects#hashCode
public static int hashCode(Object o) {
return o != null ? o.hashCode() : 0;
}
java.util.Arrays#hashCode(long[])
public static int hashCode(long a[]) {
if (a == null)
return 0;
int result = 1;
for (long element : a) {
int elementHash = (int)(element ^ (element >>> 32));
result = 31 * result + elementHash;
}
return result;
}
对象包装器与自动装箱
所有的基本类型都有一个 与之对应的类。Integer对应int。这些类称为包装器（wrapper）.
对象包装器不可变，且是final的。
int当做Integer叫做自动装箱（autoboxing）
list.add(1) 会被编译器编译成
list.add(Integer.valueOf(3))
Integer当做int叫做自动拆箱。
装箱和拆箱是编译器认可的，而不是虚拟机。编译器在生成类的字节码时，插入必要的方法调用。虚拟机只是执行这些字节码。
反射
反射库（reflection library）提供了一个非常丰富且精心设计的工具集，以便编写能够动态操纵Java代码的程序。
Class类
Class类保存了Java对象归属类的信息。
虚拟机为每个类型管理一个Class对象。所以，只有是这个类的Class对象，都是同一个。如何获得这个Class呢？
//通过类名获取
Class clazz = Employee.class;
Employee employee = new Employee();
//通过实例获取
Class<? extends Employee> aClass = employee.getClass();
String name = aClass.getName();
assertEquals("com.test.java.clazz.polimophic.entity.Employee", name);
//通过名字加载
Class<?> fromName = Class.forName("com.test.java.clazz.polimophic.entity.Employee");
另外，数组的class对象有点特殊。
String doubleArrayName = Double[].class.getName();
assertEquals("[Ljava.lang.Double;", doubleArrayName);
String intArrayName = int[].class.getName();
assertEquals("[I", intArrayName);
那么，我拿到Class对象如何确定是不是我需要的呢，用equals比较吗？因为虚拟机为每个类管理一个Class对象，所以可以用==。
对于上述三种方式获得的Class对象
assertTrue(clazz == aClass);
assertEquals(clazz, aClass);
assertEquals(clazz, fromName);
Class.forName("xxx.xx.xxx")会抛出一个检查性异常，如果找不到class会报ClassNotFoundException.
利用反射分析类的能力
在java.lang.reflect包中有三个类Field、Method和Constructor分别用户描述类的字段、方法和构造器。这三个类都有一个getName方法，返回名称。
Field类有个getType方法，返回描述字段所属的Class对象。
Method和Constructor类有能够报告参数类型的方法，Method类还有一个可以报告返回类型的方法。
这三个类还有一个叫做getModifiers的方法，它将返回一个整型数值，用不同的位开关描述public和static这样的修饰符使用情况。总之Modifiers提供了修饰符的判断方法。
Class类中的getFields、getMethods和getConstructors方法将分别返回类提供的public字段、方法和构造器组，其中包括超类的共有成员。
Class类的getDeclareFields、getDeclareMethods和getDeclareConstructors方法将分别返回类中声明的全部字段、方法和构造器，其中包括私有和受保护的成员，但不包括超类的成员。
获取Class name, 修饰符，父类
public void printClazz() {
Class clazz = Employee.class;
Class superclass = clazz.getSuperclass();
String modifiers = Modifier.toString(clazz.getModifiers());
if (modifiers.length()>0){
System.out.print(modifiers + " ");
}
System.out.println("class " + clazz.getName());
if (superclass!=null && superclass != Object.class){
System.out.print(" extends " + superclass.getName());
}
}
打印：
public class com.test.java.clazz.polimophic.entity.Employee
获取构造器
@Test
public void prinConstructor() {
StringBuilder sb = new StringBuilder();
Class clazz = Manager.class;
Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
for (Constructor declaredConstructor : declaredConstructors) {
String name = declaredConstructor.getName();
String modifiers = Modifier.toString(clazz.getModifiers());
if (modifiers.length()>0){
sb.append(modifiers).append(" ");
}
sb.append(name).append("(");
//打印参数
Class[] parameterTypes = declaredConstructor.getParameterTypes();
for (int i = 0; i < parameterTypes.length; i++) {
if (i>0){
sb.append(", ");
}
sb.append(parameterTypes[i].getName());
}
sb.append(");");
}
assertEquals("public com.test.java.clazz.polimophic.entity.Manager(java.lang.String, int, int);", sb.toString());
}
打印声明的方法
只打印自己的声明的方法，而不包含父类的。
/**
* public java.lang.String getName();
* public int getSalary();
* public void setBonus(arg0);
* public int getBonus();
*/
@Test
public void printMethod() {
StringBuilder sb = new StringBuilder();
Class clazz = Manager.class;
Method[] methods = clazz.getDeclaredMethods();
for (Method method : methods) {
Class<?> returnType = method.getReturnType();
String name = method.getName();
System.out.print(" ");
String modifiers = Modifier.toString(method.getModifiers());
if (modifiers.length()>0){
System.out.print(modifiers + " ");
}
System.out.print(returnType.getName() + " " + name + "(");
Parameter[] parameters = method.getParameters();
for (int i = 0; i < parameters.length; i++) {
if (i>0){
System.out.print(", ");
}
System.out.print(parameters[i].getName());
}
System.out.print(");\n");
}
}
打印声明的字段
/**
* private int bonus;
*/
@Test
public void printFields() {
Class clazz = Manager.class;
Field[] declaredFields = clazz.getDeclaredFields();
for (Field declaredField : declaredFields) {
Class<?> type = declaredField.getType();
String name = declaredField.getName();
System.out.print(" ");
String modifiers = Modifier.toString(declaredField.getModifiers());
if (modifiers.length() > 0) {
System.out.print(modifiers + " ");
}
System.out.println(type.getName() + " " + name + ";");
}
}
获取某个字段的value
Field提供了get方法，来获取字段value。
@Test
public void getFieldVal() throws NoSuchFieldException, IllegalAccessException {
Manager manager = new Manager("a", 1, 100);
Class<? extends Manager> clazz = manager.getClass();
Field bonus = clazz.getDeclaredField("bonus");
bonus.setAccessible(true);
Object bonusVal = bonus.get(manager);
System.out.println((int)bonusVal);
System.out.println(bonus.getInt(manager));
}
有几个需要注意的地方。
- clazz.getDeclaredField("bonus"); 注意参数的内容要和filed一致
- 由于该字段是private的，不能直接获取，需要设置访问权限，强制获取，bonus.setAccessible(true);
- Field.get(instance)这个方法返回Object对象，可以强转，也可以使用其他api、
修改某个字段的value
能读就能写
@Test
public void writeFiledVal() throws NoSuchFieldException, IllegalAccessException {
Manager manager = new Manager("a", 1, 100);
Class<? extends Manager> clazz = manager.getClass();
Field bonus = clazz.getDeclaredField("bonus");
bonus.setAccessible(true);
bonus.set(manager, 1000);
assertEquals(1000, manager.getBonus());
}
利用反射创建一个对象
前面获取到constructor之后就可以使用newInstance方法来创建新对象了。
@Test
public void newInstanceTest()
throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
Class clazz = Manager.class;
Constructor constructor = clazz.getConstructor(String.class, int.class, int.class);
Manager instance = (Manager) constructor.newInstance("a", 1, 1);
assertEquals(1, instance.getBonus());
}
需要注意的是基本类型的class是int.class，而不是Integer.class.
`
利用反射创建数组
数组和普通对象有所不同。下面演示通过反射拷贝数组。
private Object goodCopyOf(Object a, int newLength) {
Class cl = a.getClass();
if (!cl.isArray()) {
return null;
}
int length = Array.getLength(a);
Object newArray = Array.newInstance(cl.getComponentType(), newLength);
System.arraycopy(a, 0, newArray, 0, Math.min(length, newLength));
return newArray;
}
@Test
public void newArray() {
int[] a = {1,2,3};
int[] a2 =(int[]) goodCopyOf(a, 2);
assertEquals(1, a2[0]);
assertEquals(2, a2[1]);
String[] str = {"a","b","c"};
String[] str2 = (String[]) goodCopyOf(str, 2);
assertEquals("a", str2[0]);
assertEquals("b", str2[1]);
}
反射执行instance的某个方法
@Test
public void invokeMethod()
throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
Manager manager = new Manager("a", 1, 100);
Class<? extends Manager> clazz = manager.getClass();
Method method = clazz.getDeclaredMethod("getBonus");
int rs = (int) method.invoke(manager);
assertEquals(100, rs);
Method setBonus = clazz.getDeclaredMethod("setBonus", int.class);
Object invoke = setBonus.invoke(manager, 0);
assertNull(invoke);
assertEquals(0, manager.getBonus());
}
继承的设计技巧
- 将公共操作和字段放在超类
- 不要使用受保护的字段，非必须要，不要使用protected，而推荐用private
- 使用继承实现
is-a的关系，不是这样关系的类不应该使用继承 - 除非所有继承的方法都有意义，否则不要使用继承
- 在覆盖方法时，不要改变预期的行为
- 使用多态，而不是类型信息
来源
- Java核心技术 卷一 原书第10版
关注我的公众号
