关于浮点型数据类型
* float 单精度【4个字节】
* double 双精度【8个字节，精度较高】
*
* double的精度太低【相对来说的】，不适合做财务软件。
* 财务涉及到钱的问题，要求精度较高，所以SUM在基础SE类库当中为
* 程序员准备了精确度更高的类型，只不过这种类型是一种引用数据类型，
* 不属于基本数据类型，它是：java.math.BigDecimal
*
* 其实Java程序中SUM提供了一套庞大的类库，Java程序员是基于这套
* 基础的类库来进行开发的。所以要知道Java的SE类库的字节码在哪儿，
* 要知道Java的SE类库的源码在哪儿？
* *SE类库字节码：C:\Program Files (x86)\java\jdk1.7.0_75\jre\lib\rt.jar
* *SE类库源码：C:\Program Files (x86)\java\jdk1.7.0_75\src.zip【要根据自己安装的软件来 定】
*
* 例如：String.java和String.class
* 我们的（String[] args)中的String使用的就是String.class字节码文件
*
* 在java语言当中，所有的浮点型字面值【3.0】，默认值当做double类型来处理，
* 要想该字面值当做float类型来处理，需要在字面值后面添加F/f.
*
* 注意：
* double和float在计算机内部二进制存储的都是近似值。
* 在现实世界当中有一些数字是无限循环的，例如：3.33333333333333333...
* 计算机的资源是有限的，用有限的资源存储无限的数据只能存储近似值。
public class DataTypeTest06 {
public static void main(String[] args) {
/*
* 3.0是double类型的字面值
* d是double类型的变量
* 不存在类型转换
*/
double d=3.0;
System.out.println(d);
/*
* 5.1是double类型的字面值
* f是float类型的变量
* 大容量转换小容量需要加强制类型转换符，所以以下程序编译错误
* float f=5.1;
*
* 解决方案
* 第一种：强制类型转换
* float f=(float)5.1;
* 第二种：没有类型转换
* float f=5.1f;
*/
float f=(float)5.1;
System.out.println(f);
float f1=5.1f;
System.out.println(f1);
}
}
关于boolean类型
* 在Java语言当中boolean类型只有两个值：true/false,没有其他值。
* 不像c语言当中，0和1可以表示假和真。
* 在底层存储的时候boolean类型占用1个字节，因为实际存储的时候false底层是0，true底层是1。
* 布尔类型在实际开发当中非常重要，经常使用在逻辑运算和条件控制语句当中。
*/
public class DataTypeTest07 {
public static void main(String[] args) {
//编译错误：不兼容的类型
//boolean flag=1;
//boolean loginSuccess=false;
boolean loginSuccess=true;
//if语句【条件控制语句】
if(loginSuccess)
{
System.out.println("恭喜你，登录成功！");
}
else {
System.out.println("对不起，用户名不存在或者密码错误！");
}
}
} /*
* 关于基本数据类型之间的互相转换：转换规则
* 1、八种基本数据类型当中除了布尔类型之外剩下的7种类型之间都可以互相转换
*
* 2、小容量向大容量转换，称为自动类型转换，容量从小到大排序：
* byte < short < int < long < float < double
* char <
* 注意：
* 任何浮点类型不管占用多少个字节，都是比整数型容量大。
* char和short可表示的种类数量相同，但是char可以取更大的正整数
*
* 3、大容量转换成小容量，叫做强制类型转换，需要加强制类型转换符，
* 程序才能编译通过，但是在运行阶段可能会损失精度，所以谨慎使用。
*
* 4、当整数字面值没有超出byte,short,char的取值范围，
* 可以直接赋值给byte,short,char类型的变量。
*
* 5、byte,short,char混合运算的时候，各自先转换成int类型再做运算。
*
* 6、多种数据类型混合运算，先转换成容量最大的那种类型再做运算。
*
*/
/*
* 关于Java编程中运算符之：算术运算符
* + 求和
* - 相减
* * 乘积
* / 商
* % 求余数【取模】
* ++ 自加1
* -- 自减1
* 注意：
* 一个表达式当中有多个运算符，运算符有优先级，不确定的加小括号，优先级得到提升。
* 没有必要去专门记忆运算符的优先级
*/
完整代码如下：
public class DataTyteTest08 {
public static void main(String[] args) {
//以下以++为例，--运算符自学！
//关于++运算符【自加1】
int k=10;
//++运算符可以出现在变量后面【单目运算符】
k++;
System.out.println(k); //11
int y=10;
//++运算符可以出现在变量前面【单目运算符】
++y;
System.out.println(y); //11
/*
* 小结：
* ++运算符可以出现在变量前，也可以出现在变量后，无论是变量前还是变量后
* 只要++运算结束，该变量中的值一定会自加1
*/
/*
* ++ 出现在变量后
* 规则：先做赋值运算，再对变量中保存的值进行自加1
*/
int a=100;
int b=a++;
System.out.println(a); //101
System.out.println(b); //100
/*
* ++ 出现在变量前
* 规则：先进行自加1运算，然后再进行赋值操作。
*/
int m=20;
int n=++m;
System.out.println(m); //21
System.out.println(n); //21
int s=100;
System.out.println(++s); //101
System.out.println(s); //101
System.out.println("-------------------");
System.out.println(--s); //100
System.out.println(s++); //100
System.out.println(s--); //101
System.out.println(s--); //100
System.out.println(s--); //99
System.out.println(s); //98
}
}
/* 关系运算符
* > 大于
* >= 大于等于
* < 小于
* <= 小于等于
* == 等于
* ！= 不等于
*
*
* = 是赋值运算符
* == 是关系运算符
* 关系运算符的运算结果一定是布尔类型：true/false
*
* 关系运算符的运算原理：
* int a=10;
* int b=10;
* a>b 比较的时候，比较的是a中保存的10这个值和b中保存的10这个值之间的大小比较。
* a==b也是如此
*/
public class OperatorTest02 {
public static void main(String[] args) {
int a=10;
int b=10;
System.out.println(a>b);//false
System.out.println(a>=b);//true
System.out.println(a<b);//false
System.out.println(a<=b);//true
System.out.println(a==b);//true
System.out.println(a!=b);//false
}
}
/*
* 逻辑运算符号
* & 逻辑与【并且】 （两边的算子都是true，结果才是true）
* | 逻辑或【或者】 （两边的算子只要有一个是true,结果就是true）
* ！ 逻辑非（取反，！false就是true，这就是一个单目运算符）
* && 短路与
* || 短路或
* 1、逻辑运算符要求两边的算子都是布尔类型，并且逻辑运算符最终的运算结果也是一个布尔类型；
* 2、短路与和逻辑与最终的运算结果是相同的，只不过短路与存在短路现象；
* 3、短路或和逻辑或最终的运算结果是相同的，只不过短路或存在短路现象；
* 4、什么情况下发生短路现象呢？
* 5、什么时候选择使用逻辑与运算符？什么时候选择使用短路与运算符？
*/
/*
* 从某个角度来看，短路与更智能。由于后面的表达式可能不执行，
* 所以执行效率较高。这种方式在实际的开发中使用较多。短路与比
* 逻辑与使用的多，短路与更常用。
*
* 但是，在某些特殊的业务逻辑当中，要求运算两边的算子必须全部执行，
* 此时必须使用逻辑与，不能使用短路与，使用短路与可能导致右边的
* 表达式不执行。
*/
/*
* 什么情况下发生短路或？
* *第一个表达式执行结果是true，会发生短路或。
* 什么情况下发生短路与？
* *第一个表达式执行结果是false，会发生短路与。
*/
/*关于java中的赋值类运算符：
* 赋值类运算符包括两种：
* *基本的赋值运算符：=
* *扩展的赋值运算符
* +=
* -=
* *=
* /=
* %=
* 赋值类的运算符优先级：先执行等号右边的表达式，将执行结果赋值给左边的变量
*
*注意以下代码：
* byte i=10;
* i+=5;等同于：i=(byte)(i+5);
* int k=10;
* k+=5;等同于：k=(int)(k+5);
* long x=10L;
* int y=20;
* y+=x;等同于：y=(int)(y+x);
* 重要结论：
* 扩展类的赋值运算符不改变运算结果类型，假设最初这个变量的类型是byte类型，
* 无论怎样进行追加或追减，最终该变量的数据类型还是byte类型。
*
完整代码：
public class OperatorTest4 {
public static void main(String[] args) {
/*//逻辑与和短路与
int x=10;
int y=8;
System.out.println(x<y&++x<y);
System.out.println(x);//11
*/
//逻辑与和短路与
int x=10;
int y=8;
/*
* 短路与
* x<y结果是false，整个表达式结果已经确定是false
* 所有后面的表达式没有再执行，这种现象被称为短路现象。
* 短路与才会出现短路现象，逻辑与是不会存在短路现象的。
*/
System.out.println(x<y&&++x<y);
System.out.println(x);//10
/*
* 从某个角度来看，短路与更智能。由于后面的表达式可能不执行，
* 所以执行效率较高。这种方式在实际的开发中使用较多。短路与比
* 逻辑与使用的多，短路与更常用。
*
* 但是，在某些特殊的业务逻辑当中，要求运算两边的算子必须全部执行，
* 此时必须使用逻辑与，不能使用短路与，使用短路与可能导致右边的
* 表达式不执行。
*/
/*
* 什么情况下发生短路或？
* *第一个表达式执行结果是true，会发生短路或。
* 什么情况下发生短路与？
* *第一个表达式执行结果是false，会发生短路与。
*/
/*关于java中的赋值类运算符：
* 赋值类运算符包括两种：
* *基本的赋值运算符：=
* *扩展的赋值运算符
* +=
* -=
* *=
* /=
* %=
* 赋值类的运算符优先级：先执行等号右边的表达式，将执行结果赋值给左边的变量
*
*注意以下代码：
* byte i=10;
* i+=5;等同于：i=(byte)(i+5);
* int k=10;
* k+=5;等同于：k=(int)(k+5);
* long x=10L;
* int y=20;
* y+=x;等同于：y=(int)(y+x);
* 重要结论：
* 扩展类的赋值运算符不改变运算结果类型，假设最初这个变量的类型是byte类型，
* 无论怎样进行追加或追减，最终该变量的数据类型还是byte类型。
*
*/
//10没有超出byte取值范围，可以直接赋值
byte b=10;
//b=15;可以，编译通过，15没有超过byte取值范围
//编译错误，为什么？
//编译器只检查语法，不运行程序，编译器发现b+5的类型是int类型，b变量的数据类型是byte;
//大容量向小容量转换需要加强制类型转换型符，所以以下程序编译报错。
//纠正错误
b=(byte)(b+5);
System.out.println(b);
byte x1=10;
x1+=5;//等同于：x1=(byte)(x+5),其实并不等同于：x=x+5
System.out.println(x1);
byte z=0;
z+=128;//等同于：z=(byte)(z+128);
System.out.println(z);//-128【损失精度】
z+=10000;//等同于：z=(byte)(z+10000);
System.out.println(z);//-112【损失精度】
}
}
