1.JAVA反射
1)反射机制概念:在运行状态中,对于任何一个类都能够知道这个类所有属性和方法,并且对于任意一个对象,都能够调用他的任何一个方法。
2)反射的应用场合:在JAVA程序中许多对象在运行时都会出现两种类型:编译类型和运行类型。编译时的类型由声明对象时使用的类型来决定,运行时的类型由实际赋值给对象的类型决定。如:
Dodg d=new Animal();
其中编译时的类型为Dog,运行时的类型为Animal.
3)反射API:用来生成JVM中的类、接口或者对象的信息。
- Class类:反射的核心类,可以用来获取类的属性、方法等信息。
- Field类:Java.lang.reflec包中的类,表示类的成员变量,用来获取和设置类之中的属性值
- Method类:Java.lang.reflec包中的类,表示类的方法,他可以用来获取类中的方法信息。
- COnstructor类:Java.lang.reflec包中的类,表示类的构造方法。
4)获取Class对象3种方法:
package cn.tedu.test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class Animal {
public String name;
public int age;
public Animal(String name,int age) {
// TODO Auto-generated constructor stub
this.name=name;
this.age=age;
}
@Override
public String toString() {
return "Animal [name=" + name + ", age=" + age + "]";
}
public static void main(String[] args) throws ClassNotFoundException {
Animal dog=new Animal("dog",2);
//获取该类对应的class对象,方法1
Class c1=dog.getClass();
//方法2
Class c2=Animal.class;
//获取该类对应的class对象,最安全、性能最好,方法3
Class c=Class.forName("cn.tedu.test.Animal");
//获取该类对应的所有方法信息
Method[] method=c.getDeclaredMethods();
System.out.println("方法信息:");
for(Method m:method) {
System.out.println(m.toString());
}
System.out.println("成员属性:");
//获取该类对应的所有成员属性的信息
Field[] filed=c.getDeclaredFields();
for(Field f:filed) {
System.out.println(f.toString());
}
System.out.println("构造器:");
//获取该类对应的所有构造方法的信息
Constructor[] con=c.getDeclaredConstructors();
for(Constructor c3:con) {
System.out.println(c3.toString());
}
//System.out.println(dog);
}
}
5)创建对象的两种方法:
- 使用Class对象的newInstance()方法来创建该Class对象对应类的实例,这种方法要求Class对象对应的类有默认的空构造器。示例如下:
package cn.tedu.test;
public class Fish1 {
public String name;
public int age;
public String food;
public void eat() {
System.out.println("我的食物是"+food);
}
@Override
public String toString() {
return "Fish [name=" + name + ", age=" + age + ", food=" + food + "]";
}
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
//获取Fish1类的Class对象
Class c=Class.forName("cn.tedu.test.Fish1");
//使用newInstance()方法创建对象
Fish1 fish1=(Fish1) c.newInstance();
System.out.println(fish1);
}
}
输出结果如下:
- 调用Constructor对象的newInstance()
package cn.tedu.test;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class Fish {
public String name;
public int age;
public String food;
public Fish(String name,int age,String food) {
// TODO Auto-generated constructor stub
this.name=name;
this.age=age;
this.food=food;
}
public void eat() {
System.out.println("我的食物是"+food);
}
@Override
public String toString() {
return "Fish [name=" + name + ", age=" + age + ", food=" + food + "]";
}
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
Class c=Class.forName("cn.tedu.test.Fish");
Constructor con=c.getDeclaredConstructor(String.class,int.class,String.class);
Fish fish=(Fish) con.newInstance("鲨鱼",11,"小鱼");
System.out.println(fish);
}
}
输出结果如下:
2.JAVA异常
1)Throwable是Java语言中所有错误或异常的超类。下一层分为Error和Exception。
- Error:是指Java运行时系统的内部错误和资源耗尽错误。应用程序不会抛出该类的对象。如果出现了这种错误,除了告知用户,剩下的就是尽力使程序安全的终止。
- Exception:有两个分支,一是RuntimeException,另一个是CheckedException。RuntimeException是那些可能在Java虚拟机正常运行期间抛出的异常的超类,如果出现这种错误,那么一定是程序员自己的错误。CheckedException一般是外部错误,这种异常都发生在编译阶段,Java编译器会强制程序去捕获此类异常,机会出现要求你把这段可能出现异常的程序进行try catch,该类异常一般包括以下几个方面:试图在文件读取数据、试图打开一个错误格式的URL、试图根据给定的字符串查找class对象,而这个字符串表示的类不存在。
2)异常的处理方式:抛出异常有三种形式,一种是throw,一个是throws,还有一种是系统自动抛出异常。
3)throw和throws的区别: - 位置不同:
throws用在函数上,后面跟的是异常类,可以跟多个;而throw用在函数内,后面跟的是异常对象。 - 功能不同:
a)throws用来声明异常,让调用者知道该功能可能出现的问题,可以给出预先的处理方式;throw抛出具体的问题对象,执行到throw,功能就已经结束了,跳转到调用者,并将具体的问题抛给调用者。
b)throws表示出现异常的一种可能性,并不一定会发生这些异常;throw则是抛出了异常,执行throw则一定是抛出了某种异常对象。
c)两种都是消极处理异常的形式,只是抛出或者可能抛出异常,但是不会有函数去处理异常,真正处理异常有函数的上层调用处理。
3.Java内部类
1)静态内部类:定义在类内部的静态类。
a)静态内部类可以访问外部类的所有静态成员变量和方法,即使是private修饰的也可以。
b)静态内部类和一般类一致,可以定义静态方法、静态变量和构造方法等。
c)其它类需要使用静态内部类的方式为“外部类.静态内部类”。
d)Java集合类HashMap内部就有一个静态内部类Entry。像这种和外部类关系密切的,且不依赖外部实例的,都可以使用静态内部类。
package cn.tedu.test;
public class Demo1 {
private static int t=11;
private static String str1="demo1";
public static class Demo11{
public void print() {
System.out.println(str1+":"+t);
}
}
public static void main(String[] args) {
Demo1.Demo11 de=new Demo1.Demo11();
de.print();
}
}
运行结果如下:
2)成员内部类:定义在类内部的非静态类就是成员内部类。成员内部类不能定义静态方法和变量(final修饰的除外),需要注意的是,成员内部类的访问方式为“new 外部类对象.new 成员内部类对象”,示例如下:
package cn.tedu.test;
public class Demo1 {
private static int t=11;
private static String str1="demo1";
public static class Demo11{
public void print() {
System.out.println(str1+":"+t);
}
}
public class Demo12{
public void print() {
System.out.println(str1+":"+t);
}
}
public static void main(String[] args) {
//静态内部类
System.out.println("静态内部类:");
Demo1.Demo11 de1=new Demo1.Demo11();
de1.print();
System.out.println("成员内部类:");
//成员内部类
Demo12 de=new Demo1().new Demo12();
de.print();
}
}
运行结果如下:
3)局部内部类:定义在方法中的类,就是局部类,如果一个类只在一个方法中使用,则可以考虑使用局部类。示例如下:
package cn.tedu.test;
public class Demo2 {
private static int t=11;
private static String str1="demo1";
public void test(int c) {
class Inner{
public void print() {
System.out.println("局部内部类输出结果为:"+c);
}
}
Inner n=new Inner();
n.print();
}
public static void main(String[] args) {
Demo2 de=new Demo2();
de.test(55);
}
}
运行结果如下:
4)匿名内部类:仅能继承一个父类或者实现一个接口,直接使用new来生成一个对象的引用,同时匿名内部类也是没有class关键字。
注意事项:
- 使用匿名内部类时,只能继承一个类或是实现一个接口。
- 匿名内部类中无法定义构造函数,由于不存在类名
- 匿名内部类不能存在任何静态成员变量和方法
- 匿名内部类不可以是抽象的,他必须要实现继承的类或者是接口的所有抽象方法。
示例如下:
package cn.tedu.test;
public class Test {
public void test(Bird b) {
System.out.println(b.getName()+"能够飞"+b.fly()+"米");
}
public static void main(String[] args) {
Test t=new Test();
//匿名内部类
t.test(new Bird() {
@Override
public int fly() {
// TODO Auto-generated method stub
return 10000;
}
public String getName() {
return "大雁";
}
});
}
}
运行结果如下: