Java基础

1 类的加载，连接和初始化

         当我们调用Java命令来运行某个Java程序的时候，该命令会启动你一条Java虚拟机进程，不管该Java程序启动了多少个线程，他们都处于Java虚拟机进程里，他们都使用该Java进程的内存。

          当程序运行到最后正常结束，使用System.exit();或Runtime.getRuntime().exit();代码结束，或遇到未捕获异常或错误，或所在平台强制结束jvm进程。

          当程序使用某个类时，如果类还没有加载到内存，系统会通过加载，连接，初始化三个步骤对类 进行初始化。

          类的加载：类的加载是指将类的class文件读入内存，并为之创建一个java.lang.Class对象。类加载由类加载器完成，我们可以继承ClassLoader基类创建自己的类加载器

          类的二进制数据的来源：1 本地文件系统，2 jar包中的class文件，JDBC编程时用的驱动类，通过网络

         

           类的连接：把类的二进制数据合并到jre中，有验证（是否有错误），准备（为静态属性分内存）解析(符号引用变直接引用)

           初始化：虚拟机负责对类进行初始化，主要对静态属性初始化。Java中有两种方式对静态属性初始化，1声明时初始化 2，静态块初始化

          

class Shape{// 按顺序初始化static int a = 4; static{a = 5;}}

            当程序使用任何一个类时，会保证该类和其所有父类都初始化

            类初始化时机  1  创建类的事例，2 调用类静态方法，3 访问类静态属性，通过反射创建某个类的Class对象，初始化某个类的子类，直接使用java.exe运行某个类

            对于一个final型静态属性，如果在编译时就得到值，就把该属性称为编译时常量，当使用编译时常量时，系统认为类是被动使用的，不会对类初始化

             

class Shape{// 使用变量a不会导致类初始化static int a = 4; //使用变量b，会导致类初始化static int b = new Random().nextInt();}

              类加载器 ： 负责将.class文件加载到内存，并生成Class对像，jvn中，类的全限定名和其类加载器作为类的唯一标识，类加载器分为3类。

             1 根类加载器，负责加载核心类（system，String类），没有继承ClassLoad类

              2 扩展类加载器 加载jre扩展目录中的jar包 D:\program\1.7\jre\lib\ext 目录下

              3 系统类加载器  classpath环境变量的包和类路径

              类加载机制：1全盘负责：当加载某个类时，类所依赖和引用的类全部由一个类加载器加载，2 父类委托，父类不能加载，子类才加载，3 缓存机制

               获取Class对象的三种方式

                1： Class.forName() 静态方法，参数为类的全限定名2 ： 调用类的class属性    3 ： 调用对象的getClasss()方法

                一旦获取了类所对应的class对像，就可以调用class对像的方法获取对象和类的真实信息了。 Class类提供大量实例方法获取class对象所对应类的详细信息，包含如下几类方法。

                1：访问类所包含的构造器   2：访问类所包含的方法 3 ： 访问类包含的方法 4 ： 访问类上包含的注视 5 包含的内部类， 6 外部类 7 所继承的类，接口，类的修饰符

                

public class MyTest {public static void main(String[] args) {Class<ClassTest> clazz = ClassTest.class;Constructor[] ctors = clazz.getDeclaredConstructors();System.out.println("全部构造器");for (Constructor c : ctors){System.out.println(c);}Constructor[] pctors = clazz.getConstructors();System.out.println("全部public构造器");for (Constructor c : pctors){System.out.println(c);}}}@SuppressWarnings(value="uncheked")@Deprecatedclass ClassTest{private ClassTest(){}public ClassTest(String name){System.out.println("有参构造器");}public void info(){System.out.println("无参info");}public void info(String str) {System.out.println("有参info" + str);}class Inner{}}

             使用反射生成并操作对象

              Class 对象可以类里的成分包括方法（有Method对象表示），构造器（由Constructor对象表示），Field（由Field对象表示），三个类在Java.lang.reflect包下，并实现了java.lang.reflect.Member接口，程序可以通过Method对象执行对应方法，通过Constructor对象调用构造器创建对象，通过Field对像访问并修该对象属性值

              1 创建对像 

                利用反射创建对象有两种方式，1 如果类有默认构造器，用Class对象的newInstance（）方法创建实例。2 先用Class对象获取指定的Constructor对象，在调用Constructor的newInstance（）方法创建实例。

           

public class MyTest {public static void main(String[] args) throws Exception {Class<ClassTest> clazz = ClassTest.class;//默认构造器创建事例ClassTest c1 = clazz.newInstance();System.out.println(c1);// 有参构造器创建事例Constructor<ClassTest> con = clazz.getConstructor(String.class);ClassTest c2 = con.newInstance("ba");System.out.println(c2);}}class ClassTest{private String name = "hello";public ClassTest() {// TODO Auto-generated constructor stub}public ClassTest(String name){this.name = name;}@Overridepublic String toString() {// TODO Auto-generated method stubreturn name;}}

            调用方法，Method类中invoke() 方法可以，
     

public class MyTest {public static void main(String[] args) throws Exception {Class<ClassTest> clazz = ClassTest.class;//默认构造器创建事例ClassTest c1 = clazz.newInstance();System.out.println(c1);Method m = clazz.getMethod("setName", String.class);//不检测访问权限m.setAccessible(true);m.invoke(c1, "ab"); //调用方法System.out.println(c1);}}class ClassTest{private String name = "hello";public ClassTest() {// TODO Auto-generated constructor stub}public ClassTest(String name){this.name = name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {// TODO Auto-generated method stubreturn name;}}

                  访问属性值: getXX()    setXX()

     

public class MyTest {public static void main(String[] args) throws Exception {Class<ClassTest> clazz = ClassTest.class;//默认构造器创建事例ClassTest c1 = clazz.newInstance();System.out.println(c1);Field f = clazz.getDeclaredField("name");f.setAccessible(true);f.set(c1, "fd");System.out.println(c1);}}class ClassTest{private String name = "hello";@Overridepublic String toString() {// TODO Auto-generated method stubreturn name;}}

                  m3就是将要传入的method，所以，为什么先输出before，后输出after，到这里是不是全明白了呢？这，就是JDK的动态代理整个过程，不难吧？

最后，我稍微总结一下JDK动态代理的操作过程：

1. 定义一个接口，该接口里有需要实现的方法，并且编写实际的实现类。

2. 定义一个InvocationHandler类，实现InvocationHandler接口，重写invoke()方法，且添加getProxy()方法。

总结一下动态代理实现过程：

1. 通过getProxyClass0()生成代理类。

2. 通过Proxy.newProxyInstance()生成代理类的实例对象，创建对象时传入InvocationHandler类型的实例。

3. 调用新实例的方法，即此例中的add()，即原InvocationHandler类中的invoke()方法。

public class MyTest {public static void main(String[] args) throws Exception {final Student s = new Student();Do s1 = (Do) Proxy.newProxyInstance(MyTest.class.getClassLoader(), s.getClass().getInterfaces(), new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// TODO Auto-generated method stubSystem.out.println("before");Object c =  method.invoke(s, args);System.out.println("after");return c;}});s1.dosome();}}interface Do{void dosome();}class Student implements Do{@Overridepublic void dosome() {// TODO Auto-generated method stubSystem.out.println("study");}}