肃穆丶

Java基础知识

下文将罗列在实际学习开发中遇到的容易忘记的知识点，虽然简单，但有必要记下来随时查看。

概念1：

try-catch-finally块中，finally块在以下几种情况将不会执行。

（1）finally块中发生了异常。

（2）程序所在线程死亡。

（3）在前面的代码中用了System.exit（）；

（4）关闭了CPU

概念2：

泛型是什么？

答：泛型主要解决安全和代码重用率的问题，它有自动装箱和拆箱的功能。利用与一个不确定的类型来表示任意一个类型，而且泛型通过一个反射机制可以获得这个类的一系列信息，从而提高代码的优越性。

概念3：

Java中的前期绑定和后期绑定

答：前期绑定指在编译时即能确定的类型。

后期绑定指在编译时不确定类型，在运行时确定类型。

概念4：

面向对象

答：首先：面向对象是一种思想，基于面向过程，可以将复杂问题简单化。其次:它使我们从执行者变为了指挥者，比如说公司现在就是在用面向对象的思维来思考解决问题。公司招人，说明公司在发展壮大，需要一些具备专业编程的人来做事情，从而实现公司的盈利。而我就是那个具备编程能力的对象，所以这就是一种面向对象的思想。

概念5：

static和final变量：

答：static如果没有初值，默认是0；final变量则必须赋初值。

概念6：

String，StringBuffer以及StringBuilder之间的关系

（1）线程安全

StringBuffer 线程安全
StringBuilder 线程不安全

（2）速度

一般情况下,速度从快到慢:StringBuilder>StringBuffer>String,这种比较是相对的，不是绝对的。

（3）总结

如果要操作少量的数据用 = String
单线程操作字符串缓冲区下操作大量数据 = StringBuilder
多线程操作字符串缓冲区下操作大量数据 = StringBuffer

概念7：

HTTPS和HTTP的区别

答：超文本传输协议HTTP协议被用于在Web浏览器和网站服务器之间传递信息。HTTP协议以明文方式发送内容，不提供任何方式的数据加密，如果攻击者截取了Web浏览器和网站服务器之间的传输报文，就可以直接读懂其中的信息，因此HTTP协议不适合传输一些敏感信息，比如信用卡号、密码等。为了解决HTTP协议的这一缺陷，需要使用另一种协议：安全套接字层超文本传输协议HTTPS。为了数据传输的安全，HTTPS在HTTP的基础上加入了SSL协议，SSL依靠证书来验证服务器的身份，并为浏览器和服务器之间的通信加密。

区别如下：

（1）https协议需要到ca申请证书，一般免费证书很少，需要交费。

（2）http是超文本传输协议，信息是明文传输，https 则是具有安全性的ssl加密传输协议。

（3）http和https使用的是完全不同的连接方式，用的端口也不一样，前者是80，后者是443。

（4）http的连接很简单，是无状态的；HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议，比http协议安全。

概念8：

for循环的判断

（1）for（int i=5， j=10； i<10； i++）{ } 此语句不会发生编译错误。

（2）int i;

for（i=5， int j=10； i<10；i++， j++）{ } 此语句将发生编译错误。

（3）for（int i=5，j=10； i<10，j>5； i++）{ } 此语句将发生编译错误，因为语句2的返回值必须为true或者false。

概念9：

Java数据类型

java数据类型图：
                                     ┏数值型━┳━整数型：byte short int long
              ┏基本数据类 型-------┫        ┗━浮点型：float double
              ┃                     ┣字符型：char                                          
数据类型------╋                     ┗布尔型：boolean              
              ┃                ┏类（class）
              ┗引用数据类型━━╋接口（interface）
                                ┗数组（array）

引用类型就是在变量中存储的不是值而是一个内存中的地址的数据类型。也就是说变量中存储了这个变量的值所在内存中的地址每次调用这个变量都是引用这个地址而得到真正的值所以叫引用类型。

概念10：

Java常见的异常类型：

数组角标越界，空指针异常类，算术异常，字符串转换为数字异常，类型不存在异常

概念11：

Java中常见的四种监听方式：

（1）让包含“事件源”的容器对象来担任监听者。即jb.addActionListener(this);this指代一个JFrame对象。

（2）定义内部类来担任监听者。

（3）使用匿名内部类来担任监听者。

jb.addActionListener(new ActionListener()
       {

           @Override
           public void actionPerformed(ActionEvent e) {
               // TODO Auto-generated method stub
               System.exit(0);
           }

       });

（4）使用外部类来实现监听。

概念12：

Java中为什么会出现空指针异常？

（1）所谓的指针，就是java中的对象的引用。比如String s；这个s就是指针。
（2）所谓的空指针，就是指针的内容为空，比如上面的s，如果令它指向nul了，就是空指针。
（3）所谓的空指针异常，就是一个指针是空指针，你还要去操作它，既然它指向的是空对象，它就不能使用这个对象的方法。比如上面的s假如为null,你还要用s的方法，比如s.wait(1000);那么就会产生空指针异常。

概念13:

Java是解释型还是编译型语言？

答：Java比较特殊，.java文件经过编译之后，再利用解释的方式在运行。

即，经过编译之后形成了字节码文件（.class）文件，字节码文件可以跨平台运行。其可以在任何一种操作系统中的任何一个JVM上来被解释运行，即JVM是一个字节码解释器。

所以，Java先编译，再解释。

概念14：

静态和非静态的区别：

答：（1）首先静态方法中只能有静态成员变量，不能有非静态的普通成员变量。

非静态方法中，没有限制。

（2）其次，在访问方式上。静态方法只能访问静态方法，不能访问非静态的普通方法。

非静态方法则没有限制。

概念15:

接口与抽象类的区别：

答：（1）接口里得数据成员必须是静态的，而且必须被初始化。

（2）接口里得方法必须全部为abstract（即全为抽象方法）。

16、foreach语句即增强for循环的使用。

优点：代码整洁，减少了代码量。

缺点：只可以单纯的遍历数组和集合，不可以操作。

举例如下：

[java]  view plain 
      copy 
     
 
 class Demo   
 {  
     public static void main(String[] args)   
     {  
         int[] arr=new int[10];  
         int a=0;  
         //使用普通for循环赋值  
         for(int i=0;i
         {  
               
             arr[i]=a++;  
         }  
   
         //使用高级for循环来读取数组  
         for(int i:arr)  
         {  
             System.out.println(i);  
         }  
           
     }  
 }  

17、变量的表面类型和实际类型

在Java中，只要定义变量就必然要有类型，一个变量可以有两种类型：表面类型和实际类型。表面类型是在定义的时候赋予的类型，实际类型是对象的类型。

 
     
 
    
 interface Person{  
     void run();  
       
 }  
 class People implements Person{  
   
     @Override  
     public void run() {  
         System.out.println("人在行走。。。");  
           
     }  
       
 }  
   
 public class  PicClient  
 {  
     public static void main(String[] args)  
     {  
         Person p=new People();  
         p.run();  
     }  
 }   

[java]  view plain 
      copy 
     
 
 interface Person{  
     void run();  
       
 }  
 class People implements Person{  
   
     @Override  
     public void run() {  
         System.out.println("人在行走。。。");  
           
     }  
       
 }  
   
 public class  PicClient  
 {  
     public static void main(String[] args)  
     {  
         Person p=new People();  
         p.run();  
     }  
 }   

如代码中所示：主函数中对象p的表面类型是接口Person类型的，但是其实际类型是类People类型的。

18、数据结构

各种数据结构所表示的即和特点说明如下：

（1）线性表表示可重复的无序集合，元素间具有前驱和后继次序关系；不同元素的关键字可以重复，采用序号能够识别关键字重复的数据元素。

（2）排序线性表表示可重复的排序集合，元素按关键字的大小次序排序。

（3）散列表表示不可重复的无序集合，元素关键字不可重复，元素间没有次序，不排序。

（4）二叉排序树表示不可重复的排序集合，元素关键字不重复，元素按关键字升/降序排序。

19、模板方法模式

模板方法模式就是在模板方法中按照一定的规则和顺序调用基本方法。

20、排序算法总结

(1)冒泡排序，直接插入排序以及直接选择排序算法的时间复杂度为O（n2），这些排序算法简单易懂，思路清晰，算法结构为两重循环，共进行n-1趟，每趟排序将一个元素移动到排序后的位置。数据比较和移动在相邻两个元素之间进行，每趟排序与上一趟之间存在较多重复的比较、移动和交换，因此排序效率较低。

（2）希尔排序、快速排序以及堆排序、归并排序效率较高。其共同特点为：与相邻较远的元素进行比较，数据移动距离较远，跳跃式的向目的地前进，避免了许多重复的比较和数据移动。

21、Java字节流和字符流的区别

（1）字节流操作字节（8位），字符流操作字符（2个字节，16位）。

（2）字节流不进行close操作，仍然可以输出。

字符流则必须进行close操作才能输出。因为字符流使用了缓冲区，没有close关闭字符流时，也可以使用flush操作来强行将缓冲区数据输出。

22、js里边是否存在函数重载？

答：（1）js里边不存在重载。

（2）但是可以使用别的方法来模拟函数重载的效果。利用arguments数组，判断接收到几个参数，然后执行相应的操作，实现重载的效果。

23、工厂方法模式和抽象工厂模式的区别：

答：工厂方法模式是一种极端情况的抽象工厂模式，而抽象工厂模式可以看成是工厂方法模式的一种推广。
(1)、其实工厂方法模式是用来创建一个产品的等级结构的，而抽象工厂模式是用来创建多个产品的等级结构的。工厂方法创建一般只有一个方法，创建一种产品。抽象工厂一般有多个方法，创建一系列产品。
(2)、工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。
简而言之->
工厂方法模式：     一个抽象产品类，可以派生出多个具体产品类。
                              一个抽象工厂类，可以派生出多个具体工厂类。
                              每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：     多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
                             一个抽象工厂类，可以派生出多个具体工厂类。
                              每个具体工厂类可以创建多个具体产品类的实例。

24、简单工厂模式和工厂方法模式的区别：

答：简单工厂模式将抽象工厂类去掉，并且将具体工厂类中的方法设置为静态的。这样可以直接通过类来调用方法，即不需要将该工厂创建出来。是一种工厂方法模式的弱化模式，其不符合开闭原则，但是仍然是一种极其好用的设计模式。

25、数组有没有length()方法？String有没有length()方法？
答：数组没有length()方法，有length 的属性。String 有length()方法。JavaScript中，获得字符串的长度是通过length属性得到的，这一点容易和Java混淆。

26、为什么不可以以返回值区分重载方法？

　　如下两个方法：

　　　　void f(){}

　　　　int f(){ return 1;}

只要编译器可以根据语境明确判断出语义，比如在int x = f();中，那么的确可以据此区分重载方法。不过，有时你并不关心方法的返回值，你想要的是方法调用的其他效果（这常被称为“为了副作用而调用”），这时你可能会调用方法而忽略其返回值，所以如果像下面的调用：

　　　　fun();

此时Java如何才能判断调用的是哪一个 f() 呢？别人如何理解这种代码呢？所以，根据方法返回值来区分重载方法是行不通的。

以上参考《Java 编程思想》　

27、Session的相关方法比较

答：request.getSession(false)、request.getSession(true)、request.getSession()

后两个方法效果相同，第一个方法：如果session缓存中(如果cookie不存在)，不存在session，那么返回null，而不会创建session对象。也就是说使用第一个方法不一定能够得到一个Session。

28、JavaWeb中配置错误页面的方式：

答：（1）通过jsp的page指令的属性errorpage和iserrorpage来设置。

<%@ page errorPage="b.jsp"%> <%@page isErrorPage="true" %>

（2）在web.xml中配置错误页面。

<error-page>

<error-code>404error-code>

<location>/error404.jsplocation>

error-page>

29、<%@include>和有什么不同？

答：前者为JSP静态包含指令，后者为JSP的动作标签之一：动态标签。

前者将两个JSP页面合并起来，生成一个Java文件；后者分别生成各自的java文件，最后将结果合并输出。

30、JSP相关：

（1）JSP三大指令：

page指令的常用属性有：import，language, PageEncoding, ContentType, errorPage, isErrorpPage等

include指令:静态包含。

taglib指令：导入标签库。

（2）JSP的九大内置对象：

在JSP中无需创建就可以使用的9个对象，它们是：

out（JspWriter）：等同与response.getWriter()，用来向客户端发送文本数据；

config（ServletConfig）：对应“真身”中的ServletConfig；

page（当前JSP的真身类型）：当前JSP页面的“this”，即当前对象；

pageContext（PageContext）：页面上下文对象，它是最后一个没讲的域对象；

exception（Throwable）：只有在错误页面中可以使用这个对象；

request（HttpServletRequest）：即HttpServletRequest类的对象；

response（HttpServletResponse）：即HttpServletResponse类的对象；

application（ServletContext）：即ServletContext类的对象；

session（HttpSession）：即HttpSession类的对象，不是每个JSP页面中都可以使用，如果在某个JSP页面中设置<%@page session=”false”%>，说明这个页面不能使用session。

在这9个对象中有很多是极少会被使用的，例如：config、page、exception基本不会使用。

在这9个对象中有两个对象不是每个JSP页面都可以使用的：exception、session。

（3）JSP的动作标签：

动作标签用来简化java脚本，JavaWeb提供了20个JSP的动作标签，常用的有：

include标签 forward标签以及子标签param标签用来传递参数。

（4）javaBean规范：

必须有默认的无参构造器，必须提供getter/setter方法。其中属性和成员变量是不同的。可以没有这个成员变量，但是getter/setter后面的这个就叫属性。

（5）EL表达式：

全域查找：${xxx}，全域查找名为xxx的属性，如果不存在，输出空字符串，而不是null。
选择一个查找范围：${pageScope.xxx}、${requestScope.xxx}、${sessionScope.xxx}、${applicationScope.xxx}，指定域获取属性！

EL表达式11大内置对象：pageScope，requestScope，sessionScope，applicationScope，header，headerValues，param，paramValues，initParam，cookie

pageContext（一个顶N个）

其中前10个都是Map类型的，cookie的键为String类型，Value为Cookie类型。

31、加载驱动方法

1.Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver"); 调用方法 Class.forName

2. DriverManager. registerDriver(new com.mysql.jdbc.Driver()); 通过registerDriver方法注册

3.System.setProperty("jdbc.drivers", "com.MySQL.jdbc.Driver"); 通过添加系统的jdbc.drivers属性

32、接口中的数据类型和方法类型

publicinterfaceIService {

String NAME="default";

} 的默认数据类型等价于：public static final String NAME=“default” ；

接口中的变量默认是public static final 的，方法默认是public abstract 的

33、equals和==的区别：

[java]  view plain  copy 
       
      
 public class Test{   
     public String name="abc";   
     public static void main(String[] args){   
         Test test=new Test();   
         Test testB=new Test();   
         System.out.println(test.equals(testB)+","+test.name.equals(testB.name));   
     }   
 }  

[java]  view plain 
       copy 
      
 
 public class Test{   
     public String name="abc";   
     public static void main(String[] args){   
         Test test=new Test();   
         Test testB=new Test();   
         System.out.println(test.equals(testB)+","+test.name.equals(testB.name));   
     }   
 }  

输出为：false和true

解析：equals没重写时候和==一样，比较的是对象的地址，题中new 了两个对象，所以各自地址不一样，使用equals比较为false，但是string类型中的equals方法Java默认重写了，可以比较对象里的值；两个对象指向的同一个string成员变量里的值相同，所以eqauals比较也相同。

即equals方法没重写之前也是比较地址，重写之后可以比较值是否相等。

34、Java虚拟机JVM的功能：

（1）通过 ClassLoader 寻找和装载 class 文件
（2）解释字节码成为指令并执行，提供 class 文件的运行环境
（3）进行运行期间垃圾回收
（4）提供与硬件交互的平台

35、会话跟踪技术：

（1）Cookie是Web服务器发送给客户端的一小段信息，客户端请求时，可以读取该信息发送到服务器端
（2）关闭浏览器意味着会话ID丢失，但所有与原会话关联的会话数据仍保留在服务器上，直至会话过期
（3）在禁用Cookie时可以使用URL重写技术跟踪会话

36、java 类加载器

（1）引导类加载器(bootstrap class loader):它用来加载 Java 的核心库,是用原生代码来实现的
（2）扩展类加载器(extensions class loader):它用来加载 Java 的扩展库。
（3）系统类加载器(system class loader):它根据 Java 应用的类路径(CLASSPATH)来加载 Java 类
（4）tomcat 为每个 App 创建一个 Loader,里面保存着此 WebApp 的 ClassLoader。需要加载 WebApp 下的类时,就取出 ClassLoader 来使用

37、以下代码输出结果为：（C）

[java]  view plain  copy 
      
     
 "font-size:14px;">int i = 5;  
 int j = 10;  
 System.out.println(i + ~j);  

[java]  view plain 
      copy 
     
 
 "font-size:14px;">int i = 5;  
 int j = 10;  
 System.out.println(i + ~j);  

A    Compilation error because”~”doesn’t operate on integers
B      -5
C    -6
D     15

解析：很有趣的一个符号，以前没有见过。。。。。。涉及到补码等知识，公式：~j=-j-1

38、标准输入输出流：

一般用(System.in)创建InputStream对象,表示从标准输入中获取数据,用(System.out)创建OutputStream对象，表示输出到标准输出设备中。

39、关于运算时的类型问题：

[java]  view plain  copy 
      
     
 byte b1=1,b2=2,b3,b6;   
 final byte b4=4,b5=6;   
 b6=b4+b5;   
 b3=(b1+b2);   
 System.out.println(b3+b6);  

[java]  view plain 
      copy 
     
 
 byte b1=1,b2=2,b3,b6;   
 final byte b4=4,b5=6;   
 b6=b4+b5;   
 b3=(b1+b2);   
 System.out.println(b3+b6);  

以上的代码片段叙述正确的为（C）

A     输出结果：13
B      语句：b6=b4+b5编译出错
C      语句：b3=b1+b2编译出错
D      运行期抛出异常

解析：

被final修饰的变量是常量，这里的b6=b4+b5可以看成是b6=10；在编译时就已经变为b6=10了
而b1和b2是byte类型，java中进行计算时候将他们提升为int类型，再进行计算，b1+b2计算后已经是int类型，赋值给b3，b3是byte类型，类型不匹配，编译不会通过，需要进行强制转换。
Java中的byte，short，char进行计算时都会提升为int类型。

40、HashMap解决哈希冲突的方法：

HashMap通过开放地址法解决哈希冲突错

解析：

源码程序中用到了一个重要的内部接口：Map.Entry，每个 Map.Entry 其实就是一个 key-value 对。当系统决定存储 HashMap 中的 key-value 对时，完全没有考虑 Entry 中的 value，仅仅只是根据 key 来计算并决定每个 Entry 的存储位置。Entry是数组，数组中的每个元素上挂这个一条链表。
链表法就是将相同hash值的对象组织成一个链表放在hash值对应的槽位；开放地址法是通过一个探测算法，当某个槽位已经被占据的情况下继续查找下一个可以使用的槽位。很显然我们使用的不是开放地址法。

41、并发与并行的区别与联系：

并发：在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行。

并行：在单处理器中多道程序设计系统中，进程被交替执行，表现出一种并发的外部特性；在多处理器系统中，进程不仅可以交替执行，而且可以重叠执行。在多处理器上的程序才可实现并行处理。从而可知，并行是针对多处理器而言的。并行是同时发生的多个并发事件，具有并发的含义，但并发不一定并行，也亦是说并发事件之间不一定要同一时刻发生。

42、Struts1和Struts2的区别：

从action类上分析:
1.Struts1要求Action类继承一个抽象基类。Struts1的一个普遍问题是使用抽象类编程而不是接口。
2. Struts 2 Action类可以实现一个Action接口，也可实现其他接口，使可选和定制的服务成为可能。Struts2提供一个ActionSupport基类去实现常用的接口。Action接口不是必须的，任何有execute标识的POJO对象都可以用作Struts2的Action对象。
从Servlet 依赖分析:
3. Struts1 Action 依赖于Servlet API ,因为当一个Action被调用时HttpServletRequest 和 HttpServletResponse 被传递给execute方法。
4. Struts 2 Action不依赖于容器，允许Action脱离容器单独被测试。如果需要，Struts2 Action仍然可以访问初始的request和response。但是，其他的元素减少或者消除了直接访问HttpServetRequest 和 HttpServletResponse的必要性。
从action线程模式分析:
5. Struts1 Action是单例模式并且必须是线程安全的，因为仅有Action的一个实例来处理所有的请求。单例策略限制了Struts1 Action能作的事，并且要在开发时特别小心。Action资源必须是线程安全的或同步的。
6. Struts2 Action对象为每一个请求产生一个实例，因此没有线程安全问题。（实际上，servlet容器给每个请求产生许多可丢弃的对象，并且不会导致性能和垃圾回收问题）

43、非线性数据结构和线性数据结构：

数据的逻辑结构分为线性结构和非线性结构。

常用的线性结构有：线性表，栈，队列，双队列，数组，串。

常见的非线性结构有：二维数组，多维数组，广义表，树(二叉树等)，图。

44、8中基本数据类型的默认初始值

45、Java标识符：

标识符：

用来表示变量名，方法名，类名，数组名和文件名的有效字符序列。

也就是说，任何一个变量，常量，方法，对象和类都需要有名字，这些名字就是标识符。

规定如下：

（1）标识符可以由数字、字母、下划线或美元符号等组合而成。

（2）必须以字母、下划线或者美元符号开头，不能以数字开头路。

46、静态static方法竟然可以这么玩。。。

以下程序能正确输出。

[java]  view plain  copy 
      
     
 public class TestClass {  
    private static void testMethod(){  
         System.out.println("testMethod");  
    }  
    public static void main(String[] args) {  
         ((TestClass)null).testMethod();  
    }  
 }  

[java]  view plain 
      copy 
     
 
 public class TestClass {  
    private static void testMethod(){  
         System.out.println("testMethod");  
    }  
    public static void main(String[] args) {  
         ((TestClass)null).testMethod();  
    }  
 }  

若testMethod( )方法为非静态方法，则报错：空指针异常。。。

47、Java初始化顺序：

初始化过程：

1. 初始化父类中的静态成员变量和静态代码块；

2. 初始化子类中的静态成员变量和静态代码块；

3.初始化父类的普通成员变量和代码块，再执行父类的构造方法；

4.初始化子类的普通成员变量和代码块，再执行子类的构造方法；

48、Servlet的生命周期分为5个阶段：加载、创建、初始化、处理客户请求、卸载。

(1)加载：容器通过类加载器使用servlet类对应的文件加载servlet

(2)创建：通过调用servlet构造函数创建一个servlet对象

(3)初始化：调用init方法初始化

(4)处理客户请求：每当有一个客户请求，容器会创建一个线程来处理客户请求

(5)卸载：调用destroy方法让servlet自己释放其占用的资源

49、Java中的异常相关概念：

throw用于在方法内抛出异常对象。

throws关键字用于在方法上抛出异常。

try是用于检测被包住的语句块是否出现异常，如果有异常，则抛出异常，并执行catch语句。

finally语句块是不管有没有出现异常都要执行的内容。

50、静态内部类和非静态内部类创建对象的区别：