8月25日学习杂记

类:CLASS

类装载器:
根据一个类名,加上.CLASS后缀后在硬盘上去找,找到以后返回代码（这只是类装载器的一种方法,并不能所有装载器都是这样实现）

另一种编程思想-------面向方在的编程(AOP)
假设要在一个方法里想周用五百个类的方法,想要在五百个方法里加入一个新的方法,使用装载器就可以把这些方法全部通过这个装载类来进行

加载,然后返回一个一模一样的类,只是在类的前面可能进行了必要的处理,这样就会方便很多

1.什么是AOP?
AOP是OOP的延续，是Aspect Oriented Programming的缩写，意思是面向方面编程。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是

调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。
举例：假设有在一个应用系统中，有一个共享的数据必须被并发同时访问，首先，将这个数据封装在数据对象中，称为Data Class，同时，将

有多个访问类，专门用于在同一时刻访问这同一个数据对象。

今天主要通过装载类来实现AOP,课堂上张老师为我们演示了自定义一个类的装载器的实例，代码如下：

import java.io.*;
public class MyClassLoader extends ClassLoader
{
 private String path = null;
 public MyClassLoader(String path)
 {
  //错误检查省略
  this.path = path;
 }
  
 protected  Class findClass(String name)
 {
  try
  {
   File f = new File(path,name.substring(name.lastIndexOf('.')+1) + ".class");
   FileInputStream fis = new FileInputStream(f);
   ByteArrayOutputStream bos = new ByteArrayOutputStream();
   cypher(fis,bos);
   byte [] buf = bos.toByteArray();
   fis.close();
   bos.close();
   return defineClass(name,buf,0,buf.length);
  }catch(Exception e)
  {
   ;
  }
  return null;
 }
 
 public static void cypher(InputStream ips , OutputStream ops)
 {
  try
  {
   int b = 0;
   while((b=ips.read()) != -1)
   {
    ops.write(((byte)b) ^ 0xff);
   }
  }catch(Exception e){}
 }
 
 public static void main(String [] args) throws Exception
 {
   if(!args[0].endsWith("class"))
   {
    System.out.println(
     MyClassLoader.class.getClassLoader().getClass().getName());
    ClassLoader loader = new MyClassLoader(args[1]);
    ClassLoader ld = loader.getParent();
    while(ld != null)
    {
     System.out.println("     " + ld.getClass().getName());
     ld = ld.getParent();
    }
    Class cls = loader.loadClass(args[0]);
    System.out.println(cls.getClassLoader().getClass().getName());
    java.util.Date d = (java.util.Date)cls.newInstance();
    System.out.println(d.toString());
    return;
   }
  
   FileInputStream fis = new FileInputStream(args[0]);  
   File f = new File(args[1], new File(args[0]).getName());//不用检查目录最后是否有目录分割符
   FileOutputStream fos = new FileOutputStream(f);  
   cypher(fis,fos);
   fis.close();
   fos.close();  
 } 
}

代码设计思想：首先自定义一个类--MyClassLoader，继承抽象函数ClassLoader，重写ClassLoader的抽象方法，再在这个类中写一个对输入流

加密的小程序，以便对文件进行小的加密处理（注意：在加密程序的设计时，对输入输出参数不要写死，以便对此函数的灵活运用和扩展），

然后最主要的测试环节就是在主函数中实现了---首先需要对主函数的第一个输入参数进行判断，条件是是不是以.class结尾的，再分别根据两

种不同的情况进行相应的处理，如果不是以CLASS结尾的，说明要向上找加载类，直到找到为止，而以CLASS结尾的则进行加密的操作。

loadClass是实现委托机制所要包含的,包含有方法findClass,返回结果也和loadClass的返回结果一样的,它的执行机制是先要去找父类的装载

器,如果一直没有成功则执行findClass(找自己本身)

三种方法:
类名.CLASS                如:System.class
对象.getClass()           如:new Date().getClass()
Class.forName("类名")     如:Class.forName("java.util.Date");                                                                

                                                                                                              
关于异常:
如果父类抛出异常了,则子类不抛异常也可以;如果子类有异常,它所抛的异常必须是父类异常的子类;