【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：标签
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/lcw/p/3206615.html