JavaSE的常见面试题

1、    1     byte a=3;

         2     byte b=4;
         3    byte c=a+b;
         4    byte d=3+4;
以上哪一行有编译问题？应该如何解决？为什么会发生这样的问题？
        byte（8）->short（16）->int（32）->long（64）->float（32）->double（64）    
            由小到大可自由转换，由大到小必须写强转。
            注意：    1、long类型如果其长度超过int的取值范围，需在long数值后加上L符号。
                    2、float：采用科学计数法：一位符号位，8为指数位，23位尾数。
                    3、doouble：采用科学计数法：一位符号位，11位指数位，52位尾数。
    答：以上的代码会在第三行出现编译问题；将第三行的byte类型修改为int类型；因为byte+byte类型是会先转化为int
类型，在进行加法运算，故需要将第三行的byte修改为int类型。
    
    
2、1  byte a=130;
    以上有没有编译问题？应该如何解决？
    答：以上的程序有编译问题：
        byte：-128——127
        a=130在byte的取值之外，编译时会出现从int转换到byte可能会有损失的编译问题。
        
3、byte a=(byte)130;
    以上有没有编译问题？结果是？
    答：以上的编码没有编译问题；
    结果是：
    130（补码）:1000 0010     130
                       -1
            ——————————————        
       （反码）:1000 0001     -
       （原码） 0111 1110   -126
       
4、请你以最快的速度将变量a由2变成8.
        不管任何时候，所有的数在电脑上都将进行二进装换再进行计算，然后再转化为十进制数显示出来；
故最快的速度应该为位运算。
    答：    int a=2;
            a<<=2;

4、int a=5;int b=6;请你将两个数互换.（四种方法）
    1、设置一个临时变量，用于存储中间的转换值。
        /*int temp = a;
               a=b;
              b=temp;
        */
    2、利用+、-
        /*    a=a+b;    //11
            b=a-b;    //5
            a=a-b;  //6
        */
    3、利用位运算
        /*
            a=a^b;
            a=a^b;
            a=a^b;
        */
    4、一句话
        b=a+b-(a=b);   // 11 - 6

5、输入一个数，判断是不是质数（素数）
    2 3 5 7 11 13 17 19 23 29 31
    分析：从2开始到这个数的前一个数，不能这期间的任何一个数整除，称为质数
        int num=23;
        boolean f=true;//用于标记中间有没有变过
        for(int i=2;i<=Math.sqrt(num);i++){
            if(num%i==0){            
                f=false;
                break;
            }            
        }
        //在循环结束这判断，到底由于break结束循环的，还是没有遇到break，一直循环到num-1才结束的。
        if(f){
            System.out.println(num+"是质数");
        }else{
            System.out.println(num+"不是质数");
        }
        
        
6、输出乘法表：
        答：
            int row = 9;
            for (int i = 1; i <= row ; i++) {
                for (int j = 1; j <= i; j++) {
                    System.out.print(i+"*"+j+"="+i*j+"\t");
                }
                System.out.println();
            }

7、冒泡排序
    每相邻的?
    答：
        int[] arr= {9,36,2,15,46,89,11,22};
        System.out.println("排序前：");
        for(int i :arr){
            System.out.print(i+"\t");
        }
        int temp=0;
        for(int j=0;j             for(int i=0;i                 if(arr[i]>arr[i+1]){
                    //交换位置
                    temp=arr[i];
                    arr[i]=arr[i+1];
                    arr[i+1]=temp;
                }
            }
        }
        System.out.println();
        System.out.println("排序后：");
        for(int i :arr){
            System.out.print(i+"\t");
        }

8、面向对象的特征是什么？        封装   继承  多态
   如何理解这几个特征呢？自己组织语言
    答：封装：为了数据的安全性和私密性，将数据放入类中并进行封装起来，即使用private关键字进行隐藏起来，进而保护数据的私
            密性和安全性，同时留下构造器对私有字段进行初始化,同时用get、set方法对其读写功能进行不同权限的开放。
        继承：（extends）在具有相同属性众多相似类的中抽取相同的字段、相同的方法从而构成父类，进而让子类可以继承，来提高
            代码的重用效率，从而提高开发效率。java中只能继承一个父类，多个接口。因而继承多为类的字段和极少的共同属性，而
            接口多为对象的一些方法！
        多态：在通过继承父类之后，具有父类属性的同时，子类还具有本身的特有属性和方法，同一方法在不同子类中具有不同的呈现
            则称之为多态。分为：重写(在父子类中)；重载：(在一个类中)！

9、有哪些访问修饰符？ 每个修饰符的作用是什么？
    答：private 私有的       仅在类的内部能够访问 （本类）
        default 不写          可以在类的内部和被本包的其他类访问（本类、包内）
        protected 受保护的  可以在类的内部和被本包的其他类访问,还可以在其他包的子类中访问(本类、子类、包内)
        public  公共的       所有地方都能访问（公开的）
   字段应该都设置成私有的；
   可以通过访问修饰符向不同的对象开放get、set或者其他的权限。

10、static关键字有什么特点？如何使用？
    答:    特点：static：全局静态变量修饰符，被修饰的变量和方法变成共有。
            a、被静态static修饰的方法和变量随着类的加载而加载，优先于对象的存在。                    
            b、该类所有的对象都可以共享静态区域东西。    
        使用：
            a、可以通过对象、类名访问的。
            b、静态区域中只能引用静态成员（字段、方法）,非静态成员和this不可以用。
            c、没有静态构造器。
        总结：遇到static就类名.调用。

11、abstract关键字怎么用？有什么特点？
    答: abstract关键字使用:
            a、可以修饰类名。【访问修饰符】 【abstract】 【class】 类名{}
            b、可以修饰方法    。【访问修饰符】 【abstract】 【返回值】【方法名】（形参）{}
        特点：
            a、被abstract修饰的类称之为抽象类:
                1、抽象类只允许作为父类，不允许实例化（不能new）;
                2、只是作为父类存在，存在的意义只是为了让子类继承的。
            b、被abstract修饰的方法称之为抽象方法:
                1、抽象方法不能有方法体;
                2、抽象方法的存在意义就是为了让子类来重写的，子类必须重写父类的抽象方法，否则子类也必须声
                    明为抽象类。
                
12、overload和override有什么不同？
    答：overload:重载：同一个类中
            函数名相同，形参类型不同，形参个数不同，形参顺序不同，而得到的不同的结果呈现,不考虑返回值问题。
            
        override:重写：在父类与子孙类中，
            1、方法声明要和父类完全一样，包括形参
            2、访问修饰符，子类要大于等于父类的访问修饰符的范围     public > protected > default > private
            
 
13、抽象类和接口有什么异同？
    答：同：
            1、都具有抽象方法，            
        抽象类：
            1、作为父类，抽象类中的抽象方法作为一种规范。
            2.可以拥有变量、常量、构造器、抽象方法、方法。
        接口：如果一个类中只有抽象方法或者常量，那么这个类就是接口。所谓接口，就是一种规范、一种限制条件！
            1、使用：【修饰符】interface 接口名{}
            2.字段、常量：public static final int i = 10;
            3.方法：public abstract 【返回值】 【方法名】();
            4.不能有初始化块和构造器。
            5.接口是用来实现的，接口的所有方法都必须重写。

14、final关键字怎么用？
    答：1.修饰类，则该类不能被继承。
        2.修饰方法，则该方法不能被重写。
        3.修饰变量，变量就是常量。
        常量：一旦赋值不能修改。为了区分常量，一般建议常量名都大写。
        成员位置的常量初始化的时机：
            a、定义的时候就可以初始化。
            b、定义的时候没有初始化，在构造器中初始化。
            c、定义的时候没有初始化，在初始化块中初始化。

15、补齐下面的代码：
    public class Outer{
        private int num=5;
        private class Inner{
            private int num=15;
            void f(){
                int num=25;
                System.out.println(??);//要求输出5
                System.out.println(??);//要求输出15
                System.out.println(num);//要求输出25
            }
        }
    }

16、==和equals的区别？
    答： == ：比较的是栈中的地址是否相等。
        equals : String类中是以unicode码计算出来的hashcode进行比较；简单的说，就是内容比较。
            一般自定义类中都需要重写equals和hashcode方法。

17、String str=null 和String str="" 的区别？
    答：String str=null;    :是指字符串类型的str在栈中创建一个str的变量，但是没有指向。
        String str="";    :是指字符串类型的str在栈中创建一个str的变量，并指向方法区中的字符串常量池中的空字符。

18、String s=new String("abc"); 和 String s="abc";分别创建了几个String Object？二者之间有什么区别？
    答：String s=new String("abc");    ：1.在栈中创建一个s变量（对象）并存储堆中的地址；2.在堆中创建一个空间，存
            储一个指向方法区字符串常量池的地址；3.在方法区字符串常量池中创建一个空间，存储abc；
        String s="abc";    ：1.在栈中创建一个s变量（对象），并存储一个指向方法区字符串常量池的地址；2.在方法区字
            符串常量池中开辟一个空间，存储abc；
        异：后者不必再在堆中创建一个空间！
        
19、String s1="igeek";
    String s2="home";
    String s3="igeekhome";
    System.out.println(s3==s1+s2);
    System.out.println(s3.equals(s1+s2));
    System.out.println(s3=="igeek"+"home");
    System.out.println(s3.equals("igeek"+"home");
  请问上面四条语句会输出什么？
    答：
 
 
 
20、String和StringBuffer的区别?
    答：String创建变量在创建之后是无法更改的，在进行字符串的插入、拼接的时候，只能重新新建，改掉指向来实现的。这
            样极大的浪费了空间。
        StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都
            包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。主要操作是 append 和 insert 方
            法。
        优点：在拼接多的地方使用StringBuffer。
        
21、StringBuffer和StringBuilder的区别
    答：StringBuffer：线程安全的可变字符序列。多线程的时候最好采用StringBuffer，保证了数据安全，但是降低了效率。
        StringBuilder：线程不安全的可变字符序列。单个线程的时候，建议使用StringBuilder，速度更快，效率更高。

22、什么是装箱和拆箱？
    答：装箱：值类型转成引用类型称为装箱。
        拆箱：引用类型转成值类型称为拆箱。
包装类：(专指八个基本数据类型)（JDK1.5版本之后才有）
    为了对8个基本类型进行一些更方便的操作，java对每一个基本类型都提供了一个包装类。
        常见的操作之一：基本数据类型和String之间的转换
            byte  Byte
            short Short
            int  Integer
            long Long
            float Float
            double Double
            boolean  Boolean
            char Character
    基本类型转成String  toString()
    String转成基本类型的包装类    parseXXX()
    包装类转成基本类型    XXXValue()  
例：
    JDK1.5之后可以实现自动装箱（valueOF）和自动拆箱（intValue）
    //Integer i3=new Integer(10);
    //Integer i3=10;
    //JDK1.5之后可以直接这样写 自动装箱
        
23、ArrayList、LinkedList、Vector有什么区别？
    答：ArrayList底层是数组，增删慢，查找快。
            线程不安全，效率高
        LinkedList底层是链表，增删快，查找慢。
            线程不安全，效率高
        Vector底层是数组，增删慢，查找快。
            线程安全的，效率低

24、List、Set和Map什么区别？
    答：List:有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以
            根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。与 set 不同，列表通常允许重复的元素。
            更确切地讲，列表通常允许满足 e1.equals(e2) 的元素对 e1 和 e2，并且如果列表本身允许 null 元素的话，通常
            它们允许多个 null 元素。难免有人希望通过在用户尝试插入重复元素时抛出运行时异常的方法来禁止重复的列表，
            但我们希望这种用法越少越好。
        Set:一个不包含重复元素的 collection。更确切地讲，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多
            包含一个 null 元素。正如其名称所暗示的，此接口模仿了数学上的 set 抽象。 在所有构造方法以及 add、equals
            和 hashCode 方法的协定上，Set 接口还加入了其他规定，这些规定超出了从 Collection 接口所继承的内容。出于
            方便考虑，它还包括了其他继承方法的声明（这些声明的规范已经专门针对 Set 接口进行了修改，但是没有包含任何
            其他的规定）。    
        Map:基于红黑树（Red-Black tree）的 NavigableMap 实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时
            提供的 Comparator 进行排序，具体取决于使用的构造方法。

25、Collection和Collections什么区别？
   答： Collection是单列集合的顶层接口，是List和Set的接口父类。
    Collections是操作集合的工具类，有对集合的查找、排序、洗牌等功能。

26、异常分为哪几种？有什么区别？
    答：1.checked(Exception)：具有语法错误，不可通过编译，出错后就在指示地方进行改错。
        2.unchecked(RuntimeException)：没有语法错误，可通过编译，但是在运行时候会出错，出错后是指代码逻辑出现漏洞。

27、final、finallize、finally什么区别？
    答：fianl：修饰符关键字,修饰类、方法均不可被继承。修饰变量变常量且不可更改。
        finallize:【protected  void finalize()】 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
        finally:是在异常处理中try/catch中的语句，是指最后而且必须执行的语句（不管是否出现异常）。
    
28、throws和throw什么区别？
    答：throws:(关键字)
            1.用在方法后面，跟的异常的类名。
            2.可以有多个异常类名。
            3.表示可能有后面异常抛出，但是不一定会发生。
        throw：(关键字)
            1.用在方法体里面，跟的是异常对象。
            2.只能抛出一个具体的异常对象。
            3.表示抛出一个具体的异常了。只要执行到这里，一定会有异常抛出。
            
29、HashMap和TreeMap、Hashtable什么区别？
    答：HashMap：的key值不能重复且没有顺序，key值类型要重写hashcode（）和equals（）方法，线程不安全。
    
        TreeMap：的key值不能重复，key值要进行自然排序，要重写comparable（）方法。
        
        Hashtable：的key值不能重复而且没有顺序，不允许使用null作为key和value，key值类型需要重写hashcode（）和equals方法。线程安全
    
30、HashMap和Hashtable什么区别？
    答：HashMap的键可以存储null，线程不安全的
    Hashtable的键不可以存储null，线程安全的
    
31、什么是进程？什么是线程？
    答：进程：正在运行中的程序就是进程，是系统进行资源调度和分配的最小单元。每一个进程都有自己的内存空间的资源系统。
        线程：一个进程中可能有多个线程，线程是cpu调度的最小单位。
    
32、run方法和start方法有什么区别？
    答：run()方法:知识类的一个普通方法而已，如果直接调用run方法，程序中依然只有主线程一个线程，其 程序执行路径还是只有一条，
            还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有体现出多线程同步的效果。，
        start()方法：来启动一个线程，此时此线程处于(可运行)状态，并没有运行，一旦得到了cpu给定的权限（即时间片），就开始执
            行run()方法，若此时系统资源又被其他线程所争取到，则此线程就处于阻塞状态。
33、请简述下线程的生命周期。*****
    答：线程是一个动态的执行过程，他也有一个从产生到死亡的过程。
    
    线程的生命周期有五种状态：
    
    新建（new Thread）：当创建Thread类的一个实例时，此线程进入新建状态（未被启动）
    
    就绪（Runnable）：该线程的实例调用start（）方法，线程被启动，或者线程从阻塞状态进入到就绪状态，正在等待被分配cpu资源（时间片）；
    
    运行（running）：线程获得了cpu资源正在执行run（）方法，此时除非此线程自动放弃cpu资源或者有优先级跟高的线程进入，线程将一直运行到结束。
    
    死亡（dead）：当线程执行完毕或被其他线程杀死，线城就进入死亡状态，这时线程不可能再进入就绪状态等待执行。
                自然终止：正常运行run（）方法后终止
                异常终止：调用stop（）方法，error或exception让一个线程终止运行
    
    阻塞（blocked）：由于某种原因导致正在运行的现线程让出cpu并暂停自己的执行，即进入堵塞状态。
            正在睡眠：用sleep（long t）方法可使线程进入睡眠方式。一个睡眠着的线程在指定的时间过去可进入就绪状态。

            正在等待：调用wait（）方法。（调用notify方法回到就绪状态）。