java 常用类（二）--------15

一、Random - 随机类

package com.qf.random_class;

import java.util.Random;

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 知识点：Random - 随机类
		 */
		
		Random ran = new Random();
		
		//随机出int取值范围内的数据
		int num1 = ran.nextInt();
		System.out.println(num1);

		//随机出int类型0~9的数字
		int num2 = ran.nextInt(10);//底层原理：随机获取正整数的数字%10
		System.out.println(num2);
		
		//随机出double取值范围内的数据
		double num3 = ran.nextDouble();
		System.out.println(num3);
	
		//随机出boolean类型的值
		boolean bool = ran.nextBoolean();
		System.out.println(bool);
	}
}

1.2需求

 需求：点名器

package com.qf.random_class;

import java.util.Random;

public class Test02 {

	public static void main(String[] args) {
		/**
		 * 知识点：Random - 随机类
		 * 
		 * 需求：点名器
		 */
		
		String[] names = {"张三","李四","王五","小明","小红","小李"};
		
		Random ran = new Random();
		int index = ran.nextInt(names.length);
		
		System.out.println(names[index]);
	}
}

1.3 注意种子数固定，随机出的数字就是固定的

package com.qf.random_class;

import java.util.Random;

public class Test03 {

	public static void main(String[] args) {
		/**
		 * 知识点：Random - 随机类
		 * 
		 * 注意：种子数固定，随机出的数字就是固定的
		 */
		
		Random ran = new Random(100);
		System.out.println(ran.nextInt()); //-1193959466
	}
}

二、Runtime - 运行时类

2.1含义 

代表着Java的运行环境(JRE、JVM) 

package com.qf.runtime_class;

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 知识点：Runtime - 运行时类
		 * 含义：代表着Java的运行环境(JRE、JVM)
		 */
		
		//获取运行时类的对象
		Runtime run = Runtime.getRuntime();
		
		System.out.println("获取处理数：" + run.availableProcessors());//7
		System.out.println("获取最大内存数(字节)：" + run.maxMemory());
		System.out.println("获取闲置内存数(字节)：" + run.freeMemory());
		
	}
}

 2.2从 消耗时长和消耗内存 考虑一段代码的效率

package com.qf.runtime_class;

public class Test02 {

	public static void main(String[] args) {
		/**
		 * 知识点：从 消耗时长和消耗内存 考虑一段代码的效率
		 */
		
		Runtime run = Runtime.getRuntime();
		long startMemory = run.freeMemory();
		long startTime = System.currentTimeMillis();	
		String str = "张三";
		for (int i = 0; i < 10000; i++) {
			str += "法外狂徒";
			//str = new StringBuider(str).append("法外狂徒").toString();
		}
		long endMemory = run.freeMemory();
		long endTime = System.currentTimeMillis();	
		
		System.out.println("消耗时长：" + (endTime-startTime));//310
		System.out.println("消耗内存：" + (startMemory-endMemory));//-170424952
		//消耗内存出现负数的原因：在运行过程中，内存不够用时，Java的垃圾回收器(gc)会回收垃圾内存(没有引用的对象)
		
		Runtime run = Runtime.getRuntime();
		long startMemory = run.freeMemory();
		long startTime = System.currentTimeMillis();
		StringBuilder sb = new StringBuilder("张三");
		for (int i = 0; i < 10000; i++) {
			sb.append("法外狂徒");
		}
		long endMemory = run.freeMemory();
		long endTime = System.currentTimeMillis();	
		
		System.out.println("消耗时长：" + (endTime-startTime));//2
		System.out.println("消耗内存：" + (startMemory-endMemory));//765456
	}
}

 三、设计模式之单例模式

3.1前言 

new对象的过程叫做实例化 

理解：该类的对象只有一个

单例模式：
        1.私有化构造方法
        2.创建静态常量：private static final A a = new A();
        3.添加静态的get方法

 3.2单例类

package com.qf.runtime_class;

public class A {

	private static final A a = new A();

	private A() {
	}
	
	public static A getInstance(){
		return a;
	}
}

package com.qf.runtime_class;

public class Test03 {

	public static void main(String[] args) {
		
		//单例模式
		//Runtime run = Runtime.getRuntime();
		//Calendar calendar = Calendar.getInstance();
		//A a = A.getInstance();
	}
}

 3.3面试题

为什么使用private修饰？
        私有化属性，并且添加get方法让外界获取a对象
为什么使用static修饰？
        使用到该类，该类的class文件加载到方法区时(类加载机制)，就会在静态区中创建A类的对象，getInstance方法是静态方法，静态方法只能调用静态属性
为什么使用final修饰？
        应该该对象创建后，不允许外界改变

四、研究System类的属性 

4.1 注意 

注意流的方向是站在程序的角度去看待 

package com.qf.system_class;

import java.io.InputStream;
import java.io.PrintStream;
import java.util.Scanner;

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 知识点：研究System类的属性
		 */
		
		//注意流的方向是站在程序的角度去看待
		
		//系统标准的输入流（方向：控制台->程序）
		InputStream in = System.in;
		Scanner scan = new Scanner(in);
		String str = scan.next();
		scan.close();//关闭资源
		
		//程序标准的输出流（方向：程序->控制台）
//		PrintStream out = System.out;
//		out.println(str);
		
		//程序标准的错误输出流（方向：程序->控制台）
		PrintStream err = System.err;//err -- error错误
		err.println(str);
		
	}
}

 4.2 研究System的out和err

package com.qf.system_class;

public class Test02 {

	public static void main(String[] args) {
		/**
		 * 知识点：研究System的out和err
		 * 
		 * err是一个线程里的代码、out是另一个线程里的代码
		 * 感受多线程争抢CPU资源的场景
		 */
		
		System.out.println("小明");
		System.err.println("小红");
		System.out.println("小强");
	}
}

 4.3研究System的方法

package com.qf.system_class;

import java.util.Properties;

public class Test03 {

	public static void main(String[] args) {
		/**
		 * 知识点：研究System的方法
		 */
		
		//获取系统配置文件对象
		Properties properties = System.getProperties();
		System.out.println(properties);
		
		//通过键找到配置文件中对应的值
		String value = System.getProperty("os.name");
		System.out.println(value);
		
		//关闭当前虚拟机
		//System.exit(0);
	
		
	
	}
}

4.4System删除数组中的值

package com.qf.system_class;

import java.util.Arrays;

public class Test04 {

	public static void main(String[] args) {
		/**
		 * 知识点：研究System的方法
		 */
		
		int[] is = {1,2,3,4,5,6,7,8,9};
		
		System.arraycopy(is, 3, is, 2, 6);//原数组，开始下标，原数组，开始下标，拷贝次数
		
		is[is.length-1] = 0;//将0赋值给最后下标的位置
		
		System.out.println(Arrays.toString(is));
	
	}
}

 五、整数大数值运算类

package com.qf.big_class;

import java.math.BigInteger;

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 知识点：整数大数值运算类
		 */
		
		BigInteger big1 = new BigInteger("12000000000");
		BigInteger big2 = new BigInteger("12000000000");
		
		BigInteger add = big1.add(big2);
		System.out.println("加法：" + add);
		
		BigInteger subtract = big1.subtract(big2);
		System.out.println("减法：" + subtract);
		
		BigInteger multiply = big1.multiply(big2);
		System.out.println("乘法：" + multiply);
		
		BigInteger divide = big1.divide(big2);
		System.out.println("除法：" + divide);
	}
}

 5.2小数大数值运算类

package com.qf.big_class;

import java.math.BigDecimal;

public class Test02 {

	public static void main(String[] args) {
		/**
		 * 知识点：小数大数值运算类
		 * 
		 * 注意：小数在底层使用二进制存储时会失去精度，千万不能直接做运算
		 */
		
		
		BigDecimal big1 = new BigDecimal("0.5");
		BigDecimal big2 = new BigDecimal("0.4");
		
		BigDecimal add = big1.add(big2);
		System.out.println("加法：" + add);
		
		BigDecimal subtract = big1.subtract(big2);
		System.out.println("减法：" + subtract);
		
		BigDecimal multiply = big1.multiply(big2);
		System.out.println("乘法：" + multiply);
		
		BigDecimal divide = big1.divide(big2);
		System.out.println("除法：" + divide);
	}
}

package com.qf.big_class;

import java.math.BigDecimal;

public class Test03 {

	public static void main(String[] args) {
		/**
		 * 知识点：小数大数值运算类
		 * 
		 * 注意：小数在底层使用二进制存储时会失去精度，千万不能直接做运算
		 */
		
		
		BigDecimal big1 = new BigDecimal("10");
		BigDecimal big2 = new BigDecimal("3");
		
		BigDecimal divide = big1.divide(big2, 3, BigDecimal.ROUND_HALF_UP);//(除数，保留小数位，进制模式)
		System.out.println("除法：" + divide);
	}
}

六、枚举

6.1需求 

编写季节类（Season），该类只有四个对象（spring，summer，autumn，winter） 

6.1.1普通类编写 

package com.qf.enum01;

public class Season {
	
	public static final Season spring = new Season("春天", "万物复苏");
	public static final Season summer = new Season("夏天", "汗如雨下");
	public static final Season autumn = new Season("秋天", "秋高气爽");
	public static final Season winter = new Season("冬天", "白雪皑皑");

	private String name;
	private String info;
	
	private Season() {
	}
	
	private Season(String name, String info) {
		this.name = name;
		this.info = info;
	}

	public String getName() {
		return name;
	}

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

	public String getInfo() {
		return info;
	}

	public void setInfo(String info) {
		this.info = info;
	}

	@Override
	public String toString() {
		return "Season [name=" + name + ", info=" + info + "]";
	}
}

package com.qf.enum01;

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 知识点：枚举
		 * 
		 * 需求：编写季节类（Season），该类只有四个对象（spring，summer，autumn，winter）
		 */
		
		System.out.println(Season.spring);
		System.out.println(Season.summer);
		System.out.println(Season.autumn);
		System.out.println(Season.winter);
		
	}
}

 6.1.2枚举编写

package com.qf.enum02;

public enum Season{

	//默认添加了public static final Season
	spring("春天","春雨绵绵"),
	summer("夏天","烈日炎炎"),
	autumn("秋天","硕果累累"),
	winter("冬天","银装素裹");
	
	private String name;
	private String info;
	
	private Season() {
	}
	
	private Season(String name, String info) {
		this.name = name;
		this.info = info;
	}

	public String getName() {
		return name;
	}

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

	public String getInfo() {
		return info;
	}

	public void setInfo(String info) {
		this.info = info;
	}
	
	@Override
	public String toString() {
		return "Season [name=" + name + ", info=" + info + "]";
	}
	
}

package com.qf.enum02;

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 知识点：枚举
		 * 含义：枚举就是一个受限制的类
		 * 应用场景：一个类只能有固定的几个对象时，就考虑使用枚举
		 * 
		 * 使用枚举完成以下需求
		 * 需求：编写季节类（Season），该类只有四个对象（spring，summer，autumn，winter）
		 */
		
		System.out.println(Season.spring);
		System.out.println(Season.summer);
		System.out.println(Season.autumn);
		System.out.println(Season.winter);
	}
}

6.2枚举的方法

package com.qf.enum02;

public class Test02 {

	public static void main(String[] args) {
		/**
		 * 知识点：枚举的方法
		 */
		
		//通过字符串找到枚举类的某个对象
		Season season1 = Enum.valueOf(Season.class, "spring");
		System.out.println(season1);
		
		//通过字符串找到枚举类的某个对象
		Season season2 = Season.valueOf("spring");
		System.out.println(season2);
		
		//获取该枚举类中所有的对象
		Season[] seasons = Season.values();
		for (Season season : seasons) {
			//获取枚举对象的名字
			String name = season.name();
			System.out.println(name);
		}
	}
}

 6.3枚举的应用之状态机

package com.qf.enum03;

//信号灯
public enum Signal {
	RED,YELLOW,GREEN;
}

package com.qf.enum03;

import java.util.Scanner;

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 枚举的应用之状态机
		 */

		Scanner scan = new Scanner(System.in);
		System.out.println("请选择信号灯：RED，YELLOW，GREEN");
		String str = scan.next();
		scan.close();

		//通过字符串找到枚举类的对象
		Signal signal = Signal.valueOf(str);

		String trafficInstruct = getTrafficInstruct(signal);
		System.out.println(trafficInstruct);
	}

	public static String getTrafficInstruct(Signal signal){
		String instruct = "信号灯故障";
		
		switch (signal) {
		case RED:
			instruct = "红灯停";
			break;
		case YELLOW:
			instruct = "黄灯请注意";
			break;
		case GREEN:
			instruct = "绿灯行";
			break;
		}
		return instruct;
	}
}

6.4枚举应用之状态码/错误码

package com.qf.enum04;

public enum AddCode {

	ERROR_A(-1,"添加失败 -- 学生信息不合法"),
	ERROR_B(-2,"添加失败 -- 有重复学生"),
	OK(1,"添加成功");
	
	private int code;
	private String info;
	
	private AddCode() {
	}

	private AddCode(int code, String info) {
		this.code = code;
		this.info = info;
	}

	public int getCode() {
		return code;
	}

	public void setCode(int code) {
		this.code = code;
	}

	public String getInfo() {
		return info;
	}

	public void setInfo(String info) {
		this.info = info;
	}
	
	@Override
	public String toString() {
		return code + " -- " + info;
	}
}

 6.5 枚举应用之组织枚举

枚举应用之组织枚举 

含义：可以将类型相近的枚举通过接口或类组织起来（但是一般用接口方式进行组织）

原因是：
        Java接口在编译时会自动为enum类型加上public static修饰符；
        Java类在编译时会自动为 enum 类型加上static修饰符；
        就是说，在类中组织 enum，如果你不给它修饰为 public，那么只能在本包中进行访问。 

package com.qf.enum05;

//组织枚举
public class Code {
	
	enum AddCode {

		ERROR_A(-1,"添加失败 -- 学生信息不合法"),
		ERROR_B(-2,"添加失败 -- 有重复学生"),
		OK(1,"添加成功");
		
		private int code;
		private String info;
		
		private AddCode() {
		}

		private AddCode(int code, String info) {
			this.code = code;
			this.info = info;
		}

		public int getCode() {
			return code;
		}

		public void setCode(int code) {
			this.code = code;
		}

		public String getInfo() {
			return info;
		}

		public void setInfo(String info) {
			this.info = info;
		}
		
		@Override
		public String toString() {
			return code + " -- " + info;
		}
	}

	enum DeleteCode {

		ERROR_A(-1,"删除失败 -- 学生信息不合法"),
		ERROR_B(-2,"删除失败 -- 没有该学生"),
		OK(1,"删除成功");
		
		private int code;
		private String info;
		
		private DeleteCode() {
		}

		private DeleteCode(int code, String info) {
			this.code = code;
			this.info = info;
		}

		public int getCode() {
			return code;
		}

		public void setCode(int code) {
			this.code = code;
		}

		public String getInfo() {
			return info;
		}

		public void setInfo(String info) {
			this.info = info;
		}
		
		@Override
		public String toString() {
			return code + " -- " + info;
		}
	}
}

 6.6模拟计算工资的场景

package com.qf.enum06;

import java.math.BigDecimal;

//工资的枚举
public enum Salary {
	Java(StaffType.teacher),
	Html(StaffType.teacher),
	Python(StaffType.teacher),
	Reception(StaffType.administrative),
	Principal(StaffType.administrative)
	;
	
	private StaffType staffType;
	
	private Salary(StaffType staffType) {
		this.staffType = staffType;
	}
	
	public double getSalary(double baseSalary, int classHour, double teachingHourSubsidy,
			double achievements){
		
		return staffType.calculationSalary(baseSalary, classHour, teachingHourSubsidy, achievements);
	}
	

	//员工类别
	enum StaffType{
		
		//匿名内部类的对象： class 匿名类 extends StaffType
		teacher{
			@Override
			public double calculationSalary(double baseSalary, int classHour, double teachingHourSubsidy,
					double achievements) {
				
				//老师的工资：基本工资 + 课时*课时费 + 绩效
				BigDecimal big1 = new BigDecimal(String.valueOf(baseSalary));
				BigDecimal big2 = new BigDecimal(String.valueOf(classHour));
				BigDecimal big3 = new BigDecimal(String.valueOf(teachingHourSubsidy));
				BigDecimal big4 = new BigDecimal(String.valueOf(achievements));
				
				BigDecimal salary = big2.multiply(big3).add(big1).add(big4);
				
				return salary.doubleValue();
			}
		},
		//匿名内部类的对象： class 匿名类 extends StaffType
		administrative{

			@Override
			public double calculationSalary(double baseSalary, int classHour, double teachingHourSubsidy,
					double achievements) {
				
				BigDecimal big1 = new BigDecimal(String.valueOf(baseSalary));
				BigDecimal big2 = new BigDecimal(String.valueOf(achievements));
				
				BigDecimal salary = big1.add(big2);
				return salary.doubleValue();
			}
		}
		;
		
		/**
		 * 计算工资的方法
		 * @param baseSalary 基本工资
		 * @param classHour 课时
		 * @param teachingHourSubsidy 课时费
		 * @param achievements 绩效
		 * @return 应得工资
		 */
		public abstract double calculationSalary(double baseSalary,int classHour,double teachingHourSubsidy,double achievements);
	}
}

package com.qf.enum06;

public class Test01 {

	public static void main(String[] args) {
		
		double salary1 = Salary.Java.getSalary(1300, 84, 15, 1000);
		System.out.println(salary1);
		
		double salary2 = Salary.Reception.getSalary(500, 0, 0, 10000);
		System.out.println(salary2);
	}
}