黑马程序员——JAVA基础——多线程、反射

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

一、多线程：

    1、进程和线程的区别：

         进程：每个进程都有独立的代码和数据空间，进程间的切换会有较大的开 销，一个进程包含1--n个线程。

　　  线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序 计数器(PC)，线程切换开销小

    2、概念：

          多进程是指操作系统能同时运行多个程序

    3、Java 程序运行原理：

          Java 命令会启动 java 虚拟机，启动JVM，等于启动了一个应用程序,也就是启动了 一个进程。

           该进程会自动启动一个 “主线程”，然后主线程去调用某个类的 main 方法。

 

    4、java中实现多线程的方法：

          A：继承Thread类

               好处是:可以直接使用 Thread 类中的方法,代码简单

               弊端是:如果已经有了父类,就不能用这种方法

Eg：

<span style="font-family:Arial Black;">public class Demo1 {

public static void main(String[] args) {

// 匿名内部类
new Thread() {

public void run() {

for (int i = 0; i < 1000; i++) {

System.out.println("匿名内部类1  --- " + i);
}
}
}.start();

// 带名字的内部类
Thread t2 = new Thread() {

public void run() {

for (int i = 0; i < 1000; i++) {

System.out.println("匿名内部类2  --- " + i);

}

}

};

// 可以在调用其他方法
t2.start();
System.out.println(t2.getName());

}</span>

          B：实现Runable接口：

              好处是:即使自己定义的线程类有了父类也没关系,因为有了父类也 可以实现接口,而且接口是可以多实现的.

              弊端是:不能直接使用 Thread 中的方法需要先获取到线程对象后, 才能得到 Thread 的方法,代码相对复杂.

Eg：

<span style="font-family:Arial Black;">public class Demo2 {

public static void main(String[] args) {

// 创建Thread对象 ,把接口子类作为参数 传递进去 
new Thread(new Runnable() {

@Override

public void run() {

for (int i = 0; i < 1000; i++) {

System.out.println("实现接口的内部类  -- " + i);

}

}

}).start();

 

for (int i = 0; i < 1000; i++) {

System.out.println("  ----    main   -- " + i);

}

}

}


</span>

             

     5、图解：

二、反射

1、概述：

          JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；

             对于任意一个对象，都能够调用它的任意一个方法和属性；

           这种动态 (运行时) 获取的信息以及动态调用对象的方法的功能称为 java 语言的反射机制。

 

2、步骤：

          (获取 Class 对象,调用方法 就是 反射的步骤)

        A：要想解剖一个类,必须先要获取到该类的字节码文件对象。Class

        B：解剖使用的就是 Class 类中的方法，所以先要获取到每一个字节码文件对应的 Class 类 型的对象。

          a：加载：系统在运行程序的时候,会把 .class 文件加载到内存中,而编译期不会加载

          b：链接：

               (1)：验证：是否有正确的内部结构，并和其他类协调一致

               (2)：准备：负责为类的静态成员分配内存，并设置默认初始化值

               (3)：解析：将类的二进制数据中的符号引用替换为直接引用

         c：初始化：

         d：类的加载时机：

           (1)： 创建类的实例  

           (2)： 访问类的静态变量，或者为静态变量赋值   

           (3)： 调用类的静态方法  

           (4)： 使用反射方式来强制创建某个类或接口对应的 java.lang.Class 对象

           (5)：初始化某个类的子类 

           (6)：直接使用 java.exe 命令来运行某个主类  main      java  Start.class 

     C：三种方式：

图解：

      a: Object 类的 getClass()方法,判断两个对象是否是同一个字节码文件. 查看 equals()

      b :静态属性 class,锁对象

      c :Class 类中静态方法 forName() ,读取配置文件

         

 <span style="font-family:Arial Black;"> public class Demo2 {

            public static void main(String[] args) throws ClassNotFoundException,

            Exception {

 

         // 第一种 Class.forName();

        Class clz1 = Class.forName("cn.itcast_01.Demo");

 

         // 第二种 类名.class

         Class clz2 = Demo.class;

          System.out.println(clz1 == clz2);

 

        // 第三种 getClass()

         Demo d = new Demo();

          Class clz3 = d.getClass();

        System.out.println(clz1 == clz3);

 

       // 使用反射的方式 创建对象

 

          Object newInstance = clz1.newInstance();

         Demo d1 = (Demo) newInstance;

         System.out.println(d1);

          Demo d2 = new Demo();

         System.out.println(d2);

 

        }

  }</span>

3、动态代理：

        A ： 就是在程序运行的时候,生成一个 对象,来帮你做事情 (被代理对象的方法  ,  执行method的参数)

              B ： 步骤：a：获取一个代理对象 .Proxy.newInstance(xxx,xxx,xxx);就可以创建出来一个代理对象  

                          b：在调用 newInstance() ,是需要参数的  . 一共三个, 一个类加载器 ,一个被代理对象的接口数组,   最后一个 InvocationHandler接口的子类  

                          c：获取到 InvocationHandler子类对象  MyInvo 实现,InvocationHandler,重写 invoke(); 

              C ： 在代理对象调用方法的时候,就是在执行 invoke(xxx,xxx,xxx) ; 

              D ：第二个. method.被代理对象的方法.执行method.invoke(pi),就是在被代理对象的方法  ,pi通过构   造方法来赋值就可以了

Eg：

<span style="font-family:Arial Black;">package cn.itcast_04_agent;

import java.lang.reflect.Proxy;

/*
 * 测试 增加 和 删除 功能
 */
public class Demo {
public static void main(String[] args) {

// 创建对象 ,调用方法
PersonImpl pi = new PersonImpl();

 pi.add();
System.out.println("----------");

pi.delete();  
MyInvo myInvo = new MyInvo(pi); // 被代理对象
 
Person pp = (Person) Proxy.newProxyInstance(pi.getClass()
.getClassLoader(), pi.getClass().getInterfaces(), myInvo); // 获取到了一个代理对象 

System.out.println(" ***************************  "); 

// 调用
pp.add();  //  代理对象再 add  ,走的  MyInvo的 invoke() 

//pp.delete();

}

}</span>


<p align="center"><span style="font-family:SimSun;"><span style="text-align:center"><span style="font-size:14px;">-----------</span><a target=_blank target="_blank" href="http://www.itheima.com/"><span style="font-size:14px;">android</span></a></span><a target=_blank target="_blank" href="http://www.itheima.com/"><span style="font-size:14px;">培训</span></a><span style="text-align:center; text-indent:28px"><span style="font-size:14px;">、</span></span><a target=_blank target="_blank" href="http://www.itheima.com/" rel="nofollow" style="text-align:center; text-indent:28px"><span style="font-size:14px;">java培训</span></a><span style="text-align:center; text-indent:28px"><span style="font-size:14px;">、java学习型技术博客、期待与您交流！------------</span></span></span><span style="font-size:14px;"> 
</span></p> 

 

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------