Java复习3-类的继承

简介: 前言本次学习面向对象设计的另外一个基本概念:继承(inheritance)。这是Java程序设计中的一项核心技术。另外,还要学习反射(reflection)的概念。继承类、超类、子类public class Manager extends Employee{ //...}关键字extends表明正在构造的新类派生于一个已存在的类。

前言

本次学习面向对象设计的另外一个基本概念:继承(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修饰的方法是抽象方法。

抽象类不能实例化。抽象方法没有方法体。

受保护访问

  1. 仅本类可见--private
  2. 所有类可见--public
  3. 对本包和所有子类可见--protected
  4. 对本包可见--默认,不需要修饰符

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版

    关注我的公众号

img_acfe50023e4718b33064273d65e4cd67.jpe
唯有不断学习方能改变! -- Ryan Miao
目录
相关文章
|
2天前
|
JSON Java Apache
Java基础-常用API-Object类
继承是面向对象编程的重要特性,允许从已有类派生新类。Java采用单继承机制,默认所有类继承自Object类。Object类提供了多个常用方法,如`clone()`用于复制对象,`equals()`判断对象是否相等,`hashCode()`计算哈希码,`toString()`返回对象的字符串表示,`wait()`、`notify()`和`notifyAll()`用于线程同步,`finalize()`在对象被垃圾回收时调用。掌握这些方法有助于更好地理解和使用Java中的对象行为。
|
1月前
|
存储 缓存 安全
java 中操作字符串都有哪些类,它们之间有什么区别
Java中操作字符串的类主要有String、StringBuilder和StringBuffer。String是不可变的,每次操作都会生成新对象;StringBuilder和StringBuffer都是可变的,但StringBuilder是非线程安全的,而StringBuffer是线程安全的,因此性能略低。
46 8
|
1月前
|
Java
在Java中,接口之间可以继承吗?
接口继承是一种重要的机制,它允许一个接口从另一个或多个接口继承方法和常量。
89 1
|
1月前
|
Java 开发者
在 Java 中,一个类可以实现多个接口吗?
这是 Java 面向对象编程的一个重要特性,它提供了极大的灵活性和扩展性。
139 57
|
1月前
|
存储 安全 Java
java.util的Collections类
Collections 类位于 java.util 包下,提供了许多有用的对象和方法,来简化java中集合的创建、处理和多线程管理。掌握此类将非常有助于提升开发效率和维护代码的简洁性,同时对于程序的稳定性和安全性有大有帮助。
73 17
|
1月前
|
安全 Java
Java多线程集合类
本文介绍了Java中线程安全的问题及解决方案。通过示例代码展示了使用`CopyOnWriteArrayList`、`CopyOnWriteArraySet`和`ConcurrentHashMap`来解决多线程环境下集合操作的线程安全问题。这些类通过不同的机制确保了线程安全,提高了并发性能。
|
1月前
|
存储 Java 程序员
Java基础的灵魂——Object类方法详解(社招面试不踩坑)
本文介绍了Java中`Object`类的几个重要方法,包括`toString`、`equals`、`hashCode`、`finalize`、`clone`、`getClass`、`notify`和`wait`。这些方法是面试中的常考点,掌握它们有助于理解Java对象的行为和实现多线程编程。作者通过具体示例和应用场景,详细解析了每个方法的作用和重写技巧,帮助读者更好地应对面试和技术开发。
127 4
|
1月前
|
Java 编译器 开发者
Java异常处理的最佳实践,涵盖理解异常类体系、选择合适的异常类型、提供详细异常信息、合理使用try-catch和finally语句、使用try-with-resources、记录异常信息等方面
本文探讨了Java异常处理的最佳实践,涵盖理解异常类体系、选择合适的异常类型、提供详细异常信息、合理使用try-catch和finally语句、使用try-with-resources、记录异常信息等方面,帮助开发者提高代码质量和程序的健壮性。
71 2
|
1月前
|
存储 安全 Java
如何保证 Java 类文件的安全性?
Java类文件的安全性可以通过多种方式保障,如使用数字签名验证类文件的完整性和来源,利用安全管理器和安全策略限制类文件的权限,以及通过加密技术保护类文件在传输过程中的安全。
57 4
|
1月前
|
Java 数据格式 索引
使用 Java 字节码工具检查类文件完整性的原理是什么
Java字节码工具通过解析和分析类文件的字节码,检查其结构和内容是否符合Java虚拟机规范,确保类文件的完整性和合法性,防止恶意代码或损坏的类文件影响程序运行。
48 5