java基础讲解-蒲公英云

没有使用strictfp

正如我们所熟知的那样，java分为八大基本数据类型，分别是:

整数类型：byte(1) short(2) int(4) long(8)
浮点类型：float(4) double(8)
字符类型：char
布尔类型：boolean(true|false)

ps:小容量的数据在计算时，jvm会将其自动转为大容量数据，而大容量数据要转为小容量的数据，需要我们手动去转型。

其他的全部为引用类型：String类，数组，自定义类

大容量的数据类型可以转化为小容量的数据类型时，需要在前面加上强制类型转化符, 否则，java虚拟机会自动捕捉这种错误（这就涉及到error和exception的区别）,但在转换的过程中，容易造成数据的失真

Java虚拟机会自动将小容量的数据类型转化为大容量的数据类型时
转型顺序为：short,byte,char–>int–>long–>float–>–>double
short,byte,char之间不能转换

浮点型的默认类型：double
整数的默认类型： int

public class Test1 { 
    public static void main(String[] args){
        testWithoutStrictfp();
        //steictfpTest();
    }
    /** * * 正如我们所熟知的那样，java分为八大基本数据类型，分别是:<br/> *     整数类型：byte(1) short(2) int(4) long(8) * <br>    浮点类型：float(4) double(8) * <br>    字符类型：char * <br>    布尔类型：boolean(true|false) * * <br>其他的全部为引用类型：String类，数组，自定义类 * * <br>大容量的数据类型可以转化为小容量的数据类型时，需要在前面加上强制类型转化符 * 否则，java虚拟机会自动捕捉这种错误（这就涉及到error和exception的区别）,但 * 在转换的过程中，容易造成数据的失真 * * <br>Java虚拟机会自动将小容量的数据类型转化为大容量的数据类型时 * 转型顺序为：short,byte,char-->int-->long-->float-->-->double * * short,byte,char之间不能转换 * * <br>浮点型的默认类型：double * <br>整数的默认类型： int * * 原子性：一个事务或多个事务要么同时提交而不受任何因素的干扰，要么就不提交 * 有序性 * 可见性 * * @auhtor 念兮 * */
    private static void testWithoutStrictfp(){
        int i=10;  //因为整形的数据类型，默认为int
        int j=8;
        System.out.println("i+j的数值为："+(i+j));
        //因为是double类型，Java虚拟机将其默认地转型
        //因而，数据会出现失真
        double ijd=(i+j)*1.2;   
        System.out.println(ijd);
        /** * 因为是float浮点类型，Java虚拟机为发将其转型为float类类型 * 因而，我们需要将其手动转型 */
        float ijf=(float)((i+j)*1.2);
        System.out.println(ijf);
        /** * ijd的输出结果为：21.599999999999998 * ijf的输出结果为：21.6 * 因而，在数据进行转型的时候，就出现了数据的不一致 * * 怎么才能保证不失真呢，我们就需要用到strictfp这个保留字， * 它是script float potion 精准浮点，完全符合IEEE 754标准的 * IEEE745规定了硬件的数据的准确性，保罗单精度浮点数，和双精度浮点数 * 但它只能修饰类、接口、方法，不能修饰局部变量和成员变量 */
         /** * 这样也是报错，因为浮点数默认的是double，而不是float * 因而需要转型，即在10.0后面加上F/f */
        float f1=10; 
        /** * 输出结果并不是10，而是10.0 */
        System.out.println("f1"+f1);
        float f2=10.0F;
        System.out.println("f2:"+f2);
        double strictfp_ijd=(i+j)*1.2;   
        System.out.println(strictfp_ijd);
        float strictfp_ijf=(float)((i+j)*1.2);
        System.out.println(strictfp_ijf);
        System.out.println("f1/strictfp_ijf:"+f1/strictfp_ijf);
        System.out.println("f2/strictfp_ijf:"+f2/strictfp_ijf);
        short s1=10;
        /** * 这样就会报错，因为s1+1的结果类型不再是short,而是自动转型为int * 这是需要将大类型的int转换为小类型的short， */
        s1=(short)(s1+1); 
        System.out.println(s1);
        /** * 但是 s1++就不会出现错误 */
        System.out.println(s1++);
        /** * byte 2^-8~2^8-1 即-128-127 */
        byte byte1=23;
        byte byte2=24;
        /** * 这样也会报错，因为byte1+byte2时，java虚拟机将其的类型转化为int了 * 如果，我们想要获取类型为byte的结果，就必须将其转型 * 但有一个重要的方法，它的输出结果为23，难道只输出了byte1吗？ * * 答案是错误的，首先我们来了解byte这个基本数据类型，byte是字节类型的， * 它的取值范围是-128~127之间，占位是256位，也就是说，这是一个循环， * 我们全部将其转化为二进制（利用windows自带的计算器）： * 23为10111<br> * 24为11000<br> * 1000为1111101000 * 对其进行二进制的加法可得：10000010111， * 而byte是八位的，因而只取00010111 * 首位是符号位，0表示正，1表示负 * 将其转化为十进制为：结果正好为23 * 因为，所有的代码在内存中都是二进制，即0和1表示 * 这是原码的加法，计算器组成原理的知识点 * * 这也就是黑客帝国中的二进制代码的看点 */
        byte byte3=(byte)(byte1+byte2+1000);   
        System.out.println("byte:"+byte3);
        /** * 如果我们赋值的结果是100000000000000000000000，那么就会报错 * 因为l的长度是：-2^63-2^63-1,这远远超过了长度 * * 但问几遍我们写成这样：10000000000000000，没有超过长度，依然会报错 * 因为，Java虚拟机的整形数据类型默认为int，而这确实long类型，当然会报错 * 一般我们在末尾加上L/l,我们一般不用小写的l,因而这看起来其极像阿拉伯数字1 * 因而，我们一般写成为L; */
        long l1=10000000000L;
        long l2=(long)1E10;   //用科学计数法需要转型
        double d1=l1+l2;
        /** * 输出结果为：2.0E18 采用的科学计数法,因为是double类型的浮点数 * * “aEb”所表示的值是a × 10b E/e表示10，b表示指数 * 但我们国家一般要求科学计数法不是这样的，可以参见： * GB3101-1993，GBT15835-2011，GBT8170-2008 * 而是a*10b; */
        System.out.println(d1);
        /** * float fd=d1/l1;这是会报错的，因为需要进行转型 */
        float fd=(float)d1/l1;
        System.out.println(fd);
        float f4=10000000.6F;  //转型时，符合四舍五入的方法,满6才进1
        float f5=10000000.5F;
        long l4=(long)f4;
        long l5=(long)f5;
        System.out.println(l4);
        System.out.println(l5);
    }
}

使用strictfp

如果想要精度更加准确，而且不会因为硬件的改变而失真，我们可以用strictfp来修饰。它是script float potion 精准浮点，完全符合IEEE 754标准的。 IEEE745规定了硬件的数据的准确性，包括单精度浮点数，和双精度浮点数。但它只能修饰类、接口、方法，不能修饰局部变量和成员变量

private static strictfp void steictfpTest(){
    int i=10;  //因为整形的数据类型，默认为int
    int j=8;
    float f=10.0f;
    double strictfp_ijd=(i+j)*1.2;   
    System.out.println(strictfp_ijd);
    float strictfp_ijf=(float)((i+j)*1.2);
    System.out.println(strictfp_ijf);
    System.out.println(f/strictfp_ijf);
    System.out.println(System.class);
}

i++和++i的区别

private static void testPlusPlus(){
    int i,i1=20;
    /** * 这种表示i先获得i1++的数值，然后i1在自行加1 * * 换句话说，i1把初始值赋给i后，i1再自行加1 */
    i=i1++;
    System.out.println("i的数值："+i+"\ti1的数值："+i1);
    /** * 这种方式表示，i先进行加1的计算，再把值赋给i; */
    i=++i1;
    System.out.println("i的数值："+i+"\ti1的数值："+i1);
}