包装类和math的使用

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) {
		/*
		 * 由于 Java 拥有 8 个基本数据类型，这 8 个基本数据类型是无法进行对象的创建，
		 * 这个是不符合面向对象思想的，因为为了解决这个问题，Java 提供了包装类来应对这 8 个基本数据类型。
		 * 这八个包装类就属于引用数据类型，是可以创建对象的，分别是：
		 * 基本数据类型			包装类
		 * byte					Byte
		 * short				Short
		 * int					Integer
		 * long					Long
		 * float				Float
		 * double				Double
		 * char					Character
		 * boolean				Boolean
		 * 在有了包装类之后，泛型里所放的就是包装类型
		 */
		// 要想获得一个包装类，可以通过 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<Integer> numList = new ArrayList<Integer>();
		// 通过包装类，可以获得一个数据类型的最大值和最小值
		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 {
		/*
		 * 1、反射机制是 Java 所特有的机制，能够是开发者在代码运行的状态下，
		 * 动态的了解一个 Java 类所具有的属性、方法和构造方法，并且能够实现
		 * 动态的创建这个类的对象、调用这个对象的属性和方法。
		 * 2、所有的反射机制的功能入口，都是从 java.lang.Class 这个类开始的。
		 * 3、Java 所有的类都是 Class 类的对象。
		 */
		// 要想获得任何一个类的 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) {
		/*
		 * 对于 Java 运行过程中，所产生的对象也属于数据，
		 * 因此这种数据也能够存储到文件中，
		 * 而且文件中已经存储的对象数据，也能够通过流重新读取到程序中恢复成一个对象。
		 * 因此遇到的问题就是，在写出对象数据时，如何将对象变为字节序列，
		 * 以及将字节序列恢复成一个对象。需要约定对象的编码方案。
		 * 因此，我们将一个对象变为字节序列的过程称之为序列化；
		 * 将一个字节序列恢复成一个对象的过程称之为反序列化。
		 * 要想将一个对象具有序列化和反序列化的能力，则该类必须实现接口 java.io.Serializable。
		 * 只要实现该接口，那么 Java 会自动的为该类提供一套完整的序列化和反序列的方案，
		 * 我们要求任何一个 Java 类都必须实现 java.io.Serializable 接口。
		 * 原因在于，一个 Java 对象，不仅仅需要变为字节序列存储在硬盘，
		 * 而且也需要进行网络传输，无论是磁盘保存，还是网络传输，都必须变为字节序列才可以进行。
		 * 当接收磁盘保存的对象或者是对方通过网络所发送的对象数据时，也必须经过反序列化才能够变为一个对象。
		 */
		// 创建 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) {
		/*
		 * 通过序列化功能，能够将 Java 对象变为字节序列保存到文件中去，
		 * 那么通过 ObjectInputStream 也能够将存储的对象序列读取到程序中，
		 * 借助于反序列化功能，将字节序列恢复成一个 Java 对象
		 */
		// 设定需要读取的文件路径
		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<Student> stuClass = Student.class;
		// 获得 Student 的无参数构造方法
		Constructor<Student> 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);
	
}
}