黑马程序员Java培训和Android培训Java技术四

黑马程序员
四十一
泛型方法的练习题
1编写一个泛型方法，自动将Object类型的对象转换成其他类型。
private static <T> T autoConvert(Object obj)
{
  teturn (T) obj;
}
2定义一个方法，可以将任意类型的数组中的所有元素填充为相应类型的某个对象。
private static <T> void fillArray(T[] a,T obj)
{
   for(int i=0;i<a.length;i++)
    {
        a[i]=obj;      
    }
}
3采用自定义泛型方法的方式打印出任意参数化类型的集合中的所有内容。(可以使用通配符或者泛型的方法)
--在这种情况下，前面的通配符方案要比泛型方法更有效，当一个类型变量用来表达两个参数之间或者参数和返回值之间的关系时，即同一个类型变量在方法签名的两处被使用，或者类型变量在方法体代码中也被使用而不是仅在签名的时候使用，才需要使用类型方法。
public static void printCollection(Collection<?> collection)
{
    System.out.println(collection.size());//顺带打印长度
    for(Object obj: collection)
    {
     System.out.println(obj);
     }
}
public static <T> void printCollection2(Collection<T> collection)
{
  System.out.println(collection.size());//顺带打印长度
  for(Object obj: collection)
  {
     System.out.println(obj);
  }
}
4定义一个方法，把任意参数类型的集合中的数据安全地复制到相应类型的数组中。
private static <T> void copy(Collection<T> a,T[] b)
   {
       for(int i=0;i<a.size();i++)
        {
            b[i]=
         }
      
   }
5定义一个方法，把任意参数类型的一个数组中的数据安全地复制到相应类型的另一个数组中。




类型参数的类型推断
编译器判断泛型方法的实际类型参数的过程称为类型推断，类型推断是相对于知觉推断的，其实现方法是一种非常复杂的过程。


根据调用泛型方法时实际传递的参数类型或返回值的类型来推断，具体规则如下：
当某个类型变量只在整个参数列表中的所有参数uhe返回值中的一处被应用了，那么根据调用方法时该处的实际应用类型的确定，这很容易凭着感觉推断出来，即直接根据调用方法时传递的参数类型或返回值来决定泛型参数的类型，例如：swap(new String[3],3,4)-->static<E> void swap(E[] a,int i,int i)

当某个类型变量在整个参数列表中的所有参数和返回值中的多出被应用了，如果调用方法时这多处的实际应用类型都对应同一种类型来确定，这很容易凭着感觉推断出来，例如：add(3,5)-->static<T> T add(T a,T b)

当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到不同的类型，且没有使用返回值，这时候取多个参数中的最大交集类型，例如，下面语句实际对应的类型就是Number了，编译没问题，只是运行时出问题：fill(new Integer[3],3.5f)-->static <T> void fill(T[] a,T v)

当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，并且使用返回值，这时候优先考虑返回值的类型，例如：下面的语句实际对应的类型就是Integer了，编译将报告错误，将变量x的类型改为float，对比eclipse报告的错误提示，接着再将变量x类型改为Number，则没有错误：int x=(3,3.5)-->static <T> T add(T a,T b)

参数类型的类型推断具有传递性，下面第一种情况推断实际参数类型为Object，编译没有问题，而第二种情况则根据参数化的Vector类实例将类型变量直接确定为String类型，编译将出现问题：copy (new integer[5],new String[5])-->static<T> void copy(T[] a,T[] b);copy(new vector<String>0,new Integer[5])-->static<T> void copy(Collection<T> a,T[] b)








对于前面的add方法，下面这两条语句都可以运行：
System.out.println(add(2.0f,3.5));
System.out.println(add(1.5f,"abc"));











定义泛型类型
如果类的实例对象中的多处都要用到同一个泛型参数，即这些地方引用的泛型类型要保持同一个实际类型时，这时候就要采用泛型类型的方式进行定义，也就是类级别的泛型，语法格式如下：
public class GenericDao<T>
{
  private T field1;
  public void save(T obj){}
  public T getbyld(int id){}

}

类级别的泛型是根据引用该类名时指定的类型信息来参数化类型变量的，例如，如下两种方式都可以：
---GenericDao<String> dao=null;
---new genericdao<String>();

注意：
在对泛型类型进行参数化时，类型参数的实例必须是引用类型，不能是基本类型。
当一个变量被声明为泛型时，只能被实例变量和方法调用(还有内嵌类型)而不能被静态变量和静态方法调用。因为静态成员是被所有参数化的类多共享的，所以静态成员不应该有类级别的类型参数。
问题：类中只有一个方法需要使用泛型，是使用类级别的泛型，还是使用方法级别的泛型？类级别的。

四十二

Dao: Data Access Object crud:Create Retrieval Update Delete

四十三
通过反射获得泛型的参数化类型

四十四
类加载器
什么是类加载器和类加载器的作用
简单的说类加载器就是将类字节码加载到机器中的工具。

Java虚拟机中可以安装多个类加载器，系统默认三个主要类加载器，每个类负责加载特定位置的类：BootStrap ExtClassLoader AppClassLoader
BootStrap专门调用JRE/lib/rt.jar中的jar文件； ExtClassLoader调用JRE/lib/ext/*.jar中的文件；AppClassLoader专门调用CLASSPATH指定的所有jar或目录。

类加载器也是java类，因为其他是java类的类加载器本身也要被类加载器加载，显然必须有第一个类加载器不是java类，这正是BootStrap

Java虚拟机中的所有类装载器采用具有父子关系的树形结构进行组织，在实例化每个类加载器对象时，需要为其指定一个父级类装载器对象或者默认采用系统类装载器为其父级类加载。



用eclipse的打包工具将ClassLoaderTest输出成jre/lib/ext目录下的itcast.jar包，再在eclipse中运行这个类，运行结果显示为ExtClassLoader。此时的环境状态时classpath目录由ClassLoaderTest.class，ext/itcast.jar包中也有ClassLoaderTest.class，这时候我们就需要了解类加载的具体过程和原理了。



类加载器的委托机制
当Java虚拟机要加载一个类时，到底派出哪个类加载器去加载呢？
首先当前线程的类加载器去加载线程中的第一个类。
如果类A中引用了类B,Java虚拟机将使用加载类A的类加载器来加载类B。
还可以直接调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类。

每个类加载器加载类时，又现委托给其他上级类加载器。
当所有祖宗类加载器没有加载到类，回到发起者类加载器，还加载不了，则抛出ClassNotFoundException，不是灾区找发起者类加载器的儿子，因为没有getChild方法，即使有，那么多个儿子，找哪一个呢？
对着类加载器的层次结构图和委托加载原理，解释先前将ClassLoaderTest输出成jre/lib/ext目录下的itcast.jar包中后，运行结果为ExtClassLoader的原因。


每个ClassLoader本身只能分别加载特定位置和目录中的方法，但它们可以委托其他的类加载器去加载类，这就是类加载器的委托模式。类加载器一级级委托到BootStrap类加载器，当BootStrap无法加载当前所要加载的类时，然后才一级级回退到子孙类加载器去进行真正的加载。当回退到最初的类装载器时，如果它自己也不能完成类的装载，那就应该报告ClassNotFoundException异常。

有一道面试题，能不能自己写个类叫做java.lang.System，为了不让我们写System类，类加载器采用委托机制，这样可以保证爸爸优先，也就是总是使用爸爸们能找到的类，这样总是使用java系统提供的System。

四十五
编写自己的类加载器
知识讲解：
自定义的类加载器必须继承ClassLoader
loadClass方法与findClass方法
defineClass方法

编程步骤：
编写一个对文件内容进行简单加密的程序
编写了一个自己的类装载器，可实现对加密过的类进行装载和解密。
编写一个程序调用类加载器加载类，在源程序中不能用该类名定义引用变量，因为编译器无法识别这个类。程序中可以除了使用ClassLoader.load方法之外，还可以使用设置线程的上下文类加载器或者系统类加载器，然后再使用Class.forName。

实验步骤：
对不带包名的class文件进行加密，加密结果存放到另外一个目录，例如：java MyClassLoader MyTest.class F:\itcast
运行加载类的程序，结果能够被正常加载，但打印出来的类加载器名称为AppClassLoader: java MyClassLoader MyTest F:\itcast
用加密后的类文件替换CLASSPATH环境下的类文件，再执行上一步操作就出问题了，错误说明是AppClassLoader类装载器装载失败。
删除CLASSPATH环境下的类文件，再执行上一步操作就没问题了。

四十六
有包名的类不能调用无包名的类

四十七
子类不能比父类抛出更广泛的异常。

四十八
一个类加载器的高级问题分析
编写一个能打印出自己的类加载器名称和当前类加载器的父子结构关系链的MySerclet，正常发布后，看到打印结果为WebAppClassloader。
把MyServelet.class文件打jar包，放到ext目录中，重启tomcat，发现找不到HttpServlet的错误。
把servlet.jar也放到ext目录中，问题解决了，打印的结果是ExeclassLoader。
父级类加载器加载的类无法引用只能被子级类加载器加载的类。

注：有个java邮件的项目中出现了类加载器的问题。

tomcat是个很大的java程序。

四十九
代理类的概念与作用
生活中的代理
武汉人从武汉的代理商手中买联想电脑和直接跑到北京传智播客旁边来找联想总部买电脑，你觉得最终的主体业务目标有什么区别吗？基本上一样吧，都解决了核心问题，但是，一点区别都没有吗？从代理商那里买的一点好处都没有吗？

程序中的代理
要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如，异常处理，日志，计算方法的运行时间，事务管理，等等，你准备如何做？
编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能的代码。
如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是使用目标类，还是代理类，这样以后很容易切换，臂如，想要日志功能时就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段时间后，又想去掉系统功能也很容易。




AOP
系统中存在交叉业务，一个交叉业务就是要切入到系统中的一个方面，如下所示：
                   安全  事务   日志
  StudentService  ---|----|------|-----
  CourseService   ---|----|------|-----
  MiscService     ---|----|------|-----

用具体的程序代码描述交叉业务：
method1            method2             method3
{                   {                   {
-------------------------------------------------切面
....          ....        ....
-------------------------------------------------切面
  }                    }                   }
交叉业务的编程问题即为面向方向的编程(Aspect oriented proogram.简称AOP)，AOP的目标就是要使交叉业务模块化。可以采用将切面代码移动到原始方法的周围，这与直接在方法中编写切面代码的运行效果是一样的，如下所示：

--------------------------------------------------切面
  func1          func2             func3
  {              {                  {
   .....          ....               ....
  
   }              }                  }
---------------------------------------------------切面
使用代理技术正好可以解决这种问题，代理是实现AOP功能的核心和关键技术。         




动态代理技术
要为系统中的各种代理接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方式，将是一件非常麻烦的事情！写成百上千个代理类，是不是太累！
JVM可以在运行期间动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类。
JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。
CGLIB(Code Generation Library)库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么可以使用CGLIB库。CGLib (Code Generation Library) 是一个强大的,高性能,高质量的Code生成类库。它可以在运行期扩展Java类与实现Java接口。Hibernate用它来实现PO字节码的动态生成。CGLib 比 Java 的 java.lang.reflect.Proxy 类更强的在于它不仅可以接管接口类的方法，还可以接管普通类的方法。


代理类的各个方法中通常除了要调用目标的的相应方法和对外返回目标返回结果外，还可以在代理方法中的如下四个位置加上系统功能代码：
1在调用目标方法之前
2在调用目标方法之后
3在调用目标方法前后
4在处理目标方法异常的catch块中

五十
分析JVM动态生成的类
创建实现了Collection接口的动态方法和查看其名称，分析Proxy.getProxyClass方法的各个参数。
编码列出动态类中的所有构造方法和参数签名
编码列出动态类中的所有方法和参数签名
创建动态类的实例对象
1用反射获得构造方法
2编写一个最简单的InvocationHandler类
3调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传进去。
4打印创建的对象和调用对象的没有返回值的方法和getClass方法，演示调用其他有返回值的方法报告了异常。
5将创建动态类的实例对象的代理改成匿名内部类的形式编写，锻炼大家习惯匿名内部类。
总结思考：让jvm创建动态类及其实例对象，需要给它提供哪些信息？
三个方面：
1生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知；
2产生的类字节码必须有一个关联的类加载器对象；
3生成的类中的方法的代码是怎样的，也得由我们提供。把我们写的代码写在一个约定好了接口对象的方法中，把对象传给它，它调用我的方法，即相当于插入了我的代码。提供执行代码的对象就是那个InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的。在上面的InvocationHandler对象的invoke方法中加一点代码，就可以看到这些代码被调用运行了。

用Proxy.newInstance方法直接一步就创建出代理对象。



1Class clazz=Proxy.getProxyClass(ProxyTest.class.getClassLoader(),Collection.class);
System.out.println(clazz.getName());
2     Method[] methods=clazz.getMethods();
      for(Method m: methods)
      {
         System.out.println(m.getName());
       }
   System.out.println("-----------------------");
3





注:Proxy在API上的内容:
public class Proxyextends Objectimplements SerializableProxy 提供用于创建动态代理类和实例的静态方法，它还是由这些方法创建的所有动态代理类的超类。

创建某一接口 Foo 的代理：

     InvocationHandler handler = new MyInvocationHandler(...);
     Class proxyClass = Proxy.getProxyClass(
         Foo.class.getClassLoader(), new Class[] { Foo.class });
     Foo f = (Foo) proxyClass.
         getConstructor(new Class[] { InvocationHandler.class }).
         newInstance(new Object[] { handler });
或使用以下更简单的方法：
     Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
                                          new Class[] { Foo.class },
                                          handler);