-------------------android开发、java培训、期待与您交流！ ----------------------
黑马程序员有关枚举，反射，泛型的总结
Enum是定义枚举的关键字，枚举型较传统的定义常量的方式，出演了具有参数类型检测的优势之外，还具备其他他方面的有事，用户可以将一个美剧类型的成员看做是枚举类型的一个实例，这些枚举类型成员都默认被final，public,static修饰，所以当使用枚举类型成员时 枚举类型名称调用枚举类型成员即可。
枚举的一些例子：
/*
创建名称为Contents的类文件，在该类中通过doit(),diot2()进行不同的方式调用，然后通过主方法进行动调用，体现枚举类型定义常量的方式
*/
interface Constants
{ // 将常量放置在接口中
public static final intConstants_A = 1;
public static final intConstants_B = 12;
}
class ConstantsTest
{
enum Constants2
{ // 将常量放置在枚举类型中
Constants_A,Constants_B
}
// 使用接口定义常量
public static voiddoit(int c)
{ // 定义一个方法，这里的参数为int型
switch (c)
{ // 根据常量的值做不同操作
caseConstants.Constants_A:
System.out.println("doit()Constants_A");
break;
caseConstants.Constants_B:
System.out.println("doit()Constants_B");
break;
}
}
// 定义一个方法，这里的参数为枚举类型对象
public static voiddoit2(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 voidmain(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 voidcompare(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 voidmain(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 Stringdescription;
private int i = 4;
private Constants2()
{
}
// 定义参数为String型的构造方法
privateConstants2(String description)
{
this.description =description;
}
private Constants2(inti)
{ // 定义参数为整型的构造方法
this.i = this.i +i;
}
public StringgetDescription()
{ // 获取description的值
returndescription;
}
public int getI()
{ // 获取i的值
return i;
}
}
public static voidmain(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 voidmain(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 voidmain(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 Stringstr1="ball";
public Stringstr2="basketball";
public Stringstr3="itcast";
publicReflectPoint(int x,int y)
{
super();
this.x=x;
this.y=y;
}
@Override
public StringtoString() {
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 booleanequals(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(intx) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(inty) {
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 staticjava.lang.reflect.Field fieldY;
private static StringstartingClassName;
public static voidmain(String[] args) throws Exception
{
Stringstr1="abc";
Classcls1=str1.getClass();
Classcls2=String.class;
Classcls3=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(newStringBuffer("abc"));//等价与下列两行
Constructor<String>constructor1=String.class.getConstructor(StringBuffer.class);//获取构造方法
Stringstr2=(String)constructor1.newInstance(new StringBuffer("abc"));
System.out.println(str2.charAt(2));
ReflectPointpt1=new ReflectPoint(3,5);
@SuppressWarnings("unused")
FieldfieldY=pt1.getClass().getField("y");//fieldY表示字节码上的某个变量，不表示某个具体的变量
System.out.println(fieldY.get(pt1));
FieldfieldX=pt1.getClass().getDeclaredField("x");
fieldX.setAccessible(true);
System.out.println(fieldX.get(pt1));
changeStringValue(pt1);//将字符串中的某些字符替换成另外一些字符
System.out.println(pt1);
//MethodmethodCharAt=String.class.getMethod("charAt",int.class);//获取方法
//System.out.println(methodCharAt.invoke(str1,1));//invoke（调用），invoke调用methodCharAt方法上的方法
TestArguments.main(newString[]{});//调用TestArguments的主函数
TestArguments.main(newString[]{"11","222","3333"});//传参数，再调用主函数
MethodmethodCharAt=String.class.getMethod("charAt",int.class);
System.out.println(methodCharAt.invoke(str1,1));
System.out.println(methodCharAt.invoke(str1,newObject[]{2}));
TestArguments.main(newString[]{"11111","22222222222","3333333333"});
MethodmainMethod=Class.forName(startingClassName).getMethod("main",String[].class);
mainMethod.invoke(null,newObject[]{new String[]{"11","2222"}});
mainMethod.invoke(null,(Object)newString[]{"11","2222"});
int[] a1=newint[3];
int[] a2=newint[4];
int[][] a3=newint[2][3];
String[] a4=newString[3];
System.out.println(a1.getClass()==a2.getClass());
System.out.println(a1.getClass()==a4.getClass());
System.out.println(a1.getClass()==a3.getClass());
}
private static voidchangeStringValue(Object obj) throws Exception
{
//将字符串中的某些字符替换成另外一些字符方法
Field[]fields=obj.getClass().getFields();
for(Fieldfield:fields)
{
if(field.getType()==String.class)
{
String oldValue=(String)field.get(obj);
StringnewValue=oldValue.replace('b', 'a');
field.set(obj,newValue);
}
}
}
}
class TestArguments
{
public static voidmain(String[] args)
{
for(Stringarg:args)
System.out.println(arg);
}
-------------------android开发、java培训、期待与您交流！ ----------------------
扫一扫
709
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
