java基础知识查漏三

喜欢ヅ旅行 2022-07-13 11:56 202阅读 0赞

一、Servlet 和Jsp的生命周期

1、Servlet生命周期  
Servlet是运行在Servlet容器（有时候也叫Servlet引擎，是web服务器和应用程序服务器的一部分，用于在发送的请求和响应之上提供网络服务，解码基于MIME的请求，格式化基于MIME的响应。常用的tomcat、jboss、weblogic都是Servlet容器）中的，其生命周期是由容器来管理。Servlet的生命周期通过java.servlet.Servlet接口中的init（）、service（）、和destroy（）方法表示。Servlet的生命周期有四个阶段：加载并实例化、初始化、请求处理、销毁。  
  
加载并实例化  
Servlet容器负责加载和实例化Servelt。当Servlet容器启动时，或者在容器检测到需要这个Servlet来响应第一个请求时，创建Servlet实例。当Servlet容器启动后，Servlet通过类加载器来加载Servlet类，加载完成后再new一个Servlet对象来完成实例化。  
  
初始化  
在Servlet实例化之后，容器将调用init（）方法，并传递实现ServletConfig接口的对象。在init（）方法中，Servlet可以部署描述符中读取配置参数，或者执行任何其他一次性活动。在Servlet的整个生命周期类，init（）方法只被调用一次。  
  
请求处理  
当Servlet初始化后，容器就可以准备处理客户机请求了。当容器收到对这一Servlet的请求，就调用Servlet的service（）方法，并把请求和响应对象作为参数传递。当并行的请求到来时，多个service（）方法能够同时运行在独立的线程中。通过分析ServletRequest或者HttpServletRequest对象，service（）方法处理用户的请求，并调用ServletResponse或者HttpServletResponse对象来响应。  
  
销毁  
一旦Servlet容器检测到一个Servlet要被卸载，这可能是因为要回收资源或者因为它正在被关闭，容器会在所有Servlet的service（）线程之后，调用Servlet的destroy（）方法。然后，Servlet就可以进行无用存储单元收集清理。这样Servlet对象就被销毁了。这四个阶段共同决定了Servlet的生命周期。  
  
2、Jsp生命周期  
Jsp页必须转换成Servlet，才能对请求进行服务，因此Jsp的底层完全是Servlet。这样看来Jsp的生命周期就包括六个阶段：转换、编译、加载并实例化、jspInit（）调用(即初始化)、\_jspService（）调用(即请求处理)、jspDestroy（）调用(即销毁)。  
  
转换：就是web容器将Jsp文件转换成一个包含了Servlet类定义的java源文件。  
编译：把在转换阶段创建的java源文件编译成类文件。  
Jsp生命周期其他的四个阶段跟Servlet生命周期相同。

3.Web服务器是通过如下步骤使用JSP来创建网页的：  
（1）客户浏览器给服务器发送一个HTTP请求；  
（2）Web服务器识别出这是一个JSP网页的请求，并且将该请求传递给JSP引擎。通过使用URL或.jsp文件来完成；  
（3）JSP引擎从磁盘中载入JSP文件，然后将它们转化为servlet。这种转化只是简单地将所有模板文本改用println()语句，并且将所有的JSP元素转化成Java代码；  
（4）JSP引擎将servlet编译成可执行类，并且将原始请求传递给servlet引擎；  
（5）Web服务器的某组件将会调用servlet引擎，然后载入并执行servlet类。在执行的过程中，servlet产生HTML格式的输出并将其内嵌与HTTP的response上交给Web服务器；  
（6）Web服务器以静态HTML网页的形式将HTTP的response返回给浏览器；  
（7）最终，Web浏览器处理HTTP response中动态产生的HTML网页，就好像在处理静态网页一样；

一般情况下，JSP引擎会检查JSP文件对应的servlet是否已经存在，并且检查JSP文件的修改日期是否早于servlet。如果JSP文件的修改时间早于对应的servlet，那么容器就可以确定JSP文件没有被修改过并且servlet有效。 这使得整个流程与其他脚本语言相比要高效快捷一些。

二、重载和重写

overload是重载，一般是用于在一个类内实现若干重载的方法，这些方法的名称相同而参数形式不同。  
重载的规则：  
1、在使用重载时只能通过相同的方法名、不同的参数形式实现。不同的参数类型可以是不同的参数类型，不同的参数个数，不同的参数顺序（参数类型必须不一样）；  
2、不能通过设置访问权限、返回类型、抛出的异常的不同来进行重载；  
3、方法的异常类型和数目不会对重载造成影响；

override是重写（覆盖）了一个方法，以实现不同的功能。一般是用于子类在继承父类时，重写（重新实现）父类中的方法。  
重写（覆盖）的规则：  
1、重写方法的参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载.

2、重写方法的访问修饰符一定要大于被重写方法的访问修饰符（public>protected>default>private）。  
3、重写的方法的返回值必须和被重写的方法的返回一致或是修改前类型的子类型；  
4、重写的方法所抛出的异常必须和被重写方法的所抛出的异常一致，或者是其子类；  
5、被重写的方法不能为private，因为在Java中，所有的private方法默认是final的，即不可继承的。否则在其子类中只是新定义了一个方法，并没有对其进行重写。  
6、静态方法不能被重写为非静态的方法（会编译出错）。

三、java的多态

1、Java实现多态有三个必要条件：继承、重写、向上转型。  
继承：在多态中必须存在有继承关系的子类和父类。  
重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。  
向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。  
只有满足了上述三个条件，我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。  
对于Java而言，它多态的实现机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。

2、在Java中有两种形式可以实现多态。继承和接口。

继承：

public class Wine {
        private String name;
     
        public String getName() {
            return name;
        }
     
        public void setName(String name) {
            this.name = name;
        }
     
        public Wine(){
        }
     
        public String drink(){
            return "喝的是 " + getName();
        }
     
        /**
         * 重写toString()
         */
        public String toString(){
            return null;
        }
    }
     
    public class JNC extends Wine{
        public JNC(){
            setName("JNC");
        }
     
        /**
         * 重写父类方法，实现多态
         */
        public String drink(){
            return "喝的是 " + getName();
        }
     
        /**
         * 重写toString()
         */
        public String toString(){
            return "Wine : " + getName();
        }
    }
     
    public class JGJ extends Wine{
        public JGJ(){
            setName("JGJ");
        }
     
        /**
         * 重写父类方法，实现多态
         */
        public String drink(){
            return "喝的是 " + getName();
        }
     
        /**
         * 重写toString()
         */
        public String toString(){
            return "Wine : " + getName();
        }
    }
     
    public class Test {
        public static void main(String[] args) {
            //定义父类数组
            Wine[] wines = new Wine[2];
            //定义两个子类
            JNC jnc = new JNC();
            JGJ jgj = new JGJ();
     
            //父类引用子类对象
            wines[0] = jnc;
            wines[1] = jgj;
     
            for(int i = 0 ; i < 2 ; i++){
                System.out.println(wines[i].toString() + "--" + wines[i].drink());
            }
            System.out.println("-------------------------------");
     
        }
    }

OUTPUT:  
Wine : JNC--喝的是 JNC  
Wine : JGJ--喝的是 JGJ

在上面的代码中JNC、JGJ继承Wine，并且重写了drink()、toString()方法，程序运行结果是调用子类中方法，输出JNC、JGJ的名称，这就是多态的表现。不同的对象可以执行相同的行为，但是他们都需要通过自己的实现方式来执行，这就要得益于向上转型了。  
基于继承实现的多态可以总结如下：对于引用子类的父类类型，在处理该引用时，它适用于继承该父类的所有子类，子类对象的不同，对方法的实现也就不同，执行相同动作产生的行为也就不同。  
如果父类是抽象类，那么子类必须要实现父类中所有的抽象方法，这样该父类所有的子类一定存在统一的对外接口，但其内部的具体实现可以各异。这样我们就可以使用顶层类提供的统一接口来处理该层次的方法。

接口：

在接口的多态中，指向接口的引用必须是指定这实现了该接口的一个类的实例程序，在运行时，根据对象引用的实际类型来执行对应的方法。  
继承都是单继承，只能为一组相关的类提供一致的服务接口。但是接口可以是多继承多实现，它能够利用一组相关或者不相关的接口进行组合与扩充，能够对外提供一致的服务接口。所以它相对于继承来说有更好的灵活性。

实例：

class A
     
    {
     
            public String show(D obj)...{
     
                   return ("A and D");
     
            }
     
            public String show(A obj)...{
     
                   return ("A and A");
     
            }
     
    }
     
    class B extends A
     
    {
     
            public String show(B obj)...{
     
                   return ("B and B");
     
            }
     
            public String show(A obj)...{
     
                   return ("B and A");
     
            }
     
    }
     
    class C extends B{}
     
    class D extends B{}
     
    class E
     
    {
     
          public static void main(String [] args)
     
         {
     
           A a1 = new A();
     
           A a2 = new B();
     
           B b = new B();
     
           C c = new C();
     
           D d = new D();
     
           System.out.println(a1.show(b));   //①
     
           System.out.println(a1.show(c));   //②
     
           System.out.println(a1.show(d));   //③
     
           System.out.println(a2.show(b));   //④
     
           System.out.println(a2.show(c));   //⑤
     
           System.out.println(a2.show(d));  // ⑥
     
           System.out.println(b.show(b));    //⑦
     
           System.out.println(b.show(c));    //⑧
     
           System.out.println(b.show(d));    //⑨   
     
          }
     
    }

答案  
① A and A  
② A and A  
③ A and D  
④ B and A  
⑤ B and A  
⑥ A and D  
⑦ B and B  
⑧ B and B  
⑨ A and D  
分析：

该问题的关键有两点：  
一是子类与父类的关系，二是重载方法的调用问题。  
子类对象可以直接当成父类对象使用，但反过来就不可以。注意当把子类对象当成父类对象使用时，子类对象将失去所有的子类特性，只保留与父类同名的属性和方法（同名方法不仅是函数名相同，而且参数类型也要一样，否则不予保留）。一个类中如果定义了重载的方法，则系统在调用方法时，会根据参数的类型自动选择调用合适的方法。

执行优先级this.show(O)>super.show(O)>this.show((super)O)>super.show((super)O)。  
1) a1.shows(b),在A中没有含有B类参数的方法，但是含有A类参数的方法，根据子类对象父类可用的原则，所以调用方法  
public String show(A obj)...\{return ("A and A");\}  
2) a1.show(c），C类是B类的子类，而B类又是A类的子类，所以C类对象可以当制作A类对象使用。结果同上。  
3) a1.show(d），根据参数类型直接调用A中的方法  
public String show(D obj)...\{  
return ("A and D");\}  
4) a2.show(b)，a2本来是一个B对象，但是将其赋给了A类变量，所以a2只保留了与父类A同名的属性和方法，也就是说a2拥有的方法包括A类中定义的所有可继承方法，并把其中的一些方法进行了重写，换成了B类中对应的方法。

也就是说a2拥有 public String show(D obj)\{return ("A and D");\}（继承自A类）和public String show(A obj)\{return ("B and A");\}（来自B类重写）两个方法。  
show(b)调用B类中的保留的与父类同名同参方法，b可以看作是A的一个对象

public String show(A obj)...\{  
return ("B and A");  
\}  
5) a2.show(c)，同上，c可以看作是A的对象  
public String show(A obj)...\{  
return ("B and A");  
\}  
6) a2.show(d)，a2只保留了与父类A同名的属性和方法。按照优先级this.show(O)>super.show(O)>this.show((super)O)>super.show((super)O)执行了父类A的show（d）方法  
public String show(D obj)...\{  
return ("A and D");  
\}  
7) b.show(b），调用B类中的  
public String show(B obj)...\{  
return ("B and B");  
\}  
8) b.show(c)，B类中没有C类参数的方法，但是有B类参数的方法，所以调用方法  
public String show(B obj)...\{  
return ("B and B");  
\}  
9) b.show(d），解释同8

四、try-catch-finally的执行顺序

public static int returnTestInt(){ 
    int a = 0;  
    try { 
    return a++;  
    } 
    catch (Exception e) 
    {}
    finally { return ++a;  
    }
    }

上述代码的执行结果是：2

分析：

1、首先执行到try里的return，但是有finally语句还要执行，于是先执行return后面的语句，例如（x++），把要返回的值保存到局部变量。  
2、执行finally语句的内容，其中有return语句，这时就会忽略try中的return，直接返回。

原理：

finally其实是仅在return 语句执行前执行，如果return 一个函数，那么会先执行函数，但如果函数内有（return）语句，那么finally就会在这个return 语句前执行。finally在catch中的return之前执行但是如果catch中有返回值而finally中也有返回值的话finally中的返回值会替换catch中的返回值，因为catch中的返回值是存放在一个临时区中。  
如果catch块有异常向外抛出，执行顺序呢：我执行我的，你抛你得异常，我finally我的语句，我俩互不干涉，你别管我啥时执行，但我一定会执行。  
关于finally，您只需记着一点：除非调用system.exit()让程序退出（也就是将调用这个程序的进程断开了、退出了这个程序）就不会执行或断电等因素致使程序停止进程终止，否则，无论任何因素，finally块都一定会执行。

五、关于final

1.final修饰变量，则等同于常量。final如果修饰的是基本类型的变量，那么这个变量就表示为一个常数，只能赋值一次，要么在定义时赋值，要么在初始化时赋值；final修饰应用类型的变量时，变量不能再次被赋值意思是变量的地址（引用）不可以被改变，而变量所指向的内容可以被改变。  
2.final修饰方法中的参数，称为最终参数。  
3.final修饰类，则类不能被继承。所以final不能修饰接口和抽象类  
4.ffinal修饰的方法能被继承（Math类里就有），但是不能够被重写，但是可以重载。