1 反射机制&JSON解析
【
Java的高级特性：反射机制
publicclass Student {
public String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//静态代码块，只在类被加载的时候执行一次
static{
System.out.println("Student类被加载......");
}
public void test(){
System.out.println(name+"...test...");
}
public void test(int num){
System.out.println(name+"...test..."+num);
}
public void test2(){
System.out.println(name+"..test2...");
}
@Override
public String toString() {
return "Student[name=" + name + ", age=" + age + "]";
}
}
publicclass ReflectDemo {
public static void main(String[] args)throws Exception {
// 第一次使用Student类，虚拟机会先加载这个类，生成对应的Class对象
Student stu = new Student();
// 第二次使用Student类，就会复用上一次加载过的类的Class对象
Student stu2 = new Student();
// 1、获取Class对象
// 方式一：通过getClass方法
Class classzz =stu.getClass();
Class classzz2 =stu2.getClass();
System.out.println(classzz ==classzz2); //返回true
//方式二：类名.class
Class classzz3 =Student.class;
System.out.println(classzz ==classzz3); //返回true
//方式三:通过Class.forName()方法
Class classzz4 =Class.forName("bo.Student");
System.out.println(classzz ==classzz4); //返回true
//2、获取类名
//String className =classzz.getName();
String className =stu.getClass().getName();
System.out.println("类名:"+className); //返回类名:bo.Student
//3、获取构造方法
//获取无参构造器
Constructor c1 =classzz.getConstructor();
//获取带参构造方法
Constructor c2 =classzz.getConstructor(String.class,int.class);
//通过构造器创建并初始化对象
//Student stu3 = (Student)c1.newInstance();
Student stu3 =(Student)c2.newInstance("小强",18);
System.out.println("stu3"+stu3); //stu3Student [name=小强, age=18]
//classzz.getConstructors();
//classzz.getDeclaredClasses();
//4、获取成员字段
//获取类中public修饰的成员字段
Field field =classzz.getField("name");
// 获取类中已声明过的所有成员字段（包括私有的）
Field field2 =classzz.getDeclaredField("age");
// 暴利访问
field2.setAccessible(true);
// 设置某个指定对象的字段的值
field.set(stu3, "如花");
field2.set(stu3, 30);
System.out.println("stu3= " + stu3);
// clazz.getFields();
// clazz.getDeclaredFields();
// 5、获取成员方法
// 获取无参的方法
Method method =classzz.getMethod("test");
// 获取带参的方法
Method method2 =classzz.getMethod("test", int.class);
// Method method3 =clazz.getDeclaredMethod(name, parameterTypes)
//method3.setAccessible(true);
// 执行方法
method.invoke(stu3);
Student stu4 = newStudent("旺财",99);
method2.invoke(stu4, 666);
// clazz.getMethods();
//clazz.getDeclaredMethods();
}
}
】
Stage1【
public class Tester {
public static void main(String[] args){
//要生成JSON字符串，使用无参构造方法创建JSONObject
JSONObject jo = newJSONObject();
try {//将属性名name,属性值Tom放进JSONObject
jo.put("name","Tom");
//将属性名age,属性值21放进JSONObject
jo.put("age",21);
//根据put进去的属性名和属性值生成JSON字符串
String str =jo.toString();
System.out.println(str);
} catch (JSONException e) {
// TODOAuto-generated catch block
e.printStackTrace();
}
}
}
《生成：{"age":21,"name":"Tom"}》
public static void main(String[] args){
try {
JSONObject jo = newJSONObject("{'age':21,'name':'Tom'}");
// String name =(String)jo.get("name");//取出属性名为name的属性值
String name =jo.getString("name");//这个方法更方便，不用强转
// int age =(Integer)jo.get("age"); //取出属性名为age的属性值
int age = jo.getInt("age"); //这个方法更方便
System.out.println(name);
System.out.println(age);
} catch (JSONException e) {
// TODOAuto-generated catch block
e.printStackTrace();
}
}
public static voidmain(String[] args) {
//要生成JSON字符串，使用无参构造方法创建JSONObject
JSONObject jo = newJSONObject();
try {//将属性名name,属性值Tom放进JSONObject
jo.put("name","Tom");
//将属性名age,属性值21放进JSONObject
jo.put("age",21);
//根据put进去的属性名和属性值生成JSON字符串
String str =jo.toString();
System.out.println(str);
} catch (JSONException e) {
// TODOAuto-generated catch block
e.printStackTrace();
}
}
《生成：["1000phone","java","Android","iOS"]》
//要解析就用单参数构造方法创建JSONArray,参数就是要解析的JSON字符串，创建完就解决好了，放进JSONArray中
JSONArray ja = newJSONArray("['1000phone','java','android','ios']");
for(inti=0;i
System.out.println(ja.get(i));
}
public static void main(String[] args){
//这个JSONArray不再放简单的字符串，要放JSONObject
try {
JSONArray ja = newJSONArray();
//构建第一个JSONObject
JSONObject jo1 = newJSONObject();
jo1.put("name","zhangsan");
jo1.put("age",21);
ja.put(jo1);//把构建的第一个JSONObject放进JSONArray
//构建第二个JSONObject
JSONObject jo2 = newJSONObject();
jo2.put("name","lisi");
jo2.put("age",25);
ja.put(jo2);//把构建的第二个JSONObject放进JSONArray
//构建第三个JSONObject
JSONObject jo3 = newJSONObject();
jo3.put("name","wangwu");
jo3.put("age",20);
ja.put(jo3);//把构建的第三个JSonObject放进JSONArray
String str =ja.toString();//生成表示数组的JSON字符串，元素是JSON对象
System.out.println(str);
} catch (JSONException e) {
// TODOAuto-generated catch block
e.printStackTrace();
}
}
《生成：[{"age":21,"name":"zhangsan"},{"age":25,"name":"lisi"},{"age":20,"name":"wangwu"}]》
public static void main(String[] args){
try {//解析表示数组的JSON字符串，在构建JSONArray时完成解析
JSONArray ja = newJSONArray("[{'age':20,'name':'zhangsan'},"
+"{'age':25,'name':'lisi'},{'age':20,'name':'wangwu'}]");
for(inti=0;i
JSONObjectjo = ja.getJSONObject(i);//取出每个JSONObject元素
String name= jo.getString("name");//取出这个元素JSONObject的属性值
int age =jo.getInt("age");
System.out.println(name+" "+age);
}
} catch (Exception e) {
// TODO: handleexception
}
}
public class Student{
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student[name=" + name + ", age=" + age + "]";
}
}
public class Practice{
public static void main(String[] args){
List list =new ArrayList();
list.add(newStudent("Tom", 23));
list.add(newStudent("Jerray", 24));
list.add(newStudent("Mike", 22));
//1.用这个list生成一个JSON字符串
try {
JSONArray ja = newJSONArray(); //创建JSONArray
for(Studentstudent:list){//遍历list中的Student对象
JSONObjectjo = new JSONObject();//每次遍历创建一个JSONObject
jo.put("name",student.getName());//将名字放入JSONObject,，属性名为name,值为学生名字
jo.put("age",student.getAge());//将年龄放入JSONObject
ja.put(jo);//将初始化好了的JSONObject放进JSONArray
}
Stringstr= ja.toString();
System.out.println(str);
//2.解析1中的字符串，生成一个响应的ArrayList存放JSON字符串中的信息
//创建时就解析了这个字符串，把解析出来的信息放进JSONArray对象
JSONArray ja2 = new JSONArray(str);
//这是网络另一头的一个list,要把解析出来的信息放进去
Listlist2 = new ArrayList();
for(inti=0;i
JSONObjectjo = ja2.getJSONObject(i);//每次都拿出一个JSONObject
String name= jo.getString("name");//从这个JSONObject中拿出名字属性的值
int age =jo.getInt("age");//从这个JSONObject中拿出年龄属性的值
Student s =new Student(name, age);//用解析出来的两个属性信息构建一个Student对象
list2.add(s);//把这个Student对象放进list
}
for(Students:list2){//验证
System.out.println(s);
}
} catch (Exception e) {
// TODO: handleexception
}
}
}
《生成：[{"age":23,"name":"Tom"},{"age":24,"name":"Jerray"},{"age":22,"name":"Mike"}]
Student [name=Tom, age=23]
Student [name=Jerray, age=24]
Student [name=Mike, age=22]
》
】
Stage1【
public static voidmain(String[] args) {
Student student = newStudent("Tom", 21);//要生成为json字符串对象
//先用无参构造方法创建Gson对象
Gson gson = new Gson();
//用toJson直接生成表示这个student对象的json字符串
String str =gson.toJson(student); //将对象直接转换成json字符串
System.out.println(str);
}
《生成：{"name":"Tom","age":21}》
public static voidmain(String[] args) {
String str="{'name':'Tom','age':21}";//要解析的表示对象的字符串
Gson gson = new Gson();//创建Gson对象
//解析fromJson,第一个参数是要解析的字符串，第二个参数是解析出来的对象类型，是一个描述类对象
Student student =gson.fromJson(str, Student.class);
// gson.fromJson(str,Class.forName("com.xys.json.Student"));
System.out.println(student);
}
《封装类：Student同上
生成：Student [name=Tom, age=21]
》
public class Tester3{
public static void main(String[] args){
List list = newArrayList();
list.add(new Student("tom", 22));
list.add(new Student("jerry", 23));
list.add(new Student("jone",20));
Gson gson = new Gson();
String str = gson.toJson(list);
System.out.println(str);
}
}
《生成：[{"name":"tom","age":22},{"name":"jerry","age":23},{"name":"jone","age":20}]》
//要解析的字符串
String str ="[{'name':'jerray','age':23},{'name':'jone','age':20}]";
Gson gson = new Gson();
//第一个参数是要解析的字符串，第二个，TypeToken将ArrayList本身的类型和范型类型都封装了进去，
//再使用getType类型作为第二个参数
ArrayList list= gson.fromJson(str,
newTypeToken>() {
}.getType());
for (Student student : list){
System.out.println(student);
}
}
《输出:Student[name=jerray, age=23]
Student [name=jone,age=20]》
】
反射 可以让程序在运行时"看到自己"
Class 描述类的类，或描述类
static Class forName(String className)可以通过参数中的字符串形式的类的全名来获取这个类的描述类对象
newInstance()用描述类对象创建一个所描述的类的实例，这种方式比起new 类名()更灵活
可以通过描述类对象的Method[] getDeclaredMethods()获取所有声明的方法(方法描述类对象)
可以通过描述类对象的Field[] getDeclaredFields()获取所有声明的属性
Method getMethod(String name,Class[]paramTypes)可以获取指定名字、指定参数类型的方法描述对象
Method 描述方法的类
getName()获取方法名
invoke(Object obj,Object[] params)调用方法，第一个参数为调用方法的对象，第二个参数为传入的参数
1.3 JSON javascript object notation
是一种和语言、平台无关的通信格式
表示对象:{属性名:属性值,属性名2:属性值......}用一对大括号表示对象的边界，其中可以有多个属性，用逗号隔开，属性名和属性值用冒号隔开，这么一个字符串就是表示对象的JSON字符串
表示数组:[元素1,元素2,元素3.......]用一对中括号表示数组边界，其中可以有多个元素，用逗号隔开，这些元素可以是字符串，也可以是JSON对象
JSONObject类，生成和解析JSON对象字符串都是用这个类
1、生成表示对象的JSON字符串，用无参构造方法创建JSONObject实例，然后使用put方法将属性名和属性值添加进去，全部放进去后，使用toString()生成表示对象的JSON字符串
2、解析表示对象的JSON字符串，用单参构造方法JSONObject(Stringstr)来创建实例，参数就是要解析的字符串，实例创建时会自动将字符串中的对象属性名和属性值加入到JSONObject实例中，再通过get方法把属性名对应的属性值取出来
JSONArray类,生成和解析表示数组的JSON字符串
3、生成表示数组的JSON字符串，先用无参构造方法创建JSONArray实例，再调用put方法把数组元素放进去，最后用toString()生成这个表示数组的字符串
4、解析表示数组的JSON字符串，先用单参构造方法创建JSONArray实例，传入的String参数就是要解析的字符串，实例构建完，解析就已经完成，接下来就把这个元素从里面拿出来,使用get(int index)获取指定下标的元素(从0到n-1)，可以使用length()获取所包含的数组长度
如果元素是JSONObject，可使用getJSONObject(int index)
Gson 谷歌的json生成、解析框架
Gson类，通过无参构造方法创建
toJson()生成json字符串
fromJson()解析json字符串
网友评论