缺点：在类加载的时候，就实例化对象，提前占用系统资源
1 class Dog{
2
3 private Dog(){
4
5 System.out.println("小蠢狗");
6 }
7
8 private static Dog cutedog=new Dog();
9
10 public static Dog getInstanca(){
11 return cutedog;
12 }
13
14 }
（2.）懒汉式单例模式：
优点：解决了饿汉式单例，一加载就提前占用资源的问题。
缺点：线程不安全
1 class Dog{
2
3 private Dog(){
4
5 System.out.println("小蠢狗");
6 }
7
8 private static Dog cutedog=null;
9
10 public static Dog getInstanca(){
11 if (cutedog==null) {
12 cutedog=new Dog();
13 }
14 return cutedog;
15 }
16
17 }
（3.）线程锁懒汉式模式
通俗来说，就是在懒汉式单例模式的方法上加锁
synchronized：将一个方法或者代码块进行加锁，同一时间只允许一个线程访问
使用同步块对方法进行加锁，确保懒汉式单例，可以线程安全
缺点：效率低下
1 class Dog{
2
3 private Dog(){
4
5 System.out.println("小蠢狗");
6 }
7
8 private static Dog cutedog=null;
9
10 public static synchronized Dog getInstanca(){
11 if (cutedog==null) {
12 cutedog=new Dog();
13 }
14 return cutedog;
15 }
16
17 }
（4.）双重加锁懒汉模式：
只有第一次Dog为null时，才进行线程锁，当后续Dog不为null时，说明第一次已经赋值了，·产生了一个实例，就无需线程锁，可以允许多个线程同时拿走dog
class Dog{
private Dog(){
System.out.println("小蠢狗");
}
private static Dog cutedog=null;
public static synchronized Dog getInstanca(){
if (cutedog==null) {
synchronized (Dog.class) {
if (cutedog==null) {
cutedog=new Dog();
}
}
}
return cutedog;
}
}
(5.)静态内部类实现单例
优点：解决了饿汉式提前占用资源的问题，解决了懒汉式线程不安全的问题，静态内部类只有当被调用的时候才开始首次被加载。
1 class Dog{
2
3 private Dog(){
4
5 System.out.println("小蠢狗");
6 }
7
8 private static class KIttyDod{
9 private static Dog cutedog=new Dog();
10 }
11 public static Dog getInstance(){
12 return KIttyDod.cutedog;
13 }
14
15 }
【Math】
;?Math位于Java.lang包中
（1.）Math.abs(); 求绝对值
（2.）Math.cbrt(); 求立方根
（3.）Math..sprt();求平方根
（4.）Math.max/min(double1,double2); 返回两个值中最大最小值
（5.）Math.pow(a,b); 求a的b次方
（6.）Math.floor();返回小于指定浮点数的一个整数，返回的是double类型，例如10.0
Math.ceil();------大于---------
（6.）Math.round();四舍五入，返回一个整数类型，如果传入double，返回long，传入float，返回int
（7.）Math.rint();返回最接近参数的整数，如果10.5与10和11同时接近，返回偶数
（8.）Math.random()；返回[0.1,1.0)之间的double随机值
【求一个数保留几位小数】
double a=23.22122222;
double b=Math.round(a*Math.pow(10, 3))/Math.pow(10, 3);
System.out.println(b);
【Date】
/**实例化
* 空参构造，默认取到当前时间
*/
Date date=new Date();
Date d=new Date();
/**
* 传入一个long类型的时间戳，取到指定时间。
* date.getTime(); 取到一个时间的时间戳，从0时区，1970年1月1日0:0:0到当前时间毫秒数。
*/
System.out.println(d);
（1.）equals();比对两个时间是否相等
（2.）a.before(b); 检测一个时间是不是在制定时间之前
after(): --------------------------------------之后
（3.）a.compare to(b); 前面>参数 返回1 前面<小于参数，返回-1 相等,返回0
（4.）setTime()；传入一个长整型（时间戳），重新设置时间
（5.）toString();格式化日期转义格式yyyy-mm-dd。
【SimpleDateFormat】
对日期格式进行实例化。
实例化对象时，传入格式化参数，用字母代表对应部分。
* 字母 日期或时间元素 表示 示例
* y 年 Year 1996; 96
* M 年中的月份 Month July; Jul; 07
* d 月份中的天数 Number 10
* E 星期中的天数 Text Tuesday; Tue
* H 一天中的小时数（0-23） Number 0
* h am/pm 中的小时数（1-12） Number 12
* m 小时中的分钟数 Number 30
* s 分钟中的秒数 Number 55
（1.）format();用于传人一个Date类型的参数，并返回格式化之后的字符串
Date date=new Date();
SimpleDateFormat sf=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss E" );
String s=sf.format(date);
System.out.println(s);
（2.）sf.parse("2018年04月13日 14:08:15 星期五");将字符串格式的时间，转成Date类型，要求传入的字符串格式，必须与实例化时的模式，保持一致。
（3.）toPattern();返回当前格式化的模式字符串。
【Calendar日历类】
Calendar ca=Calendar.getInstance();
（1.）Calendar日历类是一个抽象类，不能直接通过new拿到对象，必须使用Calendar.getInstance();拿到一个Calendar日历类对象
（2.）ca.getTime(); 返回一个日期对象
（3.）ca.add(int field, int amount) ; 根据日历的规则，将指定的时间量添加或减去给定的日历字段。
【Random随机数类】
取随机数，有两种构造：
--------------空参构造------------
Random ran=new Random();
--------------传入一个种子数--------只要种子数相同，那么在相同次数取到的随机数肯定相同，这是伪随机数。
Random ran=new Random(100);
Random ran=new Random(System.currentTimeMillis());
System.currentTimeMillis()；拿到当前时间戳，这样就是取随机数了。
（1.）nextInt(); 随机获得一个整数
（2.）nextInt(n); 随机获得从0到n随机数，含0不含n
随机生成两位随机数： System.out.println(ran.nextInt(90)+10);
