增强for：注意：只适合取数据
// 使用增强for遍历Map集合
@Test
public void test1() {
LinkedHashMap<String, Integer> map = new LinkedHashMap<String, Integer>();
map.put("张三", 20);
map.put("李四", 21);
map.put("王五", 22);
map.put("赵六", 23);
for (Map.Entry<String, Integer> me : map.entrySet()) {
System.out.println(me.getKey() + me.getValue());
}
}
// 使用传统for遍历Map集合
@Test
public void test2() {
LinkedHashMap<String, Integer> map = new LinkedHashMap<String, Integer>();
map.put("张三", 20);
map.put("李四", 21);
map.put("王五", 22);
map.put("赵六", 23);
Set<String> keySet = map.keySet();
for (Iterator<String> it = keySet.iterator(); it.hasNext();) {
String key = it.next();
int value = map.get(key);
System.out.println(key + value);
}
}可变参数：注意：可变参数必须位于最后一项。
public class Demo1 {
/*
* 可变参数：适用于参数个数不确定，java把可变参数当做数组处理。
*
* 注意：如果出现可变参数的重载的情况，则编译器会自动调用最合适的方法匹配。
*
* 但是：
* public class Demo2 {
static void f(float i,Character...args){
System.out.println("first");
}
static void f(Character...args){
System.out.println("second");
}
public static void main(String[] args){
f(1,'a');
f('a','b');//Error无法确定调用哪个方法
}
}
*
*/
public static void main(String[] args) {
int[] i = { 1, 2, 3 };
String[] s = { "a", "b", "c" };
show(i); // 编译器会自动的把参数转变为数组的 show(new Object[]{i})
show(s); // 当使用数组作为参数(类型兼容)，那么编译器就不会帮你转化为数组了
show(s, i);// show(new Object[]{s,i})
}
/***********
* jdk5以后
***********/
private static void show(Object... obj) {
System.out.println("数组长度：" + obj.length);
}
/***********
* jdk5以前
***********/
private static void show2(Object[] obj) {
System.out.println(obj.length);
}
}输出结果：
数组长度：1
数组长度：3
数组长度：2枚举(enumeration)类：单例、多例、用于限定范围、是一个特殊类、继承Enum、每一个枚举值代表一个实例对象
public class EnumTest {
/*
* 编写一个星期几的枚举WeekDay，
* 要求：枚举值MON,TUE,WED,THU,FRI,SAT,SUN
* 调用方法返回中文格式的星期。
*/
public static void main(String[] args) {
printDay(WeekDay.WED);
}
private static void printDay(WeekDay day) {
System.out.println(day.getEnday() + ":" + day.getCnday());
}
}
enum WeekDay {
/*
* 枚举是用来限定范围，枚举值就是它的具体取值范围
* 当有多个枚举值的时候，可以通过构造函数的重载，来表示不同的对象。
* 在这里枚举只是用来封装星期信息，每一个枚举值代表一个星期对象。
* 每一个星期对象应该有一个英文的星期成员，和一个把英文星期转换成中文的方法。
*/
MON("Monday") {
public String getCnday() {
return "星期一";
}
},
TUE("Tuesday") {
public String getCnday() {
return "星期二";
}
},
WED("Wednesday") {
public String getCnday() {
return "星期三";
}
},
THU("Thursday") {
public String getCnday() {
return "星期四";
}
},
FRI("Friday") {
public String getCnday() {
return "星期五";
}
},
SAT("Saturday") {
public String getCnday() {
return "星期六";
}
},
SUN("Sunday") {
public String getCnday() {
return "星期天";
}
};
private String enday;
public String getEnday() {
return enday;
}
WeekDay(String day) {
enday = day;
}
public abstract String getCnday();
}反射：1.加载类字节码Class 2.解剖出类的个个组成部分 3.使用........主要用于框架...
public class Reflex {
// 反射无参数的构造函数
@Test
public void test1() throws Exception {
Class clazz = Class.forName("cn.itcast.demo.Person");
Constructor c = clazz.getConstructor(null);
Person p = (Person) c.newInstance(null);
}
// 反射有参数的构造函数
@Test
public void test2() throws Exception {
Class clazz = Class.forName("cn.itcast.demo.Person");
Constructor c = clazz.getConstructor(String.class);
Person p = (Person) c.newInstance("张三");
}
// 反射主函数
@Test
public void test3() throws Exception {
Class clazz = Class.forName("cn.itcast.demo.Person");
Method m = clazz.getMethod("main", String[].class);
/*
* 主函数的参数是一个字符串数组...
* invoke(Object obj, Object... args)方法...
* 接收的参数是一个可变参数列表。如果直接传递一个字符串对象数组，编译器不会帮你把数组封装到Object数组中
* 那么invoke()方法内部在遍历这个数组获取参数的时候，遍历到的结果是空
* 所以只能把他提升为Object对象，这样它才会被编译器当成一个元素封装到Object数组中
*
*/
m.invoke(null, (Object) new String[] {});
}
// 反射私有方法
@Test
public void test4() throws Exception {
Class clazz = Class.forName("cn.itcast.demo.Person");
Method m = clazz.getDeclaredMethod("getName", null);
// 修改访问权限，强制访问、、、
m.setAccessible(true);
String str = (String) m.invoke(clazz.newInstance(), null);
System.out.println(str);
}
// 反射字段
@Test
public void test5() throws Exception {
Class clazz = Class.forName("cn.itcast.demo.Person");
Person p = (Person) clazz.newInstance();
Field numField = clazz.getDeclaredField("num");
// 修改访问权限，强制访问、、、
numField.setAccessible(true);
int num = numField.getInt(p);
System.out.println(num);
Field numsField = clazz.getDeclaredField("nums");
Integer[] nums = (Integer[]) numsField.get(p);
System.out.println(nums);
}
}
内省：通过反射机制获取 setter和 getter
1.使用SUN的 java.beans：
public class JavaBeanTest {
@Test
public void test1() throws Exception {
BeanInfo bi = Introspector.getBeanInfo(cn.itcast.bean.User.class);
PropertyDescriptor[] pds = bi.getPropertyDescriptors();
for (PropertyDescriptor pd : pds) {
System.out.println(pd.getName());
}
}
@Test
public void test2() throws Exception {
Class clazz = Class.forName("cn.itcast.bean.User");
User u = (User) clazz.newInstance();
PropertyDescriptor pd = new PropertyDescriptor("name", cn.itcast.bean.User.class);
Method setMethod = pd.getWriteMethod();
setMethod.invoke(u, "张三");
Method getMethod = pd.getReadMethod();
String name = (String) getMethod.invoke(u, null);
System.out.println(name);
}
}2.使用beanutils：
public class BeanUtilTest {
// 使用 BeanUtils
@Test
public void test1() throws Exception {
User u = (User) Class.forName("cn.itcast.bean.User").newInstance();
BeanUtils.setProperty(u, "name", "张三");
String name = BeanUtils.getProperty(u, "name");
System.out.println(name);
}
// 自定义日期转换器 ConvertUtils
@Test
public void test2() throws Exception {
String name = "张三";
String birthday = "1949-10-1";
ConvertUtils.register(new Converter() {
public <T> T convert(Class<T> type, Object value) {
if (value == null)
return null;
if (!(value instanceof String))
throw new ConversionException("不能转换");
String str = (String) value;
if (str.equals(""))
return null;
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
try {
return (T) df.parse(str);
} catch (ParseException e) {
throw new RuntimeException(e);
}
}
}, Date.class);
User u = new User();
BeanUtils.setProperty(u, "name", name);
BeanUtils.setProperty(u, "birthday", birthday);
System.out.println(BeanUtils.getProperty(u, "birthday"));
System.out.println(BeanUtils.getProperty(u, "name"));
}
}泛型(generic)：注意：如果两边都使用泛型，两边必须都一样、、、类型参数变量、、、实际类型参数、、、
public class GenericTest {
/*
* 编写一个泛型方法，接收任意数组，并颠倒顺序
*/
public static void main(String[] args) {
Integer[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
changeArr(arr);
for (int val : arr) {
System.out.println(val);
}
}
public static <T> void changeArr(T[] arr) {
int len = arr.length;
if (len == 0) return;
int centre = len / 2;
int end = len - 1;
for (int star = 0; star < centre; star++, end--) {
T temp = arr[star];
arr[star] = arr[end];
arr[end] = temp;
}
}
}
523
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
