面向对象练习题（9）

目录

第一题

第二题

第三题

小结

---

第一题

思路分析：

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