反射的痛点，你get到了吗

反射

• 反射的概述

java给我们提供了一套api(java.lang.reflect),程序员可以使用这套api实现：
> 动态的获取内存中的运行时类；
> 动态的创建运行时类的对象；
> 动态的调用运行时类中的指定结构：属性、方法

• 反射的应用

Java反射机制提供的功能：
  在运行时判断任意一个对象所属的类
  在运行时构造任意一个类的对象
  在运行时判断任意一个类所具有的成员变量和方法
  在运行时获取泛型信息
  在运行时调用任意一个对象的成员变量和方法
  在运行时处理注解
  生成动态代理

• 相关api

java.lang.Class:代表一个类

java.lang.reflect.Method:代表类的方法
java.lang.reflect.Field:代表类的成员变量
java.lang.reflect.Constructor:代表类的构造器
… …

反射的应用举例

• 使用反射前：

//使用反射之前的例子
    @Test
    public void test1(){
        //1. 创建类的对象
        Person p1 = new Person();
        System.out.println(p1);
        //2. 调用对象的属性
        p1.age = 1;
        System.out.println("age : " + p1.age);
        //3. 调用对象的方法
        String info = p1.show();
        System.out.println("返回的信息：" + info);

        //使用如上的方式，在Person类外部不能调用Person类中私有的结构：构造器、属性、方法
    }

• 使用反射的例子

//使用反射的例子
    @Test
    public void test2() throws Exception {
        //前提：获取运行期中的运行时类：Person
        Class clazz = Person.class;
        //1. 创建类的对象
        Person p1 = (Person) clazz.newInstance();
        System.out.println(p1);

        //2. 调用对象的属性
        Field ageField = clazz.getField("age");
        ageField.set(p1,1);
        System.out.println(ageField.get(p1));


        //3. 调用对象的方法
        Method showMethod = clazz.getMethod("show");
        String info = (String) showMethod.invoke(p1);
        System.out.println("返回的信息：" + info);

    }
    @Test
    public void test3() throws Exception {
        //前提：获取运行期中的运行时类：Person
        Class clazz = Person.class;
        //使用反射，在Person类外部调用Person类中私有的结构：构造器、属性、方法
        //1.调用私有构造器:private Person(String name,int age)
        Constructor con = clazz.getDeclaredConstructor(String.class, int.class);
        con.setAccessible(true);
        Person p2 = (Person) con.newInstance("Tom",12);
        System.out.println(p2);

        //2. 调用私有属性:private String name;
        Field nameFiled = clazz.getDeclaredField("name");
        nameFiled.setAccessible(true);
        nameFiled.set(p2,"Jerry");
        System.out.println(nameFiled.get(p2));
        System.out.println(p2);

        //3. 调用私有方法：private void showNation(String nation)
        Method showNation = clazz.getDeclaredMethod("showNation", String.class);
        showNation.setAccessible(true);
        showNation.invoke(p2,"CHN");
    }

    /*
    两个疑问？
    1. 为什么在可以直接创建对象，调用相关结构的同时，还要提供一套反射的api做类似的事情呢？
       体现反射的动态性！

    2. 前面讲了封装性，反射的出现，是否与封装性矛盾呢？ 不矛盾！
       封装性：建议我们是否调用的问题
       反射：我们能否调用的问题

     */

其中Person类定义如下：

package com.atguigu.java;

/**
 * @author shkstart
 * @create 2020 上午 9:36
 */
public class Person {
    //属性
    private String name;
    public int age;

    //构造器
    public Person(){
        System.out.println("Person()...");
    }

    public Person(int age){
        this.age = age;
    }

    private Person(String name,int age){
        System.out.println("Person(String,int)...");
        this.name = name;
        this.age = age;
    }

    //方法

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String show(){
        System.out.println("name : " + name + ", age : " + age);
        return "name : " + name + ", age : " + age;
    }

    private void showNation(String nation){
        System.out.println("我来自：" + nation);
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

java.lang.Class的理解（重点）

理解

1. Class的理解：
    java源程序经过javac.exe执行以后，会生成一个或多个字节码文件。接着使用java.exe命令，将字节码文件代表的类加载（使用类的加载器）到内存中（放到方法区中缓存）。加载到内存中的类，称为运行时类。此运行时类就可以看作是Class的实例。

    2. Class的实例指向一个内存中的运行时类！
    3. 加载到内存中的运行时类，会被缓存。在整个jvm的生命周期内没有进行方法区gc时，只会存在一份！
    4. 前三种获取Class的方式需要掌握。前三种中，Class.forName()的方式更体现反射的动态性，更常用！

获取Class的几种方式

//如何获取Class的实例呢
    @Test
    public void test4() throws ClassNotFoundException {
        //方式一：调用类的静态属性：class
        Class clazz1 = Person.class;
        System.out.println(clazz1);//class com.atguigu.java.Person

        //方式二：调用对象的方法：getClass()
        Person p1 = new Person();
        Class clazz2 = p1.getClass();
        System.out.println(clazz2);

        //方式三：调用Class的静态方法：forName(String className)
        Class clazz3 = Class.forName("com.atguigu.java.Person");
        System.out.println(clazz3);

        System.out.println(clazz1 == clazz2);
        System.out.println(clazz1 == clazz3);

        //方式四：（了解）使用类的加载器
        ClassLoader classLoader = ReflectionTest.class.getClassLoader();
        Class clazz4 = classLoader.loadClass("com.atguigu.java.Person");
        System.out.println(clazz1 == clazz4);

    }

哪些类型可以有Class对象

/*
    哪些类型可以有Class对象？
    （1）class：
    外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类
    （2）interface：接口
    （3）[]：数组
    （4）enum：枚举
    （5）annotation：注解@interface
    （6）primitive type：基本数据类型
    （7）void
     */
    @Test
    public void test5(){
        Class c1 = Object.class;
        Class c2 = Comparable.class;
        Class c3 = String[].class;
        Class c4 = int[][].class;
        Class c5 = ElementType.class;
        Class c6 = Override.class;
        Class c7 = int.class;
        Class c8 = void.class;
        Class c9 = Class.class;

        int[] a = new int[10];
        int[] b = new int[100];
        Class c10 = a.getClass();
        Class c11 = b.getClass();
        // 只要元素类型与维度一样，就是同一个Class
        System.out.println(c10 == c11);
    }

3.4 类的加载过程（了解）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-deHAaYvW-1594460667867)(day28笔记.assets/1584934633934.png)]

• 过程一：加载环节：字节码文件加载到内存中，生成对应的Class的实例
• 过程二：链接环节：

• 验证：字节码是否合规，是否安全
• 准备：给当前类的static属性默认初始化赋值
• 解析：将符号引用转为直接引用

• 过程三：初始化：给当前类的static属性执行显式初始化、静态代码块中初始化。此操作在方法中执行。

类的加载器（了解）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IvaVDB9l-1594460667871)(day28笔记.assets/1584935409627.png)]

public static void main(String[] args) {
        //获取系统类加载器（应用程序类加载器）
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2
        //获取扩展类加载器
        ClassLoader extentionClassLoader = systemClassLoader.getParent();
        System.out.println(extentionClassLoader);//sun.misc.Launcher$ExtClassLoader@6d6f6e28
        //获取引导类加载器：失败，返回值为null
        ClassLoader bootstrapClassLoader = extentionClassLoader.getParent();
        System.out.println(bootstrapClassLoader);//null

        //用户自定义类默认使用的是系统类加载器
        ClassLoader loader1 = Person.class.getClassLoader();//
        System.out.println(loader1);//sun.misc.Launcher$AppClassLoader@18b4aac2
        //java核心类库使用引导类加载器
        ClassLoader loader2 = String.class.getClassLoader();
        System.out.println(loader2);//null

    }

如何读取配置文件的内容（重点）

//如何加载配置文件
    @Test
    public void test() throws Exception {
        //方式一：
        //单元测试方法中，相对路径是基于当前的module
        Properties pros = new Properties();
        FileInputStream fis = new FileInputStream("jdbc.properties");
        FileInputStream fis1 = new FileInputStream("src/jdbc1.properties");
        pros.load(fis1);

        String name = pros.getProperty("name");
        String password = pros.getProperty("password");
        System.out.println("name : " + name + ", password : " + password);


    }
    @Test
    public void test1() throws IOException {
        //方式二：使用类的加载器的方式也可以读取配置文件。默认路径是当前module的src目录下
        Properties pros = new Properties();
        InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc1.properties");
        pros.load(is);

        String name = pros.getProperty("name");
        String password = pros.getProperty("password");
        System.out.println("name : " + name + ", password : " + password);
    }

反射的应用1：创建运行时类的对象 （重点）

演示反射的应用的前提

package com.atguigu.java1;

/**
 * @author shkstart
 * @create 2020 下午 2:07
 */
public class Creature<T> {

    private String type;
    public double weight;

    private void info(){
        System.out.println("我是一种生物");
    }

    public void display(){
        System.out.println("type = " + type + ", weight = " + weight);
    }

}

/**
 * @author shkstart
 * @create 2020 下午 2:11
 */
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value() default "abc";
}

public interface MyInterface {

    void test();
}

package com.atguigu.java1;

/**
 * @author shkstart
 * @create 2020 上午 9:36
 */
@MyAnnotation
public class Person extends Creature<String> implements Comparable<Integer>,MyInterface{
    //属性
    private String name;
    public int age;
    private static String info = "我是一个人";

    //构造器
    public Person(){
        System.out.println("Person()...");
    }

    public Person(int age){
        this.age = age;
    }

    private Person(String name, int age){
        System.out.println("Person(String,int)...");
        this.name = name;
        this.age = age;
    }

    //方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @MyAnnotation(value="hello")
    public String show(){
        System.out.println("name : " + name + ", age : " + age);
        return "name : " + name + ", age : " + age;
    }

    private String showNation(String nation,int year) throws RuntimeException{
        System.out.println("我来到：" + nation + ",已经有" + year + "年了");
        return nation;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public void test() {

    }

    @Override
    public int compareTo(Integer o) {
        return 0;
    }

    public static void showInfo(){
        System.out.println("我是一个快乐的青年");
    }
}

创建运行时类的对象

public class NewInstanceTest {

    @Test
    public void test1() throws IllegalAccessException, InstantiationException {

        Class<Person> clazz = Person.class;
        /*
        newInstance():执行时，需要调用运行时类中的空参的构造器。这里需要满足：
        1. 运行时类中需要提供空参的构造器
        2. 空参构造器的访问权限要足够！通常，都设置为public
         */
        Person person = clazz.newInstance();

        System.out.println(person);
    }
}

反射的应用2：获取运行时类中的所有结构

• 了解：获取所有的属性及属性的各个部分

package com.atguigu.java2;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

import org.junit.Test;

import com.atguigu.java1.Person;

public class FieldTest {
  
  @Test
  public void test1(){
    
    Class clazz = Person.class;
    //getFields():获取到运行时类本身及其所有的父类中声明为public权限的属性
//    Field[] fields = clazz.getFields();
//
//    for(Field f : fields){
//      System.out.println(f);
//    }
    
    //getDeclaredFields():获取当前运行时类中声明的所有属性
    Field[] declaredFields = clazz.getDeclaredFields();
    for(Field f : declaredFields){
      System.out.println(f);
    }
  }
  
  //权限修饰符  变量类型  变量名
  @Test
  public void test2(){

    Class clazz = Person.class;
        Field[] declaredFields = clazz.getDeclaredFields();
        for(Field f : declaredFields){
            //1.权限修饰符
            int modifier = f.getModifiers();
//      System.out.println(modifier);
            System.out.print(Modifier.toString(modifier) + "\t");

//            //2.数据类型
            Class type = f.getType();
            System.out.print(type.getName() + "\t");

            //3.变量名
            String fName = f.getName();
            System.out.print(fName);
//
            System.out.println();
        }
  }
  
  
}

• 了解：获取所有的方法及方法的各个部分

package com.atguigu.java2;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

import org.junit.Test;

import com.atguigu.java1.Person;

public class MethodTest {

  @Test
  public void test1() {

    Class clazz = Person.class;
    // getMethods():获取到运行时类本身及其所有的父类中声明为public权限的方法
//     Method[] methods = clazz.getMethods();
//
//     for(Method m : methods){
//     System.out.println(m);
//     }

    // getDeclaredMethods():获取当前运行时类中声明的所有方法
    Method[] declaredMethods = clazz.getDeclaredMethods();
    for (Method m : declaredMethods) {
      System.out.println(m);
    }

  }

  // 注解信息
  // 权限修饰符 返回值类型 方法名(形参类型1 参数1,形参类型2 参数2,...) throws 异常类型1,...{}
  @Test
  public void test2() {
    Class clazz = Person.class;
    Method[] declaredMethods = clazz.getDeclaredMethods();
    for (Method m : declaredMethods) {
      // 1.获取方法声明的注解
      Annotation[] annos = m.getAnnotations();
      for (Annotation a : annos) {
        System.out.println(a);
      }

      // 2.权限修饰符
      System.out.print(Modifier.toString(m.getModifiers()) + "\t");

      // 3.返回值类型
      System.out.print(m.getReturnType().getName() + "\t");

      // 4.方法名
      System.out.print(m.getName());
      System.out.print("(");
      // 5.形参列表
      Class[] parameterTypes = m.getParameterTypes();
      if (!(parameterTypes == null && parameterTypes.length == 0)) {
        for (int i = 0; i < parameterTypes.length; i++) {

          if (i == parameterTypes.length - 1) {
            System.out.print(parameterTypes[i].getName() + " args_" + i);
            break;
          }

          System.out.print(parameterTypes[i].getName() + " args_" + i + ",");
        }
      }

      System.out.print(")");

      // 6.抛出的异常
      Class[] exceptionTypes = m.getExceptionTypes();
      if (exceptionTypes.length > 0) {
        System.out.print("throws ");
        for (int i = 0; i < exceptionTypes.length; i++) {
          if (i == exceptionTypes.length - 1) {
            System.out.print(exceptionTypes[i].getName());
            break;
          }

          System.out.print(exceptionTypes[i].getName() + ",");
        }
      }

      System.out.println();
    }
  }

}

• 掌握：获取其他的相关结构

package com.atguigu.java2;

import com.atguigu.java1.Person;
import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

/**
 * @author shkstart
 * @create 2020 下午 2:47
 */
public class OtherTest {

    /*
    获取当前类中的所有的构造器
     */
    @Test
    public void test1(){
        Class clazz = Person.class;
        Constructor[] cons = clazz.getDeclaredConstructors();
        for(Constructor c :cons){
            System.out.println(c);
        }
    }
    /*
    获取运行时类的父类
     */
    @Test
    public void test2(){
        Class clazz = Person.class;
        Class superclass = clazz.getSuperclass();
        System.out.println(superclass);//class com.atguigu.java1.Creature
    }
    /*
    获取运行时类的所在的包
     */
    @Test
    public void test3(){
        Class clazz = Person.class;
        Package pack = clazz.getPackage();
        System.out.println(pack);

    }
    /*
    获取运行时类的注解
     */
    @Test
    public void test4(){
        Class clazz = Person.class;
        Annotation[] annos = clazz.getAnnotations();
        for (Annotation anno : annos) {

            System.out.println(anno);
        }

    }

    /*
    获取运行时类所实现的接口
     */
    @Test
    public void test5(){
        Class clazz = Person.class;
        Class[] interfaces = clazz.getInterfaces();
        for (Class anInterface : interfaces) {

            System.out.println(anInterface);
        }

    }
    /*
    获取运行时类的带泛型的父类
     */
    @Test
    public void test6(){
        Class clazz = Person.class;
        Type genericSuperclass = clazz.getGenericSuperclass();
        System.out.println(genericSuperclass);//com.atguigu.java1.Creature<java.lang.String>
    }
    /*
    获取运行时类的父类的泛型
     */
    @Test
    public void test7(){
        Class clazz = Person.class;
        Type genericSuperclass = clazz.getGenericSuperclass();
        //如果父类是带泛型的，则一定可以强转为ParameterizedType
        ParameterizedType paramsType = (ParameterizedType) genericSuperclass;
        //获取泛型构成的数组
        Type[] arguments = paramsType.getActualTypeArguments();
        System.out.println(((Class)arguments[0]).getName());
    }
}

反射的应用3：调用运行时类中的指定的结构（重点）

• 调用运行时类中的指定的属性

//    调用运行时类中的指定的属性
    @Test
    public void test1() throws IllegalAccessException, InstantiationException, NoSuchFieldException {
        //情况一：调用非静态的属性
        //前提：① 获取当前的运行时类  ② 创建运行时类的对象
        //在上述前提下，我们可以调用运行时类中的非静态的属性
//       public int age;
        Class clazz = Person.class;
        Person p1 = (Person) clazz.newInstance();
        //获取当前运行时类中的属性
        Field ageField = clazz.getField("age");
        ageField.set(p1,10);
        int age = (int) ageField.get(p1);
        System.out.println(age);

//       private String name;

        //通用的步骤：
        //1. getDeclaredField(String fieldName):获取指定名的属性
        Field nameField = clazz.getDeclaredField("name");
        //2. setAccessible(true):保证此属性是可访问的
        nameField.setAccessible(true);
        //3. 设置：set(Object obj,Object value)
        //   获取：get(Object obj)
        nameField.set(p1,"Tom");
        String name = (String) nameField.get(p1);
        System.out.println(name);

        //情况一：调用静态的属性
        //private static String info = "我是一个人";
        Field infoField = clazz.getDeclaredField("info");
        infoField.setAccessible(true);
//        String info = (String) infoField.get(Person.class);
        String info = (String) infoField.get(null);//形参可以赋值为null
        System.out.println(info);
        infoField.set(null,"Person...");
    }

• 调用运行时类中的指定的方法

//    调用运行时类中的指定的方法
    @Test
    public void test2() throws Exception {
        //调用非静态的方法
        //private String showNation(String nation,int year)
        Class clazz = Person.class;
        Person p1 = (Person) clazz.newInstance();
        //通用的调用方法的步骤：
        //1. 获取指定的方法
        Method showNation = clazz.getDeclaredMethod("showNation", String.class, int.class);
        //2. setAccessible(true):保证此方法是可访问的
        showNation.setAccessible(true);
        //3. 调用此方法
        //invoke()方法的返回值即为对应的方法showNation()的返回值
        //对于运行时类中声明为void的方法，此时invoke()的返回值即为null
        String nation = (String) showNation.invoke(p1,"CHINA",10);//类比：String nation = p1.showNation("CHIINA",10)
        System.out.println(nation);

        //调用静态的方法
        //public static void showInfo()
        Method showInfo = clazz.getDeclaredMethod("showInfo");
        showInfo.setAccessible(true);
        Object returnVal = showInfo.invoke(null);
        System.out.println(returnVal);
    }

• 调用运行时类中的指定的构造器

//调用运行时类中的指定的构造器
    //private Person(String name, int age)
    @Test
    public void test3() throws Exception {

        Class clazz = Person.class;
        //1. 获取指定的构造器
        Constructor constructor = clazz.getDeclaredConstructor(String.class, int.class);
        //2.setAccessible(true):保证此构造器是可访问的
        constructor.setAccessible(true);
        //3.创建运行时类的对象
        Person p = (Person) constructor.newInstance("万玉坤",24);
        System.out.println(p);

    }

体会反射的动态性

public class ReflectionTest {

    //体会反射的动态性：动态的创建给定字符串对应的类的对象
    public <T> T getInstance(String className) throws Exception {

        Class clazz = Class.forName(className);

        Constructor constructor = clazz.getDeclaredConstructor();
        constructor.setAccessible(true);
        return (T) constructor.newInstance();

    }

    @Test
    public void test1() throws Exception {
        String className = "com.atguigu.java1.Person";
        Person p1 = getInstance(className);
        System.out.println(p1);
    }
    //体会反射的动态性：动态的创建指定字符串对应类的对象，并调用指定的方法
    public Object  invoke(String className,String methodName) throws Exception {
        Class clazz = Class.forName(className);
        Constructor constructor = clazz.getDeclaredConstructor();
        constructor.setAccessible(true);
        //动态的创建指定字符串对应类的对象
        Object obj = constructor.newInstance();

        Method method = clazz.getDeclaredMethod(methodName);
        method.setAccessible(true);
        return method.invoke(obj);
    }

    @Test
    public void test2() throws Exception {
        String info = (String) invoke("com.atguigu.java1.Person", "show");
        System.out.println("返回值为：" + info);

    }
}

反射的应用4：动态代理 (了解)

代理模式的理解

代理设计模式的原理: 

使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。

8.2 静态代理

• 举例1：

package com.atguigu.java;

public class StaticProxyTest {

  public static void main(String[] args) {
    Star s = new Proxy(new RealStar());
    s.confer();
    s.signContract();
    s.bookTicket();
    s.sing();
    s.collectMoney();
  }
}

interface Star {
  void confer();// 面谈

  void signContract();// 签合同

  void bookTicket();// 订票

  void sing();// 唱歌

  void collectMoney();// 收钱
}

class RealStar implements Star {//明星：被代理类

  public void confer() {
  }

  public void signContract() {
  }

  public void bookTicket() {
  }

  public void sing() {
    System.out.println("明星：歌唱~~~");
  }

  public void collectMoney() {
  }
}

class Proxy implements Star {//经纪人：代理类
  private Star real;

  public Proxy(Star real) {
    this.real = real;
  }

  public void confer() {
    System.out.println("经纪人面谈");
  }

  public void signContract() {
    System.out.println("经纪人签合同");
  }

  public void bookTicket() {
    System.out.println("经纪人订票");
  }

  public void sing() {
    real.sing();
  }

  public void collectMoney() {
    System.out.println("经纪人收钱");
  }
}

• 举例2：实现Runnable接口的方式

public interface Runnable {

    public abstract void run();
}

代理类：

public class Thread implements Runnable {
    private Runnable target;
    public Thread(Runnable target){
        this.target = target;
    }
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
}

被代理类：

class PrintNumber implements Runnable{
    public void run() {}
    
}

测试：

Runnable r = new PrintNumber();
Thread t = new Thread(r);
t.start();// ----> t.run()

public void collectMoney() {
}

}

class Proxy implements Star {//经纪人：代理类
private Star real;

public Proxy(Star real) {
  this.real = real;
}

public void confer() {
  System.out.println("经纪人面谈");
}

public void signContract() {
  System.out.println("经纪人签合同");
}

public void bookTicket() {
  System.out.println("经纪人订票");
}

public void sing() {
  real.sing();
}

public void collectMoney() {
  System.out.println("经纪人收钱");
}

}

- 举例2：实现Runnable接口的方式

```java
public interface Runnable {

    public abstract void run();
}

代理类：

public class Thread implements Runnable {
    private Runnable target;
    public Thread(Runnable target){
        this.target = target;
    }
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
}

被代理类：

class PrintNumber implements Runnable{
    public void run() {}
    
}

测试：

Runnable r = new PrintNumber();
Thread t = new Thread(r);
t.start();// ----> t.run()