package com.wode;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Random;
import javax.activation.FileDataSource;
/***
*
* @author Administrator
*Random类 Math使用方法 以及反射机制
*/
public class Test04_16 {
public static void main(String[] args) throws Exception {
//Random类 表示随机产生数
Random random = new Random();
System.out.println(random.nextInt());
//random.nextInt() 括号中没有给参数 所以 随机产生int类型的数 并且范围在long中
System.out.println(random.nextInt(10));
//random.nextInt(10) 表示 随机产生int类型的0-9 十个数字 他是前包后不包
//如果想随机到十 那么代码就应该是：System.out.println(random.nextInt(10)+1);
//---------------------------------------萌萌的分割线君-------------------------------------------------------
//Math 的使用方法
//Math类 是一个数学工具类 在Java语言中 常用的方法都在里面 可以通过 Math.方法名() 进行调用
System.out.println(Math.abs(-50));//运行结果 ： 50
//Math.abs 表示输出（）中数字的绝对值
System.out.println(Math.max(5, -9));//运行结果： 5
//Math.max 输出（）中最大的值
System.out.println(Math.min(5, -9));//运行结果: -9
//Math.min 输出（）中最小的值
System.out.println(Math.round(5.4));//运行结果: 5
//Math.round 输出（）中四舍五入后的值
System.out.println(Math.floor(-8.1));// 运行结果: -9.0
//Math.floor 输出（）中最大接近于正无穷的数 也就是向下取整 如果是()中是9.9 返回的值为9 这就是向下取整
System.out.println(Math.ceil(-8.9));//运行结果: -8.0
//Math.ceil 表示向上取整 如果()中是8.1 返回值是9.0 这就是向上取整
System.out.println(Math.random());
//Math.random 随机产生 0-1 之间的随机值 有可能产生0 几率很小 注意()中不能填入参数
//如果想随机0-10 之间的数 代码为：System.out.println(Math.random()*10);
//---------------------------------------萌萌的分割线君-------------------------------------------------------
//类加载机制由类加载器完成 反射：Java的反射机制是Java的特征之一
//简单的一句话：反射就是运行时探究和使用编译未知的类
Dog dog = new Dog();
Class clazz = dog.getClass();//表示获得class的具体实例 前提是知道有具体的实例 就可以使用getClass()
System.out.println(clazz);//运行结果： class com.wode.Dog 能知道他来自那个类 以及具体的地方
Class clazz1 = Dog.class;//知道类的名字 但是没有实例对象
Class clazz2 = Class.forName("com.wode.Dog");//运行期间动态传入 在不知道实例以及类的名字的时候使用
// Class.forName 会有可能产生异常 为了代码好看我将异常抛出 并且抛出的Exception 所有异常的父类 以便后面有异常的时候再次抛出异常
//Filed 类 ：提供类或者接口所有的属性信息 即使是私有的也能获得
Field [] fields = clazz2.getDeclaredFields();//获得Dog 所有属性并且用数组储存
for (int i = 0; i < fields.length; i++) {//使用循环的方法打印 出Dog类中所有的属性
System.out.println(fields[i]);
}
//Filed 获得了Dog 中所有的属性 那么怎么样修改？
for(Field field:fields){//循环出 所有的属性
if (field.getName().equals("age")) {//找到age属性并且修改 如果想修改name属性 一定会报错 因为name属性是受保护的只能看到而不能修改
field.set(dog, 8);
System.out.println(dog.age);
}
}
//Method类： 获取Dog 里面的方法
Method [] methods = clazz.getDeclaredMethods();
//通过getDeclaredMethods 来获得Dog里的所有方法 并且用for 循环输出
for (int i = 0; i < methods.length; i++) {
System.out.println(methods[i]);
}
//获得方法后 又怎么样去调用方法？
Method method = clazz.getMethod("show",String.class );
//使用 getMethod 来调用方法
method.invoke(dog, "啊汪");
//然后使用 method.invoke 来使用方法 括号里分别是实例化的对象 和需要修改的属性
//Constructor 类 ：获得Dog里的构造函数
Constructor constructor = clazz.getDeclaredConstructor(null);//使用 getDeclaredConstructor 来获取Dog里的无参构造函数
constructor.newInstance(null);//调用无参的构造函数
Constructor constructor2 = clazz.getConstructor(int.class,String.class);
constructor2.newInstance(5,"有参");//调用有参构造函数
//Object o = clazz.newInstance(); //使用Object 实例化对象 因为Object 是父类 所有不会有强转
//Dog dog2 = (Dog) clazz.newInstance();//使用newInstauce 实例化对象 这里是向下转型所以会涉及到强转
//newInstauce 也能实例化对象，通过调用构造函数来实例化对象 并且Class.Constructor 都提供了newInstauce方法
//new：是强类型 相对高效 能调用任何类public类
//newInstauce ：是弱类型 效率低 只能调用构造函数
}
}
package com.wode;
/***
*
* @author Administrator
*创建 一个狗类
*/
public class Dog {
private String name;//private 私有的 封装的思想
int age;
public void show(String name) {
System.out.println(name+"：汪汪汪"+" "+"我："+age+"岁");
}
//下面提供相应的get和set 方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Dog() {
System.out.println("无参构造函数！");
}
public Dog(int age,String neme){
super();
this.age = age;
this.name = neme;
System.out.println("有参构造函数！");
}
}