UUID、Date、SimpleDateFormat、枚举(Enum)

作业看xiaoming和Playing

UUID:通用的唯一识别码,在一台机器上生成的数字,它保证对在同一个时间中所有的机器所产生的值都是唯一
UUID是一个128位长的数字,一般用16进制表示
算法核心就是结合机器的网卡,当前时间,一个随机数合并产生UUID
看UUID

/**
 * 
 */
package com.qfedu.Day14.UUID;

import java.util.Arrays;
import java.util.Random;
import java.util.UUID;

public class UUIDDemo {

    public static void main(String[] args) {
        //转换为一个字符串的形式展示
        String uuid = UUID.randomUUID().toString();
        System.out.println(uuid);
        //当前ID用户是同一个或是第一次注册  
        //注册 --> 验证码
        
        //生成随机验证码
        Random random = new  Random();
        String strUUID = UUID.randomUUID().toString();
        String[] strs = strUUID.split("-");
        int index = random.nextInt(strs.length);
        if(strs[index].length() == 4) {
            System.out.println("验证码是:"+strs[index]);
        }else {
            System.out.println("验证码是:"+strs[index].substring(0, 4));
        }
        
        
        //生成方式
        String str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        str += str.toLowerCase();
        str += "0123456789";
        StringBuilder sbr = new StringBuilder();
        for(int i = 0 ; i<4;i++) {
            char ch = str.charAt(random.nextInt(str.length()));
            sbr.append(ch);
        }
        System.out.println(sbr);

    }

}

Date时间
1.Date类中出现了大量的"已过时"方法
"已过时"官方给定的是不要使用,不推荐使用
原因是:随着API的更新,"已过时"方法可能户随时去掉
ps:但是这么多年过去了已经Java10 -> Date中的已过时方法依旧存在
Date类是Java.Util包下的,千万不要使用java.sql.Date
Date类可以精确表示特定时间并且可以进行字符串和Date之间的解析和格式化
看DateDemo

/**
 * 
 */
package com.qfedu.Day14.Date;

import java.util.Date;
public class DateDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //创建Date对象
        Date date = new  Date();
        //ps:可以在创建对象的时候指定当前类是哪个包下
        //java.util.Date date1 = new java.util.Date();
        //可以获得当前系统时间Thu Aug 16 11:27:41 CST 2018
        System.out.println(date);
        
        //有参的构造方法-->long -->毫秒值
        //将毫秒值转换为时间
        long time = System.currentTimeMillis();
        Date date2 = new Date(time);
        System.out.println(date2);
        //返回值从1970年1月1日00:00:00到此date对象所表示的毫秒数
        System.out.println(date.getTime());
        System.out.println("中国人的时间风格:"+date.toLocaleString());
    }
    //过时方法写法  注解
    //@Override --> 帮助编译器检查当前方法是否是重写方法
    @Deprecated
    public void show() {
        System.out.println("这是一个方法过时");
    }

}

DateFormat类:

//格式化 Date类型对象 ----> String类型 format
//解析 String类型时间字符串 ----> Date类型对象 parse
总结:DateFormat是一个抽象类,实现各是是固定 short / Long
某些时候是不能满足我们的需求,提供了一个类SimpleDateFormat自定格式
看DateFormatDemo

/**
 * 
 */
package com.qfedu.Day14.Date.Format;

import java.text.DateFormat;
import java.text.ParseException;
import java.util.Date;

public class DateFormatDemo {

    public static void main(String[] args) throws ParseException {
    //格式化    Date类型对象 ----> String类型    format
    //解析       String类型时间字符串 ----> Date类型对象  parse    
     
        //先获取时间对象
        //ctrl+shift+o --> 快捷导入包
        Date date = new Date();
        System.out.println(date);
        //通过这个方法就可以获取一个时间风格--> short
        DateFormat df = DateFormat.getInstance();
        //格式化时间
        String time = df.format(date);
        System.out.println(time);
        //通过这个方法可以获取一个时间风格--> long
        df = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG);
        System.out.println(df.format(date));
        
        //解析
        
        df = DateFormat.getInstance();
        time = df.format(date);
        Date d2 = df.parse(time);
        System.out.println(d2);
    }

}

SimpleDateFormat类:
总结:比DateFormat强大,是其子类,可以定制时间表示形式
y年 M月 d日 H 24小时 h 12小时 m 分钟 s 秒
若使用无参构造方法创建对象,需要调用applyPattern确认模式
若使用有参构造方法创建对象,可以通过其参数决定模式,就不需要调用上面的方法
看SimpleDateFormatDemo

/**
 * 
 */
package com.qfedu.Day14.Date.Format;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class SimpleDateFormatDemo {
    //DateFormat --> short long 抽象类
    public static void main(String[] args) throws ParseException {
        //定义一个日期模式
        //H 24小时  h 12小时
        String pattern = "yyyy-MM-dd HH:mm:ss";
        //创建对象
        SimpleDateFormat sdf = new SimpleDateFormat();
        //使用哪种模式
        sdf.applyPattern(pattern);
        
        String time = sdf.format(new Date());
        System.out.println(time);
        //解析
        Date d = sdf.parse(time);
        System.out.println(d);
        
    }

}

Calendar时间
是Java所提供替代Date类而出现的
常用类完成了
看CalendarDemo

/**
 * 
 */
package com.qfedu.Day14.Calendar;

import java.util.Calendar;
import java.util.Date;

public class CalendarDemo {
    public static void main(String[] args) {
        //获取当前对象(获取默认时区)
        /*
         *Java.util.GregorianCalendar
         *[time=1534401313570,areFieldsSet=true,
         *areAllFieldsSet=true,lenient=true,
         *zone=sun.util.calendar.ZoneInfo
         *[id="Asia/Shanghai",offset=28800000,
         *dstSavings=0,useDaylight=false,
         *transitions=19,lastRule=null],
         *firstDayOfWeek=1,minimalDaysInFirstWeek=1,
         *ERA=1,YEAR=2018,MONTH=7,WEEK_OF_YEAR=33,
         *WEEK_OF_MONTH=3,DAY_OF_MONTH=16,
         *DAY_OF_YEAR=228,DAY_OF_WEEK=5,
         *DAY_OF_WEEK_IN_MONTH=3,AM_PM=1,
         *HOUR=2,HOUR_OF_DAY=14,MINUTE=35,
         *SECOND=13,MILLISECOND=570,
         *ZONE_OFFSET=28800000,DST_OFFSET=0] 
         */
        Calendar c = Calendar.getInstance();
        System.out.println(c);
        //获取各种有用时间
        System.out.println("系统时间为:");
        int year =  c.get(Calendar.YEAR);
        //Calendar日类 计算月份是从0开始 11结束 分别对应1-12 
        //看到的月份需要进行+1操作才是正确的月份
        int month = c.get(Calendar.MONTH);
        //天数 DATE
        int day = c.get(Calendar.DATE);
        //小时
        int hour = c.get(Calendar.HOUR);
        //分钟
        int minute = c.get(Calendar.MINUTE);
        //秒
        int second = c.get(Calendar.SECOND);
        System.out.println(year+"年"+(month+1)+"月"+day+"天"+hour+"小时"+minute+"分钟"+second+"秒");
        
        
        //看Date --> Calendar转换成Date
        Date d = c.getTime();//当前年份距离1970年的毫秒值
        
        //案例:获取2018年8月16日是这一年的第几天,第几周,当前月中第几天
        Calendar c2 = Calendar.getInstance();
        //第一个参数是对应的字段
        //例如:  设置的是什么      具体数值
//        c2.set(Calendar.YEAR, 2018);
//        //设月份 -->设置的时候 -1
//        c2.set(Calendar.MONTH, 7);
//        //设置天数
//        c2.set(Calendar.DATE,16);
        //基本不用上面的方法
        c2.set(2018,7,16);
        int day1 = c2.get(Calendar.DAY_OF_YEAR);//这一年的第几天
        System.out.println(day1);
        int week = c2.get(Calendar.WEEK_OF_YEAR);//第几个周
        int dayofMonth = c2.get(Calendar.DAY_OF_MONTH);//当前月份的日期
    
    }

}

枚举(Enum):
需求:定义一个员工类Employee,使用一个变量restday来表示当前员工是哪一天休息
使用int类型来表示是星期几:
1.类型不安全:只要满足int的存储范围
可以进行安全设置[1,7]之间的数
2.业务含义不明确 1传入的时候 周一/周天
解决问题: 定义一个类:表示星期
虽然解决了业务问题,但是员工类中依旧是int类,还是可以任意传入满足int范围的数值
解决问题:int的安全问题依然存在,如何限制传入的数据,已经有了WeekDay这个类,就可以限制,使员工类中的成员变量
只能接受WeekDay的数据
假如以后所有的项目都需要这样数据,那么我们是不是都要这样建立类?

枚举:
枚举是从Java5以后开始提供的新的数据类型,枚举是一个特殊的类,相当于是一个固定了多个常量对象的集合
语法:
访问权限修饰符 enum 枚举名{
常量1,常量2,常量3;

}
ps:枚举只能接受枚举类型
通过有反编译软件得到了枚举就是一个类但是一个特殊了并且继承了Enum这个系统提供枚举父类
ps:Enum这个类不能被显式的继承
特点:
1.枚举的直接父类是Java.lang.Enum,但不能显式的继承Enum
2.枚举流相当于一个类,可以用定义构造方法,成员变量,普通方法,抽象方法和静态方法
ps:构造方法在实际开发中会少一些,并且不要使用修饰符,默认即可
这里的构造方法不是为了枚举中的常量进行赋值,而是加载其他类文件或属性文件使用
3.枚举默认是私有构造方法,即使不谢访问权限修饰符默认也是private
4.每个枚举常量都是一个全局的,并且是固定,其实际意义就是一个当前枚举类的对象,枚举类对象不能私自使用new关键
5.枚举常量定于枚举的内部,若有多个常量使用[,]隔开,最后一个枚举常量可以使用[;]结束也可以不使用
6.枚举常量可以有{}大括号,可以在大括号中定于方法,还可以实现抽象方法,如何理解{},可以看做是当前枚举常量的匿名内部类

/**
 * 
 */
package com.qfedu.Day14.Enum;

public class Employee {
     //成员变量(那天休息)
    //private WeekDay restday;
    private WeekDays restday;//这是枚举类型
    public Employee() {
        
    }
    public Employee(WeekDays restday) {
          this.restday = restday;
    }
    public WeekDays getRestday() {
        return restday;
    }
    public void setRestday(WeekDays restday) {
        this.restday = restday;
    }
    
     
}

/**
 * 
 */
package com.qfedu.Day14.Enum;

public class WeekDay {
     private WeekDay(){ }
       //定义常量,确定1就是表示周一
     public static  final WeekDay MONDAY = new WeekDay();
     public static  final WeekDay TUESDAY =  new WeekDay();
     public static  final WeekDay WEDNESDAY =  new WeekDay();
     public static  final WeekDay THURSDAY =  new WeekDay();
     public static  final WeekDay FRIDAY =  new WeekDay();
     public static  final WeekDay SATURDAY =  new WeekDay();
     public static  final WeekDay SUNDAY =  new WeekDay();
     //public enum WeekDays {//引用数据类型还是值类型?
     MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY,SATURDAY,SUNDAY
}
}
/**
 * 
 */
package com.qfedu.Day14.Enum;

public class Demo {
    public static void main(String[] args) {
        Employee e = new Employee();
        e.setRestday(WeekDays.FRIDAY);
//        if(e.getRestday() == WeekDay.SATURDAY  || e.getRestday() == WeekDay.SUNDAY) {
//            System.out.println("休息");
//        }else {
//            System.out.println("上班");
//        }
    }

}

/**
 * 
 */
package com.qfedu.Day14.Enum;

public enum Blood {
    A,B,AB,O,RH

}

/**
 * 
 */
package com.qfedu.Day14.Enum;

public class Test {
    public static void main(String[] args) {
          //获取枚举中的值
           Blood b = Blood.A;
           //可以获取是哪个枚举常量给当前枚举对象赋值
           String str =  b.name();
           System.out.println(str);
           //当前赋值的枚举常量的序号
           int index =  b.ordinal();
           System.out.println(index);
           //这个数组中存储的是所有枚举常量值
           Blood[] bs = Blood.values();
           //传入一个字符串可以获得枚举对象--这个字符串需要是枚举常量所存在的
           Blood b2 = Blood.valueOf("A");
           
           //枚举值进行判断--switch..case
            switch (b) {
            //case所匹配的是枚举提供常量
            //枚举可以switch匹配的原因在于,在于底层每个枚举常量都有一个序号值
            case A:
                
                break;

            default:
                break;
            }
    
           
    }

}

如何使用枚举:
1.枚举中都是全局公有静态常量,可以直接使用[枚举名.常量名]调用,并且枚举只能给枚举赋值
ps:枚举常量其实就是当前枚举的实例(对象)
2.可以通过父类Enum中定义的方法来获取常量名和所定义的序号
3.当前通过反编译可以得到一个隐藏的方法values()和valueof(),可以获取存储枚举常量的数组
这个方法时静态方法,所以通过枚举名.values()就可以直接获取所有枚举常量(枚举数组)
valueof可以传入一个字符串获取枚举对象
4.枚举的判断是使用switch

扩展枚举:
1.枚举中是可以定静态方法,静态属性,成员方法和成员属性
看Extend包下的Type1;
2.需要给枚举中的常量设置自己的方法 type2
3.枚举中是可以定义抽象方法的 type3
枚举单利type4

/**
 * 
 */
package com.qfedu.Day14.Enum.Extend;

public enum Type1 {
      A,B;
    static int value;
    String type;
    public String getType() {
        return type;
    }
    public static int getValue() {
        return value;
    }
}

/**
 * 
 */
package com.qfedu.Day14.Enum.Extend;


public enum Type2 {
    //匿名内部类,作用于
      A{
          public void show() {
              System.out.println("A自己的方法");
          }
      },B;
    static int value;
    String type;
    public String getType() {
        return type;
    }
    public static int getValue() {
        return value;
    }
    
}
/**
 * 
 */
package com.qfedu.Day14.Enum.Extend;

public enum Type3 {
     
     A{
         public void show() {
             System.out.println("重写抽象方法");
         }
     };
    
    
     public abstract void  show();
}

/**
 * 
 */
package com.qfedu.Day14.Enum.Extend;

public enum Type4 {
     A
}
/*
 public final class Type4 extends Enum{
        private static final Type4 A;
        static{
                A = new Type4("A",0);
        }
       private Type4(String name ,int num){
               super(name, num );
       }
 }


*/
/**
 * 
 */
package com.qfedu.Day14.Enum.Extend;

public class EnumExtendsDemo {

    
    public static void main(String[] args) {
          //使用枚举中成员属性和方法
          Type1 t = Type1.A;
          t.type = "你好";
          System.out.println(Type1.A.getType());
          
          
          Type1.value = 30;
          System.out.println(Type1.getValue());
          
          
          Type3.A.show();
        
    }

}

/**
 * 
 */
package com.qfedu.Day14.HomeWork.Xiaoming;

public class Person {
     //一个属性 手 --> 左右手
     private Hand leftHand;//左手
     private Hand rightHand;//右手
     public Person() {
         
     }
     public Person(Hand leftHand ,Hand rightHand) {
         this.leftHand = leftHand;
         this.rightHand = rightHand;
     }
     
      //交换牌
     public void swapPokerForHand() {
        //拿到牌(知道牌)
         Poker leftPoker = leftHand.getPoker();
         Poker rightPoker = rightHand.getPoker();
         leftHand.setPoker(rightPoker);
         rightHand.setPoker(leftPoker);
     }
     
     //展示牌
     public void showInfosPoker() {
         //拿到牌(知道牌)
         Poker leftPoker = leftHand.getPoker();
         Poker rightPoker = rightHand.getPoker();
         System.out.println(leftHand.getType()+"拿的牌:"+leftPoker.getColor()+""+leftPoker.getNum());
         System.out.println(rightHand.getType()+"拿的牌:"+rightPoker.getColor()+""+rightPoker.getNum());
     }
}

/**
 * 
 */
package com.qfedu.Day14.HomeWork.Xiaoming;

public class Hand {
       //若在一个类中要使用另外一个类的属性或方法
      //提供两种方式
     //1.作为当前类一个属性,可以在整个类中进行访问
      //2.作为当前类中一个方法的参数而存在,只能在当前方法体内
      //左右手
      private String type;
      //拿的牌
      private Poker poker;
      public Hand() {
          
      }
      public Hand(String type,Poker poker) {
            this.type = type;
            this.poker = poker;
      }
    
      
     //属性私有化是为了数据安全,但是数据安全后不能对外提供访问,getter和setter
      //不是必须存在getter和setter 可以只有getter或setter
      public String getType() {
            return type;
        }
        public void setType(String type) {
            this.type = type;
        }
        public Poker getPoker() {
            return poker;
        }
        public void setPoker(Poker poker) {
            this.poker = poker;
        }
}

/**
 * 
 */
package com.qfedu.Day14.HomeWork.Xiaoming;

public class Poker {
       private String color; //牌的花色
       private String num ;// 牌的点数
       //构造方法时可以重载的
       //无参构造方法
       public Poker() {
           //super();//必须在第一行
           //this("1","2");//必须在第一行
         
       }
       //有参构造方法
       public Poker(String color ,String num) {
            this.color = color ;
            this.num = num;
       }
      
       //getter是获取属性 -->一定有返回值,但是没有参数
       public String getColor() {
             return color;
             
       }
       //Setter是给属性赋值 -->一定没有返回值,但是一定有参数
       public void setColor(String color) {
           this.color = color;
       }
       
       //getter是获取属性 -->一定有返回值,但是没有参数
       public String getNum() {
             return num; // --> return this.num;
             
       }
       //Setter是给属性赋值 -->一定没有返回值,但是一定有参数
       public void setNum(String num) {
           this.num = num;
       }
//       public void  show() {
//           //this可以当做参数传递
//           System.out.println(this);
//       }
//       
       
       //static优先级是高于对象static已经产生了但是对象还没有
//       public static void show() {
//           System.out.println(this.num);
//       }

      
}
/**
 * 
 */
package com.qfedu.Day14.HomeWork.Xiaoming;

public class Test {
    public static void main(String[] args) {
       Poker aPoker = new Poker("红桃","A");
       Poker bPoker = new Poker("方片","K");
       Hand leftHand = new Hand("左手", aPoker);
       Hand rightHand = new Hand("右手",bPoker);
       Person xiaoming = new Person(leftHand,rightHand);
       xiaoming.showInfosPoker();
       System.out.println("----------------------------交换后--------------------------");
       xiaoming.swapPokerForHand();
       xiaoming.showInfosPoker();

    }

}