温故知新

1、Servlet生命周期

　　①、初始化阶段，调用init()方法

　　②、响应客户请求阶段，调用service()方法。由service()方法根据提交方式选择执行doGet()方法还是doPost()方法

　　③、终止阶段，调用destory()方法

 

2、Servlet容器装载Servlet的几种情况

　　1、Servlet容器启动时自动装载Servlet，实现只需要在web.xml文件中<Servlet></Servlet>间加入<loadon-startup>1</loadon-startup>，数字越小表示优先级越高

　　2、客户首次向Servlet发送请求

　　3、Servlet类文件被更新后，重新装载Servlet

 

3、Servlet与九大内置对象

　　

 

4、Servlet高级

　　获取初始化参数

　　　　在web.xml中配置Servlet，可配置一些初始化参数。而在Servlet中可通过ServletConfig接口提供的方法获取这些参数

　　　　　　<init-param>
   　　　　　　<param-name>username</param-name>
   　　　　　　<param-value>admin</param-value>
　　　　　　</init-param>

　　　　　　<init-param>
   　　　　　　<param-name>password</param-name>
   　　　　　　<param-value>123456</param-value>
　　　　　　</init-param>

 　　使用this.getInitParameter("username")获取参数

 

 

 

 

—————————————————————————————————————————————————————————————————————————————————

Java---反射

1、Class类的使用

　　类是对象，类是java.lang.Class类的实例对象

public class ClassDemo {
    public static void main(String[] args) {
        // Foo的实例对象表示
        Foo foo = new Foo();
        
        // Foo类 也是一个实例对象
        // 任何一个类都是Class的实例对象，这个实例对象有三种表示方式
        
        // 第一种方式---实际表示任何一个类都有一个隐含的静态成员变量
        Class c1 = Foo.class;
        
        // 第二种方式---已知该类的对象通过getClass方法获取
        Class c2 = foo.getClass();
        
        // 第三种方式---直接通过forName
        Class c3 = null;
        try {
            c3 = Class.forName("com.Foo");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        // 官网 c1/c2/c3 表示Foo类的类类型(class type)      c1==c2==c3
        // 可以使用 c1/c2/c3 创建该类的对象实例
        try {
            // 需要有无参数的构造方法
            Foo foo1 = (Foo) c1.newInstance();
            Foo foo2 = (Foo) c2.newInstance();
            Foo foo3 = (Foo) c3.newInstance();
            foo1.print();
            foo2.print();
            foo3.print();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}
class Foo{
    void print(){ System.out.println("Foo类对象"); }
}

2、动态加载类

　　编译时刻加载类是静态加载类　　——　　运行时刻加载类是动态加载类

　　　　编译时刻和运行时刻的区别：

　　　　　　new 创建对象 是静态加载类，在编译时刻就需要加载所有的可能使用到的类（通过动态加载类可以解决）

　　　　　　Class c = Class.forName("com.class");  是动态加载类，通过类类型创建对象（Object  obj  =  (Object)c.newInstance;）

 

3、方法的反射

public class ClassDemo {
    public static void main(String[] args) {

        Class c1 = int.class;   // int
        Class c2 = String.class;
        Class c3 = double.class;
        Class c4 = Double.class;
        Class c5 = void.class;

        System.out.println(c1.getName());   // 输出int
        System.out.println(c2.getName());   // 输出java.lang.String
        System.out.println(c2.getSimpleName());// 输出String  不包含包名的类的名称
        System.out.println(c5.getName());   // 输出void

    }
}

　　获取方法的信息

public class ClassUtil {
    /*
      打印类的信息，成员函数
    * @param  obj 该对象所属类的信息
    * */
    public static void printClassMethodMessage(Object object) {
        // 要获取类的信息  首先要获取类的类类型
        Class c = object.getClass();    // 传递的是哪个子类的对象，c就是该子类的类类型

        // 获取类名称
        System.out.println("类名：" + c.getName());
        /*
        * Method类，方法对象
        * 一个成员方法就是一个Method对象
        * getMethod()方法获取的是所有的public函数，包括父类继承而来的
        * getDeclaredMethods()获取的是所有该类自己声明的方法，不问访问权限
        * */
        Method[] ms = c.getMethods(); // c.getDeclaredMethods()
        for (int i=0; i<ms.length; i++){
            // 得到方法的返回值类型的类类型
            Class resultType = ms[i].getReturnType();
            System.out.println(resultType.getName() + " ");
            // 得到方法的名称
            System.out.println(ms[i].getName()+"(");
            // 获取参数类型--->得到参数列表的类型的类类型
            Class[] paramTypes = ms[i].getParameterTypes();
            for (Class class1 : paramTypes){
                System.out.println(class1.getName()+",");
            }
            System.out.println(")");
        }
    }
}

public class Classdemo{
    public static void main(String[] args) {
        String s = "hello";
        ClassUtil.printClassMethodMessage(s);
    }
}

　　1）如何获取某个方法

　　　　方法的名称和方法的参数列表才能唯一决定某个方法

　　2）方法反射的操作

　　　　method.invoke(对象, 参数列表)

public class MethodDemo {
    public static void main(String[] args) {
        // 要获取print(int, int)方法， 1、要获取一个方法就是获取类的信息，获取类的信息首先要获取类的类类型
        A a1 = new A();
        Class c = a1.getClass();
        // 2、获取方法  名称和参数列表来决定
        // getMethod获取的是public的方法
        // getDeclaredMethod
        try {
            //  Method m = c.getMethod("print", new Class[]{int.class, int.class});
            Method m = c.getMethod("print", int.class,int.class);
            Method m1 = c.getMethod("print", String.class, String.class);
            Method m2 = c.getMethod("print");
            // 方法的反射操作  方法如果没有返回值返回null，有返回值返回具体的返回值
            m.invoke(a1, 10, 20);
            m1.invoke(a1, "hello","WORLD");
            m2.invoke(a1 , new Object[]{});
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class A{
    public void print(){
        System.out.println("helloWorld!!!");
    }

    public void print(int a, int b){
        System.out.println(a+b);
    }

    public void print(String a, String b){
        System.out.println(a.toUpperCase() + "," +b.toLowerCase());
    }
}

4、成员变量的反射

　　获取成员变量的信息

public class ClassUtil {
    /*
      打印类的信息，成员变量
    * @param  obj 该对象所属类的信息
    * */
    public static void printClassFieldMessage(Object object) {
        // 要获取类的信息  首先要获取类的类类型
        Class c = object.getClass();    // 传递的是哪个子类的对象，c就是该子类的类类型

        // 获取类名称
        System.out.println("类名：" + c.getName());
        /*
            *  成员变量也是对象
            *  java.lang.reflect.Field
            *  Field类封装了关于成员变量的操作
            *  getField方法获取的是所有的public的成员变量信息
            *  getDeclaredFields获取的是该类自己声明的成员变量的信息
            * */
            /*Field[] fs = c.getFields();*/
        Field[] fs = c.getDeclaredFields();
        for (Field field : fs){
            // 得到成员变量的类型的类类型
            Class fieldType = field.getType();
            String typeName = fieldType.getName();
            // 得到成员变量的名称
            String fieldName = field.getName();
            System.out.println(typeName+" "+fieldName);
        }
    }
}

public class Classdemo{
    public static void main(String[] args) {
        Integer n = 1;
        ClassUtil.printClassFieldMessage(n);
    }
}

5、构造函数的反射

　　获取构造函数信息

public class ClassUtil {
    /*
      打印对象的构造函数的信息
    * */
    public static void printConMessage(Object object) {
        Class c = object.getClass();

        /*
        * 构造函数也是对象
        * java.lang.Constructor中封装了构造函数的信息
        * getConstructors获取所有的public的构造函数
        * getDeclaredConstructors得到所有构造函数
        * */
        /*Constructor[] ss = c.getConstructors();*/
        Constructor[] ss = c.getDeclaredConstructors();
        for (Constructor constructor : ss){
            System.out.println(constructor.getName() + "(");
            // 获取构造函数的参数列表--->得到的是参数列表的类类型
            Class[] paramTypes = constructor.getParameterTypes();
            for (Class class1 : paramTypes){
                System.out.println(class1.getName() + ",");
            }
        }
    }
}

public class ClassDemos{
    public static void main(String[] args) {
        ClassUtil.printConMessage("hello");
        ClassUtil.printConMessage(new Integer(1));
    }
}

6、通过反射了解集合泛型的本质

public class MethodDemo {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        ArrayList<String> arrayList1 = new ArrayList<String>();
        arrayList1.add("hello");
        Class c1 = arrayList.getClass();
        Class c2 = arrayList1.getClass();
        System.out.println(c1 == c2);   // true
        /*   反射的操作都是编译后的操作   */

        /*
        * c1==c2返回true说明编译之后集合的泛型是去泛型化的
        * Java中集合的泛型是防止错误输入的，只在编译阶段有效，
        * 绕过编译就无效了
        * 验证：可以通过方法的反射来操作，绕过编译
        * */
        try {
            Method m = c2.getMethod("add", Object.class);
            m.invoke(arrayList1, 20);
            System.out.println(arrayList1.size());
            System.out.println(arrayList1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}