自学看视频增强java基础

最新推荐文章于 2021-02-12 22:38:39 发布

心宽何处不桃源

最新推荐文章于 2021-02-12 22:38:39 发布

阅读量518

点赞数 1

分类专栏： Java 文章标签： Java基础增强

本文链接：https://blog.csdn.net/Boom_Jia/article/details/64116112

版权

Java 专栏收录该内容

30 篇文章 0 订阅

订阅专栏

首先，先谈谈人生。生活总是那么不尽人意，刚刚毕业快1年，在学校学的又是Android开发，实习却做得net,现在做的是android，也许可能未来做的是java。记得，刚出学校就要走上社会，找工作一个字“难”！再加上自己没有很好的学历，看看北上广这些大城市的群里天天在说Android 行情不行，招个Android和招全栈工程师没有啥区别！尼玛！我的天！对于，一个刚刚毕业不到1年的程序员来说，身边的好朋友工资蹭蹭的往上涨，自己还是3.5k去掉五险一金到手也才不到3K，朋友圈天天谈论着房子的事，好苦逼，那么又有什么办法呢？既然你不能改变世界，那就得先改变自己。也许，会有人说：“你这个也学，那个也学。到最后，肯定一事无成！”在此，我只想说，你试过吗？你说这个有用吗？你为什么这么说？我是个95后，当我辞掉第一份关于专业的工作的时候(而且还是裸辞)，有个同事说我“任性“。确实，自己是那么太过年轻，任性了把。有个同事是我实习的师傅，他说做技术得慢慢经历，我经历的太少了，做技术得从积累再不断的沉淀。虽然，我现在做的Android，但每天晚上依然坚持回家不搞项目上的事，回家就是学学干干（白天干活，晚上学）.这是，我对我之前经历的一个小结。人生不如意，我们就来提高自己的技术去适应社会，以下这些是我看传智播客视频学的java基础增强的知识点！2017年，加油！

============================================================

Java基础知识增强：

1.java运行环境的配置编译器编译（如果碰到bad version,要么在菜单属性下改运行环境build path，要么改编译环境 java complier）

代码：

public class Demo1 {

	/**
	 * java运行环境的配置
	 * 编译器编译（如果碰到bad version,要么在菜单属性下改运行环境build path，要么改编译环境 java complier）
	 */
	public static void main(String[] args) {
	
		System.out.println("hello java!");

	}
}

总结：编译环境要和运行环境一样版本

=====================================================================

2.调试的方法

public class Demo2 {

	/**
	 * F5  跳入
	 * F6 往下走
	 * F7 跳出
	 * drop to frame 跳到代码中该方法第一行
	 * resume 绿色小三角是跳到下一段点
	 * 在debug模式下  点击breakpoints 可以显示所有断点 点叉消除断点
	 * 在断点调试时，记得点击红色小方框  停止虚拟机运行
	 * watch 观察变量或者表达式的值
	 */
	
}

=======================================================================

3.before()和after()

代码：

新建一个Person类，包含两个方法 run() 和eat()

public class Person {

	public String run(){
		System.out.println("run");
		return "1";
	}
	public void eat(){
		System.out.println("eat");
	}
}

测试类

/**
 * Person测试类
 *
 */
public class Demo4 {

	Person person;
	@Before
	public void before() {
		System.out.println("before");
		person = new Person();
	}

	@Test
	public void testRun() {
		person.run();
	}

	@Test
	public void testEat() {
		person.eat();
	}

	@After
	public void after() {
		System.out.println("after");
		person = null;
	}

}

==================================================================
4.BeforeClass 在类加载的时候运行，用于初始化资源
代码：

public class Demo5 {
	
	/**
	 * @BeforeClass  在类加载的时候运行，用于初始化资源
	 */
	@BeforeClass
	public static void beforeclass() {
		System.out.println("beforeclass");
	
	}

	@Test
	public void testRun() {
		Person person = new Person();
		person.run();
	}

	@Test
	public void testEat() {
		Person person = new Person();
		person.eat();
	}

	@AfterClass
	public static void afterclass() {
		System.out.println("afterclass");
	}
}

总结:

1.before()和after()每次运行test的时候都会执行一次

效果：

before
eat
after
before
run
after

2.BeforeClass和afterclass 在类加载的时候运行，用于初始化资源

效果：

beforeclass
eat
run
afterclass

==================================================================

5.断言（测试用的）

public class Demo6 {
	
	@Test
	public void testRun() {
		Person person = new Person();
		//断言
		Assert.assertEquals("1", person.run());
	}

	@Test
	public void testEat() {
		Person person = new Person();
		person.eat();
	}
}

====================================================================
6.枚举

代码：

/**
 * 枚举
 * @author Boom
 *
 */
public class Demo1 {

	@Test
	public void test() {
		print(Grade.C);
	}

	public void print(Grade g) { // A B C D E
		String value =g.getValue();
		System.out.println(value);
	}

	/*
	 * static class Grade { private Grade() { } public final static Grade A =
	 * new Grade(); public final static Grade B = new Grade(); public static
	 * final Grade C = new Grade(); public static final Grade D = new Grade();
	 * public static final Grade E = new Grade(); }
	 */

	enum Grade {
		//相当于类中的不同对象
		//A 100-90
		//B 90-80
		//C 80-70
		//D 70-60
		//E 60-0
		A("100-90"), B("90-80"), C("80-70"), D("70-60"), E("60-0");
		
		private String value;
		private Grade(String value){
			this.value=value;
		}
		public String getValue(){
			return this.value;
		}
	}
}

效果：

80-70

==================================================================

7.抽象方法枚举

/**
 * 抽象方法枚举
 * 
 * @author Boom
 *
 */
public class Demo1 {

	@Test
	public void test() {
		print(Grade.C);
	}
	
	@Test
	public void test2(){
		//输出名字
		System.out.println(Grade.C.name());
		//输出序数
		System.out.println(Grade.C.ordinal());
		
		String str= "B"; //如果是String str= "Y"会报错，因为不再枚举中，用于验证表单提交的数据是否属于枚举中的数据
		//Grade g = Grade.valueOf(Grade.class,str);
		Grade g = Grade.valueOf(str);
		System.out.println(g);
		
		Grade gs[] = Grade.values();
		for(Grade g1: gs){
			System.out.println(g1);
		}
 	}
	

	public void print(Grade g) { // A B C D E
		String value = g.localValue();
		System.out.println(value);
	}

	/*
	 * static class Grade { private Grade() { } public final static Grade A =
	 * new Grade(); public final static Grade B = new Grade(); public static
	 * final Grade C = new Grade(); public static final Grade D = new Grade();
	 * public static final Grade E = new Grade(); }
	 */

	enum Grade {
		// 相当于类中的不同对象
		// A 100-90 优
		// B 90-80 良
		// C 80-70 一般
		// D 70-60 差
		// E 60-0 不及格
		//让具体对象实现
		A("100-90") {
			public String localValue() {
				return "优";
			}
		}
		,
		B("90-80") {
			public String localValue() {
				return "良";
			}
		}
		,
		C("80-70") {
			public String localValue() {
				return "一般";
			}
		}
		,
		D("70-60") {
			public String localValue() {
				return "差";
			}
		}
		,
		E("60-0") {
			public String localValue() {
				return "不及格";
			}
		};

		private String value; //封装每个对象对应的分数
		//枚举的构造函数必须是私有的，避免能新建对象（new 一个对象）
		private Grade(String value) {
			this.value = value;
		}

		public String getValue() {
			return this.value;
		}
		
		//定义抽象方法
		public abstract String localValue();
		
	}
	
	//用单态设计模式定义出一个类
	enum A{ //class
		A;	//object
	}
}

效果

一般
C
2
B
A
B
C
D
E

================================================================

8.内省

代码：

新建一个person类

public class Person {
	private String name;
	private String password;
	private int age;
	
	//这个类有多少属性  不是由上面决定的，而是由get set方法决定的，这个类中有5个属性 还有一个getClass()
	public String getAb(){
		return null;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

新建测试类

/**
 * 使用内省api操作bean的属性
 */

public class Demo1 {
	
	@Test
	public void test1() throws Exception{
		//获取bean的所有属性
		BeanInfo beaninfo = Introspector.getBeanInfo(Person.class);
		//去掉父类的属性  得到bean自己的属性
		BeanInfo beaninfo1 = Introspector.getBeanInfo(Person.class,Object.class);
		
		PropertyDescriptor[] pds = beaninfo.getPropertyDescriptors();
		for(PropertyDescriptor pd : pds){
			System.out.println(pd.getName());
		}
	}
	
	//用于架构的设计，一般传统方式不用
	@Test
	public void test2() throws Exception{
		Person person = new Person();
		PropertyDescriptor pd=new PropertyDescriptor("age",Person.class);
		//得到属性的写方法，为属性赋值
		Method method = pd.getWriteMethod();
		method.invoke(person, 45);
		System.out.println(person.getAge());
		//获取属性的值
		method =pd.getReadMethod();
		System.out.println(method.invoke(person, null));
	}
	
	//高级点的内容，获取当前操作的属性的类型
	@Test
	public void test3() throws Exception{
		Person person = new Person();
		//获取属性的描述器
		PropertyDescriptor pd=new PropertyDescriptor("age",Person.class);
		System.out.println(pd.getPropertyType());
	}
	
}

========================================================================
9.静态导入包

import static java.lang.System.out;
/**
 * 静态导入包
 */
public class Demo1 {
	public static void main(String[] args) {
		out.println("哈哈");
	}
}

10.装箱/拆箱

/**
 * 装箱/拆箱
 * @author Boom
 */
public class Demo2 {
	public static void main(String[] args) {
		Integer i = 1;//装箱
		int j=i;	//拆箱
		//典型应用
		List list =new ArrayList();
		list.add(1);//装箱
		list.add(2);
		list.add(3);
		Iterator it=list.iterator();
		while(it.hasNext()){
			int k = (int) it.next();//拆箱
		}
	}
}

==================================================================

11.增强for循环只能运用到数组，集合

代码：

public class Demo3 {
	/**
	 * 增强for循环
	 * 只能运用到数组，集合
	 */
	@Test
	public void test1(){
		int arr[] ={1,2,3};
		for(int num :arr ){
			System.out.println(num);
		}	
	}
	@Test
	public void test2(){
		List list=new ArrayList();
		list.add(1);
		list.add(2);
		list.add(3);
		
		for(Object object : list){
			int i =(int) object;
			System.out.println(i);
		}
	}
	
	@Test
	public void test3(){
		Map map = new LinkedHashMap();
		map.put("1", "aaa");
		map.put("2", "bbb");
		map.put("3", "ccc");
		
		//传统方式1
		Set set= map.keySet();
		Iterator it=set.iterator();
		while(it.hasNext()){
			String key =(String) it.next();
			String value =(String) map.get(key);
			System.out.println(key+"="+value);
		}
	}
	
	@Test
	public void test4(){
		Map map = new LinkedHashMap();
		map.put("1", "aaa");
		map.put("2", "bbb");
		map.put("3", "ccc");
		//传统方式2
		Set set =map.entrySet();
		Iterator it =set.iterator();
		while (it.hasNext()) {
			Map.Entry entry = (Entry) it.next();
			String key =(String) entry.getKey();
			String value=(String) entry.getValue();
			System.out.println(key+"="+value);
		}
		
	}
	@Test
	public void test5(){
		Map map = new LinkedHashMap();
		map.put("1", "aaa");
		map.put("2", "bbb");
		map.put("3", "ccc");
		//增强for取map的第一种方式
		for(Object object:map.keySet()){
			String key = (String) object;
			String value =(String) map.get(key);
			System.out.println(key+"="+value);
		}
	}
	
	@Test
	public void test6(){
		Map map = new LinkedHashMap();
		map.put("1", "aaa");
		map.put("2", "bbb");
		map.put("3", "ccc");
		//增强for取map的第2种方法
		for(Object object :map.entrySet()){
			Map.Entry entry =(Entry) object;
			String key =(String) entry.getKey();
			String value =(String) map.get(key);
			System.out.println(key+"="+value);
			
		}
	}
	
	//使用增强for循环需要注意的问题
	//1.只适合取数据
	//2.要修改数组或者集合中的数据，我们只能用传统方式来修改
	@Test
	public void test7(){
		int arr[] ={1,2,3};
		for(int i :arr){
			i=10;
		}
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
	
	List list =new ArrayList();
	list.add("1");
	for(Object object : list){
		object="10";
	}
	System.out.println(list.get(0));
	}
}

总结：map集合有两种处理方法：

1.转换为set集合

2.转换为Map.Entry<k,v>

并且for的增强式只能取值，不能修改（因为hascode不一样）

======================================================================

12.可变参数 ...

代码：

/**
 * 可变参数
 * @author Boom
 *
 */
public class Demo4 {

	@Test
	public void testSum(){
		//sum(1,2,3,4,5,6);
		int arr[] ={1,2,3,4,5,6};
		sum(arr);
	}
	
	public void sum(int ...nums){
		//可变参数你就把它看成数组
		int Sum=0;
		for(int i : nums){
			Sum+=i;
		}
		System.out.println(Sum);
	}
	
	@Test 
	public void Aa(){
		aa(1,2,3,4,5,6);
	}
	//可变参数需要注意的是：public void  aa(int ...nums，int x)  这样不行
	public void  aa(int x,int ...nums) {
		
	}
	
	@Test
	public void bb(){
		List list = Arrays.asList("1","2","3");
		System.out.println(list);
		
		String arr[]={"1","2","3","4"};
		list = Arrays.asList(arr);
		System.out.println(list);
	
		//注意问题：可变参数的类型问题      是对象类型还是基本数据类型
		int nums[]={1,2,3,4,5};//这个细节一定要注意 Integer nums[]={1,2,3,4,5}; 
		list = Arrays.asList(nums);
		System.out.println(list);

	}
}

===================================================================

13.反射，加载类 ,获得类的字节码

代码：

新建Person类

public class Person {
	public String name="aaaa";
	private int password;
	private static int age;
	//Date 不是8种数据类型之一
	private Date birthday;
	public Date getBirthday() {
		return birthday;
	}

	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getPassword() {
		return password;
	}

	public void setPassword(int password) {
		this.password = password;
	}

	public static int getAge() {
		return age;
	}

	public static void setAge(int age) {
		Person.age = age;
	}

	//构造函数
	public Person() {
		System.out.println("person");
	}

	public Person(String name) {
		System.out.println("person name is "+name);
	}

	public Person(String name, int password) {
		System.out.println(name+";"+password);
	}

	private Person(List list) {
		System.out.println("person list");
	}
	//方法
	public void aa1(){
		System.out.println("aa1");
	}
	public void aa1(String name,int password){
		System.out.println(name+";"+password);
	}
	
	public Class[] aa1(String name,int[] password ){
		return new Class[]{String.class};
	}
	
	private void aa1(InputStream in){
		System.out.println(in);
	}
	
	public static void aa1(int num){
		System.out.println(num);
	}
	
	public static void main(String[] args) {
		System.out.println("main!");
	}
}

测试类:

/**
 *	反射，加载类 ,获得类的字节码
 */
public class Demo1 {

	public static void main(String[] args) throws ClassNotFoundException {
		//1.反射
		Class clazz =Class.forName("com.boom.reflect.Person");
		//2.加载类
		Class clazz1 = new Person().getClass();
		//3.获得类的字节码
		Class clazz2 = Person.class;
		
	}
}

===================================================================
14.解剖类的构造函数，创建类的对象

代码：

/**
 * 解剖类的构造函数，创建类的对象
 * 
 * @author Boom
 *
 */
public class Demo2 {

	// 反射构造函数，public person(){}
	@Test
	public void test() throws Exception {
		Class clazz = Class.forName("com.boom.reflect.Person");
		Constructor c = clazz.getConstructor(null);
		Person person = (Person) c.newInstance(null);
		System.out.println(person.name);
	}
	// 反射构造函数，public Person(String name) {
		@Test
		public void test2() throws Exception {
			Class clazz = Class.forName("com.boom.reflect.Person");
			//得到构造函数  由于构造函数里面是 String name
			Constructor c = clazz.getConstructor(String.class);
			Person person = (Person) c.newInstance("xxxx");
			System.out.println(person.name);
		}
		// 反射构造函数，public Person(String name, int password) {
		@Test
		public void test3() throws Exception {
			Class clazz = Class.forName("com.boom.reflect.Person");
			Constructor c = clazz.getConstructor(String.class,int.class);
			Person person = (Person) c.newInstance("xxxx",123);
			System.out.println(person.name);
		}
		// 反射构造函数，private Person(List list) {
		@Test
		public void test4() throws Exception {
			Class clazz = Class.forName("com.boom.reflect.Person");
			Constructor c = clazz.getDeclaredConstructor(List.class); //因为构造函数是私有的
			c.setAccessible(true);//暴力反射
			Person person = (Person) c.newInstance(new ArrayList<>());
			System.out.println(person.name);
		}
		
		/**
		 * 一个类内部私有的东西不能被外界访问，但是我们可以通过反射来实现
		 * getConstructor() 得到定义为public的构造方法,method和field同理
		 * getDeclaredConstructor() 得到定义为private的构造方法,method和field同理
		 */
		
		//创建对象的另外一种途径
		@Test
		public void test5() throws Exception {
			Class clazz = Class.forName("com.boom.reflect.Person");
			Person person = (Person) clazz.newInstance();
			System.out.println(person);
		}
}

===================================================================

15. 反射类的方法

/**
 * 反射类的方法
 * @author Boom
 *
 */
public class Demo3 {
	
	//反射类的 public void aa1(){
	@Test
	public void test1() throws Exception{
		Person person =new Person();
		Class clazz = Class.forName("com.boom.reflect.Person");
		//根据方法名来
		Method method =clazz.getMethod("aa1", null);
		//第一个参数是类对象，第二个参数是参数类型
		method.invoke(person,null);
	}
	//反射类的  public void aa1(String name,int password){ 
		@Test
		public void test2() throws Exception{
			Person person =new Person();
			Class clazz = Class.forName("com.boom.reflect.Person");
			//根据方法名来
			Method method =clazz.getMethod("aa1", String.class,int.class);
			//第一个参数是类对象，第二个参数是参数类型是可变参数 ...
			method.invoke(person,"zxx",38);
		}
		//反射类的 public Class[] aa1(String name,int[] password ){
		@Test
		public void test3() throws Exception{
			Person person =new Person();
			Class clazz = Class.forName("com.boom.reflect.Person");
			//根据方法名来
			Method method =clazz.getMethod("aa1", String.class,int[].class);
			//第一个参数是类对象，第二个参数是参数类型
			Class[] cs= (Class[]) method.invoke(person,"aaaa",new int[]{1,2,3});
			System.out.println(cs[0]);
		}
		
		//反射类的   private void aa1(InputStream in){
		@Test
		public void test4() throws Exception{
			Person person =new Person();
			Class clazz = Class.forName("com.boom.reflect.Person");
			//根据方法名来
			Method method =clazz.getDeclaredMethod("aa1", InputStream.class);
			method.setAccessible(true); //暴力反射
			//第一个参数是类对象，第二个参数是参数类型
			method.invoke(person,new FileInputStream("c:\\1.txt"));
		}
		//反射类的   public static void aa1(int num){  
		@Test
		public void test5() throws Exception{
		
			Class clazz = Class.forName("com.boom.reflect.Person");
			//根据方法名来
			Method method =clazz.getMethod("aa1", int.class);
			//第一个参数是类对象，第二个参数是参数类型，因为是static方法所以我们不需要类对象
			method.invoke(null,23);
		}
		
		//总结：private的方法不像public的方法，private需要通过method.setAccessible(true); 曝光一下
		
		//特殊
		
		//反射类的  public static void main(String[] args) {  
		@Test
		public void test6() throws Exception{
		
			Class clazz = Class.forName("com.boom.reflect.Person");
			//根据方法名来
			Method method =clazz.getMethod("main", String[].class);
			//method.invoke(null, new Object[]{new String[]{"1","2"}}); //因为类中没有main(String a,String b)
			method.invoke(null,(Object)new String[]{"aa","bb"});	//因为类中没有main(String a,String b)
		}
		 
		//jdk1.5 method.invoke(String methodName, Object... args)
		//jdk1.4 method.invoke(String methodName, Object obj[])
		//jdk1.4 method.invoke(null,new Object[]{new String[]{"1","2"}});
		
		
}

总结：私有的，得暴力反射下

==============================================================
16.反射字段

代码：

public class Demo4 {
	
	//反射字段  	public String name="aaaa";
	@Test
	public void test1() throws Exception{
		Person person=new Person();
		Class clazz = Class.forName("com.boom.reflect.Person");
		Field field= clazz.getField("name");
		//获得字段的值
		Object value =field.get(person);
		//获得字段的类型
		Class type = field.getType();
		System.out.println(type);
		if (type.equals(String.class)) {
			String svalue = (String) value;
			System.out.println(svalue);
		}
		//设置字段的值
		field.set(person,"xxxxx");
		System.out.println(person.name)
		;
	}
	
	//反射字段 	private int password;
	@Test
	public void test2() throws Exception{
		Person person=new Person();
		Class clazz = Class.forName("com.boom.reflect.Person");
		//因为是private,需要暴力反射
		Field field = clazz.getDeclaredField("password");
		field.setAccessible(true);
		System.out.println(field.get(person));
	}
	//反射字段      private static int age;
		@Test
		public void test3() throws Exception{
			Person person=new Person();
			Class clazz = Class.forName("com.boom.reflect.Person");
			Field field = clazz.getDeclaredField("age");
			field.setAccessible(true);
			System.out.println(field.get(person));
			
		}
}

总结：私有的，得暴力反射下

==============================================================

17.用beanutils来操作bean的属性

其中需要两个jar包，并build path

1.commons-beanutils-1.8.0.jar

2.commons-logging.jar

代码：

/**
 * 用beanutils来操作bean的属性（第三方）
 * @author Boom
 * 需要导入beanutils jar包  和common-logging jar包 支持
 */
public class Demo1 {
	
	@Test
	public void test1() throws IllegalAccessException, InvocationTargetException{
		Person person = new Person();
		BeanUtils.setProperty(person, "name", "xxxx");
		System.out.println(person.getName());
	}
	
	@Test
	public void test2() throws IllegalAccessException, InvocationTargetException{
		String name ="aaaaa";
		String password="1234";
		String age="34";
		String birthday="1980-09-09";
		
		Person person = new Person();
		BeanUtils.setProperty(person,"name",name);
		BeanUtils.setProperty(person,"password",password);
		BeanUtils.setProperty(person,"age",age); //只支持8种基本数据类型
		BeanUtils.setProperty(person, "birthday", birthday); //只支持8种数据类型
		
		System.out.println(person.getName());
		System.out.println(person.getPassword());
		System.out.println(person.getAge());
		System.out.println(person.getBirthday()); //在以前是编译不出来会报错，string--->date类型
	}
	
	//根据test2中string 到 date中会报转换异常
	@Test
	public void test3() throws IllegalAccessException, InvocationTargetException{
		String name ="aaaaa";
		String password="1234";
		String age="34";
		String birthday="1980-09-09";
		
		//为了让日期赋到bean的birthday属性上，我们给beanutils注册一个日期转换器
		ConvertUtils.register(new Converter() {
			
			@Override
			public Object convert(Class type, Object value) {
				if (value == null) {
					return null;
				}
				if (!(value instanceof String)) {
					throw new ConversionException("我只支持String类型的转换");
				}
				String str = (String) value;
				if (str.trim().equals("")) {
					return null;
				}
				
				SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
				try {
					return simpleDateFormat.parse(str);
				} catch (ParseException e) {
					throw new RuntimeException();//异常链不能断
				}
			}
		}, Date.class);
		
		
		Person person = new Person();
		BeanUtils.setProperty(person,"name",name);
		BeanUtils.setProperty(person,"password",password);
		BeanUtils.setProperty(person,"age",age); //只支持8种基本数据类型
		BeanUtils.setProperty(person, "birthday", birthday); //只支持8种数据类型
		
		System.out.println(person.getName());
		System.out.println(person.getPassword());
		System.out.println(person.getAge());
		Date date =person.getBirthday();
		System.out.println(date.toLocaleString());
	}
	
	@Test
	public void test4() throws IllegalAccessException, InvocationTargetException{
		String name ="aaaaa";
		String password="1234";
		String age="34";
		String birthday="1980-09-09";
		
		//如果要看转换器，就去看文档中convert
		ConvertUtils.register(new DateLocaleConverter(), Date.class);
		
		Person person = new Person();
		BeanUtils.setProperty(person,"name",name);
		BeanUtils.setProperty(person,"password",password);
		BeanUtils.setProperty(person,"age",age); //只支持8种基本数据类型
		BeanUtils.setProperty(person, "birthday", birthday); //只支持8种数据类型
		
		/*Map map =new HashMap();
		map.put("name", "");
		map.put("password", "123");
		map.put("age", "11");
		map.put("birthday", "1980-09-09");
		//把map集合中的值，填充bean，个人感觉可以以后用到界面展示数据
		BeanUtils.populate(person, map);*/
		
		System.out.println(person.getName());
		System.out.println(person.getPassword());
		System.out.println(person.getAge());
		System.out.println(person.getBirthday()); //在以前是编译不出来会报错，string--->date类型
	}	
}