Java基础数据类型

大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不同 的。
类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成， 那么每个单词的首字母应该大写，例如 MyFirstJavaClass。
方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后 面的每个单词首字母大写。
源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用public类 的类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为 .java。 （如果文件名和类名不相同则会导致编译错误）。
主方法入口：所有的 Java 程序由 public static void main(String []args) 方法 开始执行。

基本数据类型
byte：
byte 数据类型是8位(bit)、有符号的，以二进制补码表示的整数； 最小值是 ¬128（¬2^7）； 最大值是 127（2^7¬1）； 默认值是 0； 例子：byte a = 100，byte b = ¬50。包装类：Byte
short：
short 数据类型是 16 位、有符号的以二进制补码表示的整数 最小值是 ¬32768（¬2^15）； 最大值是 32767（2^15 ¬ 1）； Short 数据类型可以节省空间。一个short变量是int型变量所占空间的二分之一； 默认值是 0； 例子：short s = 100，short r = ¬200。
包装类：Short
int：
int 数据类型是32位、有符号的以二进制补码表示的整数； 最小值是 ¬2,147,483,648（-2^31）； 最大值是 2,147,483,647（2^31 ¬ 1）； 一般地整型变量默认为 int 类型； 默认值是 0 ； 例子：int a = 1000, int b = ¬2000。
包装类：Integer
long：
long 数据类型是 64 位、有符号的以二进制补码表示的整数； 最小值是 -9,223,372,036,854,775,808（¬2^63）； 最大值是 9,223,372,036,854,775,807（2^63 ¬1）； 这种类型主要使用在需要比较大整数的系统上；默认值是 0L； 例子： long a = 100000L，Long b = ¬200000L。 注意:"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所 以最好大写。
包装类：Long
float：
float 数据类型是单精度、32位、符合IEEE 754标准的浮点数； float 在储存大型浮点数组的时候可节省内存空间； 默认值是 0.0f； 浮点数不能用来表示精确的值，如货币； 例子：float f1 = 234.5f。
包装类：Float
double：
double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数； 浮点数的默认类型为double类型； double类型同样不能表示精确的值，如货币； 默认值是 0.0d； 例子：double d1 = 123.4。
包装类：Double
boolean：
boolean数据类型表示一位的信息； 只有两个取值：true 和 false； 这种类型只作为一种标志来记录 true/false 情况； 默认值是 false； 例子：boolean one = true。
包装类：Boolean
char：
char类型是一个单一的 16 位 Unicode 字符； 最小值是 \u0000（即为0）； 最大值是 \uffff（即为65,535）； char 数据类型可以储存任何字符； 例子：char letter = ‘A’;。
包装类：Character
（1）包装类使用方法
// 包装类提供一些类型转换的方法 、类型的属性
byte：Byte，short：Short，int：integer，long：Long，double：Double，
boolean：Boolean，char：character
// ===包装类的一些常用类变量
sum(数值*进制^(数值所在位数-1))
1）将基本数据类型变成包装类称为装箱。
2）将包装类的类型变为基本数据类型称为拆箱。
3）在JDK1.5之后，提供了自动装箱和自动拆箱功能。

// 十进制转成十六进制：
System.out.println(Integer.toHexString(500));
// 十进制转成八进制
System.out.println(Integer.toOctalString(500));
// 十进制转成二进制
System.out.println(Integer.toBinaryString(500));
// 十六进制转成十进制
System.out.println(Integer.valueOf("FFFF",16).toString());
// 八进制转成十进制
System.out.println(Integer.valueOf("776",8).toString());
// 二进制转十进制
System.out.println(Integer.valueOf("0101",2).toString());//后面不指定，默认代表十进制


// byte
System.out.println(" 基本类型：byte 二进制位数：" + Byte.SIZE);
System.out.println(" 包装类：java.lang.Byte");
System.out.println(" 最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);
System.out.println(" 最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);
System.out.println();
// short
System.out.println(" 基本类型：short 二进制位数：" + Short.SIZE);
System.out.println(" 包装类：java.lang.Short");
System.out.println(" 最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);
System.out.println(" 最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);
System.out.println();
// int
System.out.println(" 基本类型：int 二进制位数：" + Integer.SIZE);
System.out.println(" 包装类：java.lang.Integer");
System.out.println(" 最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);
System.out.println(" 最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);
System.out.println();
// long
System.out.println(" 基本类型：long 二进制位数：" + Long.SIZE);
System.out.println(" 包装类：java.lang.Long");
System.out.println(" 最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);
System.out.println(" 最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);
System.out.println();
// float
System.out.println(" 基本类型：float 二进制位数：" + Float.SIZE);
System.out.println(" 包装类：java.lang.Float");
System.out.println(" 最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);
System.out.println(" 最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);
System.out.println();
// double
System.out.println(" 基本类型：double 二进制位数：" + Double.SIZE);
System.out.println(" 包装类：java.lang.Double");
System.out.println(" 最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);
System.out.println(" 最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);
System.out.println();
// char
System.out.println(" 基本类型：char 二进制位数：" + Character.SIZE);
System.out.println(" 包装类：java.lang.Character");
System.out.println(" 最小值：Character.MIN_VALUE="  + (int) Character.MIN_VALUE);
System.out.println(" 最大值：Character.MAX_VALUE=" + (int) Character.MAX_VALUE);
// boolean
System.out.println(Boolean.FALSE);
System.out.println(Boolean.TRUE);

（2）类型转换
自动类型转换(隐式类型转换)
整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为 同一类型，然后进行运算。
精度丢失

自动转换有以下规律：
（1）小的类型自动转化为大的类型
（2）整数类型可以自动转化为浮点类型，可能会产生舍入误差
（3）字符可以自动提升为整数

// =====自动类型转换(隐式转换)
// 小的类型自动转化为大的类型
byte byteValue1=110;
int intValue1=byteValue1+50;
System.out.println(intValue1);
           
// 整数类型可以自动转化为浮点类型，可能会产生舍入误差
// Float和Double提供了快速的运算，然而问题在于转换为二进制的时候，有些数字不能完全转换，只能无限接近于原本的值
float floatValue1=2+10f;
float floatValue2=floatValue1-11.9f;
System.out.println(floatValue2);
           
// 字符可以自动提升为int
char charValue1 ='a';
int intValue2=charValue1+10;
System.out.println(intValue2);

强制类型转换(显式类型转换)
格式： (type)value type是要强制类型转换后的数据类型
注意：
（1）强制类型转换可能导致溢出或损失精度
（2）在把容量大的类型转换为容量小的类型时必须使用强制类型转换
（3）浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入
float类型(32位)：
分为：符号位S_指数位E_尾数位M
1bit（符号位） 8bits（指数位） 23bits（尾数位）
double类型(64位)：
分为：符号位S_指数位E_尾数位M
1bit（符号位） 11bits（指数位） 52bits（尾数位）
特别注意的是指数位存放的是补码,底数是2！

// ======强制类型转换
// --强制类型转换可能导致溢出或损失精度
// 导致溢出
byte d = (byte) 128;
// 00000000 00000000 00000000 10000000 128的原码
// 00000000 00000000 00000000 10000000 128的反码
// 00000000 00000000 00000000 10000000 128的补码
// 10000000 的补码
// 11111111 反码
// 10000000 原码
System.out.println(d);
/**
* 关于 原码,反码,补码的知识(了解)
* 正数的反码,补码是其本身;
* 负数的反码是符号位保持不变，其余位取反;负数的补码是在其反码的基础上+1
*/
//损失精度
System.out.println(Long.MAX_VALUE);
double floatValue3 = (double)Long.MAX_VALUE;
System.out.println(floatValue3);
           
//--在把容量大的类型转换为容量小的类型时必须使用强制类型转换
int intValueA = 120;
byte byteValueB = (byte) intValueA;
System.out.println(byteValueB);


//--浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入
int intValue3 = (int) 23.7;
int intValue4 = (int) -23.7;
System.out.println(intValue3);
System.out.println(intValue4);