Java基础概念

一 面向对象的特征有哪些方面

1.封装：

封装是保证软件部件具有优良的模块性的基础，封装的目标就是要实现软件部件的“高内聚、低耦合”，防止程序相互依赖性而带来的变动影响.
面向对象的封装性，即将对象封装成一个高度自治和相对封闭的个体，对象状态（属性）由这个对象自己的行为（方法）来读取和改变.

2.抽象：

抽象就是找出一些事物的相似和共性之处，然后将这些事物归为一个类，这个类只考虑这些事物的相似和共性之处，并且会忽略与当前主题和目标无关的那些方面，将注意力集中在与当前目标有关的方面。要善于划分问题的边界，当前系统需要什么，就只考虑什么。

3.多态

多态是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定。

4.继承

对象的一个新类可以从现有的类中派生，新类继承了原始类的特性，新类称为原始对象的一个派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。继承性很好的解决了软件的可重用性问题。

二 Java中的异常处理机制的简单原理和应用。

1 概念

异常是指java程序运行时（非编译）所发生的非正常情况或错误，Java使用面向对象的方式来处理异常，它把程序中发生的每个异常也都分别封装到一个对象来表示的，该对象中包含有异常的信息。

2 分类

Java对异常进行了分类，不同类型的异常分别用不同的Java类表示，所有异常的根类为java.lang.Throwable，Throwable下面又派生了两个子类：Error和Exception，Error表示应用程序本身无法克服和恢复的一种严重问题，程序只有死的份了，例如，说内存溢出和线程死锁等系统问题。Exception表示程序还能够克服和恢复的问题，其中又分为系统异常和普通异常，系统异常是软件本身缺陷所导致的问题，也就是软件开发人员考虑不周所导致的问题，软件使用者无法克服和恢复这种问题，但在这种问题下还可以让软件系统继续运行或者让软件死掉，例如，数组脚本越界（ArrayIndexOutOfBoundsException），空指针异常（NullPointerException）、类转换异常（ClassCastException）；普通异常是运行环境的变化或异常所导致的问题，是用户能够克服的问题，例如，网络断线，硬盘空间不够，发生这样的异常后，程序不应该死掉。
java为系统异常和普通异常提供了不同的解决方案，编译器强制普通异常必须try..catch处理或用throws声明继续抛给上层调用方法处理，所以普通异常也称为checked异常，而系统异常可以处理也可以不处理，所以，编译器不强制用try..catch处理或用throws声明，所以系统异常也称为unchecked异常。

3 面试提示

就按照三个级别去思考：虚拟机必须宕机的错误，程序可以死掉也可以不死掉的错误，程序不应该死掉的错误。

三 内部类

1 定义

内部类就是在一个类的内部定义的类，内部类中不能定义静态成员，内部类可以直接访问外部类中的成员变量，内部类可以定义在外部类的方法外面，也可以定义在外部类的方法体中。

2 分类

成员内部类

在方法体外面定义的内部类的访问类型可以是public,protected,默认的，private等4种类型，创建方法如下：

Outer outer = new Outer();
Outer.Inner1 inner1 = outer.new Innner1();

局部内部类

在方法内部定义的内部类前面不能有访问类型修饰符，但这种内部类的前面可以使用final或abstract修饰符。这种内部类对其他类是不可见的其他类无法引用这种内部类，但是这种内部类创建的实例对象可以传递给其他类访问。这种内部类必须是先定义，后使用，这种内部类可以访问方法体中的局部变量，但是，该局部变量前必须加final修饰符。

匿名内部类

在方法体内部还可以采用如下语法来创建一种匿名内部类，即定义某一接口或类的子类的同时，还创建了该子类的实例对象，无需为该子类定义名称。

静态内部类

    最后，在方法外部定义的内部类前面可以加上static关键字，从而成为Static Nested Class，它不再具有内部类的特性，所有，从狭义上讲，它不是内部类。Static Nested Class与普通类在运行时的行为和功能上没有什么区别，只是在编程引用时的语法上有一些差别，它可以定义成public、protected、默认的、private等多种类型，而普通类只能定义成public和默认的这两种类型。在外面引用Static Nested Class类的名称为“外部类名.内部类名”。在外面不需要创建外部类的实例对象，就可以直接创建Static Nested Class。
    由于static Nested Class不依赖于外部类的实例对象，所以，static Nested Class能访问外部类的非static成员变量(不能直接访问，需要创建外部类实例才能访问非静态变量)。当在外部类中访问Static Nested Class时，可以直接使用Static Nested Class的名字，而不需要加上外部类的名字了，在Static Nested Class中也可以直接引用外部类的static的成员变量，不需要加上外部类的名字。

静态方法内的内部类（静态内部类）

在静态方法中定义的内部类也是Static Nested Class，这时候不能在类前面加static关键字，静态方法中的Static Nested Class与普通方法中的内部类的应用方式很相似，它除了可以直接访问外部类中的static的成员变量，还可以访问静态方法中的局部变量，但是，该局部变量前必须加final修饰符。

3 作用

* 内部类提供了更好的封装，不允许同一个包中的其他类访问该类
* 内部类成员可以直接访问外部类的私有数据，但外部类不能访问内部类的实现细节
* 匿名内部类适合用于创建那些仅需要一次使用的类。

4 分类总结

内部类

分类	成员变量或方法	访问外部类	创建或访问方式	访问控制符
普通成员内部类（非静态、非接口）	不可以包含静态成员（态方法、静态Field、静态初始化块）	所有成员	Outer outer = new Outer();Outer.Inner1 inner1 = outer.new Innner1()	任意
静态成员内部类	任意	能访问外部类的非static成员变量(不能直接访问，需要创建外部类实例才能访问非静态变量)。	可以直接使用Static Nested Class的名字，而不需要加上外部类的名字了，在Static Nested Class中也可以直接引用外部类的static的成员变量，不需要加上外部类的名字。	任意
接口静态内部类	静态变量（public static final），抽象方法(public abstract)	只能访问外部类的类成员	外部类名.内部类名（外部引用）	public
普通局部内部类	不能有静态成员只能访问外部类的类成员	可以访问方法体中的局部变量，但是，该局部变量前必须加final修饰符	只能在方法内定义变量、创建实例或派生子类，其他类无法引用这种内部类，但是这种内部类创建的实例对象可以传递给其他类访问）	不能使用访问控制符和static，可以使用final或abstract修饰符
匿名内部类	不能有静态成员 ，不能定义构造器	可以访问方法体中的局部变量，但是，该局部变量前必须加final修饰符	只能在方法内定义变量、创建实例或派生子类其，他类无法引用这种内部类，但是这种内部类创建的实例对象可以传递给其他类访问	不能使用访问控制符，static，final或abstract修饰符
静态方法中的内部类	不能有静态成员 ，不能定义构造器	可以直接访问外部类中的static的成员变量，还可以访问静态方法中的局部变量，但是，该局部变量前必须加final修饰符。	可以访问方法体中的局部变量，但是，该局部变量前必须加final修饰符	只能在方法内定义变量、创建实例或派生子类，其他类无法引用这种内部类，但是这种内部类创建的实例对象可以传递给其他类访问

四 线程的基本概念、线程的基本状态以及状态之间的关系

1 基本概念

线程是程序中一个单一的顺序控制流程。进程内一个相对独立的、可调度的执行单元，是系统独立调度和分派CPU的基本单位指运行中的程序的调度单位。在单个程序中同时运行多个线程完成不同的工作，称为多线程。

2 基本状态

就绪，运行，synchronize阻塞，wait和sleep挂起，结束。wait必须在synchronized内部调用。

3 生命周期

 调用线程的start方法后线程进入就绪状态，线程调度系统将就绪状态的线程转为运行状态，遇到synchronized语句时，由运行状态转为阻塞，当synchronized获得锁后，由阻塞转为运行，在这种情况可以调用wait方法转为挂起状态，当线程关联的代码执行完后，线程变为结束状态。

五 堆栈

1 程序运行时的内存分配策略

按照编译原理的观点,程序运行时的内存分配有三种策略,分别是静态的,栈式的,和堆式的.

静态的

 静态存储分配是指在编译时就能确定每个数据目标在运行时刻的存储空间需求,因而在编译时就可以给他们分配固定的内存空间.这种分配策略要求程序代码中不允许有可变数据结构(比如可变数组)的存在,也不允许有嵌套或者递归的结构出现,因为它们都会导致编译程序无法计算准确的存储空间需求.

栈式的

栈式存储分配也可称为动态存储分配,是由一个类似于堆栈的运行栈来实现的.和静态存储分配相反,在栈式存储方案中,程序对数据区的需求在编译时是完全未知的,只有到运行的时候才能够知道,但是规定在运行中进入一个程序模块时,必须知道该程序模块所需的数据区大小才能够为其分配内存.和我们在数据结构所熟知的栈一样,栈式存储分配按照先进后出的原则进行分配。

堆式的

静态存储分配要求在编译时能知道所有变量的存储要求,栈式存储分配要求在过程的入口处必须知道所有的存储要求,而堆式存储分配则专门负责在编译时或运行时模块入口处都无法确定存储要求的数据结构的内存分配,比如可变长度串和对象实例.堆由大片的可利用块或空闲块组成,堆中的内存可以按照任意顺序分配和释放.

2 不同变量的内存分配机制

类变量（static修饰的变量）

在程序加载时系统就为它在堆中开辟了内存，堆中的内存地址存放于栈以便于高速访问。静态变量的生命周期--一直持续到整个"系统"关闭

实例变量

当你使用java关键字new的时候，系统在堆中开辟并不一定是连续的空间分配给变量（比如说类实例），然后根据零散的堆内存地址，通过哈希算法换算为一长串数字以表征这个变量在堆中的"物理位置"。 实例变量的生命周期--当实例变量的引用丢失后，将被GC（垃圾回收器）列入可回收“名单”中，但并不是马上就释放堆中内存

局部变量

局部变量由声明在某方法，或某代码段里（比如for循环），执行到它的时候在栈中开辟内存，当局部变量一但脱离作用域，内存立即释放

3 JVM的堆和栈

每一个Java应用都唯一对应一个JVM实例，每一个实例唯一对应一个堆。
JVM为每个新创建的线程都分配一个栈.也就是说,对于一个Java程序来说，它的运行就是通过对堆栈的操作来完成的。栈以帧为单位保存线程的状态。当线程激活一个Java方法,JVM就会在线程的 Java堆栈里新压入一个帧，在此方法执行期间,这个帧将用来保存参数,局部变量,中间计算过程和其他数据
从Java的这种分配机制来看,栈又可以这样理解:栈(Stack)是操作系统在建立某个进程时或者线程(在支持多线程的操作系统中是线程)为这个线程建立的存储区域，该区域具有先进后出的特性

4 Java中堆栈的一些特点及比较

1. 自动管理栈和堆

栈(stack)与堆(heap)都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。

2. 堆/栈的优势和劣势

栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。另外，栈数据在多个线程或者多个栈之间是不可以共享的，但是在栈内部多个值相等的变量是可以指向一个地址的，详见第3点。
堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。

3.堆/栈存储的数据类型

基本数据类型存在于栈中

Java中的数据类型有两种。一种是基本类型(primitivetypes), 共有8种，即int,short, long, byte, float, double, boolean, char(注意，并没有string的基本类型)。这种类型的定义是通过诸如int a= 3; long b = 255L;的形式来定义的，称为自动变量。值得注意的是，自动变量存的是字面值，不是类的实例，即不是类的引用，这里并没有类的存在。如int a= 3; 这里的a是一个指向int类型的引用，指向3这个字面值。这些字面值的数据，由于大小可知，生存期可知(这些字面值固定定义在某个程序块里面，程序块退出后，字段值就消失了)，*出于追求速度的原因，就存在于栈中。

存在栈中的数据可以共享

另外，栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义：

 int a=3; 
 int b=3;

 编译器先处理int a= 3；首先它会在栈中创建一个变量为a的内存空间，然后查找有没有字面值为3的地址，没找到，就开辟一个存放3这个字面值的地址，然后将a指向3的地址。接着处理int b= 3；在创建完b的引用变量后，由于在栈中已经有3这个字面值，便将b直接指向3的地址。这样，就出现了a与b同时均指向3的情况。

字面值的引用与类对象的引用不同

特别注意的是，这种字面值的引用与类对象的引用不同。假定两个类对象的引用同时指向一个对象，如果一个对象引用变量修改了这个对象的内部状态，那么另一个对象引用变量也即刻反映出这个变化。相反，通过字面值的引用来修改其值，不会导致另一个指向此字面值的引用的值也跟着改变的情况。如上例，我们定义完a与b的值后，再令a=4；那么，b不会等于4，还是等于3。在编译器内部，遇到a=4；时，它就会重新搜索栈中是否有4的字面值，如果没有，重新开辟地址存放4的值；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。

包装类数据存在于堆中

另一种是包装类数据，【如Integer,String, Double等将相应的基本数据类型包装起来的类。这些类数据全部存在于堆中】，Java用new()语句来显示地告诉编译器，在运行时才根据需要动态创建，因此比较灵活，但缺点是要占用更多的时间。String是一个特殊的包装类数据。即可以用String str = new String(“abc”);的形式来创建，也可以用String str = “abc”；的形式来创建(作为对比，在JDK 5.0之前，你从未见过Integer i = 3;的表达式，因为类与字面值是不能通用的，除了String。而在JDK5.0中，这种表达式是可以的！因为编译器在后台进行Integer i = new Integer(3)的转换)。前者是规范的类的创建过程，即在Java中，一切都是对象，而对象是类的实例，全部通过new()的形式来创建。Java中的有些类，如DateFormat类，可以通过该类的getInstance()方法来返回一个新创建的类，似乎违反了此原则。其实不然。该类运用了单例模式来返回类的实例，只不过这个实例是在该类内部通过new()来创建的，而getInstance()向外部隐藏了此细节。那为什么在String str = “abc”；中，并没有通过new()来创建实例，是不是违反了上述原则？其实没有。

4. 关于String str = “abc”的内部工作。

Java内部将此语句转化为以下几个步骤：【String str = “abc”，String str不要连着】

(1)先定义一个名为str的对String类的对象引用变量：String str；

(2)在【栈】中查找有没有存放值为”abc”的地址，如果没有，则开辟一个存放字面值为”abc”的地址，接着创建一个新的String类的对象o，并将o的字符串值指向这个地址，而且在栈中这个地址旁边记下这个引用的对象o。如果已经有了值为”abc”的地址，则查找对象o，并返回o的地址。【上文说数据时存放在堆中，此文说数据存放在栈中】[因为此处不是通过new()创建的啊]

(3)将str指向对象o的地址。

值得注意的是，一般String类中字符串值都是直接存值的。但像String str = “abc”；这种场合下，其字符串值却是保存了一个指向存在栈中数据的引用！

为了更好地说明这个问题，我们可以通过以下的几个代码进行验证。 

 String str1=”abc”; 
 String str2=”abc”; 
 System.out.println(str1==str2);//true

注意，我们这里并不用str1.equals(str2)；的方式，因为这将比较两个字符串的值是否相等。==号，根据JDK的说明，只有在两个引用都指向了同一个对象时才返回真值。而我们在这里要看的是，str1与str2是否都指向了同一个对象。 
结果说明，JVM创建了两个引用str1和str2，但只创建了一个对象，而且两个引用都指向了这个对象。

我们再来更进一步，将以上代码改成： 

 String str1=”abc”; 
 String str2=”abc”; 
 str1=”bcd”; 
 System.out.println(str1+”,”+str2);//bcd,abc 
 System.out.println(str1==str2);//false

这就是说，赋值的变化导致了类对象引用的变化，str1指向了另外一个新对象！而str2仍旧指向原来的对象。上例中，当我们将str1的值改为”bcd”时，JVM发现在栈中没有存放该值的地址，便开辟了这个地址，并创建了一个新的对象，其字符串的值指向这个地址。

事实上，String类被设计成为不可改变(immutable)的类。如果你要改变其值，可以，但JVM在运行时根据新值悄悄创建了一个新对象，然后将这个对象的地址返回给原来类的引用。这个创建过程虽说是完全自动进行的，但它毕竟占用了更多的时间。在对时间要求比较敏感的环境中，会带有一定的不良影响。

再修改原来代码：

 String str1=”abc”; 
 String str2=”abc”; 
 str1=”bcd”; 
 String str3=str1; 
 System.out.println(str3);//bcd 
 String str4=”bcd”; 
 System.out.println(str1==str4);//true

我们再接着看以下的代码。

String str1 = new String(“abc”); 
String str2 = “abc”; 
System.out.println(str1==str2); //false

String str1 = “abc”; 
String str2 = new String(“abc”); 
System.out.println(str1==str2); //false 

创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。

以上两段代码说明，只要是用new()来新建对象的，都会在堆中创建，而且其字符串是单独存值的，即使与栈中的数据相同，也不会与栈中的数据共享。

5. 数据类型包装类的值不可修改

不仅仅是String类的值不可修改，所有的数据类型包装类都不能更改其内部的值。

6 从堆和栈的功能和作用来通俗的比较

堆主要用来存放对象的，栈主要是用来执行程序的.而这种不同又主要是由于堆和栈的特点决定的: stack 是有结构的，每个区块按照一定次序存放，可以明确知道每个区 块的大小； heap 是没有结构的， 数据可以任意存放。 因此， stack 的寻址速度要快于 heap 。

六、Jsp的九大内置对象

1、appliction

该实例代表 JSP 所属的 WEB 应用本身，用于 JSP 页面，或者在 Servlet 之间信息交换。 常用方法有 getAttribute( name , value)、setAttribute( name , value)、getInitParameter( name ) 等。

2、config

代表 JSP 的配置信息， 常用方法有 getInitParameter( String paramName) 、getInitParameternames()等。

3、exception

代表页面中的异常和错误。只有页面是错误处理页面，page 的isErrorPage 属性为 true 时该对象才可以使用。常用方法 getMessage() 、printStrackTrace()等。

4、out

JSP 页面输出流，用于输出内容，形成 HTML 页面。

5、page

代表该页面本身，也就是 Servlet 中的 this ,能用 page 的地方就可以用 this .

6、pageContext

代表 JSP 页面上下文，可以访问页面中的共享数据。 常用方法有：getServletContext() 和 getServletConfig() 等。

7、request

客户端的请求参数都被封装在该对象里。这是一个常用对象，获取客户端请求参数必须使用该对象。常用方法：getParameter(String paramName)、getParameterValues(String paramName)、setAttribute(String arrtName,Object attrValue)、getAttribute(String attrName) 和 setCharacterEncoding(String env)等。

8、response

代表服务器对客户端的响应， response 对象常用于重定向，常用的方法有 getOutputStream() 、 sendRedirect(Java.lang.String location)等。

9、session

该对象代表一次会话。当客户端与站点建立连接时，会话开始;当客户端关闭浏览器时，会话结束。常用方法： getAttribute(String attrName)、setAttribute(String attrName, Object attrValue) 等。

七、JSP脚本元素

　　 使用JSP脚本元素可以将Java代码嵌入到JSP页面里，这些Java代码将出现在由当前JSP页面生成的Servlet中，使JSP将静态内容与动态内容分离出来。脚本元素包含：

1. 表达式

表达式: 是对数据的表示，系统将其作为一个值进行计算。
语法：＜%= expression %＞
例如：<%= user.getName()%>
表达式的本质：在将JSP页面转换成Servlet后，使用out.print()将表达式的值输出。这样如果user.getName()的返回值是”liky”, 那么实际上在servlet中就将转换成out.print(“liky”);
因此这里要注意以下两点：
1) 如果表达式是调用一个方法，那么这个方法必须要有返回值，而不应是void，也就是说void getName()这样的方法是不能被调用的。
2) 在方法的后面不能有分号；例如<%=getName();%>这是不允许的。

2. 脚本

脚本：就是在<% %>里嵌入Java代码，这里的Java代码和我们一般的Java代码没有什么区别，所以每一条语句同样要以”;”结束，这和表达式是不相同的
语法：＜% code %＞
脚本的本质：就是将代码插入到Servlet的service方法中。
例如：

 <%
  if (user != null ) {
 %>
  Hello <%=user%>
 <%
  } else {
 %>
  You haven't login!
 <%
  }
 %>

转译成：

 if (user != null ) {
  out.println("Hello " + user + "");
 } else { 
  out.println("You haven't login!");
 }

3. 声明

声明：就是允许用户定义Servlet中的变量、方法
语法：＜%! code %＞

return name;}>

声明的本质：其实就是将声明的变量加入到Servlet类(在任何方法之外)，方法就成了Servlet的方法。