java_关于变量,类型(基本数据类型)以及类型转换

变量:jvm在内存中开辟的一个存储空间,用来存储数据,使用变量名使用该空间
命名规则:
(1)由字母,数字_和$组成,其中数字不能开头
(2)大小写敏感
(3)不能使用关键字
(4)可以使用汉字,但不建议
(5)驼峰命名法,要做到见名知意
使用规则:
一次定义,初始化,重复使用
只能在其作用域中使用,出了作用域中,需要重新声明

===========================================
类型: JAVA语言中共分两大类
(1)基本数据类型(原始数据类型)—-8种
–整数类型:byte,short,int,long
–浮点数类型:flout,double
–字符类型:char
–布尔类型:boolean

(2)引用数据类型—无数种(例如:String字符串类型)

整数类型:
byte:也叫字节类型,在内存中占8位二进制,即在内存中占一个字节大小的空间,是数据存储的最小单位
范围:-128~127 -2^7~2^7-1
short:也叫短整型,在内存中占16位二进制，即在内存中占两个字节大小的空间
范围:-32768~32767 -2^15~2^15-1
int:也叫整型,在内存中占32位二进制，即在内存中占四个字节大小的空间
范围：-2147483648~2147483647 -2^31~2^31
long:也叫长整型,占内存中占64位二进制，即在内存中占八字节大小的空间
范围：正负922亿亿 -2^63~2^63-1

在给变量赋值时,直接写的整数值,默认是int类型的数,占32位二进制
在给byte和short类型的变量赋值时,直接写的整数值,
只要没有超出相应类型的范围,就不会编译失败
直接写的整数值,叫做字面量

int类型的所有数值计算结果一定都是32位的
01111111 11111111 11111111 11111111
+ 00000000 00000000 00000000 00000001
== == == == == == == == == == == == == == ==
= 10000000 00000000 00000000 00000000
由最大值加1,得最小值(max+1=min)—–封闭式运算
同理,min-1=max
如果想直接赋值64位的字面量,需要在数值后加L/l
long l6 = 2147483647+1;//int的封闭式运算
=> l6 = -2147483648
long l7 = 2147483647+1l;//int先变成long,再运算
=> l7 = 2147483648

/**
 整数类型的学习
*/
public class TypeDemo01{
    public static void main(String[] args){
        /*
          在给变量赋值时,直接写的整数值,
          默认是int类型的数,占32位二进制

          在给byte和short类型的变量赋值时
          直接写的整数值,只要没有超出相应类型的范围
          就不会编译失败

          直接写的整数值,叫做字面量
        */
        int a = 10;
        byte b1 = 10;
        //byte d = 128;类型不匹配,可能出现精度损失
        /*
            int类型的所有数值计算结果一定都是32位的
            01111111 11111111 11111111 11111111 
          + 00000000 00000000 00000000 00000001
          = 10000000 00000000 00000000 00000000
          由最大值加1,得最小值-----封闭式运算
        */
        int max = 2147483647;
        int count = max+1;
        System.out.println(count);

        byte b2 = 10;
        int b3 = b1+b2;//运算期间,又变回int类型
        System.out.println("------------------------------");

        long l1 = 10;
        long l2 = -10;
        System.out.println(l1);
        System.out.println(l2);


        long l3 = l2;//复制l2的数据赋值给l3
        System.out.println(l3);

        l3 = 1000;
        System.out.println(l3);
        /*
            如果想直接赋值64位的字面量,需要在数值后加L/l
        */
        long l4 = 12l;
        System.out.println(l4);
        long l6 = 2147483647+1;//int 的封闭式运算
        System.out.println(l6);//-2147483648
        long l7 = 2147483647+1l;//int先变成long再运算
        System.out.println(l7);//2147483648
    }
}

System.currentTimeMillis();会返回一个long类型的数据
此数据为 从1970年0时0分0秒到系统时间的所有毫秒数

浮点数类型:(小数)
float:
在内存中占4字节大小,32位二进制
范围:
-3.408e^38~3.408e^38
double:
在内存中占8字节大小,64位二进制
范围:
-1.79e^308~1.79e^308
字面量:默认为double类型,即64位
若想写32位的浮点数,需要在数值后加f/F;

若将数值1.1234567890123456789
分别存入float m和long n,输出,查看结果

/**
  浮点数类型的学习
  float,double
  数值字面量位double类型
  直接写float类型的数据时,在数值后加f/F

*/

public class TypeDemo02{
    public static void main(String[] args){
        /*
         浮点数赋值方式:
         3.14;  1.2e2;  .314e1
        */
        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 s = 3.14f;
        System.out.println(s);
        //float j = .512fe5;//错误写法
        float i = .512e2f;//正确
        System.out.println(i);
        /*
            将数值1.1234567890123456789
            分别存入float m和long n,输出,
            查看结果
        发现:
            浮点数类型在存储数据时,会有舍入误差
            即,不够精确..但double比float精确
            double:双精度浮点数类型
            精度-----绝对保证15到16位
            float:单精度浮点数类型
            精度------绝对保证6到7位
            还有最后一位是舍入位
        */
        float m = 1.1234567890123456789f;
        System.out.println(m);
        double n = 1.1234567890123456789;
        System.out.println(n);
        /*
            浮点数类型无法精确表示1/10,
            就像十进制数无法表示1/3一样
            所以在运算时,多数情况下都是不精确运算
        */
        double n1 = 3.0;
        double n2 = 2.9;
        System.out.println(n1-n2);
    }
}

浮点数类型无法精确表示1/10,就像十进制数无法表示1/3一样
所以在运算时,多数情况下都是不精确运算

范围从大到小排序:
double>float>long>int>short>byte
精度从大到小排序:
long>int>double>float

=================================================
字符类型: char
在内存中占2字节大小,16位二进制
凡是能用书写工具写出来的,都是字符
包括空格,换行符,制表符
赋值特点:
有且仅有一个字符
必须用单引号
另外特点:底层二进制是无符号的整数类型
即0~2^16-1(0~65535)
所以,赋值时也可以赋值整数.但是,存入
变量空间后,是其整数对应的字符

java语言默认使用字符集位Unicode.
Unicode字符集:
无论字母,还是汉字,都占两个字节
‘A’—00000000 01000001
‘a’—00000000 01100001
‘0’—00000000 00110000
什么是字符集:
即二进制和字符一一对应的关系表

编码:将字符—>二进制 存
解码:将二进制—>字符 读

写文件时,采用Unicode输入的,必须用Unicode输出,否则会乱码
(其他的字符集也一样)

JAVA语言常用的字符有
‘A’–‘Z’ 65-90
‘a’–‘z’ 97-122
‘0’–‘9’ 48-57
JAVA语言中的转义字符:
‘\’:将特殊字符变成相应意义的字符
JAVA语言的特殊字符:
单引号’\”
双引号’\”’
反斜杠’\’
制表符’\t’
换行符’\r’ (翻页效果,看不到上一页的内容)
回车符’\n’

查看字符集中某一字符对应的整数,将字符赋值给int类型的变量,即可
int num = ‘晨’;

=================================================
布尔类型:用来判断条件是否成立
在内存中占1个内存大小
只有两个值:true/false;成立/不成立;

=================================================
类型转换:
自动转换(隐式转换):范围小的赋值给范围大的类型变量,
会发生自动转换;

byte->short
        |->int->long->float->double
      char

强制转换(显式转换):范围大的赋值给范围小的类型变量,
需要强制转换;
double->float->long->int->short->byte
任何类型变量转换成char都需要强制转换
语法: (强制转换类型名(范围小的))变量;