javaSE_day18 学习笔记 —— 栈和队列、反射

1. 栈和队列

1.1 栈：先进后出

• 可以由数组实现 Stack，由链表实现LinkList
• 常用方法：
  • push()：表示压栈
  • pop(): 返回栈顶元素，并从栈中弹出来
  • peek(): 返回栈顶元素，但并不从栈中弹出来
    
    

1.2 队列：先进先出

常用方法：

• offer()：往队列中添加元素
• poll()：返回队首元素，并从队列中弹出
• peek()：返回队首元素，不从队列中弹出
  

2. 反射

• 程序运行过程中，可以获取到类的构造方法，成员变量（包括私有的）方法，对象使用类成员，我们把获取类成员和对象调用类成员机制叫反射。

Class类

• 提供反射的工具类
• Class类的对象 ----- .class文件
• 只能加载一次
• 唯一的标识：包名.类名
• 封装了大量的方法，通过方法可以获取到构造方法，方法，成员变量。

（1）获取Class类的对象3种方法

• 对象.getClass()
• 类名.class
• forName(“包名.类名”)
  

//1.获取Class类的对象的三种方法        Class对象只有一个，三种方法得到的对象是同一个
	public static void test1() throws ClassNotFoundException {
		//通过对象
		Class<? extends Student> clazz = new Student().getClass();
		
		//通过类名获取
		Class<Student> clazz2 = Student.class;
		
		//forName("包名+类名")        
		Class clazz3 = Class.forName("cn.tedu.demo2.Student");
	}

（2）获取和使用构造方法

• getDeclaredConstructors() 获取全部构造方法。 返回一个数组 Constructor[ ]
• getDeclaredConstructor(Class[ ]{ },…) 获取一个构造方法(小括号里不写，则获取无参构造方法) 。返回一个对象Constructor
• newInstance(new Object[]{“admin”}) 创建对象

//2.通过Class对象获取和使用构造方法
	public static void test2() {
		Class<Student> clazz = Student.class;
		@SuppressWarnings("rawtypes")
		Constructor[] constructors = clazz.getDeclaredConstructors();
		for(Constructor<?> construct:constructors) {
			//1 - public          
			System.out.println(construct.getModifiers()+"->"+Modifier.toString(construct.getModifiers()));
			System.out.println(construct.getName());
			@SuppressWarnings("rawtypes")
			//返回参数列表的Class类型的数组
			Class[] pClazz = construct.getParameterTypes();
			for(Class c : pClazz) {
				System.out.println(c.getName());//类型的名称
			}
			System.out.println("===========================");
		}
	}
	

获取无参的构造方法，创建对象：

通常无参构造方法创建对象，不用获取Constructor对象，可以使用clazz.newInstance() 直接由Class类型的对象调用。

//获取无参的构造方法，创建对象
	public static void test2_1() throws Exception {
		Class<Student> clazz = Student.class;
		
		//得到无参的构造方法的对象
		//Constructor con = clazz.getDeclaredConstructor();
		
		//使用无参构造方法创建对象
		//Student stu = con.newInstance();//相当于new Student()
		
		//通常无参构造方法创建对象，不用获取Constructor对象，可以使用下面的方式直接由Class类型的对象调用
		Student stu2 = clazz.newInstance();
		stu2.name="张三";
		stu2.eat("饺子");
	}
	

获取带参的构造方法，创建对象：

//获取带参的构造方法，创建对象
	public static void test2_2() throws Exception {
		Class<Student> clazz = Student.class;
		//获取带String类型参数的构造方法的对象
		Constructor<Student> constructor = clazz.getDeclaredConstructor(new Class[] {String.class});
		//设置私有的构造方法的可访问性
		constructor.setAccessible(true);
		//使用构造方法创建对象
		Student stu = constructor.newInstance(new Object[] {"李四"});
		stu.eat("米饭");
	}

（3）获取和使用功能方法

• getDeclaredMethods() 获取本类的所有方法
• getMethods() 获取本类以及父类的非私有的方法
  两个都返回一个数组 Method[ ]
• getMethod(String name,Class[]{}) 返回一个对象 Method
• m.invoke(obj,new Object[]{“admin,18”});//obj.name(“name”,18); 使用功能方法

获取功能方法：

//3.获取功能方法
	public static void test3() {
		Class<Student> clazz = Student.class;
		
		//getDeclaredMethods()获取本类的方法
		//Method[] methods = clazz.getDeclaredMethods();
		
		//getMethods()获取本类以及父类的非私有的方法
		Method[] methods = clazz.getMethods();
		
		for(Method m:methods) {
			System.out.println(m.getName());
			System.out.println(m.getReturnType());
		}
	}

使用功能方法：

//使用功能方法
	public static void test3_1() throws Exception {
		Class<Student> clazz = Student.class;
		Student stu = clazz.newInstance();//无参构造方法创建对象
		//获取sleep方法对象
		Method method = clazz.getDeclaredMethod("sleep");
		//使用方法
		method.invoke(stu);//相当于stu.sleep();
		
		//练习：获取eat方法，并调用  
		Method methodEat = clazz.getDeclaredMethod("eat",new Class[] {String.class});
		methodEat.invoke(stu,new Object[] {"馒头"});

		//获取setAge/getAge方法并调用（私有）
		Method methodSet = clazz.getDeclaredMethod("setAge",new Class[] {int.class});
		methodSet.setAccessible(true);//设置私有的构造方法的可访问性
		methodSet.invoke(stu,new Object[] {18});
		
		Method methodGet = clazz.getDeclaredMethod("getAge");
		methodGet.setAccessible(true);//设置私有的构造方法的可访问性
		System.out.println(methodGet.invoke(stu));
	}

（4）获取和使用成员变量

• getDeclaredFields() 获取所有成员变量 返回一个数组 Field[ ]
• set(stu, “王五”) 设置值
• get(stu) 获取值

获取成员变量：

//4.获取成员变量
	public static void test4() throws Exception {
		Class<Student> clazz = Student.class;
		Student stu = clazz.newInstance();
		Field[] fields = clazz.getDeclaredFields();
		for(Field f:fields) {
			System.out.println(f.getName());
		}
	}		

使用成员变量：

//使用成员变量
	public static void test4_1() throws Exception {
		Class<Student> clazz = Student.class;
		Student stu = clazz.newInstance();
		//name成员变量赋值
		Field field = clazz.getDeclaredField("name");
		field.set(stu, "王五");//相当于stu.name = "王五";
		System.out.println(field.get(stu));//相当于stu.name;
		
		//age成员变量赋值（私有）
		Field field2 = clazz.getDeclaredField("age");
		field2.setAccessible(true);//设置私有的构造方法的可访问性
		field2.set(stu,18);//相当于stu.name = "王五";
		System.out.println(field2.get(stu));//相当于stu.name;		
	}