1.Java基础复习

1.增强for循环只能用在数组或实现Iterable接口的集合类上

2.使用增强for需要注意的问题：增强for只适合取数据，要修改数组或集合中的数据，要用传统方式

3.可变参数 public void sum(int ...nums){}

4. int[] nums = {1,2,3,4,5};
List list = Arrays.asList(nums);
System.out.println(list);

 结果：[[I@15db9742]
Integer[] nums = {1,2,3,4,5};
List list = Arrays.asList(nums);
System.out.println(list);

结果：[1, 2, 3, 4, 5]

5.枚举
枚举类也是一种特殊形式的Java类
枚举类中声明的每一个枚举值代表枚举类的一个实例对象

枚举类的构造函数必须为私有（公有的话new出新的对象，就不叫枚举类了）

6.枚举

public class T1 {

public static void main(String[] args) {
print(Grade.A);

}
public static void print(Grade g) {
System.out.println(g.getValue());
}

}
enum Grade{
A("90-100"),B("80-90"),C("70-80"),D("60-70"),E("0-59");
private String value;
private Grade(String value) {
this.value = value;
}
public String getValue() {
return this.value;
}
}

7.带抽象方法的枚举
package 带抽象方法的枚举;

public class T1 {
public static void main(String[] args) {

print(Grade.A);
}
public static void print(Grade g) {
System.out.println(g.localValue());
}
}

enum Grade{
A("90-100"){
public String localValue() {
return "优";
};

},B("80-90"){
public String localValue() {
return "良";
}
},C("70-80"){
public String localValue() {
return "中";
}
},D("60-70"){
public String localValue() {
return"差";
};
},E("0-59"){
public String localValue() {
return"不及格";
};
};

private String value;
private Grade(String value) {
this.value = value;
}
public String getValue() {
return this.value;
}
public abstract String localValue();

}

8.反射就是加载类，并解剖出类的各个组成部分 

9.为什么本可以直接创建对象，获取方法。还要用反射？   放射是用来做框架的
10.反射类的构造方法，方法，属性

package 反射类的构造函数;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Field;

public class reflect1 {

public static void main(String[] args) throws Exception {
//反射类的构造函数
Class clazz1 = Class.forName("反射类的构造函数.Person");
//获取构造函数
Constructor c1 = clazz1.getConstructor(null);
//创建person对象
Person p1 = (Person)c1.newInstance(null);
System.out.println(p1.name);

Class clazz2 = Class.forName("反射类的构造函数.Person");
Constructor c2 = clazz2.getConstructor(String.class,int.class);
Person p2 = (Person)c2.newInstance("gjq",18);
System.out.println(p2.age);

Class clazz3 = Class.forName("反射类的构造函数.Person");
//注意此处变为Declared
Constructor c3 = clazz2.getDeclaredConstructor(String.class,String.class);
//对于私有构造方法，暴力反射
c3.setAccessible(true);
Person p3 = (Person)c3.newInstance("gjq","man");
System.out.println(p3.sex);

//另一种创建（无参）构造函数对象的方法
Class clazz4 = Class.forName("反射类的构造函数.Person");
Person p4 = (Person)clazz4.newInstance();

//反射类的方法

Person p5 = new Person();
//反射类
Class clazz5 = Class.forName("反射类的构造函数.Person");
//获取类的方法
Method m1 = clazz5.getMethod("m1", null);
//执行P5对象的m1方法
m1.invoke(p5, null);

//反射类
Class clazz6 = Class.forName("反射类的构造函数.Person");
//获取类的方法
Method m2 = clazz5.getMethod("m2", String.class);
//执行m1方法
m2.invoke(null,"ylz");//静态方法不需要对象

//反射类的main方法

//反射类
Class clazz7 = Class.forName("反射类的构造函数.Person");
//获取类的方法
Method m3 = clazz7.getMethod("main", String[].class);
//执行main方法
m3.invoke(null,(Object)new String[]{"1","2","3"});//invoke遇到数组参数会拆，拆成三个
//字符串，与main方法形参不一致，所以这用（Object）
//骗一下他

//反射类的属性
Person p6 = new Person();
Class clazz8 = Class.forName("反射类的构造函数.Person");
Field f1 = clazz8.getDeclaredField("height");
f1.setAccessible(true);
float height1 = (float)f1.get(p6);
System.out.println(height1);

}
}
Person类

package 反射类的构造函数;

public class Person{
float height = 1.75f;
String name = "gyc";
int age = 18;
String sex = "man";
public static void main(String[] args) {
System.out.println("main方法");
}

public Person(){
System.out.println("person");
}
public Person(String name,int age ){
this.name = name;
this.age = age;
}
private Person(String name,String sex){
this.name = name;
this.sex = sex;
}

public void m1() {
System.out.println("m1方法");
}

public static void m2(String name) {
System.out.println(name);
}
}