java基础篇（一）java数据类型、转换、进制转换

一、java数据类型划分

1、数值型：

1.1. 整形

	byte     1字节   8位   -128~127
	1字节等于8bit，8位,每一位有两种可能，2的8次方256，表示正负，故取值范围-2的七次方至2的7次方

    short    2字节   16位  -32768~32767
	2字节等于16bit，16位,每一位有两种可能，2的16次方，表示正负，故取值范围-2的15次方至2的15次方，int，long以此类推
	
    int      4字节   32位  -2^31~2^31-1

    long     8字节   64位  2^63~2^63-1，必须以大写L或者小写l结尾

1.2.浮点类型：

    float    4字节   32位  -3.403E38 ~ 3.403E38
    单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。变量值末尾要以F或者f结尾
    同样4个字节，float比long值还大，是因为它是用占得的字节表示10的几次幂
    double   8字节   64位  -1.798E308 ~ 1.798E308
    双精度，精度是float的两倍。通常采用此类型。范围更大，精度更高

2、 字符型：

char     2字节   16位   0~65535
Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。

字符型变量的三种表现形式：
1. 字符常量是用单引号(‘ ’)括起来的单个字符。例如：char c1 = 'a'; char c2 
= '中'; char c3 = '9';
2. Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。
例如：char c3 = ‘\n’; // '\n'表示换行符
3. 直接使用 Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX代表
一个十六进制整数。如：\u000a 表示 \n。

3、布尔型：

 boolean  true    false

4、引用类型：

字符串 String、 类 class 、枚举 enum、接口interface、数组array

二、基本数据类型之间的转换

1、自动类型转换：范围小→范围大

byte→short→int→long→float→double；

char→int→long→float→double          

2、强制类型转换：范围大→范围小

需要加强制转换符

3、练习

/*
基本数据类型之间的运算规则：

前提：这里讨论只是7种基本数据类型变量间的运算。不包含boolean类型的。

1. 自动类型提升：
    结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
	byte 、char 、short --> int --> long --> float --> double 

	特别的：当byte、char、short三种类型的变量做运算时，结果为int型
	
2. 强制类型转换：见VariableTest3.java


说明：此时的容量大小指的是，表示数的范围的大和小。比如：float容量要大于long的容量
*/
class VariableTest2 {
	public static void main(String[] args) {
		
		byte b1 = 2;
		int i1 = 129;
		//编译不通过
		//byte b2 = b1 + i1;
		int i2 = b1 + i1;
		long l1 = b1 + i1;
		System.out.println(i2);

		float f = b1 + i1;
		System.out.println(f);

		short s1 = 123;
		double d1 = s1;
		System.out.println(d1);//123.0

		//***************特别地*********************
		char c1 = 'a';//97
		int i3 = 10;
		int i4 = c1 + i3;
		System.out.println(i4);

		short s2 = 10;
		//char c2  = c1 + s2;//编译不通过

		byte b2 = 10;
		//char c3 = c1 + b2;//编译不通过

		//short s3 = b2 + s2;//编译不通过

		//short s4 = b1 + b2;//编译不通过
		//****************************************

	}
}

/*
强制类型转换：自动类型提升运算的逆运算。
1.需要使用强转符：()
2.注意点：强制类型转换，可能导致精度损失。



*/
class VariableTest3 {
	public static void main(String[] args) {
		
		double d1 = 12.9;
		//精度损失举例1
		int i1 = (int)d1;//截断操作
		System.out.println(i1);//12
		
		//没有精度损失
		long l1 = 123;
		short s2 = (short)l1;
		
		//精度损失举例2
		int i2 = 128;
		byte b = (byte)i2;
		System.out.println(b);//-128

	}
}

class VariableTest4 {
	public static void main(String[] args) {
		
		//1.编码情况1：
		long l = 123213;
		System.out.println(l);//int自动提升为long型，所以不用加L或者l
		//编译失败：过大的整数
		//long l1 = 21332423235234123;
		long l1 = 21332423235234123L;


		//****************
		//编译失败
		//float f1 = 12.3;//默认12.3是double，double转float报错
		float f1 = (float)12.3;
		//2.编码情况2：
		//整型常量，默认类型为int型
		//浮点型常量，默认类型为double型
		byte b = 12;
		//byte b1 = b + 1;//编译失败
		int b1 = b + 1;
		//float f1 = b + 12.3;//编译失败
		double f1 = b + 12.3;
	}
}

/*
String类型变量的使用
1. String属于引用数据类型,翻译为：字符串
2. 声明String类型变量时，使用一对""
3. String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+
4. 运算的结果仍然是String类型

*/
class StringTest {
	public static void main(String[] args) {
		
		String s1 = "Hello World!";

		System.out.println(s1);

		String s2 = "a";
		String s3 = "";

		//char c = '';//编译不通过

		//***********************
		int number = 1001;
		String numberStr = "学号：";
		String info = numberStr + number;// +：连接运算
		boolean b1 = true;
		String info1 = info + b1;// +：连接运算
		System.out.println(info1);

		//***********************
		//练习1
		char c = 'a';//97   A:65
		int num = 10;
		String str = "hello";
		System.out.println(c + num + str);//107hello
		System.out.println(c + str + num);//ahello10
		System.out.println(c + (num + str));//a10hello
		System.out.println((c + num) + str);//107hello
		System.out.println(str + num + c);//hello10a

		//练习2
		//*	*
		System.out.println("*	*"); //输出*	*
		System.out.println('*' + '\t' + '*');//输出93， char类型加法运算
		System.out.println('*' + "\t" + '*');//输出*	*，"\t"string类型表示连接
		System.out.println('*' + '\t' + "*");//输出51*，第一个加好表示加法第二个连接
		System.out.println('*' + ('\t' + "*"));//输出*	*

		//练习3
		String str1 = 4; //判断对错：no
		String str2 = 3.5f + “”; //判断str2对错：yes
		System.out.println(str2); //输出：”3.5”
		System.out .println(3+4+“Hello!”); //输出：7Hello!
		System.out.println(“Hello!”+3+4); //输出：Hello!34
		System.out.println(‘a’+1+“Hello!”); //输出：98Hello!
		System.out.println(“Hello”+‘a’+1); //输出：Helloa1
		
		//练习4
		1）short s = 5;
		s = s-2; //判断：no，int
		2） byte b = 3;
		b = b + 4; //判断：no int
		b = (byte)(b+4); //判断：yes
		3）char c = ‘a’;
		int i = 5;
		float d = .314F;
		double result = c+i+d; //判断：yes
		4） byte b = 5;
		short s = 3;
		short t = s + b; //判断：no ，int
		
		//***********************

		//String str1 = 123;//编译不通过
		String str1 = 123 + "";
		System.out.println(str1);//"123"
		
		//int num1 = str1;
		//int num1 = (int)str1;编译不通过

		int num1 = Integer.parseInt(str1);
		System.out.println(num1);//123
	}
}

三、进制转换

对于整数，有四种表示方式：

1. 二进制(binary)：0,1 ，满2进1.以0b或0B开头。
2. 十进制(decimal)：0-9 ，满10进1。
3. 八进制(octal)：0-7 ，满8进1. 以数字0开头表示。
4. 十六进制(hex)：0-9及A-F，满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。
   如：0x21AF +1= 0X21B0

1、二进制转10进制

• Java整数常量默认是int类型，当用二进制定义整数时，其第32位是符号位；
• 当是long类型时，二进制默认占64位，第64位是符号位
• 二进制的整数有如下三种形式：

1. 原码：直接将一个数值换成二进制数。最高位是符号位
2. 负数的反码：是对原码按位取反，只是最高位（符号位）确定为1。
3. 负数的补码：其反码加1。
4. 计算机以二进制补码的形式保存所有的整数。
5. 正数的原码、反码、补码都相同
6. 负数的补码是其反码+1
   

• 最高位为符号位：0：正数，1：负数
• 00001110转换为10进制为：1 * 2^3 + 1 * 2^2 + 1* 2^1 = 14
  
  10111011未知负数补码-1变为10111010，除符号位取反11000101
  计算：2^1+ 2^3+ 2^7= -69
  

2、 十进制转二进制

3、二进制转八进制和十六进制