zoukankan      html  css  js  c++  java
  • 面试题

    1.if(username.equals(‘zxx’)){}有什么不妥?

    答:如果username为空的话,会报空指针错误.java.lang.NullPointerException

      实际开发中应这么写: if(“zxx”.equals(username)){};这样就不会报错。

    2.求2/1+3/2+5/3+8/4+12/5+17/6……前20项和?

     1 package com.Test;
     2 
     3 public class Test2 {
     4 
     5     /**
     6      * @param args
     7      */
     8     public static void main(String[] args) {
     9         // TODO Auto-generated method stub
    10       System.out.println(fun(20));
    11     }
    12 
    13     public static float fun(int num){
    14         float sum=0;
    15         int j=2;
    16         for(int i=1;i<=num;i++){
    17             j+=i-1;
    18             sum+=(float)j/i;
    19         }
    20         return sum;
    21     }
    22 }

    这道题笔试的时候,在No18行没有强转为float型,导致出来的结果不正确。

    3.jvm的工作机制

     答:Java语言的一个非常重要的特点就是与平台的无关性。而使用Java虚拟机是实现这一特点的关键。一般的高级语言如果要在不同的平台上运行,至少需要编译成不同的目标代码。而引入Java语言虚拟机后,Java语言在不同平台上运行时不需要重新编译。Java语言使用模式Java虚拟机屏蔽了与具体平台相关的信息,使得Java语言编译程序只需生成在Java虚拟机上运行的目标代码(字节码),就可以在多种平台上不加修改地运行。Java虚拟机在执行字节码时,把字节码解释成具体平台上的机器指令执行。

    4:异常分为几种?有什么区别?

    答:1,编译时异常:Java.lang.Exception,2,运行期异常:Java.lang.RuntimeException,3,错误:Java.lang.Error

     编译时异常:程序正确,但因为外在的环境条件不满足引发。例如:用户错误及I/O问题----程序试图打开一个并不存在的远程Socket端口。这不是程序本身的逻辑 错误,而很可能是远程机器名字错误(用户拼写错误)。对商用软件系统,程序开发者必须考虑并处理这个问题。Java编译器强制要求处理这类异常,如果不捕 获这类异常,程序将不能被编译。

    运行时异常:这意味着程序存在bug,如数组越界,0被除,入参不满足规范.....这类异常需要更改程序来避免,Java编译器强制要求处理这类异常。

    错误:一般很少见,也很难通过程序解决。它可能源于程序的bug,但一般更可能源于环境问题,如内存耗尽。错误在程序中无须处理,而有运行环境处理

    5:public class SomeThing(){

    void SomeThing(){

    private String s=null;

    int l=s.length();

    }

    }

    有什么错?

    答:局部变量前不能放置任何修饰符(private,protected或public),final可以用来修饰局部变量。

    6,今天2013/8/5 面试的一道上机题是这样的,一个整型数组arr[] ,存有若干整形数据,求各个数值出现的次数。

    这道题用了大概20到30分钟,才写出下面的代码。

    public static void fun(int[] arr){
            int len=arr.length;
            for(int i=0;i<len;i++)
                for(int j=i;j<len;j++){
                    if(arr[i]>arr[j]){
                        int k=arr[j+1];
                        arr[j+1]=arr[j];
                        arr[j]=k;
                    }
                }
            int k=0;
            int num=1;
            while(k<len-1){
                if(arr[k]==arr[k+1]){
                    num++;
                }else{
                    System.out.println(arr[k]+"出现频率次数:"+num);
                    num=1;
                    if(k==len-2){
                        System.out.println(arr[k+1]+"出现频率次数:"+num);
                    }
                }
                k++;
            }
        }

    后来回来上网查询,才发现我这样做是多么不入流。

    网上有看到有如下做法,比较简单。

    public static void fun1(int[] arr){
            int num=arr.length;
            int [] count=new int[10];
            for(int i=0;i<num;i++){
                count[arr[i]]++;
            }
            for(int j=0;j<count.length;j++){
                if(count[j]!=0)
                System.out.println(j+"出现频率:"+count[j]);
            }
            
        }

    7.父类子类构造方法的一个题目。

    package Test;
    
    public class Test3 {
    
        /**
         * @param args
         */
        public static void main(String[] args) {
            // TODO Auto-generated method stub
           Father f=new Child();
        }
    }
    
    class Father {
    
        public Father() {
            System.out.println("Father无参数构造方法!"); /* 1 */
        }
    
        public Father(int i) {
            System.out.println("Father有参数构造方法(参数类型int)!"); /* 2 */
        }
    
        public Father(String s) {
            System.out.println("Father有参数构造方法(参数类型Stirng)"); /* 3 */
        }
    }
    
    class Child extends Father {
        public Child() {
            super(1);
            System.out.println("child");
        }
    }
    View Code

    原题大概是没有super(1);这条语句的运行结果!

    结果是报错。

    说明:如果没有1处的无参数构造方法,那么2或3处一定要在子类中主动调用父类带参数的构造方法,可以用super方法。
    如果有1处的构造方法,那么super处代码可以不要,因为Java会自动默认调用父类的无参数构造方法。

     8 一个数组存放了2n+1个整数,其中有n个数出现了2次,1个数出现了1次,找出出现1次的数是多少?

     当时我没能想出来,后来回去后找到了解法:对数组A的所有元素做异或,即A[0]异或A[1]…… 异或A[2n]结果就是答案,理由:相同的数异或等于0,而0和任何数以后等于任何数,且异或运算可交换。

    public static void main(String[] args) {
            // TODO Auto-generated method stub
            int num=0;
            int[] array={1,2,2,5,1,11,12,11,5};
            for(int i=0;i<array.length;i++){
                num=array[i]^num;
            }
            System.out.println(num);
        }

    9.redirect, forward区别

    forward方式:request.getRequestDispatcher("/somePage.jsp").forwardrequest, response);    
    redirect方式:response.sendRedirect("/somePage.jsp");

    1.从地址栏显示来说
    forward是服务器请求资源,服务器直接访问目标地址的URL,把那个URL的响应内容读取过来,然后把这些内容再发给浏览器.浏览器根本不知道服务器发送的内容从哪里来的,所以它的地址栏还是原来的地址.
    redirect是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址.所以地址栏显示的是新的URL.

    2.从数据共享来说
    forward:转发页面和转发到的页面可以共享request里面的数据.
    redirect:不能共享数据.

    3.从运用地方来说
    forward:一般用于用户登陆的时候,根据角色转发到相应的模块.
    redirect:一般用于用户注销登陆时返回主页面和跳转到其它的网站等.

    4.从效率来说
    forward:高.
    redirect:低.

    10 选择排序,冒泡排序,插入排序,快速排序
    public static void main(String[] args) {
            // TODO Auto-generated method stub
    
            int[] array = { 2, 4, 5, 1, 12, 9, 6 };
            fun1(array);
            fun2(array);
            fun3(array);
            fun4(array, 0, 6);
            for (int i : array) {
                System.out.println(i);
            }
        }
    
        /* 选择排序 */
        public static void fun1(int[] array) {
            int num = array.length;
            int temp;
            for (int i = 0; i < num - 1; i++)
                for (int j = i + 1; j < num; j++) {
                    if (array[i] > array[j]) {
                        temp = array[i];
                        array[i] = array[j];
                        array[j] = temp;
                    }
                }
            for (int i : array) {
                System.out.println(i);
            }
        }
    
        /* 冒泡排序 */
        public static void fun2(int[] array) {
    
            int num = array.length;
            int temp;
            for (int i = 0; i < num - 1; i++)
                for (int j = 0; j < num - i - 1; j++) {
                    if (array[j] > array[j + 1]) {
                        temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;
                    }
                }
            for (int i : array) {
                System.out.println(i);
            }
        }
    
        /* 插入排序 */
        public static void fun3(int[] array) {
    
            int num = array.length;
            int temp;
            for (int i = 1; i < num; i++) { // 循环从第二个数组元素开始,因为arr[0]作为最初已排序部分
                temp = array[i];
                int j = i - 1;
                while (j >= 0 && array[j] > temp) {/*
                                                     * 将temp与已排序元素从大到小比较,寻找temp应插入的位置
                                                     */
                    array[j + 1] = array[j];
                    j--;
                }
                array[j + 1] = temp;
            }
    
            for (int i : array) {
                System.out.println(i);
            }
        }
    
        /* 快速排序 */
        static int partition(int[] array, int low, int high) {
            int temp = array[low];
    
            while (low < high) {
    
                while (low < high && array[high] >= temp) {
                    high--;
                }
                int t = array[low];
                array[low] = array[high];
                array[high] = t;
                while (low < high && array[low] <= temp) {
                    low++;
                }
                int tt = array[low];
                array[low] = array[high];
                array[high] = tt;
            }
            return low;
        }
    
        static void fun4(int[] array, int low, int high) {
            if (low < high) {
                int n = partition(array, low, high);
                fun4(array, low, n);
                fun4(array, n + 1, high);
            }
        }
    View Code

    11.

    public class Test {
        public static void main(String[] args) {
            A a=new B();
            a.method();
        }
    }
    class A{
        public void method(){
            System.out.println("a:aa");
        }
    }
    class B extends A{
         void method(){
            System.out.println("b:bb");
         }
    }
    结果是编译出错。
    方法重写/覆写(Override):他是是发生在继承关系之中,是由子类进行覆写的,并且方法名称相同,参数的类型或个数需相同,而重写方法的访问权限则不能太严格。  
    优点:能够定义子类中特有的特征
    注意:访问修饰符的限制一定要大于被重写方法的访问修饰符即 (public>protected>default>private)
    上列中类A中public去掉或类B中方法加修饰符public则编译正确
    若类A中public改为private,在a.method()编译出错。因为private修饰的方法只能在本类内访问。

     
  • 相关阅读:
    线上问题随笔记录数据库连接池问题
    MySQL索引类型总结和使用技巧以及注意事项
    elastic-job的原理简介和使用
    新生 & 语不惊人死不休 —— 《无限恐怖》读后有感
    USACO Section2.1 Hamming Codes 解题报告 【icedream61】
    USACO Section2.1 Healthy Holsteins 解题报告 【icedream61】
    USACO Section2.1 Sorting a Three-Valued Sequence 解题报告
    USACO Section2.1 Ordered Fractions 解题报告
    USACO Section2.1 The Castle 解题报告
    USACO Section1.5 Superprime Rib 解题报告
  • 原文地址:https://www.cnblogs.com/gexiaoshan/p/3093260.html
Copyright © 2011-2022 走看看