标签：
先安装了JDK
?
?
?
?
?
?
?
编写求和代码
?
使用Arrays.binarySearch()编写折半搜索数组元素代码
?
?
?
?
MyEclipse：
?
?
JUnit用来为程序写测试用例。
以前总是需要自己写个main方法来测试某个方法。当需要测试另一个方法时，还要在main中再写一段代码对另一个方法进行测试。
JUnit是专业的测试工具！！！
?
为JUnit写一个包：junit.test包。所有测试类都写到这个包中。
?
package cn.itcast; ? public class Person { ????public void run() { ????????System.out.println("run"); ????} ???? ????public void eat() { ????????System.out.println("eat"); ????} } |
?
包资源管理器à选中Person类à右键ànewàJUnit TestCaseà修改包名为junit.testà下一步à选中要测试的方法。
每个测试方法都会有@Test注解。
在生成的PersonTest中给testXXX()方法添加测试内容。
?
?
?
?
?
?
@Test – 必须是public的、返回为void、无参的方法
@Before --必须是public的、返回为void、无参的方法
@After --必须是public的、返回为void、无参的方法
@BeforeClass – 必须是public的、static的、返回为void、无参的方法
@AfterClass – 必须是public的、static的、返回为void、无参的方法
?
?
Java中可以定义任意类型的属性，例如String[]中存放的就是String类型的数据，我们称之为持有String类型的数组。但1.5之前时，Java的集合类却只能持有Object类型，1.5时添加了泛型的概念，泛型允许Java创建持有任意类型的集合对象，例如：new ArrayList<String>()表示这个ArrayList中只能持有String类型的对象。
?
具有一个或多个类型参数的类就是泛型类。
泛型类都至少有一个类型变量，你需要在创建泛型类对象时给类型变量赋值。当然，你要给类型变量赋的值必须是一个类型！
ArrayList<String> arr = new ArrayList<String>();
其中String就是给ArrayList类的类型变量赋值。在ArrayList类中所有使用类型变量的地方都会被String所替换。例如：boolean add(E e)，其中e的类型就是变量，它会被String替换，最终变成boolean add(String e)。E get(int index)方法中返回值的类型为变量，它也会被String替换，最终变成String get(int index)。
?
将运行期遇到的问题转移到了编译期。例如在1.4时，ArrayList类的add()方法参数还是Object类型，当然get()方法的返回值类型也是Object。这就说明使用get()方法获返回值后，你还需要强转。错误的强转可能会出现ClassCastException。
ArrayList list = new ArrayList();
list.add("hello");
Integer i = (Integer)list.get(0);//抛出异常
?
这个问题在有了泛型之后就不会再有了。
ArrayList<Integer> list = new ArrayList<Integer>();
list.add("hello");//编译出错！
Integer i = (Integer)list.get(0);
?
很明显，是泛型把只能在运行时才能找到的错误推向了编译期！这就是泛型的优点！！！
?
?
自定义泛型类的语法基本与定义正常的法一样：
public class A<T> {}
定义泛型类时，需要在类名后面给出一对尖括号，在尖括号中给出1~N个类型变量。
?
用户在使用泛型类时，需要为类型变量赋值。例如：new A<String>()。
在泛型类中可以使用类型变量：
private T t;
public A(T t) {
this.t = t;
}
public T get() {
return t;
}
}
当用户创建A类对象时，就会给A类的类型变量T赋值，例如：new A<String>()，这说明在A类中所有的T都会被String替换。
public class A {
private String t;
public A(String t) {
this.t = t;
}
public String get() {
return t;
}
}
?
上例中，A类中定义了T类型的属性t，这个属性t的类型是一个变量，无法确定的，因为你在定义A类时，根本就不知道用户会传递什么类型给T，所以你也不能调用属性t的方法，因为你不知道t的类型，就不知道它有什么方法。但是，我们知道任何类都是Object类的子类，那么就说明你可以调用属性t的Object中存在的方法。
注意，你不能使用T类型的构造器：new T()，因为你不能确定t的类型，那么也就不知道它有什么样的构造器，甚至是否有public构造器，所以不能创建。
相同的道理，也不能创建T类型的属性，例如：new T[10]，这也是不行的！
还有一点，在泛型类中，static方法中不能使用类型变量T。
?
?
如果当前类是泛型类，那么在继承（实现）泛型类（接口）时，可以把自己的类型变量传递给父类（接口）。
public class ArrayList<E> implements List<E> {
…
}
可以这样来理解，其中public class ArrayList<E>中的<E>表示定义了一个泛型类，其中E是定义的类型变量，而implements List<E>中的<E>表示给List接口传递<E>，这是在使用变量类型E，而不是在定义了。
ArrayList<String> arr = new ArrayList<String>();
在用户创建ArrayList类对象时，传递给ArrayList类中的E的值是String，那么ArrayList会把这个String再传递给List中的E。
你可能会想，为什么一定要给父类或接口传递类型变量。那我会问你，实现类不给List接口中的E来赋值，谁来给它赋值？难道你想new List<String>()这样赋值么？接口是不能被实例化的，你只能让实现类来赋值，你不赋值，接口中的get()方法一直返回E类型！！！
?
泛型类的子类不一定必须为泛型类，也可以是非泛型类。这时因为子类没有类型变量可以传递给父类，那么也就能传递给父类类型常量了。
public class String implements Comparable<String> {
public int compareTo(String other) {…}
}
?
这时，在重写父类中方法时，所有的类型变量都是String了。
?
?
泛型类是说明这个类有类型变量，在创建这个类对象时需要给类型变量赋值。泛型方法是说明这个方法有类型变量，在调用这个方法时需要给类型变量赋值。
public <T> T get(T[] ts, int index) {
return ts[index];
}
注意，在返回值前面定义类型变量。
get()方法是一个泛型方法，它有一个类型变量T，这说明在调用get()方法时需要给get()方法的T赋值。
如果要定义一个有意义的泛型方法，那么：
所以，通常在调用泛型方法时，只需要传递参数就可以了，例如：
String[] strs = …
String s = o.get(strs, 0);
上面代码中给get()方法的类型变量T赋值为String，因为传递的参数为String数组，所以就是给T赋值为String。
当然，也可以显示给出类型变量的值：o.<String>get(strs,0)，在点后面，方法名前面给出类型值，但一般人不会这么打代码。
?
编译期状态：编译期状态，例如内部类！内部类就是只有编译器知道，而JVM不知道什么叫内部类！
泛型其实是编译期状态，即JVM不知道什么是泛型，在JVM那里所有类都是正常的类。没有类型变量。一切的一切都是编译器干的好事儿！
其实List的get()方法返回值还是Object，只是编译器帮我们添加了强转的语句。但这个强转一定不会出现问题。因为本来add()方法添加元素已经限制过了，那么在get()时，一定不会出现强转的问题。
也就是说，在ArrayList类中持有的还是Object类型，而不是我们指定的类型。当然，就算是JVM没有泛型，但编译器会帮我们完成这些问题，我们就可以当泛型真的存在。
?
通常我们看到的泛型类都没有边界限定，也就是说可以给泛型类的类型变量赋任意类型的值（当然基本类型是不可以的）。
java允许给类型变量指定边界，这样用户在给类型变量赋值时就必须在边界之内。
public class A<T extends Number> {}表示用户可以给T赋值为Number或Number的子类型。例如：new A<Integer>()这是可以的，但new A<String>()是不可以的。
?
?
Object[] objs = new String[10];
objs[0] = new Integer(100);
上面代码编译是可以通过的，但在运行时会出现ArrayStoreException。因为objs数组真实的身份是String[]，向String[]数组中存放Integer对象当然是不行的。
ArrayList<Object> list = new ArrayList<String>();
list.add(new Integer(100);
上面代码在第一行位置编译失败，因为泛型根本就不让把ArrayList<String>赋值给ArrayList<Object>，对于ArrayList<Object>而言，只能赋值ArrayList<Object>，其他的什么都不能赋值。
这也说明一个问题：
public static void printList(List<Object> list) {…}
调用printList()方法只能传递给它List<Object>类型的参数，而不能传递List<String>，或者List<Integer>，这说明我们的printList()方法有很多的限制，不够通用！！！你可能会想我再重载几次printList()方法吧，但这是行不通的！
public static void printList(List<Object> list) {…}
public static void printList(List<String> list) {…}
因为JVM不知道什么是泛型，这两个方法在到了JVM那里时都是会把泛型参数擦除，这两个方法就是相同的方法了，擦除之后即：
public static void printList(List list) {…}
public static void printList(List list) {…}
当然JVM不可能看到这样的代码，因为编译器不能让你编译通过！
处理这个问题需要使用通配符！
?
public static void printList(List<? extends Person> list) {…}
这回可以传递给printList()方法List<Student>，以及List<Teacher>参数了。只要类型参数为Person，或者是Person子类型就都可以。
你可以这样来理解通配符，通配符表示"不知道"的意思。即一个问号！但子类型通配符还是知道一些信息的，它只知道用户转递的类型参数一定是Person的子类型。虽然使用了通配符之后printList()方法更加通用了，但是这也是要付出一些代价的。因为不知道List中类型参数的真实类型，所以就不能调用list的add()方法了。你可能会想add(new Student())应该是可以的，但如果List是List<Teacher>呢，你怎么向这样的List添加Student呢？再想一想，add()方法已经作废了，什么都传递不了。
?
public static void printList(List<? super Student> list) {…}
可以传递给printList()方法List<Student>，以及List<Person>，甚至List<Object>也是可以的。只要传递给printList()方法的List类型参数为Student，或者Student的父类型就是可以的。
你现在可以向list中添加Student类型的参数，例如：list.add(new Student())。因为用户提供的参数List<Student>、List<Person>、List<Object>，无论哪一种类型，对于list.add(new Student())都是合法的。
但是，现在我们不知道list的get()方法返回的是什么了！因为用户传递的可能是List<Student>、List<Person>、List<Object>，如果我们用Student s = list.get(0)，那么如果list其实是一个List<Person>岂不是出错了！没错，只能使用Object来接收list.get(0)的返回值了。
?
所谓无界通配符，即List<?>，对通配符没有限定。你可以给List<?>赋任意的值，但是，你能使用这样的list干什么呢？也不能add()，也只能使用Object来接收get()方法返回值。
所以，通常List<?>只能表示你在使用泛型而已！编译器会认为List<?>比List更加优雅一些！你可能也看出来了，泛型还真是很垃圾！！！这也是没有办法中的办法，现在的泛型是迁移性兼容的一种版本而已！Java设计者不敢让JVM知道泛型的存在，原因是为了兼容1.4之前的版本。当所有人都在使用1.5以上版本的JDK后，Java的泛型可能就不会再是编译期状态了。
?
?
在1.5之后，Java允许把基本类型与其对应的包装器类型之间自动相互转换。例如：Integer i = 100，把int类型的100直接给了Integer类型的变量i，这就是自动装箱。int a = new Integer(100)，这是自动拆箱。
Object o = 100;//其实是把100自动装箱为Integer，即Object o = Integer.valueOf(100)。
int a = (Integer)o;//其实是把o强转为Integer后，自动拆箱为int，即int a=((Integer)o).intValue()。
?
我们已经知道自动装箱使用的是Integer.valueOf()方法，但我们要了解一下，其实valueOf()方法会使用Integer类内部的缓存来获取Integer对象。
Integer类的内部缓存了-128~127之间的256个Integer对象，如果valueOf()方法需要把这个范围之内的整数转换成Integer对象时，valueOf()方法不会去new对象，而是从缓存中直接获取，这就会导致valueOf(100)两次，都是从缓存中获取的同一个Integer对象！
Integer i1 = Integer.valueOf(100);
Integer i2 = Integer.valueOf(100);
boolean b = i1 == i2;//结果为true
?
相同的道理：
Integer i1 = 100;
Integer i2 = 100;
boolean b = i1 == i2;//结果为true
?
但是：
Integer i1 = 200;
Integer i2 = 200;
boolean b = i1 == i2;//结果为false
?
这是因为200不在Integer内部的缓存之内，所以这时valueOf()方法会new一个Integer对象。每次valueOf(200)都会创建一个新的Integer对象，所以才会是false。
?
?
可以循环遍历数组或者集合类。
?
for(元素类型 e : 数组或集合对象) {
}
增强for每循环一次，都会把数组或集合中的一个元素赋值给e，从头开始遍历，直到最后一个元素。
?
只能从头到尾的遍历数组或集合，而不能只遍历部分。
在遍历List或数组时，不能获取当前元素下标。
增强for使用便简单，这是它唯一的优点了。
增强for比使用迭代器方便一点！
?
任何实现了Iterable接口的类，都可以使用增强for来遍历。
?
?
静态导入也需要使用import关键字；
静态导入后，在调用静态方法，以及使用静态属性时就可以不再给出类名了，例如向控制台打印时可以把System.out.println()写成out.println()；System.exit(0)写成exit(0)。
?
import static 包名.类名.静态方法名;
import static 包名.类名.静态属性名;
import static 包名.类名.*;
?
不建议使用！
使用静态导入，使代码可读性降低！
?
?
int sum(int a, int b) {return a + b;} int sum(int a, int b, int c) {return a + b;} int sum(int a, int b, int c, int d) {return a + b + c + d;} |
?
看上面代码。我们知道这种重载是无止境的！
当函数的参数可以是0~n个时，我们最好的办法就是使用数组来处理，例如把上面代码修改为一个函数：
int sum(int[] arr) { int sum = 0; for(int i = 0; i < arr.length; i++) { sum +=arr[i]; } return sum; } |
?
修改后的sum()方法可以计算0~N个整数的和，但调用sum()需要传递一个数组，这使调用这个函数很不方便。
int arr = {1,2,3,,4,5,5};
sum(arr);
?
可以把数组类型的参数定义为可变参数，例如：
int sum(int[] arr) { int sum = 0; for(int i = 0; i < arr.length; i++) { sum +=arr[i]; } return sum; } |
int sum(int… arr) { int sum = 0; for(int i = 0; i < arr.length; i++) { sum +=arr[i]; } return sum; } |
?
上面代码把int[] arr修改为int… arr，其中arr就变成了可变参数。
可变参数其实就是数组。
?
当调用int sum(int…arr)方法时就方便多了。如下方式的调用都是正确的：
?
调用可变参数方法，可以传递0~N个参数来调用，也可以直接传递数组来调用。
?
可变参数只能出现在方法的形参中，局部变量或属性是不能使用这种东西的。
?
?
word文档的对齐方式有几种：左对齐、居中对齐、右对齐；
开车的方向有几种：前、后、左、右；
枚举就是有限实现个数的类型，你可能会说，byte类型也只有256个，没错，但我们真实定义为枚举的类型，一般最多也就十多个实例，再多就不会定义为枚举了。
?
在JDK1.4之前没有枚举类型，都是使用int或字符串类型来表示枚举，如果枚举只有两个选项，那么连int都用不上，只需要使用boolean类型即可。
例如：BorderLayout类的方位给出五个：CENTER、EAST、SOUTH、WEST、NORTH。当使用容器类的方法添加组件时：add(new Button(), "CENTER")，这是合法的，但因为String类型太过宽泛，所以可能会出现add(new Button(), "哈哈")的调用可能，这会导致运行时出现异常。所以，JDK1.5又新增了枚举类型。
?
定义枚举类型需要使用enum关键字，例如：
public enum Direction { FRONT、BEHIND、LEFT、RIGHT; } |
Direction d = Direction.FRONT; |
?
注意，每个枚举选项之间是用逗号隔开的。如果枚举类没有构造器、方法等，在最后一个枚举选择后面可以不打分号。但是如果枚举类还有其他成员，那么就要在最后一个枚举项后面添加分号了。
Direction类型只有四个选项，你可以理解为这个枚举类只有四个实例对象一样。外界无法去创建新的枚举对象，只能从这四个中去选择。
其实大多数时候，我们使用枚举类型还是与以及使用int或String表示的枚举一样，基本上都是很简单的。
?
1.5开始枚举类型可以在switch中使用！在1.7之后，String类型也可以放到switch中使用了。
????????Direction d = Direction.FRONT; ????????switch(d) { ????????case FRONT: System.out.println("前面");break; ????????case BEHIND:System.out.println("后面");break; ????????case LEFT: System.out.println("左面");break; ????????case RIGHT: System.out.println("右面");break; ????????????default:System.out.println("错误的方向"); ????????} ????????Direction d1 = d; ????????System.out.println(d1); |
?
注意，在switch中，不能使用枚举类名称，例如："case Direction.FRONT："这是错误的，因为编译器会根据switch中d的类型来判定每个枚举类型，在case中必须直接给出与d相同类型的枚举选项，而不能再有类型。
?
?
所有枚举类都默认是Enum类的子类，无需我们使用extends来继承。这说明Enum中的方法所有枚举类都可以的。
?
枚举类也可以有构造器，构造器不能给出访问修饰，而且默认都是private构造器。因为枚举类的实例不能让外界来创建！
enum Direction { ????FRONT, BEHIND, LEFT, RIGHT; ???? ????Direction() { ????????System.out.println("hello"); ????} } |
?
再次强调，枚举类也是类，也可以有构造器、方法和属性，只是对构造器有一些限制而已。在语法上有一些怪异罢了！
enum Direction { ????FRONT, BEHIND, LEFT, RIGHT; ????public void fun() { ????????System.out.println("hello Enum!"); ????} } |
Direction.FRONT.fun(); |
?
枚举类也可以有属性。但是，如果每个枚举常量的属性值如果都相同，那就失去了意义，我们需要让每个枚举常量的属性值不同，那么就需要自己使用构造器来创建枚举常量，然后在构造器中给每个枚举常量传递不同的值。
enum Direction { ????FRONT("前面"), BEHIND("后面"), LEFT("左面"), RIGHT("右面"); ???? ????private String explain; ???? ????Direction(String explain) { ????????this.explain = explain; ????} ???? ????public void setExplain(String explain) { ????????this.explain = explain; ????} ? ????public String getExplain() { ????????return explain; ????} } |
????????String explain = Direction.FRONT.getExplain(); ????????System.out.println(explain); |
?
还可以使用匿名类来创建枚举常量，这说明枚举常量的类型是当前枚举类的子类，而且是个匿名类。这可以让每个枚举常量有自己的类型，当然有自己的类型不是目的，而是有自己的行为才是目的！但是我们知道就算给匿名类添加了自己独有的方法，也是无法调用的，因为匿名类没有名字，只能使用父类的引用指向匿名类的实例，而多态之后只能调用父类中存在的方法。所以，使用这种情况时，通常是为了让每个枚举常量重写当前枚举类中的方法（抽象方法）。
enum Direction { ????FRONT() { ????????public void fun() { ????????????System.out.println("FROND：重写了fun()方法"); ????????} ????}, ????BEHIND() { ????????public void fun() { ????????????System.out.println("BEHIND：重写了fun()方法"); ????????} ????}, ????LEFT() { ????????public void fun() { ????????????System.out.println("LEFT：重写了fun()方法"); ????????} ????}, ????RIGHT() { ????????public void fun() { ????????????System.out.println("RIGHT：重写了fun()方法"); ????????} ????}; ???? ????public void fun() { ????????System.out.println("没有意义的方法"); ????} } |
????????Direction.FRONT.fun(); ????????Direction.BEHIND.fun(); ????????Direction.LEFT.fun(); ????????Direction.RIGHT.fun(); |
?
通常fun()方法应该定义为抽象的方法，因为每个枚举常量都会去重写它。
你无法把Direction声明为抽象类，但需要声明fun()方法为抽象方法。
enum Direction { ????FRONT() { ????????public void fun() { ????????????System.out.println("FROND：重写了fun()方法"); ????????} ????}, ????BEHIND() { ????????public void fun() { ????????????System.out.println("BEHIND：重写了fun()方法"); ????????} ????}, ????LEFT() { ????????public void fun() { ????????????System.out.println("LEFT：重写了fun()方法"); ????????} ????}, ????RIGHT() { ????????public void fun() { ????????????System.out.println("RIGHT：重写了fun()方法"); ????????} ????}; ???? ????public abstract void fun(); } |
?
?
每个枚举类都有两个不用声明就可以调用的static方法，而且这两个方法不是父类中的方法。这又是枚举类特殊的地方，下面是Direction类的特殊方法。
?
?
其实枚举也是编译期状态，在运行时JVM并不知道什么是枚举类型。这也就是说，编译器需要把枚举类型转换成普通类。
enum Direction {FRONT, BEHIND, LEFT, RIGHT} |
final class Direction extends Enum { ????public static final Direction FRONT; ????public static final Direction BEHIND; ????public static final Direction LEFT; ????public static final Direction RIGHT; ????private static final Direction ENUM$VALUES[]; ? ????static { ????????FRONT = new Direction("FRONT", 0); ????????BEHIND = new Direction("BEHIND", 1); ????????LEFT = new Direction("LEFT", 2); ????????RIGHT = new Direction("RIGHT", 3); ????????ENUM$VALUES = new Direction[] {FRONT, BEHIND, LEFT, RIGHT}; ????} ? ????private Direction(String s, int i) { ????????super(s, i); ????} ? ????public static Direction[] values() { ????????Direction adirection[]; ????????int i; ????????Direction adirection1[]; ????????System.arraycopy(adirection = ENUM$VALUES, 0, ????????????????adirection1 = new Direction[i = adirection.length], 0, i); ????????return adirection1; ????} ? ????public static Direction valueOf(String s) { ????????return (Direction) Enum.valueOf(Direction.class, s); ????} } |
?
?
让我们从Class类开始了解反射！
每个加载到方法区中的class文件都对应一个Class类的对象，你可以把Class类的对象理解为硬盘上的class文件的对应体。
?
反射是Java中的高级特性，在各种Java框架中都需要使用反射。所以，就算你将来很长一段时间不使用反射，但你使用的框架都大量使用了反射，所以想深入学习框架，那么就一定要学习反射。
框架通常通过反射来识别一个对象的"类型信息"。当你传递给框架一个对象时，框架会通过反射来了解对象的真实类型（对象实体的类型，而不是引用的类型），这个类型有几个构造器，有什么样的属性，有什么样的方法。还可以通过反射调用构造器，调用方法，对属性进行读写操作。
你可能觉得这没有什么神奇的，那是你还没了解我说的是什么！你需要再想一想，写一个方法，参数是Object obj，然后你的方法需要创建一个与参数类型相同的对象出来，还要调用这个对象上的方法。需要注意，参数是Object类型，但用户调用这个方法时，可能传递的不是Object实体对象，它的真实类型有可能是任何类型。
public static void fun(Object obj) {
}
?
我们学习面向对象也有一定的时间了，可以通过面向对象的思想，猜测一个类中应该有什么样的方法了。
一个Student类用来表示学生类型，学生应该有名字，那么学生类就应该有getName()方法。学生也应该有学号，那么学生类就应该有getNumber()方法…
一个Class类用来表示类类型，类应该有属性，那么Class类就应该有getField()方法，但一个类可以有多个属性，那么Class类有的就不是getField()，而是getFields()方法，返回值为Field[]类型。相同的道理，Class类也应该有getMethods()和getConstructors()方法，用来返回这个类的所有方法和所有构造器的定义。其实今后我们去学习，很可能就只是想使用一个类的一个方法！然后才去查找这个类，再去学习我们需要的方法，对于这个类的其他就一无所知了！你很可能在编写某个项目时会有这样的想法：某某某方法应该是某某某类的！！！然后你就去查找API！
描述学生的类型、描述老师的类型、描述计算机的类型，都是很好理解的，但描述类的类型总是让人感觉怪怪的，这也是初学者需要习惯的地方。还有，我们在学习过程中称呼这些类型时也需要注意一下，例如Field表示属性类，Field类有一个属性叫name，那么我们需要怎么说明这个name属性呢？"属性类的name属性"，这是一个不错的称呼！
?
?
要想使用反射，首先你需要得到Class对象，然后才能通过Class对象获取Constructor、Field、Method等对象。所有的反射对象都不可能自己来new，说白一点，这些反射对象对应的是class文件上的信息，你怎么可能自己去new呢？如果可以自己去new一个Class类的对象，那么是不是就不用我们再去编写.java文件，然后再通过编译器去编译成.class文件了呢？当然这是不可能的！
我们需要思考，Class除了可以返回当前对应类型的所有属性、方法、构造器的反射对象外，还有什么功能呢？例如对应类型的类名是什么？对应类型的父类是谁？对应类型是不是public类，是不是final类。对应类型有没有可能是个数组类型？有没有可能是接口类型？有没有可能是基本类型等等！如果你学会了这样思考，那么你今后学习新类是就方便多了！
?
Class c1 = "".getClass(); Class c2 = String.class; Class c3 = Class.forName("java.lang.String"); System.out.println(c1 == c2); System.out.println(c2 == c3); |
?
上面代码输出的都是true，这是因为一个.class文件，在方法区中只对应一个Class对象。
?
我们已经知道，main()方法是程序的入口。那是不是在main()方法开始执行之前，所有的class文件都已经加载到方法区中了呢？答案是：NO！通常只有需要执行到使用某个类的代码时，才会去CLASSPATH中加载class文件，如果程序从头到尾都没有使用某个类，那么这个类对应的class文件就不会被加载到内存。
可以导致一个类被加载可能有：
上面给出的几个可能也只是可能而已，如果当前类没有被加载过，才会去加载，如果已经加载到方法区中了，那么就不可能再去加载。
?
方法1：
?
方法2：
?
方法3：
?
方法4：
?
其他反射类都在java.lang.reflect包下
AccessibleObject类是Constructor、Method、Field三个类的父类。
?
?
?
?
Modifier类有一系列的static方法用来解析其他getModifiers()方法返回的int值。
Method m = … int m = m.getModifiers(); boolean b1 = Modifier.isAbstract(m);//解析m中是否包含abstract修饰 boolean b2 = Modifier.isStatic(m);//解析m中是否包含static修饰 String s = Modifiers.toString(m);//把所有修饰都转换成字符串 |
?
?
?
?
自学笔记：
?
day07
?
上节内容回顾
????1、schema约束
????
????2、sax解析原理
????????* 采用事件驱动，边读边解析
????????** 解析到开始标签时候，执行startElement方法
????????** 解析到文本时候，执行characters方法
????????** 解析到结束标签时候，执行endElement方法
?
???? dom的解析原理：
????????* 根据xml的层级结构在内存中分配一个树形结构
????????* 会把xml的标签、属性和内容，都封装成对象
????????
????3、dom4j解析xml
????????* 使用dom4j，第一步导入jar包
?
????????* 使用dom4j实现查询操作
????????????** element("")：获取第一个子标签
????????????** elements(""):获取相同名称的子标签
????????????** elements(): 获取所有的子标签
?
????????????** 获取标签里面的内容： getText方法
?
????????* 使用dom4j实现增加操作（在末尾添加）
????????????** 在p1上面执行addElement方法
????????????** 在标签上添加文本内容使用 setText方法
????????????** 回写xml
????????????????- 格式化 ： OutputFormat...
????????????????- XMLWriter
????????????????- 执行write方法把document
????????????????- 关闭流
????????
????????* 使用dom4j实现增加操作（在特定为位置添加）
????????????** 首先获取到标签下面的所有的子标签
????????????** 返回list集合
????????????** list里面的方法 add(位置,"添加的元素")
????????????** list集合的位置从0开始的
????????
????????* 使用dom4j实现修改的操作
????????????** setText("内容")方法
????????
????????* 使用dom4j实现删除 操作
????????????** remove方法
????????????** 通过父节点删除
????????????????- getParent方法
????4、学生管理系统简单实现
????????* 实现增加操作
????????????- 通过对象传递进来
????????
????????* 删除操作
????????????- 通过id删除
????????????步骤：
????????????????1、获取所有的id
????????????????????- xpath //id
????????????????2、返回list集合
????????????????3、遍历list集合
????????????????4、得到每一个id的值
????????????????5、判断这两个id是否相同
????????????????6、如果相同，获取id的父节点
????????????????7、使用父节点删除
????????
????????* 查询操作
????????????- 通过id查询
????????????- 步骤：
????????????????1、获取所有的id
????????????????2、返回的list集合
????????????????3、遍历list集合
????????????????4、判断id是否相同
????????????????5、如果相同，获取相应的内容
?
1、myeclipse的安装和使用
????* eclipse：是一个免费的开发工具
????* myeclipse：是一个收费的插件，破解myeclipse，
????????** 安装目录的要求： 不能有中文和空格
????????** 安装完成之后，选择一个工作空间 ，这个工作空间不能有中文和空格
????* 破解myeclipse
????????** 运行run.bat文件，但是运行之前，必须要安装jdk，通过配置环境变量
?
????* myeclipse的使用
????????* 创建一个工程
????????????- 类型 java project web project
????????????- 选择依赖的jdk，可以使用myeclipse自带的jdk，或者可以使用安装的jdk
????????
????????* 创建包 package
????????????- cn.itcast.test XX.XX.XX
????????
????????* 在包里面创建一个类
????????????- 类的命名规范：
????????????????** 首字母要大写
????????????????????比如： TestDemo1 UserManager
????????
????????* 在类里面创建方法
????????????public void test1(参数列表) {
????????????????方法体或者返回值;
????????????}
????????????- 方法的命名规范
????????????????首字母小写 比如：addNum()
????????
????????* 定义变量
????????????- 变量的命名规范
????????????** 首字母小写，第二个单词的首字母要大写 ，比如 userName
????????
????????* 这些命名还有一种方式
????????????** 使用汉语拼音命名 yonghuming mima
????????????** 不能把汉语拼音和英文字母混合使用
????????????????userMing
?
????????* 命名的最基本的原则：看到名字知道是什么含义
?
????????* 代码需要有缩进
?
????????* 运行程序 run as java application
???????????? debug as java application
?
2、debug的调试模式（断点调试模式）
????* 使用这种模式，调试程序（看到程序里面数据的变化）
?
????* 使用debug第一步需要设置一个断点（让程序运行停止在这一行）
????????- 显示出来行号
????????- 双击左边，出现一个圆点，表示设置了一个断点
????* 使用debug as方式，运行程序
????????- 提示是否进入到调试界面，yes
????????- 在断点那一个，有一个绿色条，表示程序停止在这一行，没有向下运行
?
????* 可以让程序向下执行，
????????- 使用 step over 快捷键是 F6（单步执行）
????????- resume F8：表示调试结束，直接向下运行
????????????** 比如当前的断点之后还有断点，跳到下一个断点，
????????????** 如果当前断点后面没有断点，程序直接运行结束
????
????* debug另外一个用途
????????** 查看程序的源代码
????????** F5 step into：进入到方法
????????** F7 step return :返回
?
3、myeclipse的快捷键的使用
????* 代码提示 alt /
????* 快速导包 ctrl shift o
????* 单行注释 ctrl /
????* 去掉单行注释 ctrl /
????* 多行注释 ctrl shift /
????* 去掉多行注释 ctrl shift
????* 删除行 ctrl d
?
4、junit的使用
????* 单元测试
?
????* 测试对象是 是一个类中的方法
?
????* juint不是javase的一部分，想要使用导入jar包
????????** 但是，在myeclipse中自带了junit的jar包
????
????* 首先junit版本 3.x 4.x
????????* 单元测试方法时候，方法命名规则 public void 方法名() {}
????
????* 使用注解方式运行测试方法, 在方法的上面
????????** @Test：表示方法进行单元测试
?
????????--- @Test
????????????public void testAdd1() {
????????????????TestJunit test01 = new TestJunit();
????????????????test01.testAdd(2, 3);
????????????}
????????????- 选中方法名称，右键运行 点击run as --- junit test
????????????- 当出现绿色条，表示方法测试通过
????????????- 当出现了红棕色条，表示方法测试不通过
?
????????--- 要运行类中的多个测试方法，点击类中的其他位置，run as --- junit test
????
????????** @Ignore ：表示这个方法不参与单元测试
?
????????** @Before: 在每个方法执行之前运行
????????** @After：在每个方法执行之后运行
?
????????** 断言（了解）
????????????- Assert.assertEquals("测试期望的值", "方法运行的实际的值")
????????
jdk5.0新特性
jdk 1.1 1.2 1.4 5.0
** 泛型、枚举、静态导入、自动拆装箱、增强for、可变参数
** 反射
?
5、泛型的简介
????* 为什么要使用泛型？
????????- 一般使用在集合上
????????** 比如现在把一个字符串类型的值放入到集合里面，这个时候，这个值放入到集合之后，失去本身的类型，只能是object类型，
????????这个时候，比如想要对这个值进行类型转换，很容易出现类型转换错误，怎么解决这个问题，可以使用泛型来解决
????
????* 在集合上如何使用泛型
????????- 常用集合 list set map
????????- 泛型语法 集合<String> 比如 List<String>
????* 在泛型里面写是一个对象，String 不能写基本的数据类型 比如int (****)
????????** 写基本的数据类型对应包装类
????????????byte -- Byte
????????????short -- Short
?
????????????int -- Integer
?
????????????long -- Long
?
????????????float -- Float
????????????double -- Double
?
????????????char -- Character
?
????????????boolean -- Boolean
?
????* 在list上使用泛型
????????list的三种实现 ArrayList linkedList Vector
????????代码：
????????@Test
????????public void testList() {
????????????List<String> list = new ArrayList<String>();
????????????list.add("aaa");
????????????list.add("bbb");
????????????list.add("ccc");
?
????????????//遍历list集合 有几种方式 三种
????????????//普通for循环 迭代器 增强for
?
????????????//普通for循环
????????????for(int i=0;i<list.size();i++) {
????????????????String s = list.get(i);
????????????????System.out.println(s);
????????????}
?
????????????System.out.println("=================");
????????????//使用增强for
????????????for (String s1 : list) {
????????????????System.out.println(s1);
????????????}
?
????????????System.out.println("=================");
????????????//使用迭代器遍历
????????????Iterator<String> it = list.iterator();
????????????while(it.hasNext()) {
????????????????System.out.println(it.next());
????????????}
?
????????* 作业1： ArrayList linkedList Vector 这三个区别
?
????* 在set上使用泛型
????????代码：
????????//泛型使用set集合上
????????@Test
????????public void testSet() {
????????????Set<String> set = new HashSet<String>();
????????????set.add("www");
????????????set.add("qqq");
????????????set.add("zzz");
????????????//set.add("qqq");
????????????//遍历set 有几种方式 两种
????????????//迭代器 增强for
????????????//使用增强for遍历
????????????for (String s2 : set) {
????????????????System.out.println(s2);
????????????}
????????????System.out.println("=================");
????????????//使用迭代器遍历
????????????Iterator<String> it1 = set.iterator();
????????????while(it1.hasNext()) {
????????????????System.out.println(it1.next());
????????????}
????????}
????
????* 在map上面使用泛型
????????- map结构：key-valu形式
????????代码：
????????//在map上使用泛型
????????@Test
????????public void testMap() {
????????????Map<String,String> map = new HashMap<String,String>();
????????????map.put("aaa", "111");
????????????map.put("bbb", "222");
????????????map.put("ccc", "333");
????????????//遍历map 有几种遍历方式 两种
????????????// 1、获取所有的key，通过key得到value 使用get方法
????????????// 2、获取key和value的关系
????????????//使用第一种方式遍历
????????????//获取所有的key
????????????Set<String> sets = map.keySet();
????????????//遍历所有key返回的set
????????????for (String key : sets) {
????????????????//通过key得到value
????????????????String value = map.get(key);
????????????????System.out.println(key+" : "+value);
????????????}
????????????
????????????System.out.println("==============");
????????????//得到key和value的关系
????????????Set<Entry<String, String>> sets1 = map.entrySet();
????????????//遍历sets1
????????????for (Entry<String, String> entry : sets1) {
????????????????//entry是key和value关系
????????????????String keyv = entry.getKey();
????????????????String valuev = entry.getValue();
????????????????System.out.println(keyv+" : "+valuev);
????????????}
????????}
?
6、泛型使用在方法上
????* 定义一个数组，实现指定位置上数组元素的交换
????* 方法逻辑相同，只是数据类型不同，这个时候使用泛型方法
????* /*
???? * 使用泛型方法 需要定义一个类型 使用大写字母表示 T :这个T表示任意的类型
???? * 写在返回值之前 void之前 <T>
???? * =======表示定义了一个类型 这个类型是 T
???? * 在下面就可以使用这个类型了 T
???? * */
????
????public static <T> void swap1(T[] arr ,int a,int b) {
????????T temp = arr[a];
????????arr[a] = arr[b];
????????arr[b] = temp;
????}
?
????** 作业2： 实现一个泛型方法，接受任意一个数组，颠倒数组中所有元素
?
7、泛型在类上的使用（了解）
????* 在一个类上定义一个类型，这个类型可以在类里面直接使用
????* public class TestDemo04<T> {
????
????//在类里面可以直接使用T的类型
????T aa;
????public void test11(T bb) {}
????
????//写一个静态方法 在类上面定义的泛型，不能再静态方法里面使用
????public static <A> void test12(A cc) {}
????}
?
8、枚举的简介
????* 什么是枚举？
????????** 需要在一定的范围内取值，这个值只能是这个范围内中的任意一个。
????????** 现实场景：交通信号灯，有三种颜色，但是每次只能亮三种颜色里面的任意一个
????
????* 使用一个关键字 enum
????** enum Color3 {
????????RED,GREEN,YELLOW;
????}
????* 枚举的构造方法也是私有的
?
????* 特殊枚举的操作（了解）
????** 在枚举类里面有构造方法
????????** 构造方法里面有参数，需要在每个实例上面都写参数
????** 在枚举类里面有抽象方法
????????** 在枚举的每个实例里面都重写这个抽象方法
?
9、枚举的api的操作
????** name() ：返回枚举的名称
????** ordinal() ：枚举的下标，下标从0开始
????** valueOf(Class<T> enumType, String name) ：得到枚举的对象
?
????** 还有两个方法，都是这两个方法不在api里面，编译的时候生成两个方法
????*** valueof(String name) 转换枚举对象
????*** values() 获得所有枚举对象数组
?
????* 练习：枚举对象、枚举对象下标、枚举对象名称表示之间的转换
????- //知道枚举的对象，得到枚举名称和下标
????@Test
????public void test1() {
????????//得到枚举对象
????????Color100 c100 = Color100.RED;
????????//枚举名称
????????String name = c100.name();
????????//枚举的下标
????????int idx = c100.ordinal();
????????System.out.println(name+" "+idx);
????}
?
????- //知道枚举的名称，得到枚举的对象和下标
????@Test
????public void test2() {
????????String name1 = "GREEN";
????????//得到对象
????????Color100 c1 = Color100.valueOf(name1);
????????//枚举下标
????????int idx1 = c1.ordinal();
????????System.out.println(idx1);
????}
?
????- //知道枚举的下标，得到枚举的对象和名称
????@Test
????public void test3() {
????????int idx2 = 2;
????????//得到枚举的对象
????????Color100[] cs = Color100.values();
????????//根据下标得到对象
????????Color100 c12 = cs[idx2];
????????//得到枚举的名称
????????String name = c12.name();
????????System.out.println(name);
????}
?
10、静态导入(了解)
????* 可以在代码里面，直接使用静态导入方式，导入静态方法或者常量
????* import static XX.XX.xxx
?
????* import static java.lang.System.out;
????import static java.util.Arrays.sort;
?
????** 比如现在实现一个计算器 在Math类里面
?
11、自动拆装箱
????* 装箱
????????** 把基本的数据类型转换成包装类
????* 拆箱
????????** 把包装类转换成基本的数据类型
?
????** ????//自动装箱
????????Integer i = 10;
????????
????????//自动拆箱
????????int m = i;
????
????** 在jdk1.4里面如何实现装箱和拆箱
????????- //在jdk1.4里面实现拆装箱
????????public void test1() {
????????????//装箱
????????????Integer m = new Integer(10);????????
????????????//拆箱????
????????????int a = m.intValue();
????????}
????** jdk是会向下兼容
????????- 比如 jdk1.4里面写的代码，这个时候到5.0里面也可以运行
?
????** 练习：向下兼容
????== 执行的结果是会调用 doSomething(double m)
????== 首先在jdk1.4里面肯定调用这个方法，如果调用下面的方法，需要类型转换，但是jdk1.4不能实现自动拆装箱
????== 由于jdk是向下兼容，所以，在jdk1.4调用这个方法，在jdk5.0里面还是会调用这个方法
????????public static void main(String[] args) {
????????????doSomething(10);
?
????????}
????????
????????public static void doSomething(double m) {
????????????System.out.println("double......");
????????}
????????
????????public static void doSomething(Integer a){
????????????System.out.println("integer.....");
????????}
????** 记住：八种基本的数据类型对应的包装类
????????* int --- Integer
????????* char--- Character
?
12、增强for循环（*****）
????* 语法 for(遍历出来的值 : 要遍历的集合) {}
????????- for(String s : list) {
????????????System.out.println(s);
????????}
????* 使用场景： 数组；实现Iterable接口的集合 可以使用增强for循环
?
????* 在集合上使用增强for循环遍历
????????list set 实现了Iterator接口，所以可以使用增强for循环
????????map不能使用增强for循环，没有实现Iterator接口，所以不能使用增强for循环
?
????* 增强for循环出现目的：为了替代迭代器
????????** 增强for底层就是迭代器实现的
????
13、内容补充
????（1）泛型擦除
????????* 首先泛型只是出现在源代码阶段，当源代码编译之后泛型就不存在了
????
????（2）练习：实现一个泛型方法，接受任意类型的数组，颠倒数组中所有元素
????代码
????public static <T> void reverses(T[] arr1) {
????????/*
???????? * 基本思想：把第一个元素和最后一个元素交换位置，把第二个元素和倒数第二个元素交换位置。。。。
???????? * 交换 长度/2
???????? * */
????????//遍历数组
????????for(int i=0;i<arr1.length/2;i++) {
????????????/*int temp = arr1[0];
????????????arr1[0] = arr1[arr1.length-1];*/
????????????T temp = arr1[i];
????????????arr1[i] = arr1[arr1.length-i-1];
????????????arr1[arr1.length-i-1] = temp;
????????}
????????
????}
?
14、可变参数
????* 可变参数可以应用在什么场景：
????** 实现两个数的相加，实现三个数的相加 四个数的相加
????-- 如果在实现的多个方法中，这些方法里面的逻辑基本相同，唯一不同的是传递的参数的个数，可以使用可变参数
?
????* 可变参数的定义方法： 数据类型...数组的名称
????* 理解为一个数组，这个数组存储传递过来的参数
????- 代码
????????public static void add1(int...nums) {
????????????//nums理解为一个数组，这个数组存储传递过来的参数
????????????//System.out.println(nums.length);
????????????int sum = 0;
????????????//遍历数组
????????????for(int i=0;i<nums.length;i++) {
????????????????sum += nums[i];
????????????}
????????????System.out.println(sum);
?
????????}
????
????* 注意的地方
????????（1）可变参数需要写在方法的参数列表中，不能单独定义
????????（2）在方法的参数列表中只能有一个可变参数
????????（3）方法的参数列表中的可变参数，必须放在参数最后
????????????- add1(int a,int...nums)
?
15、反射的原理（********理解********）
????* 应用在一些通用性比较高的代码 中
????* 后面学到的框架，大多数都是使用反射来实现的
?
????* 在框架开发中，都是基于配置文件开发
????????** 在配置文件中配置了类，可以通过反射得到类中的 所有内容，可以让类中的某个方法来执行
?
????* 类中的所有内容：属性、没有参数的构造方法、有参数的构造方法、普通方法
????
????* 画图分析反射的原理
????????* 首先需要把java文件保存到本地硬盘 .java
????????* 编译java文件，形成.class文件
????????* 使用jvm，把class文件通过类加载加载到内存中
????????* 万事万物都是对象，class文件在内存中使用Class类表示
?
????????* 当使用反射时候，首先需要获取到Class类，得到了这个类之后，就可以得到class文件里面的所有内容
????????????- 包含属性 构造方法 普通方法
????????* 属性通过一个类 Filed
????????* 构造方法通过一个类 Constructor
????????* 普通方法通过一个类 Method
?
16、使用反射操作类里面的无参数的构造方法（**会写**）
????* 首先获取到Class类
????????- // 获取Class类
????????Class clazz1 = Person.class;
????????Class clazz2 = new Person().getClass();
????????Class clazz3 = Class.forName("cn.itcast.test09.Person");
?
????* 比如： 要对一个类进行实例化，可以new，不使用new，怎么获取？
????????- //得到Class
????????Class c3 = Class.forName("cn.itcast.test09.Person");
????????//得到Person类的实例
????????Person p = (Person) c3.newInstance();
????* 代码
????//操作无参数的构造方法
????@Test
????public void test1() throws Exception {
????????//得到Class
????????Class c3 = Class.forName("cn.itcast.test09.Person");
????????//得到Person类的实例
????????Person p = (Person) c3.newInstance();
????????//设置值
????????p.setName("zhangsan");
????????System.out.println(p.getName());
????}
?
17、使用反射操作有参数的构造方法（**会写**）
????//操作有参数的构造方法
????@Test
????public void test2() throws Exception {
????????//得到Class
????????Class c1 = Class.forName("cn.itcast.test09.Person");
????????//使用有参数的构造方法
????????//c1.getConstructors();//获取所有的构造方法
????????//传递是有参数的构造方法里面参数类型，类型使用class形式传递
????????Constructor cs = c1.getConstructor(String.class,String.class);
????????//通过有参数的构造方法设置值
????????//通过有参数的构造方法创建Person实例
????????Person p1 = (Person) cs.newInstance("lisi","100");
????????System.out.println(p1.getId()+" "+p1.getName());
????}
?
18、使用反射操作属性（**会写**）
????* //操作name属性
????@Test
????public void test3() {
????????try {
????????????//得到Class类
????????????Class c2 = Class.forName("cn.itcast.test09.Person");
????????????//得到name属性
????????????//c2.getDeclaredFields();//表示得到所有的属性
????????????//得到Person类的实例
????????????Person p11 = (Person) c2.newInstance();
????????????//通过这个方法得到属性，参数是属性的名称
????????????Field f1 = c2.getDeclaredField("name");
????????????//操作的是私有的属性，不让操作，需要设置可以操作私有属性setAccessible(true),可以操作私有属性
????????????f1.setAccessible(true);
????????????//设置name值 set方法，两个参数：第一个参数类的实例，第二个参数是设置的值
????????????f1.set(p11, "wangwu"); //相当于 在 p.name = "wangwu";
????????????System.out.println(f1.get(p11)); //相当于 p.name
????????}catch(Exception e) {
????????????e.printStackTrace();
????????}
????}
?
19、使用泛型操作普通方法（**会写**）
????* 使用Method类表示普通方法
????* 代码
????//操作普通方法 ，比如操作 setName
????@Test
????public void test4() throws Exception {
????????//得到Class类
????????Class c4 = Class.forName("cn.itcast.test09.Person");
????????//得到Person实例
????????Person p4 = (Person) c4.newInstance();
????????//得到普通方法
????????//c4.getDeclaredMethods();//得到所有的普通方法
????????//传递两个参数：第一个参数，方法名称；第二个参数，方法里面参数的类型
????????Method m1 = c4.getDeclaredMethod("setName", String.class);
????????//让setName方法执行 ，执行设置值
????????//使用invoke(p4, "niuqi");传递两个参数：第一个参数，person实例；第二个参数，设置的值
????????//执行了invoke方法之后，相当于，执行了setName方法，同时通过这个方法设置了一个值是niuqi
????????m1.invoke(p4, "niuqi");
????????System.out.println(p4.getName());
????}
????
????* //操作的私有的方法 ，需要设置值是true
????* //m1.setAccessible(true);
?
????* 当操作的方法是静态的方法时候，因为静态方法调用方式是 类名.方法名，不需要类的实例
????* 使用反射操作静态方式时候，也是不需要实例的
????* 在invoke方法的第一个参数里面，写一个 null
????????- m1.invoke(null, "niuqi");
?
?
?
?
?
?
?
?
?
?
?
?
?
标签：
原文地址：http://www.cnblogs.com/Prozhu/p/5719724.html
