MYBK 面经T

1、什么是基本数据类型？列举基本数据类型。int和Integer的区别。String是类吗？

1、Integer是int的包装类，int则是java的一种基本数据类型

2、Integer变量必须实例化后才能使用，而int变量不需要

3、Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值 。

4、Integer的默认值是null，int的默认值是0

2、s1=s1+1有错吗？s1+=1有错吗？

面向对象编程的五大设计原则和三大特性

1、封装(Encapsulation)
封转是指属性私有化

根据需要提供setter和getter方法来访问属性
隐藏具体属性和实现细节，仅对外开放接口
控制程序中属性的访问级别
目的：增强数据安全性，不能让其他用户随意访问和修改数据，简化编程，使用者不必在意具体实现细节，而只是通过外部接口即可访问类的成员

2、继承（Extend）
继承是指将多个相同的属性和方法提取出来，新建一个父类

java中一个类只能继承一个父类，且只能继承访问权限非private属性和方法
子类可以重写父类中的方法，命名与父类中同名的属性
目的：代码复用

3、多态
多态（Polymiorph）可以分为两种：设计时多态、运行时多态

设计（编译）时多态：即重载（Overload），是指java允许方法名相同而参数不同（返回值可以相同也可以不同），同一个类中允许存在一个或多个以上的同名函数，只要参数类型或参数个数不同即可

运行时多态：即重写（Override）必须是在继承体系中，子类重写父类方法，JVM运行时根据调用该方法的类型决定调用那个方法

目的：增加代码的灵活度

单一职责原则：一个类，最好只做一件事，只有一个引起它变化。每个类应该实现单一的职责，如果不是，那就把类拆分

开放封闭原则：对扩展开放，对修改封闭

里氏替换原则：子类必须能够替换其基类，里氏替换原则中说，任何基类可以出现的地方，子类一定可以出现

依赖倒置原则：依赖于抽象接口，不要依赖于具体实现，简单来说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户于与实现模块间的耦合

接口隔离原则：使用多个小的专门接口，而不是使用一个大的接口

3、抽象类和接口的区别

接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。

下面比较一下两者的语法区别：

1.抽象类可以有构造方法，接口中不能有构造方法。

2.抽象类中可以有普通成员变量，接口中没有普通成员变量

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

4. 抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然

eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。

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

6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。

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

下面接着再说说两者在应用上的区别：

接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。而抽象类在代码实现方面发挥作用，可以实现代码的重用

4、Cookie和session的区别

*session和cookie的作用就是记录访问用户和服务器的交互状态。*它们让http请求变成了能记录状态的会话。cookie存在客户端，B/S里客户端就是浏览器；session存在服务器。

5、创建线程的方法

1、继承Thread

2、实现Runnable接口

3、实现Callable接口

6、Hashmap安全吗

HashMap线程不安全；HashTable线程安全（用Sychronized）

7、线程和进程的区别

进程是资源分配的最小单位，线程是CPU调度的最小单位

做个简单的比喻：进程=火车，线程=车厢

• 线程在进程下行进（单纯的车厢无法运行）
• 一个进程可以包含多个线程（一辆火车可以有多个车厢）
• 不同进程间数据很难共享（一辆火车上的乘客很难换到另外一辆火车，比如站点换乘）
• 同一进程下不同线程间数据很易共享（A车厢换到B车厢很容易）
• 进程要比线程消耗更多的计算机资源（采用多列火车相比多个车厢更耗资源）
• 进程间不会相互影响，一个线程挂掉将导致整个进程挂掉（一列火车不会影响到另外一列火车，但是如果一列火车上中间的一节车厢着火了，将影响到所有车厢）
• 进程可以拓展到多机，进程最多适合多核（不同火车可以开在多个轨道上，同一火车的车厢不能在行进的不同的轨道上）
• 进程使用的内存地址可以上锁，即一个线程使用某些共享内存时，其他线程必须等它结束，才能使用这一块内存。（比如火车上的洗手间）－“互斥锁”
• 进程使用的内存地址可以限定使用量（比如火车上的餐厅，最多只允许多少人进入，如果满了需要在门口等，等有人出来了才能进去）－“信号量”

8、sleep()和wait()区别

对于sleep()方法，我们首先要知道该方法是属于Thread类中的。而wait()方法，则是属于Object类中的。

sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。

在调用sleep()方法的过程中，线程不会释放对象锁。

而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备

从使用角度看，sleep是Thread线程类的方法，而wait是Object顶级类的方法。

sleep可以在任何地方使用，而wait只能在同步方法或者同步块中使用。

sleep和wait的区别：
1、sleep是Thread的静态方法，wait是Object的方法，任何对象实例都能调用。
2、sleep不会释放锁，它也不需要占用锁。wait会释放锁，但调用它的前提是当前线程占有锁(即代码要在synchronized中)。
3、它们都可以被interrupted方法中断。

9、单例模式（代码）

1 懒汉
    public class Singleton {  
2     private static Singleton instance = new Singleton();  
3     private Singleton (){}
4     public static Singleton getInstance() {  
5     return instance;  
6     }  
7 }  
这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用getInstance方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到lazy loading的效果。

1	静态内部类*****推荐
    public class Singleton {  
 2     private static class SingletonHolder {  
 3     private static final Singleton INSTANCE = new Singleton();  
 4     }  
 5     private Singleton (){}
 6     public static final Singleton getInstance() {  
 7         return SingletonHolder.INSTANCE;  
 8     }  
 9 }  
这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程，它跟第三种和第四种方式不同的是（很细微的差别）：第三种和第四种方式是只要Singleton类被装载了，那么instance就会被实例化（没有达到lazy loading效果），而这种方式是Singleton类被装载了，instance不一定被初始化。
    因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。

10、写出一种你熟悉的排序算法（代码）

import java.util.Arrays;
import java.util.Stack;

/**
 * 快速排序：
 * 选择两个引用，选择一个基准
 */
public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {10, 2, 19, 0, 8, 100, 28, 7, 1, 15,7};
        quickSort(arr);
//        quickSortByWhile(arr);
        System.out.println(Arrays.toString(arr));
    }

    //
    private static void quickSort(int[] arr) {
        if (arr.length == 0 || arr == null) {
            return ;
        } else {
            quick(arr,0,arr.length-1);
        }
    }
    private static void quick(int[] arr, int low, int high){
        int partition = partition(low,high,arr);
        //partition左边的数据都比它小，右边的数据都比他大
        //判断左边的数据大于1 个
        if(partition > low +1){
            quick(arr, low,partition-1);
        }
        //判断右边的数据大于1 个
        if(partition < high-1){
            quick(arr, partition+1,high);
        }
    }

    //以此划分过程时间复杂度是O(n)
    private static int partition(int low, int high, int[] arr) {
        int mark = arr[low];
        while (low < high) {
            //从后往前找比基准数据小的元素
            while (arr[high] >= mark && low < high) {
                high--;     //high可能会越界
            }
            if (low == high) {
                break;
            }
            if(arr[high]<mark){
                arr[low] = arr[high];
            }
            //从后往前找比基准数据小的元素
            while (arr[low] <= mark && low < high) {
                low++;
            }
            if (low == high) {
                break;
            }
            if(arr[low]>mark) {
                arr[high] = arr[low];
            }
        }
        arr[low] = mark;
        return low;
    }
}

11、jsp之九大内置对象与四大域对象

一,什么是内置对象?
在jsp开发中会频繁使用到一些对象,如ServletContext HttpSession PageContext等.如果每次我们在jsp页面中需要使用这些对象都要自己亲自动手创建就会特别的繁琐.SUN公司因此在设计jsp时,在jsp页面加载完毕之后自动帮开发者创建好了这些对象,开发者只需要使用相应的对象调用相应的方法即可.这些系统创建好的对象就叫做内置对象.

在servlet程序中,如果开发者希望使用session对象,必须通过request.getSession()来得到session对象;而在jsp程序中,开发中可直接使用session(系统帮我们创建好的session对象的名字就叫session)调用相应的方法即可,如:session.getId().

二,九大内置对象到底是哪九大呢?
内置对象名 类型

request	       HttpServletRequest
response       HttpServletResponse
config         ServletConfig
application    ServletContext
session        HttpSession
exception      Throwable
page           Object(this)
out            JspWriter
pageContext    PageContext 

三,解析几个内置对象
1)out对象对象,对象类型是JspWriter类,相当于带缓存的PrintWriter(不带缓存)
PrintWriter:write(“内容”) 直接向浏览器输出内容

JspWriter:writer(“内容”) 向jsp缓冲区写出内容

JspWriter当满足以下条件时之一时,缓冲区的内容写出:

a,缓冲区满了

b,刷新缓冲区

c,关闭缓冲区

d,jsp页面执行完毕

2)pageContext对象
pageContext的对象类型是PageContext,叫jsp的上下文对象.

pageContext作用:可以获取其他八个内置对象

//示例:

pageContext.getOut();
pageContext.getServletConfig()

使用场景:在自定义标签时会频繁使用到PageContext对象;或者是定义一个方法需要用到多个对象时,传一个pageContext对象就能解决问题.
四,JSP中四大域对象
分类:

ServletContext     context域
HttpServletRequet  request域
HttpSession        session域     --前三种在学习Servlet时就能接触到
PageContext        page域	 --jsp学习的

域对象的作用:保存数据,获取数据,共享数据.
保存数据:

pageContext.setAttribute("内容");//默认保存到page域
pageContext.setAttribute("内容",域范围常量);//保存到指定域中
//四个域常量
PageContext.PAGE_SCOPE
PageContext.REQUEST_SCOPE
PageContext..SESSION_SCOPE
PageContext.APPLICATION_SCOPE

获取数据:

pageContext.getAttribute("内容");

<p>pageContext.getAttribute("name",<span style="font-family:宋体;">域范围常量</span><span style="font-family:Calibri;">);</span></p>//自动在四个域中搜索数据

pageContext.findAttribute("内容");//在四个域中自动搜索数据,顺序:page域->request域->session域->application域(context域)

域作用范围:

page域:    只能在当前jsp页面使用                (当前页面)request域: 只能在同一个请求中使用               (转发)session域: 只能在同一个会话(session对象)中使用  (私有的)context域: 只能在同一个web应用中使用            (全局的)

12、List, Set, Map是否继承自Collection接口?

Collection下的集合有List Set Queue

Map 下有HashMap