枚举，Math和Random

1.
实用类：

  01.枚举  enum
     Student stu=new Student();
       我们为了保证用户一个健康的输入！ 我们使用了封装特性！
       用户就不能直接访问我们的属性了！！  private  char sex;
       提供了一个对外访问的接口！  getSex()  setSex(char sex)
      在setSex()中书写我们的逻辑！如果用户输入的不健康，有默认值！

    001.枚举是一种数据类型，名称就是enum！
        public  class  Hello{}
        public  interface  Hello{}
        public  enum  Hello{}

    002.可以限定用户的输入
                虽然之前学的封装，能保证我们数据的准确性！但是阻挡不了用户的输入！
    003.所有的 枚举值   都是static final 修饰的(静态常量)
    004.构造方法必须是私有的！ 防止外部访问！

  02.基本数据类型对应的包装类（封装类）
      包装类：
      001.基本数据类型能点出来方法吗？        不能！！ 对应的包装类可以！
      002.集合中可以存放基本数据类型吗？    不能！！ 对应的包装类可以！
      003.就是把基本数据类型转换成对象！
      004.所有的包装类都是由fianl修饰的，不能创建子类
      005.在基本数据类型需要用对象来表示的时候使用
      006.jdk1.5之后，允许了基本数据类型和包装类的混合算术运算

      byte      Byte
      short     Short
      int       Integer
      long      Long
      float     Float
      double    Double
 上面的六种，都是数值类型！ 都继承了Number类！
 然后Number实现了Serializable接口！

      boolean   Boolean
      char      Character
 他们两个都实现 了Serializable接口！   

  如果有个方法让我们传递一个Serializable类型的参数！
  我们可不可以传递8种基本数据类型的封装类呢？    可以！

  装箱和拆箱操作  （基本数据类型和对应的包装类做转换）
        装箱：把基本数据类型转换成对应的包装类
        拆箱：把包装类转换成对应的基本数据类型

   基本数据类型中叫：  自动类型转换和 强制类型转换
   引用数据类型中叫：   向上转型和向下转型！

  03.Math
      001.java.lang包下的一个算术类！
      002.是final修饰的
      003.除了构造方法之外的所有方法都是静态的！可以通过类名直接访问

     天花板函数
        ceil  天  向上取整
        floor 地  向下取整

  04.Random
       随机数
2.枚举

/**
 * 学生的实体类
 */
public class Student {

    private String name;
    private Gender sex; // 枚举类型的性别

    public String getName() {
        return name;
    }

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

    public Gender getSex() {
        return sex;
    }

    public void setSex(Gender sex) {
        this.sex = sex;
    }

    public Student(String name, Gender sex) {
        super();
        this.name = name;
        this.sex = sex;
    }

    public Student() {
        super();
    }

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

}

student

/**
 * 针对于性别的枚举类
 */
public enum Gender {

    // 需要创建枚举值
    MAN("男"), WOMAN("女");

    private String genderSex;

    private Gender(String name) {
        this.genderSex = name;

    }

    public String getGenderSex() {
        return genderSex;
    }

    public void setGenderSex(String genderSex) {
        this.genderSex = genderSex;
    }

}

Gender枚举

public class EnumTest {

    public static void main(String[] args) {
        // 创建学生对象
        Student stu = new Student();
        // 通过set（）给stu对象赋值
        stu.setName("小黑黑");
        stu.setSex(Gender.WOMAN); // 只能是MAN和WOMAN
        System.out.println(stu.getName() + "的性别是："
                + stu.getSex().getGenderSex());

    }

}

Test

3.包装类

import org.junit.Test;

public class PackageTest {

    // 所有的封装类 都有将对应的基本数据类型作为参数的方法 来构造实例
    @Test
    public void test01() {
        /**
         * Float有三个实例化构造方法  分别是  传递 double  float  String
         * 其他的数值类型都是两种构造！
         * Character只有一个构造！
         */
        Byte a = new Byte((byte) 1);
        Short s = new Short((short) 1);
        Integer b = new Integer(5);
        Long l = new Long(1);
        Float f = new Float(2);
        Double c = new Double(5);
        // 上面的六个封装类都继承了Number
        Boolean boolean1 = new Boolean(true);
        Character character1 = new Character((char) 1);
        Character character2 = new Character('1');

    }

    /**
     * 六个封装类继承了Number
     * 用String来构造实例的时候，String中存放的必须是数值类型的字符串
     * 除了Character来构造实例的时候，没有String类型的参数！
     * 其它7种封装类 都可以传递一个Stirng类型的变量，来构造实例！
     * 注意点：
     *    Stirng类型的变量必须能转换成数值类型，否则会抛出异常(NumberFormatException)！
     */
    @Test
    public void test02() {
        Byte a = new Byte("1");
        Short s = new Short("1");
        Integer b = new Integer("1");
        Long l = new Long("1");
        Float f = new Float("1");
        Double c = new Double("1");
        // 除了大小写的true 其它都返回false
        Boolean boolean1 = new Boolean("");
        System.out.println(boolean1);
        // 编译报错 Character character1 = new Character("1");
    }

    /**
    *除了Character，都有对应的parse的方法
    */
    @Test
    public void test03() {
        Integer i = new Integer("5");
        System.out.println(i + 1);
        System.out.println(Integer.parseInt("54321") + 1);
        // 转换进制 把2进制的1011转换成10进制的数字
        System.out.println("10对应的2进制：" + Integer.parseInt("1011", 2));

        /**    String num = "27";
            System.out.println(Integer.parseInt(num) + 1);
            Double.parseDouble("20");
            Byte.parseByte("1");
            Short.parseShort("1");
            System.out.println(1 + 1 + "2"+1); // 221
            System.out.println("1" + (1 + 2)); // 13
        */
    }

    @Test
    public void test04() {
        System.out.println(Integer.toBinaryString(28)); // 转换成2进制
        System.out.println(Integer.toHexString(28)); // 转换成16进制
        System.out.println(Integer.toOctalString(28)); // 转换成8进制
    }

    /**
    * valueOf
    * 把基本数据类型转换成对应的封装类
    * 除了Character没有传递String类型的参数
    *
    * xxxValue
    * 把xxx类型转换成xxx对应的基本数据类型
    */
    @Test
    public void test05() {
        // 基本数据类型和对应封装类之间的转换 我们称之为 装箱和拆箱操作
        int a = 5;
        Integer integer = Integer.valueOf(a); // 装箱 把基本数据类型a转换成了包装类integer
        integer.intValue(); // 拆箱 把包装类integer转换成基本数据类型

        Double d = Double.valueOf(20.0);
        double h = d.doubleValue();

        Character character = Character.valueOf('a');
        character.charValue();
    }

    @Test
    public void test06() {
        int a = 127;
        int b = 127;
        System.out.println(a == b);
    }

    @Test
    public void test07() {
        Integer a = new Integer(1);
        Integer b = new Integer(1);
        System.out.println(a == b);
    }

    @Test
    public void test08() {
        /**
         * Integer a = 127;
        Integer b = 127;
        System.out.println(a == b);  //true
         */

        Integer a = 128;
        Integer b = 128;
        /**
         * 01.128是int类型  是基本数据类型
         * 02.a是integer类型 是包装类
         * 03.想把基本数据类型转换成包装类
         * 04.就需要使用valueOf(128)
         * 05.观看底层代码得知
         *
        public static Integer valueOf(int i) {
        assert IntegerCache.high >= 127;
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);    当我们传入的值 大于127或者小于-128就会创建新对象
        }
         */
        System.out.println(a == b);
    }

}

包装类

4.Math     Random

public class MathTest {

    public static void main(String[] args) {

        System.out.println("向上取整：" + Math.ceil(20.001));
        System.out.println("向下取整：" + Math.floor(20.999));
        System.out.println("四舍五入：" + Math.round(20.5));
        System.out.println("四舍五入：" + Math.round(20.4));
        System.out.println("最大值：" + Math.max(5, 20));
        System.out.println("最小值：" + Math.min(20.4, 0.1));
        System.out.println("绝对值：" + Math.abs(-52));
        System.out.println("绝对值：" + Math.random());
        /**
         * Math.random() 底层是执行了Random类中的nextDouble()
         *
        public static double random() {
        Random rnd = randomNumberGenerator;
        if (rnd == null) rnd = initRNG();
        return rnd.nextDouble();
        }
         */

    }

}

Math

import java.util.Random;

public class RandomTest {

    public static void main(String[] args) {
        // 创建随机数对象
        Random random = new Random();
        for (int i = 0; i < 100; i++) {
            // System.out.println(random.nextBoolean());随机输入boolean值
            // System.out.println(random.nextDouble()); 返回0-1但不包含1的随机小数
            // System.out.println(random.nextInt()); 返回int类型最小值到最大值之间的随机整数
            // System.out.println(random.nextInt(10));返回0-10之间的整数 不包含10
        }

    }

}

Random