Java基础知识回顾

[fengfeilong0529]

反射、 枚举、泛型、多线程、JVM内存分区等...

[fengfeilong0529]

反射：

• JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象。
• Android中一般用来调用系统@hide的类和api。

  参考：

• https://blog.csdn.net/lwl20140904/article/details/80163880
• https://www.jianshu.com/p/9be58ee20dee

  获取class的三种方式：

• Object ——> getClass()，所有类都继承自Object类，都有getClass()方法；

  Student stu1 = new Student();//这一new 产生一个Student对象，一个Class对象。  
  Class stuClass = stu1.getClass();//获取Class对象  

• 任何数据类型（包括基本数据类型）都有一个“静态”的class属性；

  Class stuClass2 = Student.class;  

• 通过Class类的静态方法：forName（String className）(最常用)；

  try {  
  //注意此字符串必须是真实路径，就是带包名的类路径，包名.类名
  Class stuClass3 = Class.forName("com.feilong.Student");  
  } catch (ClassNotFoundException e) {  
  e.printStackTrace();  
  }  

  ps：在运行期间，一个类，只有一个Class对象产生。

  三种方式常用第三种，第一种对象都有了还要反射干什么。第二种需要导入类的包，依赖太强，不导包就抛编译错误。一般都第三种，一个字符串可以传入也可写在配置文件中等多种方法。

示例：

• 反射获取构造方法并使用：

  
  //获取Class
  Class clazz = Class.forName("com.feilong.Student"); 
  //获取所有公有构造方法
  Constructor[] conArray = clazz.getConstructors();
  //获取所有构造方法（包括公有、私有、默认、受保护的）
  Constructor[] conArray = clazz.getDeclaredConstructors();
  //获取公有、无参的构造方法
  Constructor con = clazz.getConstructor(null);
  //调用构造方法(无参)  
  Object obj = con.newInstance(); 

//调用构造方法(有参)
Constructor con = clazz.getDeclaredConstructor(char.class); con.setAccessible(true);//暴力访问(忽略掉访问修饰符)
obj = con.newInstance(’男’);

- #### 反射获取成员变量并使用：

//获取Class对象
Class stuClass = Class.forName("com.feilong.Student");
//获取所有公有的字段
Field[] fieldArray = stuClass.getFields();
//获取所有的字段(包括私有、受保护、默认的) fieldArray = stuClass.getDeclaredFields();
//获取公有字段并调用 Field f = stuClass.getField("name");
//获取一个对象
Object obj = stuClass.getConstructor().newInstance();//产生Student对象–》Student stu = new Student();
//为字段设置值
f.set(obj, "刘德华");//为Student对象中的name属性赋值–》stu.name = "刘德华"
//验证
Student stu = (Student)obj;
System.out.println("验证姓名：" + stu.name);

//获取私有字段****并调用 Field f = stuClass.getDeclaredField("phoneNum");
f.setAccessible(true);//暴力反射，解除私有限定
f.set(obj, "18888889999");
System.out.println("验证电话："+ stu);

- #### 反射获取成员方法并调用：

//获取Class对象
Class stuClass = Class.forName("com.feilong.Student");
//获取所有公有方法
Method[] methodArray = stuClass.getMethods();
//获取所有的方法，包括私有的 methodArray = stuClass.getDeclaredMethods();
//获取公有的show1()方法 Method m = stuClass.getMethod("show1", String.class);
//实例化一个Student对象
Object obj = stuClass.getConstructor().newInstance();
m.invoke(obj, "刘德华");

//获取私有的show4()方法 m = stuClass.getDeclaredMethod("show4", int.class);
m.setAccessible(true);//暴力反射，解除私有限定
Object result = m.invoke(obj, 20);//需要两个参数，一个是要调用的对象（获取有反射），一个是实参
System.out.println("返回值：" + result);

[fengfeilong0529]

枚举：

• 概念：枚举是一种特殊的数据类型，之所以特殊是因为它既是一种类（class）类型却又比类型多了些特殊的约束，但是这些约束的存在也造就了枚举类型的简洁，安全性以及便捷性。创建枚举类型要使用enum关键字，隐含了所创建的类型都是java.lang.Enum类的子类（java.lang.Enum是一个抽象类）。枚举类型符合通用模式Class Enum<E extends Enum>，而E表示枚举类型的名称。枚举类型的每一个值都映射到protected Enum(String name,int ordinal)构造函数中，在这里，每个值的名称都转换成一个字符串，并且序数设置表示了此设置被创建的顺序。

  使用枚举的好处：

• 枚举型可以直接与数据库打交道，我通常使用varchar类型存储，对应的是枚举的常量名；
• switch语句支持枚举型，当switch使用int、String类型时，由于值的不稳定性往往会有越界的现象，对于这个的处理往往只能通过if条件筛选以及default模块来处理。而使用枚举型后，在编译期间限定类型，不允许发生越界的情况；
• 当你使用常量类时，往往得通过equals去判断两者是否相等，使用枚举的话由于常量值地址唯一，可以用==直接对比，性能会有提高；
• 常量类编译时，是直接把常量的值编译到类的二进制代码里，常量的值在升级中变化后，需要重新编译引用常量的类，因为里面存的是旧值。枚举类编译时，没有把常量值编译到代码里，即使常量的值发生变化，也不会影响引用常量的类；

• 枚举类编译后默认为final class，不允许继承可防止被子类修改。常量类可被继承修改、增加字段等，容易导致父类的不兼容；

  用法一：

  public enum Color {
  RED,BLUE,GREEN
  }

  用法二：

  
  enum Car {
  lamborghini(900),
  tata(2),
  audi(50),
  fiat(15),
  honda(12);
  
  private int price;
  
  Car(int p) {
      price = p;
  }
  
  int getPrice() {
      return price;
  } 
  }

public class Main { public static void main(String args[]){ System.out.println("所有汽车的价格："); for (Car c : Car.values()) System.out.println(c + " 需要 " + c.getPrice() + " 千美元。"); } }

[fengfeilong0529]

泛型:

• 概念：泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。 泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
• 参考：https://www.cnblogs.com/coprince/p/8603492.html

  特点：

• 将运行期的错误转移到编译期；
• 泛型只在编译期有效，运行时会去泛型化，即：泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型；

  泛型的使用：

• 泛型类：

  • 泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map。

    
    //此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
    //在实例化泛型类时，必须指定T的具体类型
    public class Generic<T>{ 
    //key这个成员变量的类型为T,T的类型由外部指定  
    private T key;
    
    public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
       this.key = key;
    }
    
    public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
        return key;
    }
    }

  //泛型的类型参数只能是类类型（包括自定义类），不能是简单类型 //传入的实参类型需与泛型的类型参数类型相同，即为Integer. Generic genericInteger = new Generic(123456);

  //传入的实参类型需与泛型的类型参数类型相同，即为String. Generic genericString = new Generic("key_vlaue"); Log.d("泛型测试","key is " + genericInteger.getKey()); //结果：123456 Log.d("泛型测试","key is " + genericString.getKey()); //结果：key_value

  注意：以上的可省略，省略后会根据实际传入的参数判断T 类型，如： Generic gen = new Generic(123); //此时 gen.getKey()的值为123

• 泛型接口

  • 泛型接口与泛型类的定义及使用基本相同。

  • 泛型接口常被用在各种类的生产器中，如下：

    //定义一个泛型接口
    public interface Generator<T> {
    public T next();
    }

    当实现泛型接口的类，未传入泛型实参时：

    /**
    * 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
    * 即：class FruitGenerator<T> implements Generator<T>{
    * 如果不声明泛型，如：class FruitGenerator implements Generator<T>，编译器会报错："Unknown 
    class"
    */
    class FruitGenerator<T> implements Generator<T>{
    @Override
    public T next() {
        return null;
    }
    }

    当实现泛型接口的类，传入泛型实参时：

    /**
    * 传入泛型实参时：
    * 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator<T>
    * 但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。
    * 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的 
    实参类型
    * 即：Generator<T>，public T next();中的的T都要替换成传入的String类型。
    */
    public class FruitGenerator implements Generator<String> {
    
    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
    
    @Override
    public String next() {
        Random rand = new Random();
        return fruits[rand.nextInt(3)];
    }
    }

• 泛型方法