3 数据的类型
- 基本数据类型-原始数据类型
- 引用数据类型
3.1 基本数据类型
基本数据类型：8种 byte,short,int,long,float,double,char,boolean
归纳分类:
整数类型：4种 byte,short,int,long
浮点类型：2种 float,double
字符类型：1种 char
布尔类型：1种 boolean
(1)整数类型：
byte(不常用):也叫字节类型，在内存中占8位二进制，即在内存中占1字节大小的空间，
是数据存储的最小单位。
0000 0000 0 =============>为了计数考虑正负，零开头为正，1开头为负
0111 1111 127
1000 0000 -128
1000 0001 -127
1111 1111 -1
范围：-128~127
幂表示：-2^7~2^7-1
short(不常用)：也叫短整型。在内存中占16位二进制，2字节大小。
0000 0000 0000 0000 0
0111 1111 1111 1111 32767
1000 0000 0000 0000 -32768
1111 1111 1111 1111 -1
范围：-32768~32767
幂表示：-2^15~2^15-1
int(常用):也叫整型。在内存占32位二进制，4字节大小。
范围：-2147483648~2147483648
幂表示：-2^31~2^31-1
long(常用)：也叫长整型。在内存占64位二进制，8字节大小。
范围：正负922亿亿左右
幂表示：-2^63~2^63-1
/**变量类型例子*/
public class TypeDemo01{
public static void main(String[] args){
/*
在给变量赋值时，直接写的整数值，默认的就是
int类型的数，在内存占32位数。
在给byte，和short类型的变量赋值时，直接写的整数值，
只要没超出相应的类型的范围，就不会出现编译错误（语法错误）
直接写的整数值，叫字面量
*/
int a=10;//0000 0000 0000 0000 0000 0000 0000 0101
byte b=10;
short c=10;
//byte d=128;//类型不匹配，可能会有精度损失
/*
int类型的所有数值计算结果一定都是32位。
0111 1111 1111 1111 1111 1111 1111 1111
+ 0000 0000 0000 0000 0000 0000 0000 0001
= 1000 0000 0000 0000 0000 0000 0000 0000----->-2147483648
封闭式运算：
max+1 等于min
min-1 等于max
*/
int max=2147483647;
int count=max+1;
System.out.println(count);
byte b1=10;
byte b2=10;
int b3=b1+b2;//b1与b2运算期间，又变成32位二进制
System.out.println("--------分割线-------------");
long l1=10;//32位的10，存入l1，自动添加32个0
long l2= -10;//32位的-10，存入12，自动添加32个1
System.out.println(l1);
System.out.println(l2);
long l3=l2;//l2中的数据复制一份到l3中
System.out.println(l3);//-10
l3=1000;
System.out.println(l3);
/*
如果想直接赋值64位的字面量整数时，需要在数值后添加L/1
*/
long l4=12L;//64位的12存入l4中
long l5=-12l;//64位的-12存入l5中
long l6=2147483647+1;/*32位加32位最后还是32位，封闭计算
结果-2147483648*/
System.out.println(l6);
long l7=2147483647+1L;
System.out.println(l7);//32位加64位得出64位
}
}
（2）浮点数类型；2种---小数类型
float:在内存中占4字节大小，32位二进制
范围： -3.403E38~3.403E38
double： 在内存中占8字节大小，64位二进制
范围：-1.79E308~1.79E308
字面量：默认类型为double，即64位的浮点数类型
如果想直接写32位的浮点数，需要在数值后添加f/F
比如： double num=3.14;
float num1=3.14F;
/**
浮点数类型的学习
float,double
数值字面量为double类型，
直接写float类型的数值时，需要添加F/f
*/
public class TypeDemo02{
public static void main(String[] args){
/*浮点数赋值方式；
3.14；1.2E；.512
*/
double a=3.14;
System.out.println(a);
double b=1.2e2;
System.out.println(b);
double c=.512;
System.out.println(c);
double d=.123E2;
System.out.println(d);
float h=3.14F;
System.out.println(h);
//float j=.512FE2;//错误写法
float i=.512E2F;//正确写法
System.out.println(i);
/*
将数值1.1234567890123456789分别存入float的变量m中和double的变量n中，
然后输出，查看结果。
输出的结果分别为：
1.1234568
1.1234567890123457
发现：
浮点数在存储数据时，会有舍入误差，即不够精确，但是double要比float
更精确一些（相比floata,要精确多一倍）
double：双精度浮点数类型
float:单精度浮点数类型
*/
float m=1.1234567890123456789F;
System.out.println(m);
double n=1.1234567890123456789;
System.out.println(n);
/*
浮点数类型无法精准表示1/10，就像10进制数无法表示1/3一样。
所以在运算时，多数情况下都是不精确运算
*/
double n1=3.15;
double n2=2.5;
double n3=n1-n2;
System.out.println(n3);
}
}（3）字符类型：char 在内存中占2字节大小，16位二进制。
赋值特点：1）值中有且只有一个字符；2）字符必须使用单引号引起来.
另外特点:底层二进制是无符号的整数类型即0~2^16-1---->0~65535
所以赋值时，也可以赋值整数，但是存入变量空间后，其实是其整数对应的字符。
java语言默认使用的字符集为unicode。
unicode字符集：
无论字母，还是汉字，都占两个字节大小
'A'-----00000000 01000001
'a'-----00000000 01100001
'O'-----00000000 00110001
什么是字符集：即二进制与字符的一一对应关系的表
常见字符集： GBK、 GBK2312、 UTF-8
java语言常用的字符： 'A'-'Z'->65~90
'a'-'z'->97-122
'0'-'9'->48-57
java语言中的转义字符： '\':将特殊字符变成相应意义的字符。
java语言中的特殊字符：单引号、双引号、制表符、换行符、回车符号
'\''---->单引号
'\"'---->双引号
'\\'---->反斜线
'\t'---->制表符
'\r'---->换行符（有翻页效果，看不到上一页的数字）
/* 在不同的控制台内部会有不同的效果，
有的平台只有换行效果不翻页 */
'\n'---->回车符
需求：查看字符集中某一字符对应的整数，将字符赋值给int类型的变量即可
（4）布尔类型：用来判断条件是否成立的，在内存中占1字节大小。
只有两个值true/false， true:表示条件成立
false:表示条件不成立
/**
字符类型的学习
凡是能用书写工具写出来的，都是字符，
包括空格、换行符、制表符
*/
public class TypeDemo03{
public static void main(String[] args){
char c1='a';
System.out.println(c1);
char c2='啊';
System.out.println(c2);
//char c3='';//编译错误，不能为空
char c3=' ';//编译正确，可以为空格
//char c4=' ';//编译错误，只能为一个空格
//char c5="b";//编译错误，只能使用单引号
System.out.println("------分割线-------");
char c6=20013;
char c7=20102;
System.out.println(c6);
System.out.println(c7);
char c8=65;
char c9=97;
char c10=48;
System.out.println(c8);
System.out.println(c9);
System.out.println(c10);
System.out.println("------分割线-------");
char c11='\\';
System.out.println(c11);
//char c12=''';没有加\的时候报错，前面加\进行转义
char c12='\'';
System.out.println(c12);
//char c12='"';没有加\的时候也可以正常输出",但特殊字符前面一般加\进行转义
char c13='\"';
System.out.println(c13);
char c14='\t';//char c14='t';t是一个制表符，不加\输出是t但不为制表符
System.out.println("姓名"+c14+"年龄");
System.out.println("小"+c14+"12");/*制表符的输出效果：姓名 年龄
小 12
将上下对应
*/
System.out.println("你\rworld");
System.out.println("中国\n最伟大");
System.out.println("------分割线-------");
int num='高';
int n1='圆';
int n2='圆';
int n3='我';
int n4='爱';
int n5='你';
System.out.println(num);
System.out.println(n1);
System.out.println(n2);
System.out.println(n3);
System.out.println(n4);
System.out.println(n5);
System.out.println("------分割线-------");
boolean f1=true;
boolean f2=false;
System.out.println(f1);
System.out.println(f2);
int age1=33;
int age2=54;
boolean f3=age1>age2;
System.out.println(f3);
boolean f4=age1<=age2;
System.out.println(f4);s
}
}
3.2 不同基本数据类型的范围和进度排序
范围从大到小排序： double>float>long>int>short>byte
（char的范围可以类似=short）
精度从大到小排序：（int,long,float,double）
long>int>double>float
3.3 类型转换
（1）自动转换（隐式转换）：占内存小的类型变量赋值给占内存大的类型变量， 会发生自动转换。
byte b=5;
short b1=b;//8位的5赋值给16位的5，在前面自动添加8个零
int c1=-1;
long c2=c1;//32位的-1赋值给了64位的c2里，自动添加了32个1
long c3=-1;
byte--->short--->int--->long--->float--->double
char
（2）强制转换：占内存大的类型变量赋值给占内存小的类型变量，需要强制转换。
语法如下：（占内存小的变量类型名）变量；
注意：有可能出现精度损失。
int a=1;
byta a1=(byte)a;
long b=-10;
int b1=(int)b;
double--->float--->long--->int---->short--->byte
char
public class TypeSwitchDemo01{
public static void main(String[] args){
/*类型转换：
自动转换（隐式转换）
强制转换（显式转换）
*/
/*
练习：
将short类型的b赋值给int类型的a;
将byte类型的c赋值给double类型的d；
将float类型的e赋值给double类型的g;
将double类型的n1赋值给float类型的n2;
将float类型的n2赋值给int类型的n3;
将int类型的n3赋值给byte类型的n4;
分别输出
*/
short b=2;
int a=b;
System.out.println(a);
byte c=4;
double d=c;
System.out.println(d);
float e=0.3F;//float e=0.3;不加F出现错误
double g=e;
System.out.println(g);
double n1=0.618;
float n2=(float)n1;
int n3=(int)n2;
byte n4=(byte)n3;
System.out.println(n2);
System.out.println(n3);
System.out.println(n4);
}
}3.4 引用数据类型
引用数据类型(无数种，除了现有的，我们还可以自定义类型)
String：字符串类型
赋值特点：（1）必须使用双引号
（2）引号内有0或0个以上字符
（3）字符串的数据之间可以进行拼接操作
（可以和八大基本数据类型进行拼接，拼接后还是字符串类型）
public class StringDemo01{
public static void main(String[] args){
/*字符串类型：String
赋值特点：
1、必须使用双引号
2、引号内有0个或0个以上的字符都可
3、字符串可以做拼接操作，拼接后的数据仍是字符串类型。
*/
String name="小张";
//String n1='小王'；//编译错误
String n1="";//编译正确，可以为空字符串
String n2=" ";//编译争取，空格字符串
String m="中国";
String m1="666";
//可以进行拼接操作，拼接符号为+
String m2=m+m1;
System.out.println(m2);
int count=777;
String result=m+count;//做拼接操作
System.out.println(result);
System.out.println(3+2+"中国");//结果为“5中国”
System.out.println(3+"+"+2+"="+(3+2));//3+2=5
System.out.println(3+3+"3"+3*3);//"639"
/*
在做运算时，+前后只要有一个是字符串类型就会做拼接操作。结果是
字符串类型。
*/
}
}附加：
System.currentTimeMillis();会返回一个long类型的数据，此数据为从1970年1月1日0时0分
0秒到系统当前时间之间的所有毫秒数。
public class TestDemo01{
public static void main(String[] args){
/*
计算10亿*3，输出结果
计算10亿+10亿+10亿，输出结果
计算10亿*3L，输出结果
计算10亿L+10亿L+10亿L，输出结果
*/
int a=1000000000*3;
System.out.println(a);
int b=1000000000+1000000000+1000000000;
System.out.println(b);
long c=1000000000*3L;
System.out.println(c);
long d=1000000000L+1000000000L+1000000000L;
System.out.println(d);
/*
System.currentTimeMillis();会返回一个long类型的数据，
此数据为从1970年1月1日0时0分0秒到系统当前时间之间的
所有毫秒数。
*/
long time=System.currentTimeMillis();
System.out.println(time);
/*
将time的值换算成年份，+1970
*/
long num=time/1000/60/60/24/365;
System.out.println(num+1970);
}
}