黑马程序员-枚举、反射、泛型（2）

最新推荐文章于 2018-07-10 09:27:04 发布

征服heart

最新推荐文章于 2018-07-10 09:27:04 发布

阅读量736

点赞数 1

分类专栏：个人文章标签：黑马程序员-枚举反射泛型

本文链接：https://blog.csdn.net/u014300492/article/details/27484575

版权

个人专栏收录该内容

20 篇文章 0 订阅

订阅专栏

------------------- 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培训、期待与您交流！ ----------------------

征服heart

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录