spackage cn.ekgc.javasenior.day20210623;
public class MathDemo {
public static void main(String[] args) {
// Java 提供了 Math 这个数学计算的工具类
// Math 提供了两个常量值，分别是 E 和 PI
System.out.println("PI = " + Math.PI);
System.out.println("E = " + Math.E);
System.out.println("abs() 获得任意数字的绝对值：" + Math.abs(-101));
// 对于 floor() 来说，是对于一个浮点数进行向下取整，也就是直接将小数点去掉
System.out.println("floor() 能够获得靠近这个值的最大值：" + Math.floor(55.9));
System.out.println("pow() 能够计算任意数字的任意幂次的值：" + Math.pow(3, 2));
// 使用 Math 的 random() 能够获得一个 [0, 1) 之间的随机数
System.out.println("使用 Math 的 random() 获得随机数：" + Math.random());
System.out.println("Math 的 round() 能够对一个浮点型进行四舍五入：" + Math.round(55.1));
}
}
package cn.ekgc.javasenior.day20210623;
import java.util.ArrayList;
import java.util.List;
public class WrapperClassDemo {
public static void main(String[] args) {
// 要想获得一个包装类，可以通过 new 的形式来创建对象
Integer num1 = new Integer(1);
System.out.println(num1);
// 也可以按照基本类型进行直接赋值
Integer num2 = 1;
Integer num3 = 123;
int num4 = num3;
int num5 = 111;
Integer num6 = num5;
List numList = new ArrayList();
// 通过包装类，可以获得一个数据类型的最大值和最小值
System.out.println("int 类型的最大值是：" + Integer.MAX_VALUE + "，最小值是：" + Integer.MIN_VALUE);
System.out.println("int 类型的二进制数据：" + Integer.BYTES);
// 可以通过包装类的构造方法将 String 进行转换
Integer num7 = new Integer("100");
System.out.println(num7);
// 由于包装类是一个引用数据类型，那么包装类的值时可以为 null
Integer num8 = null;
}
}
反射机制
package cn.ekgc.javasenior.day20210629;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectDemo01 {
public static void main(String[] args) throws Exception {
// 要想获得任何一个类的 Class 类的对象，有两种方式：
// 方式一：直接通过类名的 class 属性获得
Class stuClass1 = Student.class;
// 方式二：首先创建该类的对象，然后通过调用该对象的 getClass() 获得
Student student = new Student();
Class stuClass = student.getClass();
// 在获得 Class 对象之后，就可以借助于反射机制，获得这个类的属性、方法和构造方法
// 获得 Student 的所有属性，反射机制将每个属性都对应为一个 Field 对象
// 对于 getFields() 只能够获得所有的使用 public 修饰的属性
Field[] fields = stuClass.getFields();
for (Field field : fields) {
System.out.println(field);
}
// 要想获得所有 Student 写出的属性，使用 getDeclaredFields()
System.out.println("==========================");
Field[] declaredFields = stuClass.getDeclaredFields();
for (Field field : declaredFields) {
System.out.println(field);
}
System.out.println("==========================");
// 也可以通过属性名，获得某个具体的属性，并且进行赋值
// 获得 name 属性
Field nameField = stuClass.getField("name");
// 获得 name 属性对应的 Field 对象后，就可以使用这个 Field 对象进行属性值的赋值
// 在使用 set() 赋值时，需要指明给哪个对象的该属性赋值，第二个参数指的是所赋予的具体值
// 以下代码的作用就是给 student 对象的 name 属性赋予 张涛
// 等价于：student.name = "张涛"
nameField.set(student, "张涛");
System.out.println(student.name);
// 对于反射机制，会将方法对应到 Method 对象上，
// 要想获得一个类的所有方法，也有 getMethods() 和 getDeclaredMethods()
System.out.println("==========================");
Method[] declaredMethods = stuClass.getDeclaredMethods();
for (Method method : declaredMethods) {
System.out.println(method);
}
System.out.println("==========================");
// 通过方法名可以获得一个具体方法的 Method 对象，并且通过 invoke() 来调用这个方法
Method sayHelloMethod = stuClass.getMethod("sayHello");
// 通过反射机制调用该方法
// 以下代码就是：student.sayHello();
sayHelloMethod.invoke(student);
System.out.println("==========================");
// 通过反射机制也可以获得该类的构造方法，
// 如果要获得一个类的所有构造方法，可以通过 getConstructors() 或者是 getDeclaredConstructors()
Constructor[] declaredConstructors = stuClass.getDeclaredConstructors();
for (Constructor constructor : declaredConstructors) {
System.out.println(constructor);
}
System.out.println("==========================");
// 由于构造方法的方法名都是相同，那么可以通过参数列表来获得某个具体的构造方法
Constructor constructor = stuClass.getConstructor(String.class, String.class, String.class);
// 获得某个具体的构造方法，那么就可以通过这个构造创建对象
Student stu = (Student) constructor.newInstance("张涛", "9527", "男");
System.out.println(stu);
}
}
package cn.ekgc.javasenior.day20210629;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class SerializableDemo01 {
public static void main(String[] args) {
// 创建 User 对象
User user = new User("王大锤", "13601002978", 1);
// 如果需要将一个对象保存到文件中，那么可以借助于 ObjectOutputStream 完成
// 创建需要保存数据的文件路径
String path = "C:\Users\Arthur\Desktop\users.txt";
// 根据文件路径创建 File 对象
File file = new File(path);
// 初始化 FileOutputStream 和 ObjectOutputStream 类型的变量
FileOutputStream out = null;
ObjectOutputStream oos = null;
try {
// 通过 File 对象创建 FileOutputStream 对象
out = new FileOutputStream(file);
// 通过 FileOutputStream 对象创建 ObjectOutputStream 对象
oos = new ObjectOutputStream(out);
// 通过 ObjectOutputStream 将 User 对象写出
oos.writeObject(user);
System.out.println("对象写入成功！");
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
// 关闭最外层的流
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
package cn.ekgc.javasenior.day20210629;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class SerializableDemo02 {
public static void main(String[] args) {
// 设定需要读取的文件路径
String path = "C:\Users\Arthur\Desktop\users.txt";
// 根据文件路径创建对应的 File 对象
File file = new File(path);
// 分别创建 FileInputStream 和 ObjectInputStream 类型的变量
FileInputStream in = null;
ObjectInputStream ois = null;
try {
// 通过 File 对象创建 FileInputStream 对象
in = new FileInputStream(file);
// 通过 FileInputStream 对象创建 ObjectInputStream 对象
ois = new ObjectInputStream(in);
// 通过 ObjectInputStream 对象的 readObject() 读取文件中的数据
// 并且通过反序列化，将数据恢复成一个对象
User user = (User) ois.readObject();
System.out.println(user);
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
try {
// 关闭 ObjectInputStream 对象
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
package cn.ekgc.javasenior.day20210629;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class StudentDemo {
public static void main(String[] args) throws Exception {
// 对于普通的属性或者是方法的调用，需要创建对象
Student student = new Student();
student.name = "法外狂徒张三";
student.cellphone = "110";
student.setGender("男");
System.out.println(student);
System.out.println("=================");
// 使用反射机制实现以上功能
// 获得 Student 的 Class 对象
Class stuClass = Student.class;
// 获得 Student 的无参数构造方法
Constructor constructor = stuClass.getConstructor();
// 借助于无参数构造方法创建对象
Student stu = constructor.newInstance();
// 获得 Student 的 name 属性
Field nameField = stuClass.getField("name");
// 给 stu 对象的 name 属性赋值
nameField.set(stu, "法外狂徒张三");
// 同理获得 cellphone 属性
Field cellphoneField = stuClass.getDeclaredField("cellphone");
cellphoneField.set(stu, "110");
// 获得 Student 的 setGender()
Method setGenderMethod = stuClass.getMethod("setGender", String.class);
// 执行该方法
setGenderMethod.invoke(stu, "男");
System.out.println(stu);
}
}
package cn.ekgc.javasenior.day20210629;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Iterator;
import javax.activation.FileDataSource;
public class Student01 {
public static void main(String[] args) throws Exception {
Class stuclass1 = Student.class;
Student student = new Student();
Class stuclass = student.getClass();
Field[] fields = stuclass.getFields();
for(Field field: fields) {
System.out.println(field);
}
System.out.println("=========================");
Field[]declaFields = stuclass.getDeclaredFields();
for(Field field: declaFields) {
System.out.println(field);
}
System.out.println("=========================");
Field nameField = stuclass.getField("name");
nameField.set(student,"法外狂徒张三");
System.out.println(student.name);
Method[] declaredMethods = stuclass.getDeclaredMethods();
for(Method method: declaredMethods) {
System.out.println(method);
}
System.out.println("=========================");
Method sayhello = stuclass.getMethod("sayHello");
sayhello.invoke(student);
Constructor[] declaredConstructors = stuclass.getConstructors();
for(Constructor con: declaredConstructors) {
System.out.println(con);
}
Constructor constructor = stuclass.getConstructor(String.class,String.class,String.class);
Student stu = (Student )constructor.newInstance("张三丰","9527","男");
System.out.println(stu);
}
}
