java变量与基本数据类型及转换

变量

概念

能存储计算结果或者能表示抽象概念。变量可以通过变量名访问

三要素

变量类型 变量名 = 值；
可以拆分为两个步骤：
//声明
数据类型 变量名；int a；string name；
//赋值
变量名 = 值；a = 10；name = “凯撒”;
解释：
1.变量名必须符合标识符命名规范，阿里编程规约变量名采用小驼峰命名法
2.基本数据类型 和 引用数据类型 8个（byte ，short ，int ，long， float ，double ，char， boolean） 其他都是引用数据类型(数组，类，接口，枚举)
3. 值必须匹配数据类型
4. 变量通常是可变的，可以重复赋值

例如

public class Demo{
        int a = 3;//成员变量（堆）
        int b = 10;
        String c;
        public void fun(int x){//方法的参数为局部变量
        int a = 20;//局部变量（栈）
        double d = 32;
        System.out.println(a);
        System.out.println(c);
        }
}

局部变量和成员变量的区别

注意事项

1. 在同一个范围内，变量名不能相同
2. int b = 3.14; 错误的，变量的值必须和数据类型匹配
3. name = “凯撒”; 错误的，变量必须先声明再赋值
4. int x; System.out.println(x); x为局部变量，也是错误的，局部变量必须赋值才能使用

数据类型

数据类型分类

基本数据类型（8个）

整数类型

<1>byte x = (byte)128;

public class IntDemo { 
       public static void main(String[] args) { 
       // byte short int long 
       // 数据类型 变量名 = 值; 
       byte a1 = 127; 
       // 面试题： byte a2 = (byte) 128; 请问 a2的值为多少?
       byte a2 = (byte) 128; 
       System.out.println(a2); 
       // -128 byte a3 = (byte) 129; 
       System.out.println(a3);
      // -127 // 因为值最终都会转换成2进制数 
      // 十进制数中: 128 = 127 + 1 
      // 二进制: 127 (0111 1111) 
      // 1 (0000 0001) 
     // 1000 0000 如何转换成十进制数？ 
     // 求一个负数的二进制数? 
     // -7
     // 步骤1：先求7的二进制数 
     // 0000 0111 (原码) 
     // 步骤2：取反(0的变成1，1的变成0) 
     // 1111 1000 (反码) 
     // 步骤3：+1 
     // 1111 1001 (补码) 
     // 1000 0000 转换成 十进制
      // 步骤1：减1 // 0111 1111
     // 步骤2：取反 
     // 1000 0000
    // 步骤3：计算结果128，前面加一个负号 // -128 } }

<2>每种整型的取值范围

public class IntDemo2 {
       public static void main(String[] args) { //byte的取值范围
            System.out.println(Byte.MIN_VALUE); // -128
            System.out.println(Byte.MAX_VALUE); // 127 //short的取值范围                      
            System.out.println(Short.MIN_VALUE);//-32768 
            System.out.println(Short.MAX_VALUE); // 32767 //int的取值范围 
            System.out.println(Integer.MIN_VALUE); //-2147483648 
            System.out.println(Integer.MAX_VALUE);//2147483647 //long的取值范围 
            System.out.println(Long.MIN_VALUE);//-9223372036854775808 
            System.out.println(Long.MAX_VALUE);//9223372036854775807 } }

<3>定义long类型变量

public class IntDemo3 { 
       // 声明long型常量可以后加‘ l ’或‘ L ’ 
      public static void main(String[] args) { 
     // 2147483647 int a = 2147483647; 
     // 因为类似于2147483647字面值都是int类型， 
     // 若给long类型的变量赋值，值超过了int的取值范围 // 添加L或者l
     long b = 2147483648L;
 } 
 }

<4>整型变量的默认值都为0

<5> 定义2,8,16进制数

public class IntDemo4 { 
       public static void main(String[] args) { 
       // 二进制数 0b开头 
       int a = 0b10; System.out.println(a);  // 2
       // 八进制数 0开头 
       int b = 010; System.out.println(b); // 8 
       // 十进制数
        int c = 10; System.out.println(c); // 10 
        // 十六进制数 0x开头 
        int d = 0x10; System.out.println(d); //16 
        }
     }

浮点类型

<1>定义浮点类型

public class DoubleDemo { 
       public static void main(String[] args) {
        // 浮点类型有2个： float 和 double 
        // 3.5 这个值，默认为double类型 
        double x = 3.8; 
        // Java浮点型常量默认为double型,如要声明一个常量为float型， 
        // 则需在数字后面加f或F，如： 
        float y = 3.8F; 
        // 使用科学计数法，给浮点类型赋值 
        double z = 3.14E2; // 3.14 乘以 10的平方 
        System.out.println(z);// 314.0 
        }
    }

<2> 精度问题
float 保留8位有效的小数
double保留 16位有效的小数

int k = 1 / 3; //两个整数相除，为整除 0 
System.out.println(k); // 0 float m = 1.0f / 3; 
System.out.println(m); //0.33333334 
double n = 1.0 /3; 
System.out.println(n); // 0.3333333333333333

<3> float与double精度丢失问题

在做银行的项目就不要使用 float和double 运算 
原因，弄清楚小数如何转换成2进制数： 
(1) 十进制整数如何转化为二进制数 算法很简单。
举个例子，11表示成二进制数： 
11/2=5 余 1 
5/2=2 余 1 
2/2=1 余 0 
1/2=0 余 1 
0结束 
11二进制表示为(从下往上):1011 
这里提一点：所有的整数转变为二进制数的算法会不会无限循环下去呢？绝对不会，整数永远可以用二进 制精确表示 ，但小数就不一定了。 
(2) 十进制小数如何转化为二进制数 算法是乘以2直到没有了小数为止。
举个例子，0.9表示成二进制数 
0.9*2=1.8 取整数部分 1 
0.8(1.8的小数部分)*2=1.6 取整数部分 1 
0.6*2=1.2 取整数部分 1 
0.2*2=0.4 取整数部分 0 
0.4*2=0.8 取整数部分 0 
0.8*2=1.6 取整数部分 1 
0.6*2=1.2 取整数部分 0 ......... 
0.9二进制表示为(从上往下): 1110010..... 注意：上面的计算过程循环了，也就是说*2永远不可能消灭小数部分，这样算法将无限下去。 很显然，小数的二进制表示有时是不可能精确的 。

import java.math.BigDecimal; 
// ctrl+shift+o 
public class DoubleDemo3 { 
       public static void main(String[] args) { 
       //float和double的精度丢失问题 
       double result = 1.0 - 0.9; 
       System.out.println(result);// 0.09999999999999998 
       // 值最终都会转换成2进制数 
       //为什么会输出这种结果： 超过精度能表示的范围就会产生误差 //如何解决? BigDecimal解决运算时精度丢失问题 
       BigDecimal num1=new BigDecimal("1.0"); 
       BigDecimal num2 =new BigDecimal("0.9"); 
       BigDecimal result2=num1.subtract(num2); // num1 - num2 
       System.out.println(result2);
        } 
   }

布尔类型（boolean）

public class BooleanDemo{
       public static void main(String[] args){
       boolean b = false;//布尔类型默认值为false
       boolean c = true;//布尔类型一般用于流程控制
       System.out.println(b+" "+c);
       }
}

字符类型

<1> 定义字符类型
char类型是一个单一的 16 位 Unicode 字符； 最小值是 \u0000（即为0）； 最大值是 \uffff（即为65,535）； char 数据类型可以储存任何字符； 例子：char letter = ‘A’;。

//第1种赋值方式： ASCII码 
char x1 = 97; // ASCII码（128个字符，都有一个10进制数与之对应） 
System.out.println(x1); 
//第2种赋值方式：''单引号，单引号括起来的"单个"字符 （不能时0个或者多个） 
char x2 = '我'; 
char x3 = '1'; 
System.out.println(x3 == 1); //true 还是 false? 
System.out.println((int)'1'); // char == int // 49 == 1 
//规定：低于int类型【byte，char，short】的变量在运算时会自动转换成int 
// double int ,低的会自动转换高的，再做运算 //第3种方式：unicode编码,看到以 \\u开头的，都是unicode编码 
// unicode 统一码，万国码 每种语言中的每个字符设定了统一并且唯一的二进制编码 
// 4E00-9FA5 中文的范围 
char x4='\u90b1'; 
System.out.println(x4); // demo.properties 属性文件(不能存储汉字，会将汉字转换成unicode编码) 
char x5='\u79CB';

<2> ASCII表
<3> 常见的转义字符
\n 换行(LF) ，将当前位置移到下一行开头
\r回车(CR) ，将当前位置移到本行开头
\t水平制表(HT) （跳到下一个TAB位置）
\代表一个反斜线字符\ System.out.println("\");
’ 代表一个单引号（撇号）字符

基本数据类型转换

大转小需要强制转换，小转大自动转换。