JAVA基础8(代码剖析)

类加载全过程
 1.new 一个类对象
 2.调用类的静态成员(除了final常量)和静态方法
 3.使用java.lang.reflect包的方法对类进行发射调用
 4.当虚拟机启动,java hello 则一定会初始化hello类 说白了就是先启动main方法所在的类
 5.当初始化一个类，如果其父类木有被初始化 则先会初始化他的父类
 
类的被动引用(不会发生类的初始化)
1.当访问一个静态域时， 只有真正声明这个域的类才会被初始化
  通过子类引用父类的静态变量 不会导致子类初始化
2.通过数据定义类引用 不会触发此类的初始化
3.引用常量不会触发此类的初始化(常量在编译阶段就存了调用类的常量池中了)

被不同加载器加载的同一个类 被视为不同的类

案例 自定义类加载器

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * 自定义文件系统类加载器
 * @author 尚学堂高淇 www.sxt.cn
 *
 */
public class FileSystemClassLoader extends ClassLoader {
	
	//com.bjsxt.test.User   --> d:/myjava/  com/bjsxt/test/User.class      
	private String rootDir;
	
	public FileSystemClassLoader(String rootDir){
		this.rootDir = rootDir;
	}
	
	@Override
	protected Class<?> findClass(String name) throws ClassNotFoundException {
		Class<?> c = findLoadedClass(name);
		//应该要先查询有没有加载过这个类。如果已经加载，则直接返回加载好的类。如果没有，则加载新的类。
		if(c!=null){
			return c;
		}else{
			ClassLoader parent = this.getParent();
			try {
				c = parent.loadClass(name);	   //委派给父类加载
			} catch (Exception e) {
//				e.printStackTrace();
			}
			
			if(c!=null){
				return c;
			}else{
				byte[] classData = getClassData(name);
				if(classData==null){
					throw new ClassNotFoundException();
				}else{
					c = defineClass(name, classData, 0,classData.length);
				}
			}
			
		}
		
		return c;
		
	}
	
	private byte[] getClassData(String classname){   //com.bjsxt.test.User   d:/myjava/  com/bjsxt/test/User.class
		String path = rootDir +"/"+ classname.replace('.', '/')+".class";
		
//		IOUtils,可以使用它将流中的数据转成字节数组
		InputStream is = null;
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		try{
			is  = new FileInputStream(path);
			
			byte[] buffer = new byte[1024];
			int temp=0;
			while((temp=is.read(buffer))!=-1){
				baos.write(buffer, 0, temp);
			}
			
			return baos.toByteArray();
		}catch(Exception e){
			e.printStackTrace();
			return null;
		}finally{
			try {
				if(is!=null){
					is.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				if(baos!=null){
					baos.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
	}
}

案例：改变当前线程的加载器

/**
 * 线程上下文类加载器的测试
 * @author 尚学堂高淇 www.sxt.cn
 *
 */
public class Demo05 {
	public static void main(String[] args) throws Exception {
		ClassLoader loader = Demo05.class.getClassLoader();
		System.out.println(loader);
		
		
		ClassLoader loader2 = Thread.currentThread().getContextClassLoader();
		System.out.println(loader2);
		
		Thread.currentThread().setContextClassLoader(new FileSystemClassLoader("d:/myjava/"));
		System.out.println(Thread.currentThread().getContextClassLoader());
		
		Class<Demo01> c = (Class<Demo01>) Thread.currentThread().getContextClassLoader().loadClass("com.bjsxt.test.Demo01");
		System.out.println(c);
		System.out.println(c.getClassLoader());
		
	}
}

1.内部类仍然是一个独立的类 ，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号
2.内部类可以使用修饰符(public ,protected, default,private)
静态内部类的基本用法：
 a.静态内部类可以包含静态成员， 非静态成员
 b.静态内部类可以直接调用外部类的静态属性，静态方法，但不能调用外部类的普通属性 普通方法
 c.在不相关的类中，可以直接创建静态内部类的对象(不需要通过所在外部类)
 d.静态内部类实际上和外部类联系很少，也就是命名空间上的联系
 
成员内部类(普通内部类)
成员内部类基本用法：
  a.成员内部类就像一个成员变量一样存在于外部类中
  b.成员内部类可以访问外部类的所有成员(包含:private)
  c.成员内部类的this指内部类对象本身,要拿到外部类对象可以使用:外部类名+.this
     成员内部类的对象是一定要绑到一个外部类的对象上的，因此：创建成员内部类对象时需要持有外部类对象的引用。
     因此， 要先有外部类对象， 后有成员内部类对象 
  d.成员内部类不能有静态成员
  e.成员内部类对象的创建方式：
    外部类内部  Inner inner= new Inner()
    外部类外部   Inner inner= new Outer().Inner();

方法类基本用法：
  a.方法内部类的地位和方法的局部变量的位置类似
     因此不能修饰局部变量的修饰符也不能修饰局部内部类，譬如 public, private, protected,static transient等
  b.方法内部类只能在声明的方法内是可见的
     因此定义局部内部类之后，想用的话就要在此方法内直接实例化，记住这里顺序不能反了，一定要先声明后时候，否则编译器会说找不到
  c.方法内部类不能访问定义它的方法内的局部变量， 除非这个变量被定义为final
     本质原因；局部变量和方法内部类生命周期不一致
　d.方法内部类只能包含非静态成员
 
 
匿名内部类：
   1.匿名内部类的实例化方法：new SomeInterfaceOrClass(){}
      意思是创造一个实现(继承)了 SomeInterfaceOrClss的类对象
   2.根据声明的位置， 判断匿名内部类是成员内部类还是方法内部类
      注： 一般是 方法内部类 具备方法内部类的特征
三种使用方法；  a.继承式  b接口式   c.参数式

 案例：内部类

public class Demo02{
  public static void main(String[] args){
   Outer02.StaticNestedClass osic= new Outer02.StaticNestedClass();  //在不相关的类中，可以直接创建静态内部类的对象(不需要通过所在外部类)
   // 或者  这种方式要import  xxx.xxx.Outer02.StaticNestedClass;
    StaticNestedClass osic= new StaticNestedClass();
  }

}

class Outer02{
   int c =5;
   static int d=5;
   
   void ttt(){
     StaticNestedClass sic= new StaticNestedClass();
   }

   //静态内部类
   static class StaticNestedClass{
      int a=0;             //静态内部类可以包含静态成员， 非静态成员
	  static int b=0;      //静态内部类可以包含静态成员， 非静态成员
	  public void test(){
	    System.out.println(d); //静态内部类可以直接调用外部类的静态属性，静态方法，
		 System.out.println(c); //但不能调用外部类的普通属性 普通方法
	  }
	  
   }
   //普通内部类(成员内部类)
   private class FieldInnerClass{
    static int e=0;   //成员内部类不能有静态成员
   }
   void syaHello()
   {
      //方法内部类(局部内部类)
      class LocalClass{
	  }
   }
   //匿名内部类
   Runable runable =new Runable(){ //两个作用，定义了匿名内部类的类体，船舰了匿名内部类的一个实例
   @Overide
   public void run() {
   }
   };

}