java 对象实例化过程中的多态特性解析

时间：2022-12-05 12:53:54|栏目：JAVA代码|点击：次

java 对象实例化过程中的多态特性

执行对象实例化过程中遵循多态特性 ==> 调用的方法都是实例化的子类中的重写方法，只有明确调用了super.xxx关键词或者是子类中没有该方法时，才会去调用父类相同的同名方法。

通过案例说明

package com.njau.test1; 
class Test {
    public static void main(String[] args) {
        System.out.println(new B().getValue());
    }
    static class A {
        protected int value;
        public A (int v) {
            setValue(v);
        }
        public void setValue(int value) {
            this.value= value;
        }
        public int getValue() {
            try {
                value ++;
                return value;
            } finally {
                this.setValue(value);
                System.out.println(value);
            }
        }
    }
    static class B extends A {
        public B () {
            super(5);
            setValue(getValue()- 3);
        }
        public void setValue(int value) {
            super.setValue(2 * value);
        }
    }
}

通过上述代码

始终明确调用的方法必须是实例化子类中重写的方法。

首先，在main函数中，【new B()】new了一个B类的实例化对象，在实例化对象时，调用了B类中的构造函数，执行【super(5)】，也就是public A(int v)------>setValue(v)，由于调用的方法必须是实例化子类中重写的方法的原则。因此，这里调用的是B类中的setValue(v)方法，此时B实例的value值设置为2 x 5 = 10，后执行super.setValue(10)，将value=10的值存储起来。

执行完super(5)后，执行构造函数中的【setValue(getValue()- 3)】中【getValue()】，由于B类中没有getValue()方法，则调用父类（A类）中的getValue()方法，value++所得到的值为11，并存储在value中（先执行finally中的部分，后执行try中的return），在finally中，调用了【this.setValue(value)】，由于调用的方法必须是实例化子类中重写的方法的原则，调用的是B类中的setValue(v)方法，此时B实例的value值设置为2 x 11= 22，之后执行System.out.println(value)

即在控制台上打印22

执行完finally中的部分，后执行try中的return,将value++执行后，存储在value中的11，return回去；执行【setValue(getValue()- 3)】，即：setValue(8)

执行setValue(8)时，由于调用的方法必须是实例化子类中重写的方法的原则，则调用B类中的setValue(v)方法，此时B实例的value值设置为2 x 8= 16；此时B类中的构造函数执行结束。

在实例化对象以后，执行【new B().getValue()】，由于B类中没有getValue()方法，则调用父类（A类）中的getValue()方法，value++所得到的值为17，并存储在value中，在finally中，调用了【this.setValue(value)】，由于调用的方法必须是实例化子类中重写的方法的原则，调用的是B类中的setValue(v)方法，此时B实例的value值设置为2 x 17= 34，之后执行System.out.println(value)

即在控制台上打印34

执行完finally中的部分，后执行try中的return,将value++执行后，存储在value中的17，return回去；执行【System.out.println(new B().getValue())】

即在控制台上打印17

value值的变化过程，仅解释实例化对象时，构造函数中：super(5)与setValue(getValue()+3)两部分。图中两条线，起点分别为【new B()】与【setValue(getValue()+3)】：

执行结果为：

java对象的三个特性（封装、继承、多态）

类（类型）和对象：对象是独一无二的。对象有其所属之类型。对象是类型的一个具体的实例。

创建编写一个 class ：定义一个类型。类型是编写出来的，即使程序不运行，类型已然存在。

对象：对象是new出来的，在程序运行期间new出来的，存在于内存中（堆中）。如果程序未运行，则对象不存在。

对象的三大特性：

1.封装

1.1 把本属于某个类型的成员属性（静态特性）和职责（动态特性）定义到一个类中。

1.2 访问权限控制：使用权限访问修饰符控制成员（属性和方法）的访问（可见性）。

private：最小访问权限，仅限类的内部可以访问。
<无修饰符>：包修饰符，友好访问修饰符，类内，包内可以访问。
protected：类内，包内，子类可以访问。
public：类内，包内，子类，包外都可以访问。

类的两大成员：

1.属性：有默认值，0 0.0 false '\0' null。引用类型的默认值是null值。

2.方法：方法中，可以访问成员属性。

构造方法：

用于构造对象（对对象进行成员属性初始化），构造对象的过程可能简单，也可能复杂。

和类同名。语法：new 构造方法(参数列表)
无返回值。其作用仅为构造对象。
构造方法可以重载。

this关键字：

访问当前对象的属性和方法。
this(参数列表)，只能放在构造方法的第一行，并且只能单独使用。
当方法的参数和成员属性名称冲突的时候，可以使用this进行区分。

2.继承

2.1 为什么要继承：消除重复。子类可以继承父类的某些成员。

2.2 extends 关键字：扩展。一个类只能继承一个父类。如果没有指定父类的话，则默认继承自Object类。Object类是根类型，终级类，没有父类。其它一切引用类型都是直接或间接继承自Object类型。

2.3 什么成员可以被继承？1. 私有成员不能被继承。2. 构造方法不能被继承。

2.4 子类对象构造的过程：按照继承的顺序，递归创建各类型的状态值。

3.多态

同一个类型所展现出的行为或属性的多种形态。

使用父类（祖先类、接口）的引用指向子类（派生类，实现类）的对象。

多态的使用场景：某些场景，只希望关注某些（不同的具体类型）类型的共性（祖先类，接口），而忽略其它独特的特性。

final：

修饰类，表示类不可被继承。
修饰方法，表示方法不能被重写。
修饰成员属性，或者普通变量，表示值不可修改。

static：静态的

一旦属性和方法，添加了static关键字，表示属性和方法是属于类的，而不是属于某一个具体的对象的。
通过“类名.静态成员”来访问，而无须先创建对象。

抽象类：

当定义一个类时，如果某个方法暂时不便实现，或者无法实现，或者不适合实现，或者希望具体的子类来提供实现，可以使用abstract关键字来修饰此方法，表示抽象方法，抽象方法无需提供实现。
当一个类中存在抽象方法时，类必须定义成抽象类。但是，一个抽象类中可以没有抽象方法。
抽象类不能实例化，但可以定义构造方法。
抽象类是类，拥有一切类的特性，除了不能实例化。