一、继承
1.1继承的概念
Java中的继承:子类就是享有父类的属性和方法,并且还存在一定的属性和方法的扩展。
Subclass,从另一个类派生出的类,称为子类(派生类,扩展类等)
Superclass,派生子类的类,称为超类(基类) 习惯上称子类的直接超类为,父类(没有独立英文词描述)
- 继承的定义:
- 子类的成员中一部分是子类自己声明定义的,另一部分是从他的父类继承的。
- 子类继承父类的成员变量作为自己的一个成员变量
- 子类继承父类的方法作为子类中的一个方法
1.2super 关键字
在java中,如果声明一个类继承另一个类,需要使用extends关键字。
格式修饰符 class B extends A就是B类继承A类,称A是B的父类,B是A的子类。
java语言中不支持多继承(一个类继承多个类)。
1.3Object类
java.lang.Object类: 所有类的祖先
在定义一个类的时候不用加extends Object默认都是继承的Object类的。
Object类中提供了一些方法,这些方法为了达到想要的效果,我们一般在类中重写使用。下面是一些Object类中常用的方法:
getClass()
:获取类的class对象。hashCode()
:获取对象的hashCode值。equals()
:比较对象是否相等,比较的是值和地址,子类可重写以自定义。clone()
:克隆方法。toString()
:toString()
方法返回一个字符串,该字符串由对象的类名、at符号字符“@”和对象的哈希码的无符号十六进制表示组成notify()
:随机选择一个在该对象上调用wait方法的线程,解除其阻塞状态。该方法只能在同步方法或同步块内部调用。notifyAll()
:解除所有那些在该对象上调用wait方法的线程的阻塞状态。该方法只能在同步方法或同步块内部调用。wait()
:导致线程进入等待状态,直到它被其他线程通过notify()或者notifyAll唤醒。该方法只能在同步方法中调用。- finalize():对象回收时调用
1.4super关键字
在Java中,super是一个关键字,它是一个引用变量,用于引用直接父类对象。当创建子类的实例时,父类的实例被隐式创建,由super关键字引用变量引用。
调用父类的构造方法:
只能在子类的构造方法中。
必须在方法的第一句。
使用super操作被隐藏的成员变量和方法。
例如,如果子类重写了父类的某一个方法,即子类和父类有相同的方法定义,但是有不同的方法体,此时,我们可以通过super来调用父类里面的这个方法。使用super访问父类中的成员与this关键字的使用相似,只不过它引用的是子类的父类。
主要用法
引用父类的成员(需要相应的访问权限):
super.变量 或 super.方法([参数列]) 在子类构造方法中调用父类的构造方法: super([…]);//与this用法类似,应放在构造方法的第一行位置上。
子类无法继承超类的private成员,但可以通过属性的getter/setter方法访问超类的属性
1.5对象实例化的内存情况
jvm
1、首先JVM运行一个class文件时,使用类加载器先将Phone类加载到方法区,然后main方法压栈(入栈)。·2、在栈中运行main方法,当看到局部变量p时,会在栈中开辟一块空间;当看到new Phone()时,会在堆内存中开辟空间,并将堆内存中的对应地址0x123赋值给p;还会拿到方法区的地址值指向方法区。
·3、在main方法中运行到给对象p的属性赋值时,通过地址去堆内存中找到相应属性并赋值,运行p.sendMessage()这一步时,也是根据地址值去堆内存中找到相应的对象,再用对象去方法区中找到sendMessage()方法,然后将sendMessage()方法压到栈中(入栈),调用完毕sendMessage()方法会出栈。
·4、main方法运行结束后会出栈。
堆
堆区: 存储new出来的对象,每个对象都包含一个与之对应的class的信息。栈
栈区: 栈中只保存基础数据类型的值和对象以及基础数据的引用方法区
方法区: 包含所有的class和static变量。方法区中包含的都是在整个程序中永远唯一的元素,如class,static变量。
二、类的派生
2.1子类的对象构造顺序
执行顺序:先执行父类构造方法,再执行子类构造方法。在多层继承层时,编译器会一直上溯到最初类,再从“上”到“下”依次执行。
2.2子类的继承性
在继承中访问权限的问题:
若子类和父类在同一个包内,子类可以继承父类中访问权限设定为public、 protected、 default的成员变量和方法。
若子类和父类不在同一个包内,子类可以继承父类中访问权限设定为public、 protected的成员变量和方法。
2.3成员变量的隐藏和方法的重写
2.3.1方法的重写
重写和重载的区别:重载是在本类之中,重写是在父类和子类之间。
概述
方法重写的一些要求:两同两小一大:
- 当子类中定义了和父类同名的成员变量时,子类就隐藏了继承的成员变量。
- 方法重写是指:子类中定义一个方法,并且这个方法的名字、放回类型、参数个数和类型与从父类中继承的方法完全相同。
- 如果子类想使用被隐藏的方法就必须使用关键字super;
两同:方法名相同,参数列表一致。
两小:子类返回值类型更小或相等,子类抛出异常小于等于父类的抛出异常(这个以后会学)
一大:子类的访问权限比父类大或者相等。
支持在子类中声明一个与超类中方法签名相同的,新实例方法,从而overriding覆盖超类方法(方法的重写) 由于方法签名与父类中的方法签名相同,为避免歧义,使用@Override注解显式声明重写超类方法
重写的方法,返回类型为基本数据类型的禁止改
支持在子类中声明一个与超类中方法签名相同的静态方法,从而hiding隐藏超类静态方法(静态方法的隐藏无需@Override注解修饰)
子类可直接调用超类中静态成员(public/protected)
重写方法的访问范围,必须大于等于超类声明的范围
2.3.2成员变量的隐藏
成员变量的隐藏
- 变量只能被隐藏,不能被重写。
- 可以用子类的静态变量来隐藏父类的静态变量,也可以用子类的非静态变量隐藏父类的静态变量。要是属性名相同就会被隐藏,这一属性的类型没有什么关系。
- 静态方法只能被隐藏不可被重写。
- 不能用子类的静态方法隐藏父类的非静态方法。
- 不能用子类的非静态方法覆盖父类的静态方法。
2.4final的用法:
2.4.1final描述成员变量
在Java中,final关键字可以用来修饰成员变量。当一个成员变量被声明为final时,它的值在初始化后就不能再被修改。这意味着你必须在声明final变量时或在构造函数中对其进行初始化。
当
final
关键字用来修饰对象类型的成员变量时,它表示该变量所引用的对象在初始化后不能再被改变。但是,这并不意味着该对象本身是不可变的。例如,下面的代码定义了一个名为myList
的final
变量,它引用了一个ArrayList
对象:class MyClass { public final List<String> myList = new ArrayList<>(); public MyClass() { myList.add("Hello"); myList.add("World"); } }
在这个例子中,尽管
myList
变量本身是final
的,但是我们仍然可以修改它所引用的ArrayList
对象。也就是说,我们可以向列表中添加、删除和修改元素。
2.4.2final描述成员方法
在Java中,
final
关键字也可以用来修饰成员方法。当一个方法被声明为final
时,它不能被子类重写。这意味着子类不能提供一个与父类中的final
方法具有相同方法签名的方法,但是继承仍然可以继承这个方法,也就是说可以直接使用class A { public final void f1() { } } public class B extends A { public void f1() { // 编译出错,因为f1不可以被重写 } public final void f1() { } public void f2() { f1(); // 编译通过,final会被继承给子类,子类可以直接调用。 } }
当一个类中的方法被声明为
final
时,它只能在该类中被实现一次。这意味着任何继承自该类的子类都不能重写这个方法
2.4.3final描述类
在Java中,
final
关键字也可以用来修饰类。当一个类被声明为final
时,它不能被继承。意味着此类在一个继承树中是一个叶子类,并且此类的设计已被认为很完美而不需要进行修改或扩展。通常叫做最终类。final class A { public final void f1() { } } class B extends A { // 编译报错,因为A被final修饰,不可以成为任何类的父类。 }
总结
- 修饰变量为常量值不可变。
- 修饰对象值可变,引用不变。
- 修饰方法,方法不可重写。
- 修饰类,无子类被称为最终类。不能被继承也不能重写。
三、多态
Java引用变量有两个类型:一个是编译时类型,一个是运行时类型。编译时类型由声明该变量时使用的类型决定。
编译时类型是指变量在声明时所指定的类型。例如,在下面的代码中,变量
myList
的编译时类型是List
:List<String> myList = new ArrayList<>();
运行时类型是指变量在运行时实际引用的对象的类型。在上面的例子中,变量
myList
在运行时引用了一个ArrayList
对象,因此它的运行时类型是ArrayList
。运行时类型由实际赋给该变量的对象决定。就是new的对象。
如果编译时类型和运行时类型不一致,就可能出现所谓的多态。
多态的前提条件:1、子类继承父类 2、子类重写父类方法、 3、父类引用指向子类对象 多态的
3.1上转型
因为子类其实是一种特殊的父类,因此Java允许把一个子类对象直接赋给一个父类引用变量,无须任何类型转换,或者被称为向上转型,向上转型由系统自动完成。
上转型(Upcasting)是指将子类类型的引用赋值给父类类型的引用。这种转换是安全的,因为子类是父类的一种特殊形式,它继承了父类的所有成员变量和方法。
例如,假设我们有一个名为
Animal
的类和一个继承自Animal
的子类Dog
:class Animal { public void eat() { System.out.println("Animal is eating"); } } class Dog extends Animal { public void bark() { System.out.println("Dog is barking"); } }
在这个例子中,我们可以将一个
Dog
类型的引用赋值给一个Animal
类型的引用,这就是上转型:Dog dog = new Dog(); Animal animal = dog; // 上转型 animal.eat(); // 输出 "Animal is eating"
在上面的代码中,我们创建了一个
Dog
对象,并将它赋值给一个名为dog
的变量。然后,我们将dog
变量赋值给一个名为animal
的变量。这就是上转型。
3.2下转型
试图把一个父类实例转换成子类类型,则这个对象对象必须实际上是子类实例才行(即编译时类型为父类类型,而运行时类型是子类类型),否则将在运行时引发ClassCastException(强制类型转换错误)异常。
下转型(Downcasting)是指将父类类型的引用赋值给子类类型的引用。这种转换是不安全的,因为父类并不一定是子类的一种特殊形式。因此,在进行下转型之前,我们需要使用
instanceof
运算符来检查对象是否是目标类型的实例。例如,假设我们有一个名为
Animal
的类和一个继承自Animal
的子类Dog
:class Animal { public void eat() { System.out.println("Animal is eating"); } } class Dog extends Animal { public void bark() { System.out.println("Dog is barking"); } }
在这个例子中,我们可以将一个
Animal
类型的引用赋值给一个Dog
类型的引用,但是我们需要先检查对象是否是Dog
类型的实例:Animal animal = new Dog(); if (animal instanceof Dog) { Dog dog = (Dog) animal; // 下转型 dog.bark(); // 输出 "Dog is barking" }
在上面的代码中,我们创建了一个
Dog
对象,并将它赋值给一个名为animal
的变量。然后,我们使用instanceof
运算符检查animal
变量所引用的对象是否是Dog
类型的实例。如果检查结果为真,我们就可以安全地进行下转型,并调用子类特有的方法。
总结
相关的不同类型间的转换,是多态的表现形式
当你用父类引用指向子类对象的时候,
1、成员变量不变,调用结果为父类的成员变量的值
2、成员方法改变,调用结果为子类的成员方法的结果
3、静态成员方法不变,调用的结果为父类的静态成员方法
引用成员之间的转换:
向上转型:子类转换成父类 由小到大 基本数据类型的自动类型转换
向下转型:父类转换成子类 由大到小 基本数据类型的强制类型转换
3.3思考
1.在Java中,方法具有多态性,但实例变量不具有多态性。实例变量并不具有多态性。当我们使用父类类型的引用来访问实例变量时,访问的是父类中定义的变量,而不是子类中定义的变量。
2.Java中,静态变量和静态方法都不具有多态性,静态方法并不与任何特定的对象相关联,它们只与类相关联。因此,当我们使用父类类型的引用来调用静态方法时,调用的是父类中定义的方法,而不是子类中定义的方法。
四、类加载实例化过程
当Java虚拟机(JVM)加载并初始化一个类及其父类时,它会按照以下顺序执行:
- 父类的静态变量和静态代码块按照在代码中出现的顺序依次执行。
- 子类的静态变量和静态代码块按照在代码中出现的顺序依次执行。
- 父类的成员变量和非静态代码块按照在代码中出现的顺序依次执行。
- 父类的构造函数执行。
- 子类的成员变量和非静态代码块按照在代码中出现的顺序依次执行。
- 子类的构造函数执行。
例如,假设我们有以下类定义:
class Parent { static { System.out.println("父类静态代码块"); } { System.out.println("父类非静态代码块"); } public Parent() { System.out.println("父类构造函数"); } } class Child extends Parent { static { System.out.println("子类静态代码块"); } { System.out.println("子类非静态代码块"); } public Child() { System.out.println("子类构造函数"); } }
当我们创建一个
Child
对象时,将按照以下顺序输出:父类静态代码块 子类静态代码块 父类非静态代码块 父类构造函数 子类非静态代码块 子类构造函数
需要注意的是,静态变量和静态代码块只会在类被加载时执行一次。这意味着,如果我们创建多个
Child
对象,那么非静态代码块和构造函数将被多次执行,但是静态变量和静态代码块只会被执行一次。