【Java】Java复习笔记－第四部分

反射

反射：

　　在运行时动态分析或使用一个类进行工作。
　　java.lang.Class类：描述类信息的类。
　　类对象：描述一个类信息的对象，当虚拟机加载类的时候，就会创建这个类的类对象并加载该对象，Class是类对象的类型。

获得类对象的方式：

　　用" 类名.class "获得这个类的类对象。
　　用类的对象掉用getClass()，如object.getClass()得到这个对象的类型的类对象。
　　可以使用Class.forName(类名)，也可以得到这个类的类对象，（注意，这里写的类名必须是全限定名（全名），是包名加类名，XXX.XXX.XXXX）。
　　基本类型也有类对象，用" 封装类.TYPE "可以获得对应的基本类型的类对象。

---

java.lang.reflect包下的三个重要类：

　　Field属性类：用来描述属性的信息。
　　Method方法类：方法的信息的描述。
　　Constructor构造方法类：用来描述构造方法的信息。

---

Class类中的常用方法

newInstance()

　　创建此 Class 对象所表示的类的一个新实例(调用无参构造创建的对象)。

getDeclaredMethods()

　　获得的是一个Method方法类对象的数组，获得本类(不包括父类)声明的所有(包括private的)方法对象。

getMethods() //推荐使用

　　获得的是一个Method方法类对象的数组，获得所有(父类的也包括)publice的方法对象。

getDeclaredConstructors()

　　获得的是一个Constructor构造方法类对象的数组，获得这个类声明的所有构造方法对象。

getConstructors() //推荐使用

　　获得的是一个Constructor构造方法类对象的数组，获得所有publice的构造方法对象。

getDeclaredFields() //推荐使用

　　获得的是一个Field属性类对象的数组，获得本类声明的所有属性的属性对象。

getFields()

　　获得的是一个Field属性类对象的数组，获得所有publice的属性对象。

---

使用反射构造一个类的对象的步骤

1.  获得类对象
2. 获得构造方法对象
3. 获得对象，用构造方法对象调用构造方法，如果使用无参构造方法，可以跳过第二步，直接使用" 类对象.newInstance() "方法来获得这个类的对象
4. 获得方法对象
5. 用方法对象调用方法（用这个类的对象作为第一参数）

　　如下面的例子：

反射机制的实现类：

 1 public class TestReflect
 2  {    
 3     public static Object get(String className , Map<String,Object> map) throws Exception
 4     {
 5         Class c = Class.forName(className); //获得类对象
 6         Object o = c.newInstance(); //获得对象
 7         Set<String> set = map.keySet();
 8         for(String str : set)
 9         {
10             String s = "set" + str.substring(0,1).toUpperCase()+str.substring(1);
11             Field f = c.getDeclaredField(str);
12             Method m = c.getMethod(s, f.getType()); //获得方法对象
13             m.invoke(o, map.get(str)); //用方法对象调用方法
14         }
15         return o;
16     }
17 
18     public static void main(String[] args) throws Exception 
19     {    
20         Map m = new HashMap();
21         m.put("name", "zhang");
22         m.put("age", 22);
23         Object o = get("day07.reflect.Student",m);
24         Student s = (Student) o;
25         System.out.println(s.getName() + " " + s.getAge());
26         
27         Map m1 = new HashMap();
28         m1.put("name", "li");
29         m1.put("gender", "男");
30         Object o1 = get("day07.reflect.Teacher",m1);
31         Teacher t = (Teacher) o1;
32         System.out.println(t.getName() + " " + t.getGender());
33     }
34 }

View Code

学生类：

 1 public class Student 
 2 {
 3     private String name;    
 4     private int age;    
 5     public int getAge() 
 6     {
 7         return age;
 8     }    
 9     public void setAge(int age) 
10     {
11         this.age = age;
12     }    
13     public String getName() 
14     {
15         return name;
16     }    
17     public void setName(String name) 
18     {
19         this.name = name;
20     }
21 }    

View Code

教师类：

 1 public class Teacher 
 2 {
 3     private String name;    
 4     private String gender;    
 5     public String getGender() 
 6     {
 7         return gender;
 8     }    
 9     public void setGender(String gender) 
10     {
11         this.gender = gender;
12     }    
13     public String getName()
14     {
15         return name;
16     }    
17     public void setName(String name) 
18     {
19         this.name = name;
20     }    
21 }

View Code

  

---

内部类

定义：

　　定义在另外一个类中的类，就是内部类。
　　编译后生成的两个独立的类：Outer.class 和Outer$Inner.class。

内部类的分类：

静态内部类：

　　静态内部类定义在类中，任何方法外，用static修饰
　　静态内部类只能访问外部类的静态成员。
　　在外部类的外部，要创建一个静态内部类对象不需要外部类对象：
　　Outer.Inner in = new Outer.Inner();
　　在本类内部生成内部类对象的方式：

Inner in = new Inner();    

成员内部类：

　　作为外部类的一个成员存在，与外部类的属性、方法并列
　　在内部类中可以直接访问外部类的私有属性。
　　内部类和外部类的实例变量允许命名冲突。
　　在内部类中访问实例变量：this.属性
　　在内部类访问外部类的实例变量：外部类名.this.属性
　　在外部类的外部，要创建一个成员内部类对象，要首先建立一个外部类对象，然后再创建一个成员内部类对象。

Outer out = new Outer();
Outer.Inner in = out.new Inner();

　　在本类内部生成内部类对象的方式：
　　在静态方法中：Inner in = new Outer().new Inner();
　　在非静态方法中：Inner in = this.new Inner();
　　成员内部类不可以有静态成员，这是因为静态属性是在加载类的时候创建，这个时候内部类还没有被创建。

局部内部类：

　　在外部类的方法中定义的内部类
　　与局部变量类似，在局部内部类前不可以加修饰符public和private，其作用域为定义它的代码块。
　　局部内部类不仅可以访问外部类的实例变量，还可以访问外部类的局部变量，但要求外部类的局部变量必须为final的。
　　配合接口使用，来做到强制弱耦合。
　　在外部类的外部不可创建局部内部类对象，只能在局部内部类所在的方法中创建：

Inner in = new Inner();

匿名内部类：

　　一种特殊的局部内部类
　　没有名字，也没有class、extends、implements关键字
　　用一种隐含的方式实现一个接口或继承一个类，并且只能创建一次实例。
　　实现方式：在某个语句中，new 父类/父接口名字(){ 类体中实现方法 }
　　例如：

1 TreesSet ts = new TreeSet(new Comparator()
2 {
3     public int compare(Object o1, Object o2)
4     {
5         return 0;
6     }
7 });    

View Code

　　匿名内部类属于局部内部类，那么局部内部类的所有限制都对其生效。
　　匿名内部类是唯一一种无构造方法的类，因为构造器的名字必须合类名相同，而匿名内部类没有类名。

 

---

 异常

异常的分类

　　Java会将所有的异常封装成对象，其根本父类为Throwable。
　　Throwable有两个子类：Error 和Exception。

Error：

　　一个Error对象表示一个程序错误，指的是底层的低级的不可恢复的严重错误
　　遇到Error，程序一定会退出，因为已经失去了运行所必须的物理环境。
　　对于Error我们无法进行处理，因为我们是通过程序来应对错误的，可是程序已经退出了。

Exception：

　　由特定因素，导致程序无法继续，但不影响虚拟机的正常执行。

未检查异常(Runtime Exception)：

　　是因为程序员没有进行必要的检查，由于程序员的疏忽而引起的异常。
　　对于未检查异常可以不处理，编译可以通过，应对未检查异常的方法就是养成良好的检查习惯

已检查异常(非Runtime Exception)：

　　是不可避免的，对于已检查异常必须处理，否则编译不通过。

 

异常处理的机制：

　　当一个方法中有一条语句出现了异常，它就会throw（抛出）一个异常对象（throw 异常对象），然后后面的语句不会执行，而返回上一级方法，其上一级方法接受到了异常对象之后，有可能对这个异常进行处理(进行处理则不会上抛)，也可能将这个异常传到它的上一级，如果最上一级(main方法)不处理就会传给虚拟机，虚拟机就会终止程序的运行。

 

异常的处理方式：

　　throws和try-catch方法
　　try-catch处理方式：

try
{     //一个

    (1)可能出现异常的语句

} catch(XxxException e /*捕获的异常*/)
{    //0或n个

    (2)处理异常的代码

} finally
{     //0或1个

    (3)必须要执行的代码

}
(4)方法中的其他代码

View Code

　　如果代码正确，那么程序不经过catch语句直接向下运行；
　　如果代码不正确，则将返回的异常对象和e进行匹配，如果匹配成功，则处理其后面的异常处理代码。
　　try中如果发现错误，即跳出try块去匹配catch，那么try后面的语句就不会被执行。
　　一个try可以跟多个catch语句，用于处理不同情况，但是不能将父类型的exception的位置写在子类型的excepiton之前。
　　在try-catch后还可以再跟一子句finally。其中的代码语句论有没有异常都会被执行(因为finally子句的这个特性，所以一般将释放资源，关闭连接的语句写在里面)。
　　finally中的代码和try-catch中的代码冲突时，finally中的代码一定会被执行且会忽略try-catch中的代码。但是如果try-catch中有System.exit(0);(虚拟机退出语句)，则不会去执行fianlly中的代码。

throws/throw处理方式：

　　throw 写在方法内，后面跟一个异常对象。
　　throws 在方法的定义中说明方法可能抛出的异常，后面跟异常类的名字，声明这个方法将不处理异常，把异常交给上一级方法处理。
　　调用时，调用者不能抛出范围更小的异常。
　　对于方法a，如果它定义了throws Exception。那么当它调用的方法b返回异常对象时，方法a并不处理，而将这个异常对象向上一级返回，如果所有的方法均不进行处理，返回到主方法，如主方法也不进行处理，则到虚拟机中，程序中止。
　　如果在方法的程序中有一行throw new Exception()，那么其后的程序不执行，如果没有对这个可能出现的检查结果进行处理，那么程序就会报错。
throws和throw没有必然的联系。

注意：

　　方法的覆盖中，如果子类的方法抛出的例外是父类方法抛出的例外的父类型，那么编译就会出错：子类无法覆盖父类。
　　子类抛出的例外或者与父类抛出的例外一致，或者是父类抛出例外的子类型，或者子类型不抛出例外。
　　如果父类型无throws时，子类型也不允许出现throws。此时只能使用try catch。 

自定义异常：

　　a. 使其继承Exception或者RuntimeException。
　　b. 写构造器，直接调用父类的构造器

---

断言(assert)

　　用来调试、测试代码

格式：

　　assert 布尔表达式: 字符串 (如果布尔表达式为false时，这个字符串才会显示)

注意：

　　assert默认是关闭的，使用时需要使用" -ea "进行开启，" -da "是关闭，如：java -ea 类名。
　　断言是以异常方式去执行的，当断言的布尔表达式为假时，会中断代码。
　　不能继承性的打开(java -ea:类名 这样只能打开该类，如果存在父类，不会去打开父类)

---

图形界面

AWT：

　　抽象窗口工具(Abstract Window Toolkit)
　　组件：图形界面中所有能看到的，比如按钮等。
　　容器：用来管理其他组件的对象
　　布局管理器：布置组件在容器中的位置和大小

Swing：

　　AWT的一个增强版

构造图形界面的步骤：

1. 选择一个容器
2. 设置容器的布局管理器
3. 向容器中添加组件
4. 事件的监听

---

容器(Container)

　　用于管理其他的组件的对象，组件必须放到容器里
　　JFrame：一个最顶层的窗体容器，所有其他的组件必须放在顶层容器里。
　　JPanel：不是顶层容器，必须放在顶层容器中，是透明的（默认）。

容器的方法：

1. add(Component com) 将组件加入容器。
2. setLayout(LayoutManager manager) 设置布局管理器。
3. setSize(int width,int height) 设置窗口大小
4. setVisible(boolean b) 显示或隐藏此组件
5. setDefaultCloseOperation(int operation) 设置关闭窗体上时默认执行的操作

 

---

布局管理

　　布置组件在容器中的位置和大小

FlowLayout：

　　流式布局管理，Panel和JPanel的默认布局管理就是FlowLayout

三种构造方式：
　　FlowLayout() 
　　构造一个新的 FlowLayout，居中对齐，默认的水平和垂直间隙是 5 个单位。 
　　FlowLayout(int align) 
　　构造一个新的 FlowLayout，对齐方式是指定的，默认的水平和垂直间隙是 5 个单位。 
　　FlowLayout(int align, int hgap, int vgap) 
　　创建一个新的流布局管理器，具有指定的对齐方式以及指定的水平和垂直间隙。 

BorderLayout：

　　按方位进行布局管理，不明确指定，就会默认加载在中间，Frame和JFrame默认的布局管理器是BorderLayout

两种构造方式：
　　BorderLayout() 
　　构造一个组件之间没有间距的新边界布局。 
　　BorderLayout(int hgap, int vgap) 
　　用指定的组件之间的水平间距构造一个边界布局。

GridLayout：

　　网格布局，通过行列、间距来用网格分割，把组件放入网格中，先行后列摆放组件。

三种构造方式：
　　GridLayout() 
　　创建具有默认值的网格布局，即每个组件占据一行一列。 
　　GridLayout(int rows, int cols) 
　　创建具有指定行数和列数的网格布局。 
　　GridLayout(int rows, int cols, int hgap, int vgap) 
　　创建具有指定行数和列数的网格布局，并将水平和垂直间距设置为指定值。

---

组件

　　图形界面中所有能看到的

• JButton ：按钮
• JTextField：单行文本域
• JTextArea：多行文本区
• JLabel：标签