1.java四大特性:抽象、继承、封装,多态

构造函数:

http://blog.csdn.net/qq_33642117/article/details/51909346

2.java数据基本类型:byte  short  int  long  double  float  char  boolean,

包装类型:Boolean,Character,Byte,Short,Integer,Long,Float,Double

Integer :整型变量的值在-128-127之间时不会new新的对象,而是直接引用常量池中的Integer对象
,当增形变量的值不在-128-127之间时直接new新对象

public class Test03 {

    public static void main(String[] args) {
Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150; System.out.println(f1 == f2);//结果为true
System.out.println(f3 == f4);//结果为false
}
}

3.静态代码块:静态代码块在类加载时执行,且只执行一次
ps:  在new对象之前加载   例:

public class StaticTest {
public static void main(String[] args){
new Test1();
new Test1();
}
}
class Test1{
public Test1(){
System.out.println("Test1构造方法");
} static{
System.out.println("我是静态代码块,先执行我!!");
} }

执行结果:

我是静态代码块,先执行我!!
Test1构造方法
Test1构造方法

静态方法是直接被类调用,不可以被对象调用:

public class Student {
public static void main(String[] args) {
// TODO Auto-generated method stub Student stu1=new Student();
stu1.method3();
Student.method1();
Student.method2();
} public static void method1(){
System.out.println("123");
}
public static void method2(){
System.out.println("456");
}
public void method3(){
System.out.println("789");
} }

4.jvm内存中栈stack 堆heap 方法区method area

栈:定义基本数据变量,对象引用,函数调用的现场保存
堆:new关键字  创建对象    GC(垃圾收集器管理)的主要区域
方法区和堆都是各个线程共享的内存区域,

String str = new String("hello");
str放在栈中,new的字符串对象放在堆中, hello放在方法区的常量池中

https://www.cnblogs.com/dingyingsi/p/3760730.html

5.StringBuffer与StringBuider区别

StringBuffer支持并发操作,线程安全,适合多线程,  作用:String是不可改变
其属性不可改变,当对String对象操作的时候可能会产生大量的中间字符串对象,造成
因此使用可以改变的StringBuffer
StringBuider 不支持并发操作,线程不安全,不适合多线程,单线程中性能高

https://www.cnblogs.com/A_ming/archive/2010/04/13/1711395.html

str.intern() 的作用:会将共享池中的字符串与外部的字符串s进行比较,如果共享池中已经有
与之相等的字符串,则不会将外部的字符串放入共享池,返回的也是共享池中的
字符串,如果不同则将外部的字符串放入共享池中,并返回其字符串的句柄

-------这样做的好处就是节省空间。

java内存分配机制:

https://www.cnblogs.com/dingyingsi/p/3760730.html 
http://blog.csdn.net/tutngfei1129287460/article/details/7383480 

例:  个人见解,不知道是否正确,如果有大神发现错误,还望指正

 //常量池中本来就不含有jva字符,所以new的jva会放入常量池,属于同一个对象,返回true  先new一个SringBuffer对象,此时单独开辟一个区域,然后调用append方法
//拼接字符串(相当于对字符串的拼接而不是new的对象了),将拼接完成的字符串放入常量池,此时new出来的对象就是需要放入常量池的,返回true
String s1 = new StringBuilder("j").append("va").toString();
System.out.println(s1.intern()==s1);//true //常量池中本身就有字符串java所以返回的并不是同一个字符串 s2.intern()返回常量池中的
//java s2为new的字符所以不相等返回false
String s2 = new StringBuilder("ja").append("va").toString();
System.out.println(s2.intern()==s2);//false //返回false因为new出来的对象单独开辟一块区域放在java堆中,与常量池中的不同和
String s3 = new StringBuilder("Programming").toString();
System.out.println(s3.intern()==s3);//false

对于字符串的存储:

public static void main(String[] args){
String s1 = "Programming";
String s2 = new String("Programming");
String s3 = "Program";
String s4 = "ming";
String s5 = "Program" + "ming";
String s6 = s3 + s4;
String s7 = new StringBuilder("Programming").toString();
String s8 = new StringBuilder("Program").append("ming").toString(); System.out.println(s1 == s2); //false s1被赋予字符串Programming后发现常量池中并没有这一字符串,就将其
//放入常量池
System.out.println(s1 == s5);//true //字符串的+操作其本质是创建了StringBuilder对象进行append操作,
//然后将拼接后的StringBuilder对象用toString方法处理成String对象,s5拼接完成后发现常量池中已经有字符串Programming
//所以s5直接取常量池中的字符串所以返回true
System.out.println(s1 == s6);//false 这个暂时没搞懂
System.out.println(s1 == s5.intern());//true
System.out.println(s1 == s6.intern());//true
System.out.println(s2 == s2.intern());//false 因为s2 new了一个字符串对象,在堆中单独开辟一块区域,并不是常量池
//中对象 所以返回false
System.out.println(s7.intern()==s7);//false //返回false因为new出来的对象单独开辟一块区域放在java堆中,与常量池中的不同
System.out.println(s8.intern()==s8);///false 这个单独执行时是true 放在这里一起执行是false,个人推测
//是因为常量池中已经存在字符串Programming,而s8是new出来的,他拼接完成之后,其地址与常量池中字符串的地址
//不同,返回false }

6.泛型:

https://www.cnblogs.com/lwbqqyumidi/p/3837629.html

7.java事务:事务通常用在数据库的操作中,在一个事务中,必须一个事物的所有操作全部成功,这个事物才算成功,如果事务中的任一步失败了,整个事务都会失败,例如:

在A--->B的转账操作中,步骤有1.A账户减去100元     2. B账户增加100元     如果A的账户已经划去了100元但是B的账户增加100元失败则整个交易取消,A的账户的100元不会扣除

http://blog.csdn.net/sinat_33536912/article/details/51200630

8.方法重写(OverRide)与重载(OverLoad):

重写一般用于继承的时候,子类继承父类的方法,并对父类的方法进行重写。

重载一般是用于在一个类内实现若干重载的方法,这些方法的名称相同而参数形式不同

https://www.cnblogs.com/lonelyDog/archive/2011/11/16/2251011.html

9.java内部类与静态内部类:都是在一个外围类内再写一个类,故称为嵌套类:

静态类与费静态类的区别:

https://www.cnblogs.com/itdev/p/5665531.html

内部类:

class OuterClass {
...
class NestedClass {
...
}
}

静态内部类:

class OuterClass {
...
class InnerClass {
...
} static class StaticNestedClass {
...
}
}

内部类与静态内部类实例化的方法有所不同:内部类要通过外部类的实例化对象进行实例化

例:

OuterClass outerObject = new OuterClass();
OuterClass.InnerClass innerObject = outerObject.new InnerClass();

静态内部类:直接实例化对象

OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();  
参考:http://blog.csdn.net/iispring/article/details/46490319

10.值传递与引用传递:

先说结论:1.基本类型传值,对形参的修改不会影响实参

2.引用类型(非基本类型)引用,同一个对象的形参和实参指向同一个地址,所以对形参的修改写会影响到实参

3.String,Integer、Double等几个及基本类型的包装类的对象不可改变,可以理解为传值,最后的操作不会修改实参对象。

(1)基本类型的变量创建出来其参数并不指向某一内存而是就等于这个值本身,

而引用类型的的变量它指向一个内存地址,内存地址中存放这个对象本身

(2)

值传递:

方法调用时,实际参数把它的值传递给对应的形式参数,函数接收的是原始值的一个copy,此时内存中存在两个相等的基本类型,即实际参数和形式参数后面方法中的操作都是对形参这个值的修改,不影响实际参数的值

引用传递:

也称为传地址。方法调用时,实际参数的引用(地址,而不是参数的值)被传递给方法中相对应的形式参数,函数接收的是原始值的内存地址;
在方法执行中,形参和实参内容相同,指向同一块内存地址,方法执行中对引用的操作将会影响到实际对象

例:

public class Javabianliang {
public static void main(String[] args){
TestClass tc = new TestClass();
Test t = new Test();
int a = 50;
//调用前
System.out.println(a);
System.out.println(t.a);
//调用后 对象的值被改变 基本类型 int的值未被改变
tc.value1(a);
System.out.println(a);
tc.value2(t);
System.out.println(t.a);
} } class TestClass{
public void value1(int a){
a = a + 1;
} public void value2(Test test){
test.a = test.a + 1;
}
}
class Test{
int a = 20;
}
https://www.zhihu.com/question/31203609

11.进程与多线程:

https://www.zhihu.com/question/25532384

多线程与多进程:http://blog.csdn.net/luoweifu/article/details/46595285

进程:是一个执行过程,动态的概念 --->会分配内存
线程:是进程的一个单元,线程是系统最小的执行单元

线程锁详解

参考:同步锁synchronized的使用详解:http://blog.csdn.net/luoweifu/article/details/46613015

1.synchronized只锁定同一个对象中的线程,不同对象的线程无法锁定。锁定的对象只能由当前线程执行,其他线程不能执行,直到当前线程被释放。

2.当一个线程访问对象的一个synchronized(this)同步代码块时,另一个线程可以访问这个对象中的非synchronized(this)代码块

3.给一个对象加锁,在run方法中可对一个对象加锁,是的同时只能由一个线程访问此被加锁的对象,其他试图访问account对象的线程将会阻塞,直到该线程访问account对象结束

4.修饰一个方法:

public synchronized void method()
{
}

在用synchronized修饰方法时要注意以下几点:

(1) synchronized关键字不能继承。

(2)在定义接口方法时不能使用synchronized关键字。

(3)构造方法不能使用synchronized关键字,但可以使用synchronized代码块来进行同步。

5.修饰一个静态方法:

静态方法是属于类的而不属于对象的。同样的,synchronized修饰的静态方法锁定的是这个类的所有对象,即此类的所有的对象都受这个同步锁的约束,这与1中的情况不同。

6.修饰一个类,作用同5一样

java中线程锁:一个对象只能有一个锁,当一个线程获得锁之后,其他线程就无法获得,直到这个线程被释放,重要作用就是:防止多个线程同时对一个数据进行处理造成错误

Thread中的sleep、wait、yield、notify、notifyall、join方法

参考:

java线程中yield(),sleep(),wait()区别详解

sleep()方法会让当前线程暂停执行指定的时间,将执行机会(cpu)让给其他线程,但是对象的锁依然保持,因此休眠时间结束后会自动恢复,且sleep方法暂停后,其他线程都可以有执行的机会,包括低优先级的线程

yield方法与sleep方法类似,但是不能指定用户暂停多长时间,且只能让通优先级的线程有执行的机会

join,使调用join方法的线程执行完毕后,其他线程才能够继续执行,即顺序执行

例:

 t1.start();
//等待t1结束,这时候t2线程并未启动
t1.join(); //t1结束后,启动t2线程
t2.start();
//等待t2结束
t2.join();

wait()、notify()、notifyall()都是是object类的方法,wait会让当前线程放弃对象的锁(线程暂停执行),进入对象等待池,只有调用对象的notify方法才能唤醒等待池中的线程进入等锁池,如果线程重新获得对象的锁就可以进入就绪状态。

notifyall方法则是将对象等待池中的所有等待那个对象的线程放到等锁池中

线程的创建方式:1.继承Thread类实现其中的run方法,在run方法中实现执行代码

public class JavaThread extends Thread{
@Override
public void run() {
boolean flag= true;
int i = 0;
while(flag){
System.out.println(getName()+"我是线程1");
if(i++==100){
break;
}
} System.out.println("我要走了");
}

此方法需要用Thread类new一个线程,然后调用start()方法启用线程

Thread th = new JavaThread();
th.setName("哈哈哈");
th.start();

2.实现runnable接口,实现其中的run方法

class Actress implements Runnable{
@Override
public void run() { boolean flag= true;
int i = 0;
while(flag){
System.out.println(Thread.currentThread().getName()+"我是线程2");
if(i++==100){
break;
}
} } }

新建线程:

Thread t1 = new Thread(new Actress());
actressTh.start();

3.实现Callable接口,该接口中的call方法可以在线程执行结束时产生一个返回值

public class JavaThread {
public static void main(String[] args) {
/**
* 采用FutureTask 实现Callable的调用,
*/
int sum=0;
CallThread ct = new CallThread(3);
//执行 Callable 方式,需要 FutureTask 实现类的支持,
FutureTask<Integer> result = new FutureTask<>(ct);
new Thread(result).start();
try {
//调用Future对象的get方法获取线程中call方法返回的数据
sum = result.get();
System.out.println(sum);
} catch (Exception e) {
e.printStackTrace();
} /**
* 采用线程池实现Callable方法的调用
*/
// List<Future<Integer>> list = new ArrayList<>();
//采用线程池,最大线程数为10
// ExecutorService service = Executors.newFixedThreadPool(10);
// for(int i=0;i<10;i++){
//service.submit()会返回一个Future对象,将Future对象存入list
// list.add(service.submit(new CallThread(3)));
// }
// int sum = 0;
// for(Future<Integer> future:list){
// try {
//调用Future对象中的get方法获取线程中call方法的返回值
// sum += future.get();
// } catch (InterruptedException | ExecutionException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// }
//System.out.println(sum);
}
} class CallThread implements Callable<Integer>{
private int Test; public CallThread(int Test) {
this.Test = Test;
}
@Override
public Integer call() throws Exception {
int sum = 0;
for(int i=1;i<=Test;i++){
sum+=i;
}
return sum;
} }

线程池:
线程池就是就像一个容器,而这个容器就是用来存放线程的,且有固定的容量
如果没有线程池,当需要一个线程来执行任务时就需要创建一个线程,我们设创建线程的时间为t1,执行线程的时间为t2,销毁线程的时间为t3。每次创建线程到线程销毁时间是t1+t2+t3

而线程池技术会将t1和t3时间的操作安排在在服务器程序的启动和结束的时间段或者一些空闲的时间段并且线程池中会始终保持有其容量大小的线程存在,当需要使用线程时就从线程池中调用,这大大节省了资源,提高了效率

[java] view
plain
 copy

 
  1. 线程池详解参考:
  2. http://blog.csdn.net/hsuxu/article/details/8985931

ExecutorService:

ExecutorService service= Executors.newFixedThreadPool(100);
方法:
execute(Runnable)  
接收一个Runnable对象作为参数,并且以异步的方式执行他,但是这和执行后不会返回执行后的结果
submit(Runnable)  
同样接收一个runnable对象作为参数,但是会返回一个Future 对象。这個 Future 对象可以用于判断 Runnable 是否结束执行。
扩展:future对象的使用及作用:简单来说就是当我们需要某一个线程A的执行结果(即要想进行下一步操作必须要A这一线程执行完毕)
才能继续执行接下来的操作时,一般的runnable方法只能调用join方法阻塞主线程B来等待线程A执行完毕,这样就造成了时间浪费无法体现多线程的优势,而使用future可以在执行线程A时同时异步执行其他不需要A的结果的线程,且可以时刻返回线程A的执行状态,看A是否执行完毕
例子:假如你突然想做饭,但是没有厨具,也没有食材。网上购买厨具比较方便,食材去超市买更放心。
实现分析:在快递员送厨具的期间,我们肯定不会闲着,可以去超市买食材。所以,在主线程里面另起一个子线程去网购厨具。
我们要想做菜,必须要厨具和食材都齐全才能开始,若购买厨具是最耗时的环节,我们不调用join方法等待购买厨具线程执行完毕就会出现厨具还没买到就开始做菜的错误
所以若使用runnable方法我们只能等待购买厨具这个线程执行完毕才能执行其他方法,而使用future对象,我们就可以在购买厨具的同时进行食材的购买

[java] view
plain
 copy

 
  1. 具体实现及功能看文章:https://www.cnblogs.com/cz123/p/7693064.html

Callable对象:
submit(Callable) 
submit(Callable)
和方法 submit(Runnable) 比较类似,但是区别则在于它们接收不同的参数类型。Callable 的实例与 Runnable 的实例很类似,但是 Callable 的 call() 方法可以返回一个结果。方法 Runnable.run() 则不能返回结果。Callable 的返回值可以从方法 submit(Callable) 返回的 Future 对象中获取。
invokeAny(...)  
invokeAll(...)  
用于线程池的关闭:
shutdown():不会立即终止线程池,而是要等所有任务缓存队列中的任务都执行完后才终止,但再也不会接受新的任务
shutdownNow():立即终止线程池,并尝试打断正在执行的任务,并且清空任务缓存队列,返回尚未执行的任务
isTerminated方法:判断所有子线程是否全部执行完毕并关闭,如果全部执行完毕则返回true。注意除非首先调用shutdown或shutdownNow,否则isTerminated永不为true。
若关闭后所有任务都已完成,则返回true。

[java] view
plain
 copy

 
  1. 详解参考:http://blog.csdn.net/bairrfhoinn/article/details/16848785

12.静态变量与实例变量

静态变量是用static修饰的变量,其为全局变量,所有的实例对象引用该变量时都指向同一地址,任一个对象对其值做出改变后,其他变量再引用就是已经改变的值

实例变量未用static修饰,为对象私有,一个对象改变其值不影响别的变量的引用

public class Javabianliang {
public static void main(String[] args){
StaticBianliang sbl = new StaticBianliang();
System.out.println("赋值前sbl.a="+sbl.a);
System.out.println("赋值前sbl.b="+sbl.b);
sbl.a = 20;
sbl.b = 30;
System.out.println("赋值后sbl.a="+sbl.a);
System.out.println("赋值后+sbl.b="+sbl.b); StaticBianliang sb2 = new StaticBianliang();
System.out.println("赋值后sb2.a="+sb2.a);
System.out.println("赋值后sb2.a="+sb2.b);
}
} class StaticBianliang{
static int a = 1;
int b = 2;
}

输出结果:

赋值前sbl.a=1
赋值前sbl.b=2
赋值后sbl.a=20
赋值后+sbl.b=30
赋值后sb2.a=20
赋值后sb2.a=2
http://blog.csdn.net/daochugundepidan/article/details/48557489

13.克隆:浅克隆与深克隆

https://www.cnblogs.com/Qian123/p/5710533.html

14.关于关键字:throws、throw、try、catch、finally分别如何使用?以及try、catch、finally的执行先后顺序

try catch通常成对存在,在try块中执行一段程序,若程序不出错则跳过catch块,若try块内抛出异常则catch块执行

public class JavaException {
public static void main(String[] args) {
try{
System.out.println("我是try块");
int i = 1/0;
System.out.println("try快出错后的代码是否执行?");
}
catch (Exception e){
System.out.println("try出错,catch块执行");
}
}
}

throw语句用来明确的抛出一个异常,执行到这一步必然会抛出异常;

throws用来声明一个方法可能抛出的异常,并不一定会抛出,只有在出现异常时才抛出;

finally块的执行在try和catch块返回值之前执行

关于finally的详细解析http://blog.csdn.net/jiasanshou/article/details/6996932/

15.TreeMap和TreeSet在排序时如何比较元素?Collections工具类中的sort()方法如何比较元素?

参考java面试题全集(上)第56题

TreeSet实现比较:

Student类中实现Comparable接口

public class Student implements Comparable<Student> {
private String name;
private int age; public Student(String name,int age) {
this.name= name;
this.age = age;
} @Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
} @Override
public int compareTo(Student o) { return this.age - o.age; //比较年龄升序
}
}

主函数测试

public class TestStudent1 {
public static void main(String[] args) {
/**
* age不能有重复的值,因为在Student类中调用了方法对age排序
* treeSet要求存放的对象所属类(即Student中)必须实现Comparable接口
* 该接口提供了比较元素的compareTo()方法,当插入元素时会回调该方法比较元素的大小。
*/
Set<Student> set = new TreeSet<>();
set.add(new Student("tonghao", 20)); //
set.add(new Student("tonghao", 21));
set.add(new Student("Bruce LEE", 60));
set.add(new Student("Bob YANG", 22)); for(Student stu : set){
System.out.println(stu);
} }
}

List实现比较

public class Student1 {
private String name;
private int age; public Student1(String name, int age) {
this.name = name;
this.age = age;
} public String getName() {
return name;
} public int getAge() {
return age;
} @Override
public String toString() {
return "Student1 [name=" + name + ", age=" + age + "]";
} }
public static void main(String[] args) {
/**
* Collections工具类的sort方法有两种重载的形式,第一种要求传入
* 的待排序容器中存放的对象比较实现Comparable接口以实现元素的比
* 较(跟上边TreeSet的实现方法一样);
*
* 这里使用的是第二种
* 第二种不强制性的要求容器中的元素必须可比较,但是要求传入
* 第二个参数,参数是Comparator接口的子类型(需要重写compare方
* 法实现元素的比较)
*/
List<Student1> list = new ArrayList<>();
list.add(new Student1("zhangsan", 21));
list.add(new Student1("lisi", 21));
list.add(new Student1("wanger", 23));
list.add(new Student1("zhengwu", 24));
Collections.sort(list, new Comparator<Student1>() { @Override
public int compare(Student1 o1, Student1 o2) {
return o1.getName().compareTo(o2.getName());
}
});
for(Student1 stu :list){
System.out.println(stu);
}
}
}

16.Java web中转发forward和重定向redirect的区别:

参考:https://www.cnblogs.com/Qian123/p/5345527.html

forward(转发):
是服务器请求资源,服务器直接访问目标地址的URL,把那个URL的响应内容读取过来,然后把这些内容再发给浏览器.浏览器根本不知道服务器发送的内容从哪里来的,因为这个跳转过程实在服务器实现的,并不是在客户端实现的所以客户端并不知道这个跳转动作,所以它的地址栏还是原来的地址.

redirect(重定向):
是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址.所以地址栏显示的是新的URL.

转发是服务器行为,重定向是客户端行为。

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

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

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

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

17.java web九大内置对象

1、request对象
request 对象是 javax.servlet.httpServletRequest类型的对象。 该对象代表了客户端的请求信息,主要用于接受通过HTTP协议传送到服务器的数据。(包括头信息、系统信息、请求方式以及请求参数等)。request对象的作用域为一次请求。

2、response对象
response 代表的是对客户端的响应,主要是将JSP容器处理过的对象传回到客户端。response对象也具有作用域,它只在JSP页面内有效。

3、session对象
session 对象是由服务器自动创建的与用户请求相关的对象。服务器为每个用户都生成一个session对象,用于保存该用户的信息,跟踪用户的操作状态。session对象内部使用Map类来保存数据,因此保存数据的格式为 “Key/value”。 session对象的value可以使复杂的对象类型,而不仅仅局限于字符串类型。

4、application对象
 application 对象可将信息保存在服务器中,直到服务器关闭,否则application对象中保存的信息会在整个应用中都有效。与session对象相比,application对象生命周期更长,类似于系统的“全局变量”。

5、out 对象
out 对象用于在Web浏览器内输出信息,并且管理应用服务器上的输出缓冲区。在使用 out 对象输出数据时,可以对数据缓冲区进行操作,及时清除缓冲区中的残余数据,为其他的输出让出缓冲空间。待数据输出完毕后,要及时关闭输出流。

6、pageContext 对象
pageContext 对象的作用是取得任何范围的参数,通过它可以获取 JSP页面的out、request、reponse、session、application 等对象。pageContext对象的创建和初始化都是由容器来完成的,在JSP页面中可以直接使用 pageContext对象。

7、config 对象
config 对象的主要作用是取得服务器的配置信息。通过 pageConext对象的 getServletConfig() 方法可以获取一个config对象。当一个Servlet 初始化时,容器把某些信息通过 config对象传递给这个 Servlet。 开发者可以在web.xml 文件中为应用程序环境中的Servlet程序和JSP页面提供初始化参数。

8、page 对象
page 对象代表JSP本身,只有在JSP页面内才是合法的。 page隐含对象本质上包含当前 Servlet接口引用的变量,类似于Java编程中的 this 指针。

9、exception 对象
exception 对象的作用是显示异常信息,只有在包含 isErrorPage="true" 的页面中才可以被使用,在一般的JSP页面中使用该对象将无法编译JSP文件。excepation对象和Java的所有对象一样,都具有系统提供的继承结构。exception 对象几乎定义了所有异常情况。在Java程序中,可以使用try/catch关键字来处理异常情况; 如果在JSP页面中出现没有捕获到的异常,就会生成 exception 对象,并把 exception 对象传送到在page指令中设定的错误页面中,然后在错误页面中处理相应的
exception 对象。

java基础知识汇总(持续更新中....)的更多相关文章

  1. Java基础知识(持续更新中...)

    1.成员变量:全局变量/字段(Field),不要称之为属性(错误)直接定义在类中,方法外面 1.类成员变量    使用static修饰的变量 2.实例成员变量 没用使用static修饰的变量 局部变量 ...

  2. Python 基础知识(持续更新中)

    内置数据类型:     整型     浮点型     字符串     布尔值     空值 None     列表 list     元组 tuple     字典 dict     集合 set   ...

  3. C++ 基础知识汇总 持续更新

    摘录一些C++面试常考问题,写一些自己的理解,花了挺长时间的,作图是真的累,欢迎来摘果子. static关键字 用于声明静态对象: 静态函数只在本文件可见.(默认是extern的) 全局静态对象:全局 ...

  4. java视频教程 Java自学视频整理(持续更新中...)

    视频教程,马士兵java视频教程,java视频 1.Java基础视频 <张孝祥JAVA视频教程>完整版[RMVB](东西网) 历经5年锤炼(史上最适合初学者入门的Java基础视频)(传智播 ...

  5. 沉淀,再出发:Java基础知识汇总

    沉淀,再出发:Java基础知识汇总 一.前言 不管走得多远,基础知识是最重要的,这些知识就是建造一座座高楼大厦的基石和钢筋水泥.对于Java这门包含了编程方方面面的语言,有着太多的基础知识了,从最初的 ...

  6. 《WCF技术剖析》博文系列汇总[持续更新中]

    原文:<WCF技术剖析>博文系列汇总[持续更新中] 近半年以来,一直忙于我的第一本WCF专著<WCF技术剖析(卷1)>的写作,一直无暇管理自己的Blog.在<WCF技术剖 ...

  7. 中国.NET:各地微软技术俱乐部汇总(持续更新中...)

    中国.NET:各地微软技术俱乐部汇总(持续更新中...)   本文是转载文,源地址: https://www.cnblogs.com/panchun/p/JLBList.html by ​史记微软. ...

  8. AngularJS进阶(十二)AngularJS常用知识汇总(不断更新中....)

    AngularJS常用知识汇总(不断更新中....) 注:请点击此处进行充电! app.controller('editCtrl',['$http','$location','$rootScope', ...

  9. 痞子衡嵌入式:史上最强i.MX RT学习资源汇总(持续更新中...)

    大家好,我是痞子衡,是正经搞技术的痞子.今天痞子衡给大家介绍的是i.MX RT学习资源. 类别 资源 简介 官方汇总 i.MXRT产品主页 恩智浦官方i.MXRT产品主页,最权威的资料都在这里,参考手 ...

  10. Pig基础学习【持续更新中】

    *本文参考了Pig官方文档以及已有的一些博客,并加上了自己的一些知识性的理解.目前正在持续更新中.* Pig作为一种处理大规模数据的高级查询语言,底层是转换成MapReduce实现的,可以作为MapR ...

随机推荐

  1. Hibernate学习5—Hibernate操作对象2

    第二节:Session 常用方法讲解 2)load和get()方法: 数据库中不存在与OID 对应的记录,Load()方法会抛出异常: load方法默认采用延迟加载,load出来的对象是一个代理类.开 ...

  2. 数据结构与算法JavaScript描述——栈的使用

    有一些问题特别适合用栈来解决.本节就介绍几个这样的例子.   1) 数制间的相互转换 可以利用栈将一个数字从一种数制转换成另一种数制.假设想将数字n 转换为以b 为基数的数字,实现转换的算法如下. 使 ...

  3. 【学步者日记】C#使用线程

    http://note.youdao.com/noteshare?id=2810300cdfa3f4d973792dcf30a31db9 System.Threading.Thread th; th ...

  4. Windows Server 2012十大实用快捷键组合

    在本文中,我们将一起体验快捷键如何在微软最新服务器操作系统中帮助用户提升工作效率. 微软推出的最新服务器操作系统比我印象中任何一款前代Windows Server产品都依赖于键盘操作——当然,这些产品 ...

  5. Array 数组类

    除了 Object 之外, Array 类型恐怕是 ECMAScript 中最常用的类型了.而且,ECMAScript 中的数组与其他多数语言中的数组有着相当大的区别.虽然 ECMAScript 数组 ...

  6. ansible自动化运维工具使用详解

    一. ansible 简介 1. ansible ansible是新出现的 自动化 运维工具 , 基于Python研发 . 糅合了众多老牌运维工具的优点实现了批量操作系统配置.批量程序的部署.批量运行 ...

  7. linux条件变量

    条件变量用于线程之间的通信,和互斥锁一起使用.条件变量用于及时通知等待的线程条件的变化,使线程不至于错过变化. 考虑下面的情况,有AB两个线程对index这个全局变量进行++,一个线程C用于判断,in ...

  8. 读《分布式一致性原理》CURATOR客户端

    创建会话 使用curator客户端创建会话和其它客户端产品有很大不同 1.使用CuratorFrameworkFactory这个工厂类的两个静态方法来创建一个客户端: public static Cu ...

  9. Python 小结

    1. Python pass是空语句,是为了保持程序结构的完整性. pass 不做任何事情,一般用做占位语句. 2.删除一个list里面的重复元素 方法一:是利用map的fromkeys来自动过滤重复 ...

  10. Django学习笔记之Class-Based-View

    Django写的多了,有些问题才逐渐认识到. 比如有一个view比较复杂,调用了很多其他的函数.想要把这些函数封装起来,怎么办? 当然,可以用注释#------view------这样将函数隔离开,这 ...