第一题

思路分析：

首先我们在main方法中创建了一个 C c = new C(); 那么这句话就会去调用C 类的无参构造器，在c类的无参构造器中，有这么一句话this("hello")

我们知道this()带参数，并且在构造器中，表示的是对构造器，进行调用，因为this是访问本类的，所有会去调用本类的有参构造器

那么这句话就会去调用本类的带一个参数的构造器，也就是这个构造器注意会有一个隐藏的super() super就是去访问父类的构造器

public C(String name){

         super("hahah");//隐藏的

System.out.println("我是c类的有参构造");

}

但是要注意，在这个有参构造器中，会有一个隐藏的super();

因此会去访问父类的有参构造器，就会去访问这个

public B(String name) {

        super();//隐藏的

        System.out.println(name + "我是B类的有参构造");//2

}

但是要注意，在父类的无参构造器中，还会有一个隐藏的super，因此会去调用A类的无参构造器所以最后输出的内容是

1.我是A类

2.hahah我是B类的有参构造

3.我是c类的有参构造

4.我是c类的无参构造

package idea.homework.homework14;

public class homework14 {
    public static void main(String[] args) {
        C c = new C();
    }
}

class A {//A类

    public A() {
        System.out.println("我是A类");//1
    }
}

class B extends A { //B类,继承A类		//main方法中： C c =new C(); 输出么内容? 3min
    public B() {
        System.out.println("我是B类的无参构造");
    }

    public B(String name) {
        System.out.println(name + "我是B类的有参构造");//2
    }
}
/*
思路分析
1.首先我们在main方法中创建了一个 C c = new C();  那么这句话就会去调用C 类的无参构造器，在c类的无参构造器中，有这么一句话this("hello")
我们知道this()带参数，并且在构造器中，表示的是对构造器，进行调用，因为this是访问本类的，所有会去调用本类的有参构造器
那么这句话就会去调用本类的带一个参数的构造器，也就是这个构造器  注意会有一个隐藏的super() super就是去访问父类的构造器
    public C(String name) {
        super("hahah");//隐藏的
        System.out.println("我是c类的有参构造");//3
    }
    但是要注意，在这个有参构造器中，会有一个因此的super();因此会去访问父类的有参构造器，就会去访问这个
    public B(String name) {
        super();//隐藏的
        System.out.println(name + "我是B类的有参构造");//2
    }

    但是要注意，在父类的无参构造器中，还会有一个隐藏的super，因此会去调用A类的无参构造器
    所有最后输出的内容是
    1.我是A类
    2.hahah我是B类的有参构造
    3.我是c类的有参构造
    4.我是c类的无参构造



 */

class C extends B {   //C类，继承 B类
    public C() {
        this("hello");
        System.out.println("我是c类的无参构造");//4
    }

    public C(String name) {
        super("hahah");
        System.out.println("我是c类的有参构造");//3
    }
}

第二题

思路分析：

什么是多态，多态具体体现有哪些？

多态，方法或者对象具有多种形态是OOP编程的第三大特征建立在封装和继承之上多态的具体体现

1.方法多态

(1).重载体现多态

(2).重写体现多态

2.

(1)对象的编译类型和运行类型可以不一致编译类型在定义时就确定不能变化

(2)对象的运行类型是可以变化的可以同过getClass()方法查看运行类型

(3)编译类型看等号的左边运行类型看等号的右边多态可以体现在多态数组，多态参数等

package idea.homework.homework15;

public class homework15 {
    public static void main(String[] args) {
        //15.什么是多态，多态具体体现有哪些？(可举例说明)
        /*
        多态，方法或者对象具有多种形态是OOP编程 的第三大特征建立在封装和继承之上
        多态的具体体现
        1.方法多态
        (1).重载体现多态  (2).重写体现多态
        2.
        (1)对象的编译类型和运行类型可以不一致 编译类型在定义时就确定不能变化
        (2)对象的运行类型是可以变化的  可以同过getClass()方法查看运行类型
        (3)编译类型看等号的左边  运行类型看等号的右边
        多态可以体现在多态数组
         */

        AAA obj = new BBB();//向上转型
        AAA b1 = obj;
        System.out.println("obj的运行类型=" + obj.getClass());//BBB
        obj = new CCC();//向上转型  父类的引用指向子类的对象

        System.out.println("obj的运行类型=" + obj.getClass());//CCC
        obj = b1;

        System.out.println("obj的运行类型=" + obj.getClass());//BBB

    }
}

class AAA{}

class BBB extends AAA{}

class CCC extends BBB{}

第三题

思路分析：

java的动态绑定机制是什么？

1.当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定

2.当调用对象属性时，没有动态绑定机制，哪里声明哪里使用

package idea.homework.homework16;

public class homework16 {
    public static void main(String[] args) {
        //16.java的动态绑定机制是什么？
        /*
         **1.当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定**

         **2.当调用对象属性时 ，没有动态绑定机制，哪里声明哪里使用**
         */
    }
}

小结

1.了解什么是动态绑定机制，方法看运行类型，属性没有动态绑定机制，哪里声明，哪里使用

2.熟练的掌握，封建继承多态，多态很重要，在我们做的题目中，就需要我们自己主动的去发现，两个类中有很多共同的属性，我们就把他们提取出来，做成一个父类

面向对象练习题（9）

第一题

第二题

第三题

小结

猜你喜欢