java面向对象题目及解析

判断
1、基本数据类型的变量是对象。

错，基本数据类型的变量，指向的是一个单独的内存空间，
比如:int a = 1;a指向内存中的某一地址，这个地址存放int型数据，值为1

2、抽象类可以不含抽象方法。
对，

抽象方法:java中的抽象方法就是以abstract修饰的方法，这种方法只声明返回的数据类型、方法名称和所需的参数，没有方法体，也就是说抽象方法只需要声明而不需要实现。
抽象方法与抽象类:

当一个方法为抽象方法时，意味着这个方法应该被子类的方法所重写，否则其子类的该方法仍然是abstract的，这个子类由于继承父类，拥有抽象方法，因此它也是抽象类，即声明为abstract。abstract抽象类不能用new实例化对象，abstract方法只允许声明不能实现。如果一个类中含有abstract方法，那么这个类必须用abstract来修饰（即含抽象方法的类一定是抽象类（或者接口）)，当然abstract类也可以没有abstract方法。 一个抽象类里面没有一个抽象方法可用来禁止产生这种类的对象。

3、抽象类必须实现接口中的所有方法吗？

NO,抽象类不用全部实现接口中的所有方法，其余的方法实现可以交给该抽象类的子类去实现即可。

interface ITest {
void test1(); //（ abstract void test1（）、test2亦对，所以实现接口的类不一定需要实现所有的抽象方法/方法。）
void test2();
}

public abstract class Test implements ITest {
//抽象类不用全部实现接口中的所有方法
//暗含抽象类也能实现接口
public void test1(){
System.out.println(“test1！！”);

}

}

class TestChild extends Test { //上面接口ITest 中剩余的方法test2，在该抽象类Test 的子类TestChild 去实现即可。

@Override
public void   test2() {
      System.out.println("test2！！");
}

}

所以抽象类实现一个接口时，不用全部声明实现接口中的所有方法。

4、接口在设计中更多地体现了种类的含义。
错

5、构造方法必须自己定义，不能继承父类的构造方法。
对
子类不可以继承父类的构造方法
父类中的构造方法是不能继承的，但是在实例化子类的时候会调用父类的构造方法
子类不可以继承父类的构造方法，只可以调用父类的构造方法。子类中所有的构造函数都会默认访问父类中的空参数构造函数，这是因为子类的构造函数内第一行都有默认的super（）语句。super（）表示子类在初始化时调用父类的空参数的构造函数来完成初始化。一个类都会有默认的空参数的构造函数，若指定了带参构造函数，那么默认的空参数的构造函数，就不存在了。这时如果子类的构造函数有默认的super（）语句，那么就会出现错误，因为父类中没有空参数的构造函数。因此，在子类中默认super（）语句，在父类中无对应的构造函数，必须在子类的构造函数中通过this或super（参数）指定要访问的父类中的构造函数。

6、 String类型的数据域默认值是null
对

7、类之间的关系不包含（D）
A.关联 B.聚合 C.继承 D.实现

实现是类与接口，不是类与类

java类与类、接口与接口的六种关系：





8、以下不是多态存在的必要条件(D)。
A. 继承父类或实现接口
B. 方法重写(方法覆盖)。
C. 父类或接口引用指向子类对象。
D. 实现接口。

实现接口
父类引用指向子类对象指的是：

例如父类Animal，子类Cat,Dog。其中Animal可以是类也可以是接口，Cat和Dog是继承或实现Animal的子类。

Animal animal = new Cat();

即声明的是父类，实际指向的是子类的一个对象。

那这么使用的优点是什么，为什么要这么用？可以用这几个关键词来概括：多态、动态链接，向上转型

也有人说这是面向接口编程，可以降低程序的耦合性，即调用者不必关心调用的是哪个对象，只需要针对接口编程就可以了，被调用者对于调用者是完全透明的。让你更关注父类能做什么,而不去关心子类是具体怎么做的,你可以随时替换一个子类,也就是随时替换一个具体实现,而不用修改其他.

以后结合设计模式（如工厂模式，代理模式）和反射机制可能有更深理解。

下面介绍java的多态性和其中的动态链接，向上转型：

面向对象的三个特征：封装、继承和多态；

封装隐藏了类的内部实现机制，可以在不影响使用者的前提下修改类的内部结构，同时保护了数据；

继承是为了重用父类代码，子类继承父类就拥有了父类的成员。

方法的重写、重载与动态连接构成多态性。Java之所以引入多态的概念，原因之一是它在类的继承问题上和C++不同，后者允许多继承，这确实给其带来的非常强大的功能，但是复杂的继承关系也给C++开发者带来了更大的麻烦，为了规避风险，Java只允许单继承，派生类与基类间有IS-A的关系（即“猫”is a “动物”）。这样做虽然保证了继承关系的简单明了，但是势必在功能上有很大的限制，所以，Java引入了多态性的概念以弥补这点的不足，此外，抽象类和接口也是解决单继承规定限制的重要手段。同时，多态也是面向对象编程的精髓所在。

理解多态，首先要知道“向上转型”。

我定义了一个子类Cat，它继承了Animal类，那么后者就是前者是父类。我可以通过

Cat c = new Cat();
实例化一个Cat的对象，这个不难理解。但当我这样定义时：

Animal a = new Cat();
这代表什么意思呢？

很简单，它表示我定义了一个Animal类型的引用，指向新建的Cat类型的对象。由于Cat是继承自它的父类Animal，所以Animal类型的引用是可以指向Cat类型的对象的。这就是“向上转型”。

那么这样做有什么意义呢？因为子类是对父类的一个改进和扩充，所以一般子类在功能上较父类更强大，属性较父类更独特， 定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能，又可以抽取父类的共性。 所以，父类类型的引用可以调用父类中定义的所有属性和方法，而对于子类中定义而父类中没有的方法，父类引用是无法调用的；

10、数据域可以是基本数据类型，也可以是引用型数据类型。
对

11、

答案选d

用static修饰的方法称为静态方法，修饰变量则为静态变量，又分别叫做类方法或者类变量。
静态方法中不能直接调用非静态方法。因为非静态方法不是独立存在的，它是依附于对象存在——即只有申明了对象，才能通过对象调用。而静态方法则可以直接通过类名调用，而不需要申明对象。因此直接引用非静态方法就会出错。
比如常见的main方法都是静态的，必须由static修饰，因此在main方法里调用类的其他非静态方法，都是需要先申明对象，才能用。否则就会出现引用非静态方法的错误。
要解决这个问题，可以去除一般方法的static关键字（如果是main方法，则不能去掉static）。另外一种方法就是把需要引用的方法也设置成静态方法。

c比较相等是false
d匹配为true，a，b也为true

判断题
1．构造方法第一句不是this或者super时，表示这里默认有个super()语句被省略了。

√

2、创建一个子类的对象时，无论怎样，都会创建这个子类的父类对象

此题有争议，试卷上为√
Java - 创建子类实例时要先创建父类实例

1. 会访问方法区中父类的元数据

2. 会在堆内存中为父类分配空间，用来存储父类实例属性

3. 但是，这块堆内存属于子类所有
   
   但某网友回答：
   你的理解没有问题，按照你房子的比喻我再来说说
   一个对象可以理解为一个房子，而一个类只是规定了什么地方要放什么东西，比如客厅要放沙发，餐厅要有餐桌
   创建一个新对象，就是建造一栋新房子，如果你不去初始化对象，那么这个房子就是空的，没有任何装饰家具，你也不能用它来做任何有意义的事(当然这只是个比喻，空房子不能说没有用)
   当调用构造函数时，才会真正让这个对象有意义，那就是布置这个房子，布置这个房子有很多设计师，子类和父类就是两个设计师，他们之间的关系可以理解为父类设计师是子类设计师的指导，首先子类会让父类先来，父类说他要A B C D E等等，于是就叫人搬来这些东西放在房子里，父类布置好了，子类就来布置了，子类就会继续在房子里添置家具等等，有时候父类和子类会有冲突，比如父类说瓷砖地板好，子类说木地板好，这时候以子类为准，因为最终这个房子是给子类的，父类只是一个顾问指导而已，这就相当于方法重写。

所以如果你说创建一个子类对象会不会同时也创建了父类对象，那答案肯定是没有
说有的如果他的意思是这个子类对象在某个时刻完全是一个父类对象，因为那个时刻他具备了父类对象所有的特征，但不具备子类的特征，那还是可以接受的，但这个过程只会创建一个对象，如果说有的认为创建了两个或者更多的对象，那肯定是错误的

3
注意int类型，所以1/2要变成0，2/3要变成1，如下

4、

4、
5、5、
下图程序输出结果我为

答案：1
因为子类不能重写父类的静态方法
首先我们要区分清楚静态方法跟实例方法的区别：
java中，static修饰符修饰的方法就是静态方法。所谓静态就是指：在编译之后所分配的内存会一直存在（不会被回收），直到程序退出内存才会释放这个空间。在外部调用静态方法时，可以使用”类名.方法名”的方式，也可以使用”对象名.方法名”的方式。而实例方法只有后面这种方式。
静态方法在编译期间就会分配内存，直到程序退出才会释放，实例方法是在创建对象时才分配相应的内存，对于父类引用指向子类对象，可以调用二者共同的方法、变量。
因此即便是在子类对象中定义一个于父类一模一样的静态方法，但是这个静态方法属于子类本身，在内存中会分配两块控件去存放这两个静态变量，因此静态方法不存在重写。

（解析2：首先要明确一个概念，静态方法属于类，在编译阶段类被加载时，类的静态方法或者属性就会被分配内存，存储到类所在的内存中（堆内存的方法区中）；而类的非静态方法却是属于对象的，每个对象都有一份非静态方法的引用，并且若方法被重写，引用的就是子类重写的方法，且这是在运行时创建；

正因如此，即使子类重写了父类的静态方法，但是本质上它们还是两个独立的类，在内存中分别占用不同的内存，它们的静态方法也是在编译时就被加载，独立的占用着不同的内存。上面的代码中，一个父类的变量，指向子类的对象，调用一个被子类重写的静态方法时，由于这是一个父类的变量，并且静态方法属于类，所以在调用时，JVM会去父类所在的内存中寻找这个方法，所以最终的结果就是调用父类的方法，而不是子类重写的方法。）

8、
方法覆盖的原则：

1）父类中private修饰的方法不能被继承，所以也就谈不上覆盖不覆盖了。

2）父类中final修饰的方法，表示最终的，只能被继承，不能被覆盖。

下面几个判断原则可以归结为：一同一大两小

一同：方法签名必须相同。

方法签名 = 方法名称 + 参数列表，参数列表 = 参数个数 + 参数类型 + 参数顺序。

也就是说，方法名称，参数个数，参数类型，参数顺序必须都相同。

一大：子类方法的访问权限大于等于父类方法的访问权限。
两小：子类方法的返回值类型小于等于父类方法的返回值类型，子类方法声明抛出的异常小于等于父类方法声明抛出的异常。

因为继承是从一般到特殊的关系，所以子类的返回值和抛出异常，应该是比父类更具体的，也就是更小。

答案 a

答案 a
7、
答案 b
构造方法是一种特殊的方法，具有以下特点。
（1）构造方法的方法名必须与类名相同。
（2）构造方法没有返回类型，也不能定义为void，在方法名前面不声明方法类型。
（3）构造方法的主要作用是完成对象的初始化工作，它能够把定义对象时的参数传给对象的域。
（4）构造方法不能由编程人员调用，而要系统调用。
（5）一个类可以定义多个构造方法，如果在定义类时没有定义构造方法，则编译系统会自动插入一个无参数的默认构 造器，这个构造器不执行任何代码。
（6）构造方法可以重载，以参数的个数，类型，或排列顺序区分。

8、
答案 d
解析：

1、break使用会跳出（终止）当前循环：

package javaPrimary;

public class Loop {

public static void main(String[] args) {  
    for(int i=0; i<10; i++){  
        if(i==5){  
            break;  
        }  
        System.out.println(i);  
    }  
}  

}

输出：0 1 2 3 4

2、continue使用跳出当前循环，开使下一循环：
package javaPrimary;

public class Loop {
public static void main(String[] args) {
for (int i = 0; i < 8; i++) {
if (i == 5) {
continue;
}
System.out.println(i);
}
}
}

3、跳出多重循环：

package javaPrimary;

public class Loop {

public static void main(String[] args) {  

    loop: for (int i = 0; i < 10; i++) {  
        for (int j = 0; j < 10; j++) {  
            for (int k = 0; k < 10; k++) {  
                for (int h = 0; h < 10; h++) {  
                    if (h == 6) {  
                        break loop;  
                    }  
                    System.out.print(h);  
                }  
            }  
        }  
    }  
    System.out.println("      breakout");  
}  

}