黑马程序员-枚举、反射、泛型(2)

时间:2023-02-18 20:15:28

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