面试汇总（四）--JAVA_SE基础复习

                   JavaSE基础知识复习

1.数据类型相关，包装类与对应基本数据类型区别、装拆箱?

  (char能不能存汉字)

   数据类型：原始数据类型、引用数据类型

   八大基本数据类型：byte short char int long float double boolean

   原始类型的分装类：booleanBoolean charCharacter byteByte  shortShort intInteger longLong floatFloat doubleDouble

   装拆箱：

   装箱 ：基本数据类型转换为对应的包装数据类型的过程

   拆箱：包装数据类型转换为对应的基本数据类型的过程

   java5之前的手动装箱：int i=10;                               java5之后的手动装箱：Integer x=i;

                        Integer x=Integer.valueOf(i);           java5之后的手动拆箱：i=x

   java5之前的手动拆箱：i=x.intValue();                          java5有自身的机制来转换

2.equals /==

      ==

      a.==对于基本数据类型的操作时，比较的是两个变量的值是否相等

      b.==对于引用型变量时，表示的是两个在堆中存储的地址是否相等，即栈中的内容是否相等，而其本身则存储在堆中

      equals

       a.equals操作表示的两个变量是否对同一个对象的引用，即堆中的内容是否相同

        1、java中equals和==的区别 值类型是存储在内存中的堆栈（简称栈），而引用类型的变量在栈中仅仅是存储引用类型变量的地址，而其本身则存储在堆中。

   2、==操作比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同。

   3、equals操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。

   4、==比较的是2个对象的地址，而equals比较的是2个对象的内容，显然，当equals为true时，==不一定为true。

3.静态成员、实例成员及初始化的过程

   首先静态成员有static修饰，而实例成员没有

   静态成员也就是类成员：类在首次使用时，在静态区域开辟存储单元（也叫类存储区域，所有对象共享），开始完成类的初始化，

                         类只被初始化一次，程序执行完就销毁

   实例成员也就是对象成员：每当创建一对象时就实例化一次，不用时就销毁

  类的初始化（静态成员初始化）：

         a.默认初始化

         b.声明初始化

         c.初始化块

         d.构造器

  对象的初始化（实例成员初始化）：

        a.默认初始化

        b.声明初始化

        c.静态化块初始化

       注意：静态化块会随着类的首次加载，生命周期中，static{}只加载一次

              不会随着对象的初始化而在次初始化---先进行类的初始化，再进行对象的初始化

4.访问修饰符

  public：public表明该数据成员、成员函数是对所有用户开放的，所有用户都可以直接进行使用

  private：private表示私有，私有的意思就是除了class自己之外，任何人都不可以直接用。

  protected：protected对于继承自己的子女，同一目录下的class可以使用，对于外部的class是不可以用的。

  作用域    当前类    同一package    子孙类      其他package

  public      ok        ok             ok         ok

  protected   ok        ok             ok

  friendly    ok        ok

  private     ok

  不写时默认为friendly

5.java方法传参 (基本数据类型，引用数据类型)区别   

       一个按值传递    一个按地址传递

    栈：先进后出   对列：

6.重载，重写

   重载：是一个类中多态性的表现，在一个类中定义同名的方法，他们可以有不同的参数或参数类型

   重写：重写是父类和子类之间多态性的表现，子类继承父类

         重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。

        如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。

        子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。

       如果在一个类中定义了多个同名的方法，

      它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。

       Overloaded的方法是可以改变返回值的类型。

7.抽象类，接口区别     

    抽象类:被abstract 修饰的类即为抽象类，抽象类不能创建实例对象，含有abstract的方法类必须定义为

         抽象类，抽象类的方法不必是抽象的，也可以是具体的方法，抽象类中定义抽象方法必须在具体类中实现，所以不能有抽象的构           造方法或抽象的静态方法，如果子类没有实现抽象类中的所有方法，那么子类也必须定义为抽象类。

     接口  ：可以说成是抽象类的特例。接口中所有的方法都必须是抽象的，接口中方法定义默认为public abstract。

          接口中的变量是全局常量，即public static final 修饰的。

     语法区别：

          1）抽象类里可以有构造方法，而接口内不能有构造方法。

          2）抽象类中可以有普通成员变量，而接口中不能有，其变量是全局常量，即public static final 修饰的。

          3）抽象类中可以包含非抽象的普通方法，而接口中所有的方法必须是抽象的。

          4）抽象类中抽象方法的访问类型可以是public ,protected,和默认类型。

             接口中方法只能是public 类型的，且默认是public abstract。

          5）抽象类中可以包含静态方法，接口不能。

          6）抽象类和接口都可包含静态成员变量，抽象类中静态成员变量的访问类型可以是任意的，

             接口中定义的变量只能是public static ,且默认是public static 类型。

          7）一个类可以实现多个接口，但只能继承一个抽象类。

            在应用上：接口更多是在系统框架设计方法发挥作用，主要定义模块之间的通信，

        抽象类在代码实现方面发挥作用，可以实现代码的重用。

           8.抽象类可以实现接口，接口支持多继承

8.集合，map相关问题

   集合分为两个框架：Collection(单列)  Map（双列-key-value

  List,Set,Map 等

   a.List Set Map 与Collection的关系

       List Set 是继承Collection接口  而Map不继承

   b.List Set Map 三个接口，在存取元素时，有什么特点？

       List以特定的次序来持有元素，可以有重复的元素，Set无法拥有重复的元素， Map保存key-value 的值，value可以有多值

9.异常

 a.分类，

     异常分为两类：一般异常和程序运行时异常

 b.常见的一般异常和运行时异常  3种

       一般异常：try catch{}没写，编译出错，直接报错；线程相关的异常；ClassNotForfound;io流相关的异常

       运行异常：空指针异常，数组下标越界，算法异常

 c.异常处理技术.并解释throw throws

       throw:抛出的是异常实例，且每次只能抛出一个异常实例，只能放在方法体的内部

       throws:只能放在（声明）在方法名后，抛出的是异常类，可以抛出多个异常类，多个异常类用逗号隔开,说明某个方法可能会产生异常       

10.java特性 oop解释/java5新特性

      java特性：封装，继承，多态，抽象

      java5的新特性：装拆箱，静态导入，引进泛型，枚举法，StringBuilder

  a.一个类文件中可以放几个类

     一个java源文件可以包含多个类，每个源文件之多有一个public类。如果有的话，

    那么源文件的名字必须与之相同。如果源文件中没有public类，则源文件用什么名字都可以，

    但是最好还是具有特定的意义，免得自己都不记得里面写的是什么了。

  b.内部类有几种

  c.heap和stack有什么区别。

     栈是一种线形集合，其添加和删除元素的操作应在同一段完成。

     栈按照后进先出的方式进行处理。堆是栈的一个组成元素 ,堆先进先出   

  d.GC是什么? 为什么要有GC?

   GC是垃圾收集器。Java 程序员不用担心内存管理，

     因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一：

     System.gc()

      Runtime.getRuntime().gc()

  e.垃圾回收的优点和原理。并考虑2种回收机制。

      Java语言中一个显著的特点就是引入了垃圾回收机制，使c++程序员最头疼的内存管理的问题迎刃而解，它使得Java程序员在编写程     序的时候不再需要考虑内存管理。由于有个垃圾回收机制，Java中的对象不再有“作用域”的概念，只有对象的引用才有“作用域”。     垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情     况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行     垃圾回收。回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。

  f.垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收（GC）？

11.String创建几个对象的问题/StringBuffer/StringBuilder（可变）

    String 不可变，    StringBuffer线程安全，StringBuilder线程不安全

 

12.final, finally, finalize

        final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，

            不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。

            将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须

            在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载。

      finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，

               那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。

     finalize—方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中

              清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。

              它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。

               finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

13.排序算法

       1.冒泡排序

            for(int i=0;i<arr.length-1;i++){

                 for(int j=0;j<arr.length-1-i;j++){

                        if(arr[j]>arr[j+1]){  //把大的找出来

                            int temp=arr[j];

                             arr[j]=arr[j+1];  //交换元素

                             arr[j+1]=temp;

                }

             }

           }

       2.选择排序（从第一个元素开始，一次将最小的值放入）

             for(inti=0;i<arr.length-1;i++){

                  //找最小值的位置

                   int  minIndex=i;

                  for(int j=i+1;j<arr.length;j++){

                       if(arr[j]<arr[minIndex]){

                         minIndex=j;

               }

            }

                //与当前的考察位置的数交换

               int  temp=arr[i];

                   arr[i]=arr[minIndex];

                   arr[minIndex]=temp;

          }

       3.插入排序

          for( int i=1;i<arr.length;i++){

               if(arr[i]<arr[i-1]){  //判断是否要插入

                   int pos=-1;  //找目标位置

                   for(int j=0;j<i;j++){

                       if(arr[j]>arr[i]){

                            pos=j;

                            break;

                }

             }

                  int temp=arr[i];

                 //移位，从pos位置开始，到i-1的位置，向后移动1位

                    for（int j=i-1;j>=pos;j--）{

                          arr[j+1]=arr[j];

              }

                 //插入

                     arr[pos]=temp;

           }

         }

14.线程相关

     1.什么是线程

       CPU分配资源的最小单位

     2.实现多线程的方法

          a.继承Thread的类，重写run()方法

          b.实现Runnable接口

        start（）方法：本地方法，最终和操作系统交互，该线程有了争夺CPU使用的权利

     但是什么时候执行，执行几次，都是随机的

     3.实现线程同步的方法

      同步块（Synchronized关键字）、同步静态块、同步实例方法

15.XML操作相关

    1.XML-----适用于数据传输和数据共享

       a.是一种可扩展标记语言，很像html,但xml不是html的替代

       b.xml支持标签的自我定义（同时还需给标签样式和属性）

       c.主要的功能：适用于数据传输和数据共享

     XML(Extensible Markup Language)即可扩展标记语言，它与HTML一样，都是SGML(Standard Generalized Markup Language标砖通用    标记语言)。XML是Internrt环境中跨平台的，依赖于内容的技术，是当前处理结构化文档信息的有力工具。拓展标记语言XML是一种简单    的实际存储语言，使用一系列简单的标记描述数据，而这些标记可以用方便的方式建立，虽然XML占用的空间比二进制数据要占用更多的    空间，但XML极其简单易于掌握和使用。

    2.XML有哪些作用？

      Web.xml的作用是配置欢迎页，servlet 、filter、listenter等的。

    3.如何解析XML文件？

       a.dom解析:占用内存大，基于树模型，效率高，支持回溯

       b.sax解析：占用内存小，不支持回溯，效率不高

       c.dom4j：总体性能较好，效率较高，内存占用比较小，支持回溯，语法简单，容易上手和理解

16.设计模式

      一共有23种设计模式

      常用的有：工厂模式，代理模式，单例模式，原始模型模式（protoType）,装饰模式

17.流

    流：字节流和字符流

    字节流：继承InputStream/OutputStream  字符流：继承InputStreamRead/OutputStreamWrite

 没有线程的单例

 public class Student{

     private static Student stu=null;

     private Student（）{

         syso("===我被实例化了===");

  }

     public static void getInstance(){

           if(stu==null){

           stu=new Student();

     }

  }

}

懒汉模式：

public class Student_lan{

private static Student_lan stu=null;

private Student_lan(){-----私有化构造器

System.out.println("======我被实例化了=======");

}

public static synchronized void getInstance(){

if(stu==null){

stu=new Student_lan();

}

}

}

多线程单例-----饿汉模式---使用的是jvm中自带的锁

public class Student_e{

private static Student_e stu=new Student_e();

private Student_e(){-----私有化构造器

System.out.println("======我被实例化了=======");

}

 

public static Student_e getInstance(){

return stu;

}

}

优化的懒汉模式（懒汉和饿汉两种特性）

public class Student_yh{

private Student_yh(){-----私有化构造器

System.out.println("======我被实例化了=======");

}

//静态成员内部类

public static classs Y{

private static Student_yh stu=new Student_yh();

}

public static Student_yh getInstance(){

return Y.stu;

}

}