------------------- android开发、java培训、期待与您交流！ ----------------------
黑马程序员-（高新技术）有关枚举，反射，泛型的总结
(1)泛型：
泛型在集合中经常用到，泛型的本质化是参数化类型；也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口和泛型方法。
在1.5之前，是没有泛型的；参数可以任意化，那么后面就要做显示的强制类型转换，并且很容易出现转换错误，在编译期可能发现不了，那么这就形成了安全隐患；
但在引入泛型后就不一样了，它在编译的时候会自动检查类型安全，并且所有强制转换都是隐式的，不但方便，还提高了代码的复用性；
泛型在使用中应该注意的细节：1，泛型的类型参数只能是类类型，不能是简单类型，类型参数可以有多个；2，同一种泛型可以对应多个版本，因为参数类型不确定；3，泛型的参数还可以是通配符类型，例如Class<?> classType = Class.forName(Java.lang.String); 常用的泛型实例如下：
public class Lhist<V> {
public Lhist(int capacity) { ... }
public int size() { ... }
public void add(V value) { ... }
public void remove(V value) { ... }
public V get(int index) { ... }
}
4，？通配符的扩展：
a、上边界： Vector< ?extends Number >：允许Number类以及其子类的传入
b、下边界： Vector< ?super Integer >：允许Integer类以及其父类的传入
5，自定义泛型
定义一个交换数值的函数，交换数组中的两个元素，数组类型不定
private static < T > void swap(T[ ] a, int i , int j )
{
T temp = a[ i ];
a[ i ] = a[ j ];
a[ j ] = T temp;
}
(2)增强For循环：
Collection在JDK1.5后出现的父接口Iterable就是提供了这个for语句。格式：for(数据类型变量名: 数组或集合){ 执行语句；}作用：简化了对数组，集合的遍历。增强For循环和迭代器的区别：(1)，For循环只能对集合进行遍历获取，不能操作集合；(2)，迭代器除了遍历，还可以进行remove集合中元素的操作；如果是用ListIterator,还可以在遍历过程中对集合进行增删改查的操作；传统For和增强For的区别：增强For有一个局限性，就是必须有被遍历的目标；建议在遍历数组的时候，建议用传统For，因为可以定义角标。
(3)可变参数的函数：返回值类型函数名(参数类型… 形式参数){ 执行语句；}其实接收的是一个数组，可以指定实际参数个数。只要将要操作的元素作为参数传递即可；隐式的将这些参数封装成了数组；
(4)静态导入：如：import java.util.Arrays; 导入的是Array这个类中所有的静态成员，那么它调用方法的时候可以省略不写。但当有两个类有相同的方法时，必须指明是哪个类在调用，也就是说不能省略。
Enum是定义枚举的关键字，枚举型较传统的定义常量的方式，出演了具有参数类型检测的优势之外，还具备其他他方面的有事，用户可以将一个美剧类型的成员看做是枚举类型的一个实例，这些枚举类型成员都默认被final，public,static修饰，所以当使用枚举类型成员时 枚举类型名称调用枚举类型成员即可。
（5）享元模式：
如果有多很小的对象，它们有许多相同的东西，那就可以把它们变成一个对象，把那些不同的额东西变成外部属 性，作为方法的参数传入，相同的东西称为内部状态。
这里需要指出，如果没有自动装箱和拆箱功能，我们需要调用ValueOf方法来实现上述的目的，如：
Integer a3 = Integer. ValueOf(3);将基本数据类型数据3封装为包装类Integer。
（6）反射：
说反射之前，先要明确一下Class的含义；
java程序中的各个java类，他们属于同一类事物，那么可以用面向对象的思想类分析这类事物。把它们也看成一个类，那么这个类的名字就是Class；（注意：C是大写！）
这个Class类描述的是类的信息：包括类的名字，类的访问属性，类所属于的包名，字段名称的列表，方法名称的列表，等等
比如：Person类代表人，他的实例对象就是张三，李四这样一个个具体的人；
在java中Class类代表java类，它的各个实例对象又分别对应各个类在内存中的字节码，例如：
Person类的字节码，ArrayList类的字节码等等；
一个类被类加载器加载到内存中，占用一片储存空间，这个空间里面的内容就是类的字节码，
不同类的字节码是不同的，所以它们在内存中的内容是不同的，这一个个的空间可分别用一个个的对象来表示，这些对象显然具有相同的类型，就是CLass类型；
得到各个字节码对应的实例对象三种方法：（Class类型）
1，类名.class , 例如：System.class
2，对象.getClass(),例如：new Date().getClass()
3，Class.forName("类名"),例如，Class.forName("java.util.Date");
注意：第三种比较常用，实际开发中，有些类是后期临时传入的；
九种类型的Class预定义对象；
boolean,byte,char,short,int,long,float,double
void也是，例如void.class
数组类型的Class实例对象：
Class.isArray() 判断不是不数组
总之，只要在源程序中出现的类型，都有各自的Class实例对象；
Java的反射机制主要由以下类来实现，(除了Class类)这些类都位于java.lang.reflect包中：
Class类：代表一个类。
Field 类：代表类的成员变量（成员变量也称为类的属性）。
Method类：代表类的方法。
Constructor 类：代表类的构造方法。
Array类：提供了动态创建数组，以及访问数组的元素的静态方法。
Class类是Reflection API中的核心类，它有以下方法,获取成员变量、成员方法、接口、超类、构造方法等
getName()：获得类的完整名字。
getFields()：获得类的public类型的属性。
getDeclaredFields()：获得类的所有属性。
getMethods()：获得类的public类型的方法。
getDeclaredMethods()：获得类的所有方法。
getMethod(String name, Class[] parameterTypes)：获得类的特定方法，name参数指定方法的名字，parameterTypes 参数指定方法的参数类型。
getConstructors()：获得类的public类型的构造方法。
getConstructor(Class[] parameterTypes)：获得类的特定构造方法，parameterTypes参数指定构造方法的参数类型。
newInstance()：通过类的不带参数的构造方法创建这个类的一个对象。
反射就是把java类中的各种成分映射成相应的java类
一个java类中用一个Class类的对象来表示一个类中的组成部分；
成员变量，方法，构造方法，包等等信息也用一个个的java类来表示，假如汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示。
一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法，可以得到这些实例对象。
反射机制的优点与缺点 :
为什么要用反射机制？直接创建对象不就可以了吗，这就涉及到了动态与静态的概念。
静态编译：在编译时确定类型，绑定对象,即通过。
动态编译：运行时确定类型，绑定对象。
动态编译最大限度发挥了java的灵活性，体现了多态的应用，有以降低类之间的藕合性。
一句话，反射机制的优点就是可以实现动态创建对象和编译，体现出很大的灵活性，特别是在J2EE的开发中 它的灵活性就表现的十分明显。但就是在运行时才动态的创建和编译，所以它对程序的性能是有影响的！
使用反射基本上是一种解释操作，有一种本末倒置的感觉。我们可以告诉JVM，我们希望做什么并且它满足我们的要求。
然而这类操作总是慢于只直接执行相同的操作。
其实，反射就是一种解剖的过程，在这个过程中无疑Class中的各种成分都可以归纳为一个个的对象。解剖出来的东西都用相应类的实例对象来表示，然而它们都包含自己特有的信息。
暴力反射：
有些private的成员变量，由于权限问题我们拿不到，就可以用反射。通过 getDeclaredField()拿到这个具体的字段
然后调用 setAccessible()方法，记得参数置为true；例如：fieldX.setAccessible(true);
当然方法也一样，必须用getDeclearMethod(); 得到具体方法后调用 method.setAccessible(true);
注意：暴力反射一般很少用，因为既然是private，那么就是不想让外部看见或者调用，所以尽量不要通过暴力反射来访问。
反射的具体用法：
反射一个字符串：
通常方式：String str = new String(new StringBuffer("abc"));
反射方式：String srt = (String)constructor.newInstance(new StringBuffer("abc");
调用获得的方法时要用到上面相同类型实例对象。
用默认构造方法创建实例对象的方式：Class.newInstance()方法，反射框架中会经常用到
例子：String obj = (String)Class.forName("java.lang.String").newInstance();
该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象；
该方法用到了缓存机制来保存默认构造方法的实例对象。
数组的反射应用：
1，相同类型、维数的数组字节码是相同的。
2，在new字符串数组的时候，由于执行会拆包，所以加上new Object[] 相当于封装成一个Object类型的数组，或者改成“(Object)” 也行，就是告诉虚拟机这个包别拆！
3，因为main是静态方法，所以调用传参不需要对象，为null
mainMethod.invoke(null, new Object[]{new String[]{"111","222","333"}});
反射类的成员方法应用：
Class clazz = Person.class;
Method method = clazz.getMethod(methodName, new Class[]{paramClazz1, paramClazz2});
method.invoke();
反射类的构造函数应用：
Constructor con = clazz.getConstructor(new Class[]{paramClazz1, paramClazz2,...}) con.newInstance(params...)
反射类的属性应用：
Field field = clazz.getField(fieldName);
field.setAccessible(true);
field.setObject(value);
枚举的一些例子：
/*
创建名称为Contents的类文件，在该类中通过doit(),diot2()进行不同的方式调用，然后通过主方法进行动调用，体现枚举类型定义常量的方式
*/
interface Constants
{ // 将常量放置在接口中
public static final int Constants_A = 1;
public static final int Constants_B = 12;
}
class ConstantsTest
{
enum Constants2
{ // 将常量放置在枚举类型中
Constants_A, Constants_B
}
// 使用接口定义常量
public static void doit(int c)
{ // 定义一个方法，这里的参数为int型
switch (c)
{ // 根据常量的值做不同操作
case Constants.Constants_A:
System.out.println("doit() Constants_A");
break;
case Constants.Constants_B:
System.out.println("doit() Constants_B");
break;
}
}
// 定义一个方法，这里的参数为枚举类型对象
public static void doit2(Constants2 c)
{
switch (c)
{ // 根据枚举类型对象做不同操作
case Constants_A:
System.out.println("doit2() Constants_A");
break;
case Constants_B:
System.out.println("doit2() Constants_B");
break;
}
}
public static void main(String[] args)
{
ConstantsTest.doit(Constants.Constants_A); //使用接口中定义的常量
ConstantsTest.doit2(Constants2.Constants_A); //使用枚举类型中的常量
ConstantsTest.doit2(Constants2.Constants_B); //使用枚举类型中的常量
ConstantsTest.doit(3);
// ConstantsTest.doit2(3);
}
}
/*
在以下项目中创建ConstenttsTest类，该类中以内部类的形式定义枚举型
*/
import static java.lang.System.*;
class EnumMethodTest
{
enum Constants2
{ // 将常量放置在枚举类型中
Constants_A, Constants_B
}
// 定义比较枚举类型方法，参数类型为枚举类型
public static void compare(Constants2 c)
{
// 根据values()方法返回的数组做循环操作
for (int i = 0; i < Constants2.values().length; i++)
{
// 将比较结果返回
out.println(c + "与" + Constants2.values()[i] + "的比较结果为："
+ c.compareTo(Constants2.values()[i]));
}
}
// 在主方法中调用compare()方法
public static void main(String[] args)
{
compare(Constants2.valueOf("Constants_B"));
}
}
/*
在枚举类型中可以添加构造方法，但是规定这个构造方法必须为private修饰符所修饰，枚举类型型定义的构造方法如下
*/
import static java.lang.System.*;
class EnumIndexTest
{
enum Constants2
{ // 将常量放置在枚举类型中
Constants_A("我是枚举成员A"), //定义带参数的枚举类型成员
Constants_B("我是枚举成员B"), Constants_C("我是枚举成员C"), Constants_D(3);
private String description;
private int i = 4;
private Constants2()
{
}
// 定义参数为String型的构造方法
private Constants2(String description)
{
this.description = description;
}
private Constants2(int i)
{ // 定义参数为整型的构造方法
this.i = this.i + i;
}
public String getDescription()
{ // 获取description的值
return description;
}
public int getI()
{ // 获取i的值
return i;
}
}
public static void main(String[] args)
{
for (int i = 0; i < Constants2.values().length; i++)
{
out.println(Constants2.values()[i] + "调用getDescription()方法为："
+ Constants2.values()[i].getDescription());
}
out.println(Constants2.valueOf("Constants_D") + "调用getI()方法为："
+ Constants2.valueOf("Constants_D").getI());
}
}
泛型是使程序员定义安全的类型，Object类为最上层的父类，很多程序员为了使程序更为通用，设计程序时通常是传入的值与返回的值都以Object类型为主，当需要使用这些泛型时，必须正确地将该实例转换成原来的类型，否则在运行时将会发生异常
/*
在常见ArrayClass类时使用泛型
*/
class ArrayClass<T>
{
private T[] array; // 定义泛型数组
public void SetT(T[] array)
{ // 设置SetXXX()方法为成员数组赋值
this.array = array;
}
public T[] getT()
{ // 获取成员数组
return array;
}
public static void main(String[] args)
{
ArrayClass<String> a = new ArrayClass<String>();
String[] array = { "成员1", "成员2", "成员3", "成员4", "成员5" };
a.SetT(array); // 调用SetT()方法
for (int i = 0; i < a.getT().length; i++)
{
System.out.println(a.getT()[i]); //调用getT()方法返回数组中的值
}
}
}
/*
在AnyClass类中使用泛型实例化常用集合类
*/
import java.util.*;
class AnyClass
{
public static void main(String[] args)
{
// 定义ArrayList容器，设置容器内的值类型为Integer
ArrayList<Integer> a = new ArrayList<Integer>();
a.add(1); // 为容器添加新值
for (int i = 0; i < a.size(); i++)
{
// 根据容器的长度循环显示容器内的值
System.out.println("获取ArrayList容器的值：" + a.get(i));
}
// 定义HashMap容器，设置容器的键名与键值类型分别为Integer与String型
Map<Integer, String> m = new HashMap<Integer, String>();
for (int i = 0; i < 5; i++)
{
m.put(i, "成员" + i); //为容器填充键名与键值
}
for (int i = 0; i < m.size(); i++)
{
// 根据键名获取键值
System.out.println("获取Map容器的值" + m.get(i));
}
// 定义Vector容器，使容器中的内容为String型
Vector<String> v = new Vector<String>();
for (int i = 0; i < 5; i++)
{
v.addElement("成员" + i); //为Vector容器添加内容
}
for (int i = 0; i < v.size(); i++)
{
// 显示容器中的内容
System.out.println("获取Vector容器的值" + v.get(i));
}
}
}
反射：
package feifei;
public class ReflectPoint {
private int x;
public int y;
public String str1="ball";
public String str2="basketball";
public String str3="itcast";
public ReflectPoint(int x,int y)
{
super();
this.x=x;
this.y=y;
}
@Override
public String toString() {
return "ReflectPoint [ str1=" + str1
+ ", str2=" + str2 + ", str3=" + str3 + "]";
}
@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;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
}
package feifei;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/*
* 反射就是把java类中的各种成分映射成相应的Java类。
* */
public class ReflectTest {
private static java.lang.reflect.Field fieldY;
private static String startingClassName;
public static void main(String[] args) throws Exception
{
String str1="abc";
Class cls1=str1.getClass();
Class cls2=String.class;
Class cls3=Class.forName("java.lang.String");
System.out.println(cls1==cls2);
System.out.println(cls1==cls3);
System.out.println(cls1.isPrimitive());//不是基本类型字节码
System.out.println(int.class.isPrimitive());//是基本类型字节码
System.out.println(int.class==Integer.class);//两者字节码类型不一样
System.out.println(int.class==Integer.TYPE);//是基本类型字节码
System.out.println(int[].class.isPrimitive());//数组类型不是原始字节码
System.out.println(int.class.isArray());//是数组
//只要在源程序中出现的对象，都有各自的class实例对象，例如：int[],void...
//new String(new StringBuffer("abc"));//等价与下列两行
Constructor<String> constructor1=String.class.getConstructor(StringBuffer.class);//获取构造方法
String str2=(String)constructor1.newInstance(new StringBuffer("abc"));
System.out.println(str2.charAt(2));
ReflectPoint pt1=new ReflectPoint(3,5);
@SuppressWarnings("unused")
Field fieldY=pt1.getClass().getField("y");//fieldY表示字节码上的某个变量，不表示某个具体的变量
System.out.println(fieldY.get(pt1));
Field fieldX=pt1.getClass().getDeclaredField("x");
fieldX.setAccessible(true);
System.out.println(fieldX.get(pt1));
changeStringValue(pt1);//将字符串中的某些字符替换成另外一些字符
System.out.println(pt1);
//Method methodCharAt=String.class.getMethod("charAt",int.class);//获取方法
//System.out.println(methodCharAt.invoke(str1,1));//invoke（调用），invoke调用methodCharAt方法上的方法
TestArguments.main(new String[]{});//调用TestArguments的主函数
TestArguments.main(new String[]{"11","222","3333"});//传参数，再调用主函数
Method methodCharAt=String.class.getMethod("charAt",int.class);
System.out.println(methodCharAt.invoke(str1,1));
System.out.println(methodCharAt.invoke(str1,new Object[]{2}));
TestArguments.main(new String[]{"11111","22222222222","3333333333"});
Method mainMethod=Class.forName(startingClassName).getMethod("main",String[].class);
mainMethod.invoke(null,new Object[]{new String[]{"11","2222"}});
mainMethod.invoke(null,(Object)new String[]{"11","2222"});
int[] a1=new int[3];
int[] a2=new int[4];
int[][] a3=new int[2][3];
String[] a4=new String[3];
System.out.println(a1.getClass()==a2.getClass());
System.out.println(a1.getClass()==a4.getClass());
System.out.println(a1.getClass()==a3.getClass());
}
private static void changeStringValue(Object obj) throws Exception
{
//将字符串中的某些字符替换成另外一些字符方法
Field[] fields=obj.getClass().getFields();
for(Field field:fields)
{
if(field.getType()==String.class)
{
String oldValue=(String)field.get(obj);
String newValue=oldValue.replace('b', 'a');
field.set(obj,newValue);
}
}
}
}
class TestArguments
{
public static void main(String[] args)
{
for(String arg:args)
System.out.println(arg);
}
------------------- android开发、java培训、期待与您交流！ ----------------------