------- android培训、java培训、期待与您交流！ ----------
枚举
枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则编译器就会报错。枚举可以让编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。
用普通类如何实现枚举功能，定义一个WeekDay的类来模拟枚举功能。
思路：
私有的构造方法；
每个元素分别用一个公有的静态成员变量表示；
可以有若干公有方法或抽象方法，例如，要提供nextDay方法必须是抽象的。
public abstract class WeekDay {
private WeekDay()
{
}
public final static WeekDay SUN = new WeekDay(){
@Override
public WeekDay nextDay() {
return MON;
}
};
public final static WeekDay MON = new WeekDay(){
@Override
public WeekDay nextDay() {
return SUN;
}
};
public abstract WeekDay nextDay();
public String toString()
{
return this==SUN?"SUN":"MON";
}
}
public class EnumTest {
public static void main(String[] args) {
WeekDay weekDay = WeekDay.MON;
System.out.println(weekDay.nextDay());
}
}
举例：定义一个WeekDay的枚举。
扩展：枚举类的values,valueOf,name,toString,ordinal等方法。
枚举是一种特殊的类，其中每个元素都是该类的一个实例对象。
public class EnumTest {
public static void main(String[] args) {
WeekDay weekDay = WeekDay.FRI;
System.out.println(weekDay);
System.out.println(weekDay.name());
System.out.println(weekDay.ordinal());
System.out.println(WeekDay.valueOf("SUN").toString());
System.out.println(WeekDay.values().length);
}
public enum WeekDay
{
SUN,MON,TUE,WED,THI,FRI,SAT;
}
}实现带有构造方法和抽象方法的枚举
带构造方法的枚举
1.构造方法必须定义成私有的；
2.如果有多个构造方法，确定该选择哪个构造方法；
3.枚举元素MON和MON()的效果一样，都是调用默认的构造方法。
带方法的枚举
定义枚举TrafficLamp
实现普通的next方法
实现抽象的next方法：每个元素分别是枚举类的子类来生成的实例对象，这些子类采用类似内部类的方式进行定义。
增加上表示时间的构造方法。
public enum TrafficLamp
{
RED(30) {
@Override
public TrafficLamp nextLamp() {
return GREEN;
}
},
GREEN(45) {
@Override
public TrafficLamp nextLamp() {
return YELLOW;
}
},
YELLOW(5) {
@Override
public TrafficLamp nextLamp() {
return RED;
}
};
private int time;
public abstract TrafficLamp nextLamp();
private TrafficLamp(int time)
{
this.time = time;
}
}反射
反射就是把java类中的各种成分映射成相应的java类。
一个类中的组成部分：成员变量、方法、构造方法、包等信息都可以用一个个相应的java类来表示。
Constructor类
Constructor类代表某一个类中的一个构造方法。
得到某个类的所有的构造方法：
Constructor[] constructors = Class.forName("java.lang.String").getConstructors();
得到某一个构造方法：
Constructor constructor = Class.forName("java.lang.String").getConstructor(StringBuffer.class);
创建实例对象：
通常方式：String str = new String(new StringBuffer("abc"));
反射方式：String str = (String)constructor.newInstance(new StringBuffer("abc"));
用我们比较熟悉的Person类来举例，用反射的方式创建它的一个实例对象。
import java.lang.reflect.Constructor;
class Person
{
private String name;
private int age;
public Person()
{
}
public Person(String name,int age)
{
this.name = name;
this.age = age;
}
public void shout()
{
System.out.println("name = " + name + ",age = " + age);
}
}
public class TestPerson {
public static void main(String[] args) throws Exception
{
//先获取Person类的字节码，然后调用getConstructor(参数列表)。
Constructor constructor = Person.class.getConstructor(String.class,int.class);
Person p = (Person)constructor.newInstance("zhangsan",20);
}
}Field类
Field类代表某个类中的一个成员变量。
用反射的方式不但可以访问类中非私有的成员变量，同时可以访问私有的成员变量。
接着上面的Person类进一步对其成员变量进行访问。
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
class Person
{
private String name;
private int age;
public Person()
{
}
public Person(String name,int age)
{
this.name = name;
this.age = age;
}
public void shout()
{
System.out.println("name = " + name + ",age = " + age);
}
}
public class TestPerson {
public static void main(String[] args) throws Exception
{
//通过反射方式创建实例对象
Constructor constructor = Person.class.getConstructor(String.class,int.class);
Person p = (Person)constructor.newInstance("zhangsan",20);
//成员变量name是私有化的，需要先获得声明的变量然后设置为可访问。
Field fieldName = p.getClass().getDeclaredField("name");
fieldName.setAccessible(true);
fieldName.set(p, "lisi");
System.out.println(fieldName.get(p));
}
}
Method类
Method类代表某个类中的一个成员方法。
得到类中的某一个方法：
Method charAt = Class.forName("java.lang.String").getMethod("charAt",int.class);
调用方法：
通常方式：str.charAt(1);
反射方式：charAt.invoke(str,1);
创建Person实例对象，并对其内部的shout()方法进行调用。
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
class Person
{
private String name;
private int age;
public Person()
{
}
public Person(String name,int age)
{
this.name = name;
this.age = age;
}
public void shout()
{
System.out.println("name = " + name + ",age = " + age);
}
}
public class TestPerson {
public static void main(String[] args) throws Exception
{
//通过反射方式创建实例对象
Constructor constructor = Person.class.getConstructor(String.class,int.class);
Person p = (Person)constructor.newInstance("zhangsan",20);
//通过反射方式获取到shout()方法，并对其调用
Method methodShout = p.getClass().getMethod("shout");
methodShout.invoke(p);
}
}用反射方式执行某个类中的main方法
import java.lang.reflect.Method;
public class TestMainMethod {
public static void main(String[] args) throws Exception {
String startingClassName = args[0];
Method mainMethod = Class.forName(startingClassName).getMethod("main", String[].class);
mainMethod.invoke(null,(Object)new String[]{"1"});
}
}这样设计的好处在于创建框架阶段，我们不知道要调用哪个类的main方法，可以将未知类设置成参数传递给args[]。
框架的概念及用反射技术开发框架的原理
1.框架与框架要解决的核心问题
我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用我的框架，把门窗插入进我提供的框架中。框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。
2.框架要解决的核心问题
我在写框架（房子）时，你这个用户可能还在上小学，还不会写程序呢？我写的框架程序怎样能调用到你以后写的类（门窗）呢？
因为在写程序时无法知道要被调用的类名，所以，在程序中无法直接new 某个类的实例对象了，而要用反射方式来做。
package com.itheima.day1;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Collection;
import java.util.Properties;
public class ReflectTest {
public static void main(String[] args) throws Exception {
InputStream is = new FileInputStream("config.properties" );
Properties props = new Properties();
props.load(is);
is.close();
String className = (String)props.get( "className");
Collection collections = (Collection)Class.forName(className).newInstance();
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);
System. out.println(collections.size());
}
}
129
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
