Java常见面试题及答案（131~140企业真题）

131、j2ee中的应用服务器有哪些？（ACD）

A. Weblogic

B. Tomcat

C. JBoss

D. WebSphere

E. IIS

132、EJB程序与普通的java程序区别有哪些？

EJB是sun的服务器端组件模型，最大的用处是部署分布式应用程序当然，还有许多方式可以实现分布式应用，类似微软的.net技术。

凭借 java 跨平台的优势，用EJB 技术部署的分布式系统可以不限于特定的平台。EJB(EnterpriseJavaBean)是J2EE的一部分，定义了一个用于开发基于组件的企业多重应用程序的标准。其特点包括网络服务支持和核心开发工具(SDK)。

在J2EE里，Enterprise Java Beans(EJB)称为Java企业Bean，是Java 的核心代码，分别是会话 Bean（Session Bean），实体 Bean（Entity Bean）和消息驱动 Bean（MessageDriven Bean）。

简单来讲：比如做一个工程就和盖房子，如果，你会 java，那么你就拥有了基本的技能，一步一步累砖，总能把房子盖好但是EJB就是一个框架，盖房子的时候，先有这个框架，然后你根据这个框架去累砖，房子就会盖的又快又好。java是基础，EJB 是在java上发展出来的模型，框架。

133、请简述什么是集群？

服务器集群就是指将很多服务器集中起来一起进行同一种服务，在客户端看来就象是只有一个服务器。集群可以利用多个计算机进行并行计算从而获得很高的计算速度，也可以用多个计算机做备份，从而使得任何一个机器坏了整个系统还是能正常运行。一旦在服务器上安装并运行了群集服务，该服务器即可加入群集。群集化操作可以减少单点故障数量，并且实现了群集化资源的高可用性。

134、字符串中有重复的内容去重 例如：abbccccaaddaggb-->abvadagb

public class Test {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("a");
        list.add("a");
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        System.out.println("没有去重前的数据为>>>" + list.toString());
        for (int i = 0; i < list.size() - 1; i++) {
            for (int j = list.size() - 1; j > i; j--) {
                if (list.get(j).equals(list.get(i))) {
                    list.remove(j);
                }
            }
        }
        System.out.println("去重后的数据为>>>" + list.toString());
    }
}

135、利用 java 面向对象的思路设计正方形、长方形、圆的计算面积的类圆：

class MianJi {
    float r;
    float pai = (float) 3.14;

    void gongShi() {
        Float s = pai * r * r;
        System.out.println("圆的面积为" + s);
    }

    void zhengFangXing(float bianChang) {
        System.out.println("正方形的面积为" + bianChang * bianChang);
    }

    void changFangXing(float chang, float kuan) {
        System.out.println("长方形的面积为" + chang * kuan);
    }

    public static void main(String[] arg) {
        MianJi c = new MianJi();
        System.out.println("请输入圆的半径：");
        Scanner sc = new Scanner(System.in);
        c.r = sc.nextFloat();
        c.gongShi();
        System.out.println("请输入正方形的边长：");
        float bian = sc.nextFloat();
        c.zhengFangXing(bian);
        System.out.println("请输入长方形的长和宽：");
        float chang = sc.nextFloat();
        float kuan = sc.nextFloat();
        c.changFangXing(chang, kuan);
    }
}

136、任何>=6的偶数都可以分解为两个质数之和，从键盘输入一个偶数，输出其分解的质数

public class Test {
    public static void main(String[] args) {
        int num = inPut();
        outPut(num);
    }

    public static int inPut() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入大于 6 的偶数：");
        int num = sc.nextInt();
        if (num % 2 != 0 || num <= 6) {
            System.out.println("输入错误，请重新输入大于 6 的偶数：");
            return inPut();
        }
        return num;
    }

    public static boolean isPrim(int num) {
        for (int i = 2; i <= Math.sqrt((double) num); i++) {
            if (num % i == 0) {
                return false;
            }
        }
        return true;
    }

    public static void outPut(int num) {
        for (int i = 2; i <= num / 2; i++) {
            if (isPrim(i) == true && isPrim(num - i) == true) {
                System.out.println(i + " " + (num - i));
            }
        }
    }
}

137、什么叫对象？什么叫类？什么是面向对象（OOP）？

类的概念：类是具有相同属性和行为的一组对象的集合。它为属于该类的所有对象提供了统一的抽象描述，其内部包括属性和行为两个主要部分。在面向对象的编程语言中，类是一个独立的程序单位，它应该有一个类名并包括属性说明和服务说明两个主要部分。

对象的概念：对象是系统中用来描述客观事物的一个实体，它是构成系统的一个基本单位。一个对象由一组属性和对这组属性进行操作的一组服务组成。从更抽象的角度来说，对象是问题域或实现域中某些事物的一个抽象，它反映该事物在系统中需要保存的信息和发挥的作用；它是一组属性和有权对这些属性进行操作的一组服务的封装体。客观世界是由对象和对象之间的联系组成的。

类与对象的关系就如模具和铸件的关系，类的实例化结果就是对象，而对一类对象的抽象就是类。类描述了一组有相同特性（属性）和相同行为（方法）的对象。

上面大概就是它们的定义吧，也许你是刚接触面象对象的朋友，不要被概念的东西搞晕了， 给你举个列子吧，如果你去中关村想买几台组装的PC机，到了那里你第一步要干什么，是不是装机的工程师和你坐在一起，按你提供的信息和你一起完成一个装机的配置单呀，这个配置单就可以想像成是类，它就是一张纸，但是它上面记录了你要买的PC机的信息，如果用这个配置单买10台机器，那么这10台机子，都是按这个配置单组成的，所以说这10台机子是一个类型的，也可以说是一类的。那么什么是对象呢，类的实例化结果就是对象，用这个配置单配置出来（实例化出来）的机子就是对象，是我们可以操作的实体，10 台机子，10 个对象。每台机子都是独立的，只能说明他们是同一类的，对其中一个机（对象）做任何动作都不会影响其它9台机器，但是我对类修改，也就是在这个配置单上加一个或少一个配件，那么装出来的9个机子都改变了，这是类和对象的关系(类的实例化结果就是对象) 

138、JAVA中使用final修饰符，对程序有哪些影响？

● 修饰类

当用final修饰一个类时，表明这个类不能被继承。也就是说，如果一个类你永远不会让他被继承，就可以用final进行修饰。final类中的成员变量可以根据需要设为final，但是要注意 final 类中的所有成员方法都会被隐式地指定为final 方法。在使用 final 修饰类的时候，要注意谨慎选择，除非这个类真的在以后不会用来继承或者出于安全的考虑，尽量不要将类设计为 final类。

● 修饰方法

被final修饰的方法将不能被子类覆盖，主要用于：

把方法锁定，以防任何继承类修改它的含义。

在早期的Java实现版本中，会将final方法转为内嵌调用，所以效率能够提升。

● 修饰变量

对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。当用 final 作用于类的成员变量时，成员变量（注意是类的成员变量，局部变量只需要保证在使用之前被初始化赋值即可）必须在定义时或者构造器中进行初始化赋值，而且final变量一旦被初始化赋值之后，就不能再被赋值了。

139、写出 5 个你在 JAVA 开发中常用的包含（全名），并简述其作用。

● java.lang.*

提供利用Java编程语言进行程序设计的基础类。最重要的类是Object（它是类层次结构的根）和Class（它的实例表示正在运行的应用程序中的类）。

● java.util.*

包含集合框架、遗留的Collection类、事件模型、日期和时间设施、国际化和各种实用工具类（字符串标记生成器、随机数生成器和位数组、日期 Date 类、堆栈 Stack 类、向量 Vector 类等）。集合类、时间处理模式、日期时间工具等各类常用工具包。

● java.io.*

Java 的核心库java.io提供了全面的IO接口。包括：文件读写、标准设备输出等。Java 中 IO是以流为基础进行输入输出的，所有数据被串行化写入输出流，或者从输入流读入。

● java.net.*

并非所有系统都支持 IPv6 协议，而当 Java 网络连接堆栈尝试检测它并在可用时透明地使用它时，还可以利用系统属性禁用它。在IPv6不可用或被显式禁用的情况下，Inet6Address  对大多数网络连接操作都不再是有效参数。虽然可以保证在查找主机名时 java.net.InetAddress.getByName之类的方法不返回Inet6Address，但仍然可能通过传递字面值来创建此类对象。在此情况下，大多数方法在使用 Inet6Address 调用时都将抛出异常。

● java.sql.*

提供使用JavaTM编程语言访问并处理存储在数据源（通常是一个关系数据库）中的数据的API。此API包括一个框架，凭借此框架可以动态地安装不同驱动程序来访问不同数据源。

140、方法重载（overload）需要满足什么条件，方法覆盖/方法重写（override）需要满足什么条件？

重载需要满足的条件：在同一类中定义的方法，方法名必须相同，参数一定不同。

发生覆盖的条件：“三同一不低”，子类和父类的方法名称，参数列表，返回类型必须完全相同，而且子类方法的访问修饰符的权限不能比父类低。子类方法不能抛出比父类方法更多的异常。即子类方法所抛出的异常必须和父类方法所抛出的异常一致，或者是其子类，或者什么也不抛出；被覆盖的方法不能是final类型的。因为final修饰的方法是无法覆盖的。被覆盖的方法不能为private。否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。被覆盖的方法不能为static。所以如果父类中的方法为静态的，而子类中的方法不是静态的，但是两个方法除了这一点外其他都满足覆盖条件，那么会发生编译错误。反之亦然。即使父类和子类中的方法都是静态的，并且满足覆盖条件，但是仍然不会发生覆盖，因为静态方法是在编译的时候把静态方法和类的引用类型进行匹配。

重写规则：重写方法不能比被重写方法限制有更严格的访问级别。（但是可以更广泛，比如父类方法是包访问权限，子类的重写方法是public访问权限）。比如：Object类有个toString()方法，开始重写这个方法的时候我们总容易忘记public修饰符，编译器当然不会放过任何教训我们的机会。出错的原因就是：没有加任何访问修饰符的方法具有包访问权限，包访问权限比 public当然要严格了，所以编译器会报错的。参数列表必须与被重写方法相同。重写有个孪生的弟弟叫重载，也就是后面要出场的。如果子类方法的参数与父类对应的方法不同，那么就是你认错人了，那是重载，不是重写。返回类型必须与被重写方法的返回类型相同。

父类方法A：void eat(){}子类方法B：int eat(){}两者虽然参数相同，可是返回类型不同，所以不是重写。

父类方法A：int eat(){} 子类方法 B：long eat(){} 返回类型虽然兼容父类，但是不同就是不同，所以不是重写。​​​​​​​