Java2EE基础练习及面试题_chapter05面向对象（中_03）

申明： 未经许可，禁止以任何形式转载，若要引用，请标注链接地址
全文共计5368字，阅读大概需要3分钟
欢迎关注我的个人公众号：不懂开发的程序猿

面试01

/*
面试题：
多态是编译时行为还是运行时行为？
如何证明？
 */

package com.jerry.java;

import java.util.Random;

/**
 * @author jerry_jy
 * @create 2022-09-28 16:48
 */
public class Exer6 {
    /*
    面试题：
    多态是编译时行为还是运行时行为？
    如何证明？
     */
    public static Animal getInstance(int key) {
        switch (key) {
            case 0:
                return new Cat();
            case 1:
                return new Dog();
            default:
                return new Sheep();
        }

    }

    public static void main(String[] args) {
        int key = new Random().nextInt(3);

        System.out.println(key);

        Animal animal = getInstance(key);

        animal.eat();

    }
}

class Animal {
    protected void eat() {
        System.out.println("animal eat food");
    }
}

class Cat extends Animal {
    protected void eat() {
        System.out.println("cat eat fish");
    }
}

class Dog extends Animal {
    public void eat() {
        System.out.println("Dog eat bone");
    }

}

class Sheep extends Animal {
    public void eat() {
        System.out.println("Sheep eat grass");
    }


}

面试02

//考查多态的笔试题目：

package com.jerry.java;

/**
 * @author jerry_jy
 * @create 2022-09-28 16:52
 */
public class Exer7 {
    //考查多态的笔试题目：

    public static void main(String[] args) {
        Base1 base = new Sub1();
        base.add(1, 2, 3);

//		Sub1 s = (Sub1)base;
//		s.add(1,2,3);
    }
}
class Base1 {
    public void add(int a, int... arr) {
        System.out.println("base");
    }
}

class Sub1 extends Base1 {

    public void add(int a, int[] arr) {
        System.out.println("sub_1");
    }

//	public void add(int a, int b, int c) {
//		System.out.println("sub_2");
//	}

}

面试03

    /*
    面试题：==和equals的区别

1 == 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型 就是比较内存地址

2 equals的话，它是属于java.lang.Object类里面的方法，如果该方法没有被重写过默认也 是==;我们可以看到String等类的equals方法是被重写过的，而且String类在日常开发中 用的比较多，久而久之，形成了equals是比较值的错误观点。

3 具体要看自定义类里有没有重写Object的equals方法来判断。

4 通常情况下，重写equals方法，会比较类中的相应属性是否都相等。
     */

面试04

    int it = 65;
    float fl = 65.0f;
    System.out.println(“65和65.0f是否相等？” + (it == fl)); //true
    char ch1 = 'A'; char ch2 = 12;
    System.out.println("65和'A'是否相等？" + (it == ch1));//true
    System.out.println(“12和ch2是否相等？" + (12 == ch2));//true
    String str1 = new String("hello");
    String str2 = new String("hello");
    System.out.println("str1和str2是否相等？"+ (str1 == str2));//false
    System.out.println("str1是否equals str2？"+(str1.equals(str2)));//true
    System.out.println(“hello” == new java.util.Date()); //编译不通过

面试05

    //面试题

        char[] arr = new char[]{'a', 'b', 'c'};
        System.out.println(arr);//abc
        int[] arr1 = new int[]{1, 2, 3};
        System.out.println(arr1);//[I@1b6d3586
        double[] arr2 = new double[]{1.1, 2.2, 3.3};
        System.out.println(arr2);//[D@4554617c

面试06

    /*
    【面试题】
    如下两个题目输出结果相同吗？各是什么：
     */

        Object o1 = true ? new Integer(1) : new Double(2.0);
        System.out.println(o1);//1.0

        System.out.println("===============");
        Object o2;
        if (true)
            o2 = new Integer(1);
        else
            o2 = new Double(2.0);
        System.out.println(o2);//1

面试07

/*
继承性
java类是否可以多继承，怎么实现多继承？
答：java没有多继承，但可以通过接口的形式来达到多继承的目地。
 */

面试08

定义类A 和类B 如下：

 (1) 若在应用程序的main 方法中有以下语句：
A a=new A();
a.show();//Class A: a=1	d=2.0
则输出的结果如何？
(2) 若在应用程序的main 方法中定义类B 的对象b：
A b=new B();
b.show();
则输出的结果如何？
Class A: a=1	d=2.0
Class B: a=3.0	d=Java program.

面试09

写出重载与重写的区别。

重载（overload)和重写(overried，有的书也叫做“覆盖”）的区别？
答：方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。

面试10

Overload的方法是否可以改变返回值的类型？
可以

面试11

//写出错误答案错误的原因

class Demo{
int show(int a,int b){return 0;}
}
下面那些函数可以存在于Demo的子类中。
A.public int show(int a,int b){return 0;}//可以，覆盖。
B.private int show(int a,int b){return 0;}//不可以，权限不够。
C.private int show(int a,long b){return 0;}//可以，和父类不是一个函数。没有覆盖，相当于重载。
D.public short show(int a,int b){return 0;}//不可以，因为该函数不可以和给定函数出现在同一类中，或者子父类中。
E.static int show(int a,int b){return 0;}//不可以，静态只能覆盖静态。

面试12

//写出错误答案错误的原因

class Demo{
int show(int a,int b){return 0;}
}
下面那些函数可以存在于Demo的子类中。
A.public int show(int a,int b){return 0;}//可以，覆盖。
B.private int show(int a,int b){return 0;}//不可以，权限不够。
C.private int show(int a,long b){return 0;}//可以，和父类不是一个函数。没有覆盖，相当于重载。
D.public short show(int a,int b){return 0;}//不可以，因为该函数不可以和给定函数出现在同一类中，或者子父类中。
E.static int show(int a,int b){return 0;}//不可以，静态只能覆盖静态。

面试13

//写出程序结果

class Super {
	public int get() {
		return 4;
	}
}

class Demo15 extends Super {
	public long get() {
		return 5;
	}

	public static void main(String[] args) {
		Super s = new Demo15();
		System.out.println(s.get());
	}
}

编译失败，因为子类父类中的get方法没有覆盖。但是子类调用时候不能明确返回的值是什么类型。
所以这样的函数不可以存在子父类中。

面试14

Object类的使用说明

我比较两个String总是false，但是它们明明都是"abc" ！
答：比较String一定要使用equals或equalsIgnoreCase方法，不要使用 ==
因为==比较的是两个引用（变量）是否指向了同一个对象，而不是比较其内容。

面试15

为什么要重写toString()方法？
为什么要重写equals()方法？

当自定义使用equals()时，可以重写。用于比较两个对象的“内容”是否都相等

面试16

写出“==”和equals的区别

面试17

类似：两个对象a和b，请问a==b和a.equals(b)有什么区别？

面试18

以下代码如何优化
if(username.equals(“admin”){
  ....
}
答案：
if(“admin”.equals(username)){
}

面试19

包装类的使用
写出8中基本数据类型的包装类
    Byte    Short   Integer     Long    Float   Double  Boolean     Character

面试20

int 和 Integer 有什么区别

答：Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。
int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。
原始类型封装类型及其对应的包装类：boolean Boolean,char Character,byte Byte,short Short,int Integer,long Long,float Float,doubl Double
引用类型和原始类型的行为完全不同，并且它们具有不同的语义。
引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关。

面试21

以下代码的运行结果是：

    public static void main(String[] args) {
        Integer i1 = 128;
        Integer i2 = 128;
        int i3 = 128;
        int i4 = 128;
        System.out.println(i1 == i2);//false
        System.out.println(i3 == i4);//true
        System.out.println(i1 == i3);true
    }

Integer的i1和i2是对象，他们==比较的是地址。如果-128~127范围，那么使用缓存的常量对象，如果超过这个范围，是新new的对象，不是常量对象

面试22

以下代码的运行结果是：

public static void main(String[] args) {
    double a = 2.0;
    double b = 2.0;
    Double c = 2.0;
    Double d = 2.0;
    System.out.println(a == b);//tue
    System.out.println(c == d);//false，比较的Double包装类的地址值
    System.out.println(a == d);//true，因为==是比较的值
}