黑马程序员_java高新技术(1)枚举、反射、内省

------- android培训、java培训、期待与您交流！ ----------

JDK 5.0
静态导入，自动装箱拆箱，增强for循环，
可变参数，枚举，泛型，元数据

day01***Eclipse/枚举
*Workspace与project
    会切换工作间与导入项目
*Perspective(透视图)与view
windows下有reset perspective重置透视图
*设置整个workspace的javac与java
*设置单个工程的javac与java
    
*快捷键的绑定与代码模块
*利用快捷键提高工作效率
    在应用中具体举例讲解。
@@快捷键
Ctrl+1        快速改正

Alt+选中    看源码(没有源码则粘贴源码进去，文件夹-External Folder),(java)文件-External File)
Alt+/        联想功能
Alt+左右    看源码时的前后顺序
Alt+上下    移动选中的代码
ctrl+Alt+上下    复制选中的代码
ctrl+T        查看类的继承关系

f2        f2进入提示框,查看方法的说明

ctrl+shift+X/大写    ctrl+shift+Y/小写
ctrl+shift+f 格式化format代码
ctrl+shift+o 导包

ctrl+shift+/ 加注释
ctrl+shift+\ 除注释

ctrl+shift+L    查看所有快捷键
ctrl+shift+T    直接看源码(自己输入)

Alt+shift+s 自动生成一些源代码source等
选中代码Alt+shift+M ==> extract Method 提取方法
@@断点
f5：step into跳入
f6：step over跳过
f7：step return 跳回

drop to fram ：跳到当前方法的第一行
resume：跳到下一个断点(没有下一个则运行完整个程序)
watch：观察变量或表达式的值

断点注意问题：
1，断点调试完成后，要在breakpoints视图中清除所有断点
2，断点调试完成后，一定记得结束运行断点的JVM
@@eclipse的使用技巧

02 eclipce及ide开发工具的简介
myeclipse是eclipse的插件，使eclipse可以进行web项目开发
现在myeclipse整合了eclipse，包含了eclipse工具。
myeclipse是用java开发的

进程中的javaw.exe 开启的就是图形化的java控制台，而不像java.exe开启的是dos命令行。
专业术语(面试)
java ee
ide--> Integrated Development Environment 集成开发环境
jms
jmx
jndi

03 eclipse工程管理与快捷键配置。
  window--preferences常用

一个相对独立的项目就是一个工程，一个工程中涉及的多个java文件，资源文件等用一个工程进行管理。
   开发工具能对所有的源文件集中管理，记住每个源文件的位置和相互关系。
   工程中有哪几个源文件，启动类是哪个，启动参数设置等配置信息在工程中都记录。
   一个workspace可以包含多个project。如果要为eclipse再配置一套环境选项，可以再创建一个work是。
资源文件就是配置文件。

file--switch workspace 切换工作间
一个工作间有自己的特色环境配置，其下的工程与工作间的环境配置一样。

java工程的包名 com.机构名.内容    name:类名(大写)
快捷键的使用技巧：General-keys，设置 Alt+/ 进行内容提示，要注意解除Alt+/ 原来的绑定关系。直接输入alt+/
    就可以找到它的绑定关系，删除用 remove binding 。
    
04 透视图 与程序调试
    透视图：window --Show View
    透视图其实就是界面的布局。不同的透视图，包含不同的视图（view），每个视图的位置、大小也不同。
    断点
    f5 :step into
    f6: step over
    f7: step return
    调试:双击设置断点，右键 debug as ...打开debug视图 选中参数，右键watch
    drop to frame: 跳到当前方法的第一行
    resume： 跳到下一个断点。(如果没有下一个，则运行完整个程序)
    watch:观察变量或表达式的值
    注意：
    调试完后，要在breakpoints视图中清除所有断点。
    调试完后，一定记得结束运行断点的jvm。
05 编译与运行环境
    java--compiler 编译时的环境
    java--Installed JREs 运行时的环境
    
    单独工程 右键--Properties java Compiler编译环境
             --Run as --其它--JRE 查看单独一个工程的运行环境
    高版本的java能否运行低版本的javac编译的程序？能：1.6jre的java，能运行1.5的javac编译的程序。
    低版本的java能否运行高版本的javac编译的程序？不能：1.5jre的java，不能运行1.6编译的程序。
06 java模板代码 window--pre--java--Editor Templates
    代码模块的设置java-editor-Templates,new，
    name：tryf
    pattern：try{
    line_selection选中的内容
    }finally{
    cursor光标
    }
   使用模板  选中代码 右键  Surround With 循环/try异常/同步...
07 导入已有的工程：
    先将工程文件拷贝到工作间下
    然后file--import--general--Existig Projects Workspace--目录
   jre的库设置
   包和库的设置  选中工程--右键--Build Path--其它--Libraries --Add Library(多个jar包)--user Library--自己命名库，增加多个jar包
08 @@静态导入(JDK1.5后)与编译器语法设置
  import 导入一个类或某个包中所有的类
  import static 导入一个类中的某个静态方法或所有静态方法。

//import static java.lang.Math.max;
import static java.lang.Math.*;

  System.out.println(max(3, 6));可以省略类名
  System.out.println(abs(3 - 6));

09 @@可变参数与Overload面试题
   可变参数的特点：
    可变参数你就把它看成数组
    只能出现的参数列表的最后面；
    ...位于变量类型和变量名之间，前后有无空格都可以
    调用可变参数的方法，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式方法可变参数。
    可以以数组的形式来调用可变参数。
public class VarableParameter {
    public static void main(String[] args){
        System.out.println(add(2,3,4));
        System.out.println(add(1,2,3,4,5));
    }
    public static int add(int x,int...args){
        int sum = x;
        for(int i =0;i<args.length;i++){
            sum += args[i];
        }
        return sum;
    }
}
可变参数注意问题：
        int nums[] = {1,2,3,5};
        //把数组当成一个对象放进了list中了
        list = Arrays.asList(nums);
        System.out.println(list);//打印[[I@7ced01]地址值
        
        Integer num[] = {1,2,3,5};
        //把数组中的每个元素都当成一个对象放进了list中了
        list = Arrays.asList(num);
        System.out.println(list);//打印[1, 2, 3, 5]

overload重载 Vs override 覆盖
   override可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。
    在覆盖要注意以下的几点：
    1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；
    2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；
    3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；
    4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。
   overload对我们来说可能比较熟悉，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。
    在使用重载要注意以下的几点：
    1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序；
    2、不能通过访问权限、返回类型、抛出的异常进行重载；
    3、方法的异常类型和数目不会对重载造成影响；
    4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。

10 @@增强for循环
    增强for循环注意问题：增强for只适合取数据，不能改变数据。
    for(type 变量名 : 集合变量名){...}
    注意：迭代变量必须在()中定义
          集合变量可以是数组或实现了Iterable接口的集合类。
11 @@自动装箱与拆箱(JDK1.5后)
Integer iObj = 3;//自动装箱
System.out.println(iObj + 12);//自动拆箱

Integer i1 = 13;
Integer i2 = 13;
//在装箱成Integer时，如果在-128~127;范围内，就会缓存以来。
System.out.println(i1==i2);//ture

Integer i3 = 134;
Integer i4 = 134;
//在装箱成Integer时，如果超过-128~127;范围，就不会缓存以来。
System.out.println(i3==i4);//false
这是一种享元模式。flyweight。(word中的字符，OS中的图标。。。等)
享元模式下：
word文档中的每个字符
把26个字符提前实例化变成对象，word中的每个字符只是调用某个字符对象的方法，参数是坐标。
通过方法 i(int x,int y)//调用字符 i 的方法，参数是字符想要显示的坐标
非享元模式下：
每次写下一个字符就是一次实例化，对每个字符进行实例化
i(char ch,int x,int y)//大量的创建实例，浪费内存资源。

Integer i5 = Integer.valueOf(127);
Integer i6 = Integer.valueOf(127);
System.out.println(i5==i6);//true
Integer i7 = Integer.valueOf(128);
Integer i8 = Integer.valueOf(128);
System.out.println(i7==i8);//false

12@@枚举
为什么要有枚举
    问题：要定义星期几或性别的变量，该怎么定义？假设1-7分别表示星期一到星期七，但有人会写 0；
    枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。
    枚举可以让编译器在编译时就可以控制程序中的非法值，普通变量的方式在开发阶段无法实现这一功能。
用普通类如何实现枚举功能，定义一个Weekday的类来模拟枚举功能
    *私有的构造方法
    *每个元素分别用一个公有的静态成员变量表示
    *可以有若干公有方法或抽象方法，要提供nextDay()方法必须是抽象的。
枚举的基本应用
    *举例：定义一个WeekDay的枚举。
    *扩展：枚举类的values，valueOf，getName，toString，ordinal等方法
    *总结：枚举是一个特殊的类，其中的每个元素都是该类的一个实例化对象。
        例如可以调用WeekDay.SUN.getClass().getName和WeekDay.class.getName()
枚举也可以实现接口、或者继承抽象类。
JDK5.0中扩展了switch语句，它除了接受int，byte，char，short，还可以接受一个枚举类型。
//测试枚举的常用方法
        public void test2(){
        System.out.println(Grand.C.name());//枚举常量的名字 C
        System.out.println(Grand.C.ordinal());//枚举常量的序数 2
        
        String str = "B";
        //Grand g = Grand.valueOf(Grand.class, str);
        Grand g = Grand.valueOf(str);    //开发中常用！
        System.out.println(g);            //B
        
        Grand gs[] = Grand.values();    //返回枚举类Grand中所有的枚举常量
        for(Grand g1 : gs)
            System.out.println(g1);        //A     B    C    D    E        
        
    }

@@枚举入门
    public static void main(String[] args) {
    
        WeekDay weekDay2 = WeekDay.FRI;//该句话编译时，会调用WeekDay的七个构造函数

        System.out.println(weekDay2);FRI
        System.out.println(weekDay2.name());//FRI
        System.out.println(weekDay2.ordinal());//5 位置
        System.out.println(weekDay2.toString());//FRI
        System.out.println(weekDay2.getClass());//class cn.itcast.day1.EnumTest$WeekDay
        
        System.out.println(WeekDay.valueOf("SUN").toString());//SUN
        System.out.println(WeekDay.values().length);//7
        
    }
    //格式
(1)最简单
    public enum WeekDay{
        SUN,MON,TUE,WED,THU,FRI,SAT
    }
(2)带构造方法的枚举，构造方法必须私有
    public enum WeekDay{//相当于内部类
        
        SUN(1),MON(),TUE,WED,THU,FRI,SAT;//必须放第一行
        private WeekDay(){System.out.println("first");}
        private WeekDay(int day){System.out.println("second");}
    }
(3)带抽象方法的枚举
    public enum TrafficLamp{
        RED {//生成一个类文件EnumTest$TrafficLamp$1.class
            @Override
            public TrafficLamp nextLamp() {
                return GREEN;
            }
        },GREEN {//生成一个类文件EnumTest$TrafficLamp$2.class
            @Override
            public TrafficLamp nextLamp() {
                return YELLOW;
            }
        },YELLOW {//生成一个类文件EnumTest$TrafficLamp$3.class
            @Override
            public TrafficLamp nextLamp() {
                return RED;
            }
        };
        public abstract TrafficLamp nextLamp();
    }
(4)带构造方法和抽象方法的枚举
    public enum TrafficLamp{
        RED(30) {//生成一个类文件EnumTest$TrafficLamp$1.class
            @Override
            public TrafficLamp nextLamp() {
                return GREEN;
            }
        },GREEN (45){//生成一个类文件EnumTest$TrafficLamp$2.class
            @Override
            public TrafficLamp nextLamp() {
                return YELLOW;
            }
        },YELLOW (5){//生成一个类文件EnumTest$TrafficLamp$3.class
            @Override
            public TrafficLamp nextLamp() {
                return RED;
            }
        };
        public abstract TrafficLamp nextLamp();
        private int time;
        private TrafficLamp(int time){this.time = time;}
    }
(5)带构造方法和普通方法的枚举
    public enum TrafficLamp{
        RED(30) {//生成一个类文件EnumTest$TrafficLamp$2.class
            @Override
            public TrafficLamp nextLamp() {
                return GREEN;
            }
        },GREEN (45){//生成一个类文件EnumTest$TrafficLamp$2.class
            @Override
            public TrafficLamp nextLamp() {
                return YELLOW;
            }
        },YELLOW (5);//不生成类文件
        public  TrafficLamp nextLamp(){
            return null;
        }
        private int time;
        private TrafficLamp(int time){this.time = time;}
    }
*枚举就相当于一个类，其中也可以定义构造方法、成员变量、普通方法、抽象方法
*枚举元素必须位于枚举体中的最开始部分，枚举元素列表的最后面有分号与其他成员隔开。
    把枚举中的成员方法或变量等放在枚举前面，会编译失败。
*带构造方法的枚举
    构造方法必须私有
    可以有多个构造方法
    枚举元素MON和MON() 效果一样，都是调用默认的构造方法。
*带方法的枚举
    实现普通的方法
    实现抽象的方法：每个元素分别是有枚举类的子类来生成的实例对象，这些子类采用类似内部类的方式进行定义。
    
*枚举只有一个成员时，就可以作为一种单例的实现方式。
***反射/JavaBean
17 反射
人->Person
Java类->Class

@@Class类


*Class类代表Java类
对应各个类在内存中的字节码，例如，Person类的字节码，ArrayList类的字节码，等
一个类被类加载器加载到内存中，占用一片存储空间。这个空间里面的内容可分别用一个个的对象来表示。
这些类具有相同的类型，就是Class类。

*@@实例化如何得到各个字节码对应的实例对象(Class对象)
1,类名.class  例如System.class
2,对象.getClass 例如 new Date().getClass()
3,Class.forName("类名"), 例如 Class.forName("java.util.Date")
 
    Person p1 = new Person();

1    Class cls1 = Date.class
    Class cls2 = Person.class

2    p1.getClass();

3    Class.forName("java.lang.String");    

*@@Class 类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。
每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。
基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 Class 对象。
int.class.isPrimitive();//true   判定指定的 Class 对象是否表示一个基本类型。
Integer.class.isPrimitive();false
int.class == Integer.TYPE;//true
int.class == Integer.class;//false

void.class.isPrimitive();//true
Void.class.isPrimitive();//false
void.class == Void.TYPE;//true
void.class == Void.class;//false。Void 类是一个不可实例化的占位符类，它持有对表示 Java 关键字 void 的 Class 对象的引用。

Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。

@@方法摘要
<U> Class<? extends U>
 asSubclass(Class<U> clazz)
          强制转换该 Class 对象，以表示指定的 class 对象所表示的类的一个子类。
static Class<?> forName(String className)
          返回与带有给定字符串名的类或接口相关联的 Class 对象。
static Class<?> forName(String name, boolean initialize, ClassLoader loader)
          使用给定的类加载器，返回与带有给定字符串名的类或接口相关联的 Class 对象。
 String getName()
          以 String 的形式返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称。
 boolean isPrimitive() 共有9种为true，8种基本类型和 void
          判定指定的 Class 对象是否表示一个基本类型。
    有九种预定义的 Class 对象，表示八个基本类型和 void。这些类对象由 Java 虚拟机创建，与其表示的基本类型同名，
    即 boolean、byte、char、short、int、long、float 和 double。
    这些对象仅能通过下列声明为 public static final 的变量访问，也是使此方法返回 true 的仅有的几个 Class 对象。
    

例    public static void main(String[] args) throws ClassNotFoundException {
        
        String str1 = "abc";
        Class cls1 = str1.getClass();
        Class cls2 = String.class;
        Class cls3 = Class.forName("java.lang.String");
        System.out.println(cls1 == cls2);//true
        System.out.println(cls1 == cls3);//true

        System.out.println(cls1.isPrimitive());//false
        System.out.println(int.class.isPrimitive());//true
        System.out.println(Integer.class.isPrimitive());false
        System.out.println(int.class == Integer.class);//false
        System.out.println(int.class == Integer.TYPE);//true

        System.out.println(int[].class.isPrimitive());//false
        System.out.println(int[].class.isArray());//true  判定此 Class 对象是否表示一个数组类。
        
        System.out.println(void.class.isPrimitive());//true
        System.out.println(void.class == Void.TYPE);//true
        System.out.println(void.class == Void.class);//false，Void 类是一个不可实例化的占位符类，它持有对表示 Java 关键字 void 的 Class 对象的引用。
    }
总之，只要在源程序中出现的类型，都有各自的Class实例对象。例如int[],void

*反射就是把Java类中的各种成分映射成相应的java类。
表示java类的Class类显然要提供一系列的方法，来获得其中的变量、方法、构造方法、
修饰符、包等信息。这些信息就是用相应类的实例对象来表示，它们是Field/Methed/Constructor/Package等
*一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象。

@@Constructor类 构造方法对应的类
得到某个类所有的构造方法
Constructor[] constructors = Class.forName("java.lang.String").getConstructors();
得到具体某一个构造方法//得到的是参数为StringBuffer的构造方法。
Constructor consturctor = Class.forName("java.lang.String").getConstructor(StringBuffer.class);
创建带参数的实例对象
    通常 String str = new String(new StringBuffer("abc"));
    反射 String str = (String)constructor.newInstance(new StringBuffer("abc"));
创建不带参数的实例对象，直接用java类.newInstance();
StringBuilder str3 = (StringBuilder)StringBuilder.class.newInstance();
System.out.println(str3.append("abc"));//abc

@@Field类 成员变量对应的类
 Object get(Object obj)
          返回指定对象上此 Field 表示的字段的值
 Class<?> getType()
          返回一个 Class 对象，它标识了此 Field 对象所表示字段的声明类型。

ReflectPoint pt1 = new ReflectPoint(3,5);

Field fieldY = pt1.getClass().getField("y");//得到public成员对应的类对象
System.out.println(fieldY.get(pt1));

Field fieldX = pt1.getClass().getDeclaredField("x");//得到private成员对应的类对象
fieldX.setAccessible(true);//暴力反射，强制访问类的私有成员。
System.out.println(fieldX.get(pt1));
作业：将任何一个对象的所有String类型的成员变量所对应的字符串内容中的“b”改为“a”

    private static void changeStringValue(Object obj) throws IllegalArgumentException, IllegalAccessException {
        // TODO Auto-generated method stub
        Field[] fields = obj.getClass().getFields();
        for(Field field : fields){
            if(field.getType() == String.class){
                String oldValue = (String)field.get(obj);
                String newValue = oldValue.replaceAll("b","a");
                field.set(obj, newValue);
            }
        }
        
    }

@@Method类 成员方法对应的类

Method类代表某个类中的一个成员方法
*得到类中的一个方法
    Method charAt = Class.forName("java.lang.String").getMethod("charAt",int.class);
*调用方法 String str = new String("abc");
    通常：str.charAt(1);
    反射：charAt.invoke(str,1);//b
     CharAt.invoke(str,new Object[]{1});//jdk1.4时的方法，把参数对象放进Object数组中
如果传递给Method对象的invoke方法的第一个参数为null，这有着什么样的意义呢？
说明该Method对象对应是一个静态方法！

@@用反射执行main方法


目标：写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。
jdk1.5 整个数组是一个参数，而jdk1.4数组中的每个元素对应一个参数。
1.5兼容1.4，所以不能用mainMethod.invoke(null,new String[]{xxx})，会被当1.4的方法处理。
*解决办法
mainMethod.invoke(null,new Object[]{new String[]{xxx}});
mainMethod.invoke(null,(Object)new String[]{xxx});编译器会做特殊处理！认为是main方法。

//main方法的调用
//通常方式    TestArguments.main(new String[]{"1","2","3"});
//反射方式
String startClass = args[0];//将 最开始执行类  传进来
Method mainMethod = Class.forName(startClass).getMethod("main",String[].class);
mainMethod.invoke(null, new Object[]{new String[]{"jdk","1.5"}});
mainMethod.invoke(null,(Object)new String[]{"jdk","1.5"});

    class TestArguments{
    public static void main(String[] args){
        for(String arg : args){
            System.out.println(arg);
        }
    }

@@数组的反射1
数组所属的java类是同一个字节码，前提 数组的维度和数组元素的类型都相同！
int [] a1 = new int[]{1,2,3};
int [] a2 = new int[4];
int[][] a3 = new int[2][3];
String [] a4 = new String[]{"a","b","c"};
System.out.println(a1.getClass() == a2.getClass());//true
//System.out.println(a1.getClass() == a4.getClass());//编译失败

System.out.println(a1.getClass().getName());//[I  表示该java类是   一维数组，元素类型是int
System.out.println(a1.getClass().getSuperclass().getName());//java.lang.Object

        
Object aObj1 = a1;//int[] 是Object类型    Object中装的是一个  int型一维数组
Object aOvj2 = a4;//String[] 是Object类型    Object中装的是一个String型一维数组
//Object[] aObj3 = a1;//编译失败，int基本类型不是Object类型   Object中不能装一个 基本类型的值。  
Object[] aObj4 = a3;//int[] 类型是Object类型    每个Object中装的是 一个int型的一维数组
Object[] aObj5 = a4;//String 类型是Object类型    每个Object中装的是一个 String类型的值
    

//Arrays中的方法原型 public static <T> List<T> asList(T... a)
System.out.println(Arrays.asList(a1));
//[[I@ca0b6]  表示List<int[]> list = Arrays.asList(int[] al) 转换成的list集合中只有一个元素 即   al (一个一维的int类型数组),
、    说明int(基本数据类型)不能传入泛型中! 基本数据类型数据不能传进Object类型中；                                        
System.out.println(Arrays.asList(a4));//[a, b, c]    List<String> list = Arrays.asList(a4)集合中有3个元素，
、    String类型可以传入泛型中。String类型可以装进Object类型中！

泛型在1.5以前用Object表示
1.5后用<T>表示
泛型中不能传入基本数据类型的数据！

System.out.println(a1);//[I@ca0b6  相当于a1.getClass().getName()+"@"+Integer.toHexString(a1.hashCode())
System.out.println(a4);//[Ljava.lang.String;@10b30a7

Class类的getName()方法
Element Type       Encoding  
boolean           Z  （特殊）
byte           B  
char           C  
class or interface Lclassname; （特殊）
double           D  
float           F  
int           I  
long           J    （特殊）
short           S  

类或接口名 classname 是上面指定类的二进制名称。
示例：

 String.class.getName()
     returns "java.lang.String"
 byte.class.getName()
     returns "byte"
 (new Object[3]).getClass().getName()
     returns "[Ljava.lang.Object;"
 (new int[3][4][5][6][7][8][9]).getClass().getName()
     returns "[[[[[[[I"
 
@@数组的反射2
java.lang.reflect 下的Array全是静态方法

    private static void printObject(Object obj){
        Class clazz = obj.getClass();
        if(clazz.isArray()){            //**重要方法
            int len = Array.getLength(obj);    //**重要方法
            for(int i = 0;i<len;i++){
                System.out.println(Array.get(obj,i));//**重要方法
            }
        }else{
            System.out.println(obj);
        }
    }

    printObject(a4);//a   b      c
    printObject("xyz");//xyz
    printObject('a');//a
    printObject(123);//123
    printObject(true);//true
怎么得到一个数组中的元素类型？
int[] a = new int[]{1,2,3};
//System.out.println(a[0].getClass().getName());//编译失败
//System.out.println(a[1].getClass().getName());//编译失败
System.out.println(a.getClass().getName());//    [I

Object[] a = new Object[]{"a",1};
System.out.println(a[0].getClass().getName());    //    java.lang.String
System.out.println(a[1].getClass().getName());//    java.lang.Integer
System.out.println(a.getClass().getName());//        [Ljava.lang.Object;

没法得到一个数组的元素类型，只能得到其中某个元素的类型。

@@hashCode的用处
ArrayList和HashSet的比较 及 hashCode的分析。

内存泄露：对象没有被释放，一直占用内存资源。
在元素类中覆写hashCode和equals方法后
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + x;
        result = prime * result + y;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        ReflectPoint other = (ReflectPoint) obj;
        if (x != other.x)
            return false;
        if (y != other.y)
            return false;
        return true;
    }

Collection collections =  new HashSet();
ReflectPoint pt1 = new ReflectPoint(3,3);
ReflectPoint pt2 = new ReflectPoint(5,5);
ReflectPoint pt3 = new ReflectPoint(3,3);
    collections.add(pt1);
    collections.add(pt2);
    collections.add(pt3);
    collections.add(pt1);
//如果改变了pt1的y值，那么就无法成功删除pt1了，会造成内存泄露.
    pt1.y = 7;
    collections.remove(pt1);
    System.out.println(collections.size());
@@反射的作用==实现框架的功能
*我做房子卖给用户，有用户自己安装门窗和空调，我做的房子就是框架，
用户需要使用我的框架，把门窗插入进我提供的框架中。
框架与工具类的区别，工具类被用户调用，而框架调用用户提供的类！
*框架要解决的核心问题
我在写框架(房子)的时候，你这个用户还在上小学，还不会写程序，我写的框架程序怎么调用
你以后写到的类呢？
因为在写程序时无法知道要被调用的类名，所以，在程序中无法直接new某个类的实例对象，而要用反射的方式做。

你做的门调用锁，锁是工具，你做的门被房子调用，房子是框架，房子和锁都是被人提供。
//@@不用类加载器的方式
config.properties(工程的目录下)文件中的内容 className=java.util.ArrayList

InputStream ips = new FileInputStream("config.properties");
Properties props = new Properties();
props.load(ips);
ips.close();
String className = props.getProperty("className");
Collection collections = (Collection)Class.forName(className).newInstance();
//以上所有等于Collection collections =  new ArrayList();
@@用类加载器的方式管理资源和配置文件

getRealPath() 安装目录
配置文件的路径设置==》 安装目录/配置文件内部路径
一定要记住完整的路径，但完整的路径不是硬编码，而是运算出来的。

InputStream ips = ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/day1/config.properties");
//或者 InputStream ips = ReflectTest2.class.getResourceAsStream("config.properties");//省略中间加载器，默认ReflectTest2的class文件的路径。效果如上！
Properties props = new Properties();
props.load(ips);
ips.close();
String className = props.getProperty("className");
Collection collections = (Collection)Class.forName(className).newInstance();
@@加载配置文件小结
//1==不用类加载器（配置资源在javaenhance_my工程的下面）
//InputStream ips = new FileInputStream("config.properties");

//2==用类加载器的方式加载配置文件(不省略中间获取加载器的步骤，所以资源路径名要写全)（配置资源在javaenhance_my工程中的cn/itcast/day1下面）
//InputStream ips = ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/day1/config.properties");

//3==省略中间获取加载器的步骤，则资源路径 默认为ReflectTest2的class文件的路径。效果如上！
InputStream ips = ReflectTest2.class.getResourceAsStream("config.properties");

//4==将配置文件放在新建的包中，在cn/itcast/day1 文件中建立一个资源文件包 cn.itcast.day1.resource
InputStream ips = ReflectTest2.class.getResourceAsStream("resource/config.properties");
        
//5==用绝对路径 String name=“/...”;前面有个/表示 ：配置文件的路径与前面一个类(Re..2)的class文件路径不相关，所以要写全配置文件的路径名。
//InputStream ips = ReflectTest2.class.getResourceAsStream("/cn/itcast/day1/resource/config.properties");
@@内省Introspector
为什么学习内省?开发框架时，经常需要使用java对象的属性来封装程序的数据，
每次都使用反射技术完成此操作过于麻烦，所以sun开发了一套API，专门用于操作java对象的属性。
内省访问JavaBean属性的两种方式：
1，通过PropertyDescriptor类操作Bean的属性
2，通过Introspector类获得Bean对象的BeanInfo，
    然后通过BeanInfo来获取属性的描述器(PropertyDescriptor),
    通过这个属性描述器就可以获取某个属性对应的getter/setter方法，然后通过反射来调用这些方法。

@@由内省引出的JavaBean  JavaBean就是特殊一点的java类

*JavaBean是一种特殊的Java类，主要用于传递数据信息，这种java类中的方法主要用于访问私有的字段，且方法名符合某种命名规则。
JavaBean的属性 是根据方法得来的。属性要私有private，get和set方法要公有public！
比如一个方法是 setAge()-->属性 age
*如果要在2个模块之间传递多个信息，可以将这些信息封装到一个JavaBean中，这种JavaBean(也叫java类)的实例对象通常称之为值对象(Value Object)。
如果去掉set get后 剩下的字符串第二个字母是小写，那么属性名全小写；
          剩下的字符串第二个字母是大写，那么属性名全大写；
@@一个JavaBean中的属性的定义
public class Person {    //一个JavaBean类
    
    private String name ;    //字段
    private String password ;    //字段
    private int age ;    //字段
    
    /*
     * 一个JavaBean的属性有哪些，由(并且只由)它的get或set方法(有一个方法就行了)决定的。
     * 如果只有上面三个私有成员变量，它们只能叫做字段，
     * 但是如果有了下面的公有的get或set方法，它们就可以叫做属性了。
     *
     * 所以判断一个JavaBean有哪些属性，应该通过它有哪些get或set方法来判断。
     * 另外：任何类都继承了Object类，而Object类中有一个getName()方法，所有会有一个name属性。
     *
     *本类共五个属性：ab    age class name password (系统默认顺序)
     * */
    
    //此函数使得Person类多了一个属性，叫做ab
    public String getAb() {
        return null;
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
}
@@使用内省API操作bean的属性
public class Demo1 {
    
    //得到bean的所有属性:可以含继承来的，或不含继承来的
    @Test
    public void test1() throws Exception{
        Person p = new Person();
        
        BeanInfo beanInfo_all = Introspector.getBeanInfo(Person.class);
        //对Person进行内省，也内省了它继承的类        
    
        PropertyDescriptor[] pds_all =beanInfo_all.getPropertyDescriptors();
        System.out.println(pds_all.length);// 5
        for(PropertyDescriptor pd : pds_all){
            System.out.println(pd.getName());
            //Person这个JavaBean类的所有属性值,包括继承下来的
            //：ab  age  class    name    password
        }
        
        BeanInfo beanInfo_self = Introspector.getBeanInfo(Person.class,Object.class);
        //在断点Object.class之下，对Person.class进行内省，得到的是Person类自己的属性！
        PropertyDescriptor[] pds_self =beanInfo_self.getPropertyDescriptors();
        System.out.println(pds_self.length);//    4
        for(PropertyDescriptor pd : pds_self){
            System.out.println(pd.getName());
            //Person这个JavaBean类的所有属性值,不包括继承下来的
            //：ab  age      name    password
        }
        
    }
    //只想得到bean的特定属性: age
    @Test
    public void test2() throws Exception{
        Person p = new Person();
        
        PropertyDescriptor pd = new PropertyDescriptor("age",Person.class);
        //得到属性的写方法：为属性赋值
        Method method_set = pd.getWriteMethod();//public void setAge(int age)
        method_set.invoke(p, 45);
        
        //获取属性的值:
        Method method_get = pd.getReadMethod();//public int getAge()
        System.out.println(method_get.invoke(p, null));
        
        
    }
    //高级点的内容：获取当前操作的属性的类型
    @Test
    public void test3() throws Exception{
        Person p = new Person();
        
        PropertyDescriptor pd = new PropertyDescriptor("age",Person.class);
        
        //得到属性的类型
        System.out.println(pd.getPropertyType());//    int        
        
    }
}


@@BeanUtils工具包
用BeanUtils工具包方便些！
好处：自动进行类型转换，BeanUtils以字符串的形式对JavaBean进行操作！
BeanUtils.getProperty(pt1,"x");
BeanUtils.setProperty(pt1,"x","9");//自动进行类型转换，将String "9"换成int 9

好处：PropertyUtils以属性本身的类型进行操作！
PropertyUtils.setProperty(pt1, "x", 9);//不进行类型转换。
System.out.println(PropertyUtils.getProperty(pt1, "x"));

好处：支持操作成员变量的内部数据。操作属性链的功能！
BeanUtils.setProperty(pt1,"birthday.time", "111");
System.out.println(BeanUtils.getProperty(pt1,"birthday.time"));

好处：拷贝属性，将JavaBean转换成Map对象，
/*//java7的新特性
Map map = (name:"wzq",age:18);
BeanUtils.setProperty(map, "name", "cdd");*/

Person bean = new Person();
BeanUtils.populate(bean, map);//将Map填充进JavaBean

------- android培训、java培训、期待与您交流！ ----------