数据类型与运算符

1.变量和类型

  变量指的是程序运行时可变的量，相当于开辟了一块内存空间来保存一些数据。

  类型则是对变量的种类进行了划分，不同的类型的变量具有不同的特性。

   我们所讨论的“变量”主要和我们的“内存”这样的设备密切相关。

         

1.1整型变量

      基本的语法格式

    int  变量名= 初始值；

代码实例

      int num=5;  //定义一个整型变量

     System.out.println（num）;

注意事项：

      1.int 表示变量的类型是一个整型

      2.变量名是变量的标识，后续都是通过这个名字来使用变量

      3.java中=表示赋值（和数字不一样），意思是给变量设置一个初始值。

      4.初始值操作是可选的，但是建议创建变量的时候都显式初始化。

      5.最后不要忘记分号，否则会编译失败。

      6.//表示注释。 注释作为代码的解释说明部分，不参与编译运行。

在java中，一个变量占4个字节。和操作系统没有直接关系。

     什么是字节？

       字节是计算机中表示空间大小的基本单位。 

      计算机使用二进制表示数据，我们认为8个二进制位（bit）位一个字节（Byte）

      我们平时的计算为8GB内存，意思是8G字节。

      其中 1KB= 1024 Byte,1MB=1024KB,1GB=1024MB.

     所以8GB相当于80多亿个字节

4个字节表示的数据范围是 -2的31次方 到 2的31次方减1  也就是大概 -21亿到+21亿

   使用一下代码查看java中的整型数据范围：

     System.out.println(Integer.MAX_VALUE)；  //int的最大值

     System.out.println(Integer.MIN_VALUE)；   //int的最小值

如果运算的结果超出了Int的最大范围，就会出现溢出的情况

       int   maxvalue=Integer.MAX_VALUE;

       System.out.println(maxValue+1);

       int   minvalue=Integer.MIN_VALUE;

       System.out.println(minValue-1);

1.2长整型变量

    基本语法格式：

      long  变量名 =初始值；

   代码示例

          long num=10L; //定义一个长整型变量。

          System.out.println(num);

   注意事项：

      1.基本语法格式和创建int变量基本一致，只是把类型修改成long

      2.初始化设定的值位10L，表示一个长整型的数字

      3.使用10初识化也可以，10的类型是int，10L的类型是long，使用 10L或者 10l 更好一些

java中long类型占8个字节，表示数据范围 -2的63次方 至 2的63次方减1

  使用以下代码查看 Java 中的长整型数据范围 :

      

System . out . println ( Long . MAX_VALUE );

System . out . println ( Long . MIN_VALUE )

   

// 运行结果

9223372036854775807

- 9223372036854775808  

这个数据范围远超过int的表示范围，足够绝大部分的工程场景使用

      1.3双精度浮点型变量

基本语法格式

       double 变量名=初始值；

代码实例： 

     double  num=1.0；

   System.out.println(num)

神奇的代码1：

         int a=1;

         int b=2;

System.out.println(a/b);   //执行结果   0

在java中，int除以 int的值仍然是int（会直接舍弃小数部分）。

如果想得到 0.5，需要使用double类型来计算

     double  a=1.0；

     double b=2.0;

System.out.println(a/b);  //执行结果 0.5

神奇的代码2：

    double  num=1.1；

System.out.println(num*num)

// 执行结果     1.2100000000000002

java中的double虽然也是8个字节，但是浮点数的内存布局和整数差别很大，不能单纯的用2的n次方的形式表示数据范围。

java的double类型的内存布局遵守IEEE 754标准（和C语言一样），尝试使用有限的内存空间表示可能的无限的小数，势必会存在在一定的精度误差。

1.4单精度浮点型变量

基本格式

     float 变量名 = 初始值；

代码示例： 

      float num=1.0f;    //写作 1.0F 也可以

      System.out.println(num);

float 类型在java 中占四个字节，同样遵守 IEEE 754标准，由于表示的数据精度范围较小，一般在工程上用到浮点数都优先考虑double，不太推荐使用float.

1.5 字符类型变量

基本格式：

   char 变量名 = 初始值 ；

代码示例

   char ch= 'A'；

注意事项：

  1.java中使用 单引号+单个字母 的形式表示字符字面值。

  2.计算机中的字符本质上是一个整数。在c语言中使用ASCLL表示字符，而java中使用Unicode表示字符。因此一个字符占用两个字节，表示的字符种类更多，包括中文。

    使用一个字符表示一个汉字：

     char ch='王'；

     System.out.println(ch);

  在执行时可能会出现乱码，此时我们在执行时加上-encoding UTF-8选项即可

    javac  -encoding UTF-8 Test.java

1.6字符类型变量

基本语法格式

   byte 变量名=初始值;

代码示例

   byte value =0;

   System.out.println(value);

注意事项

   1.字节类型表示的也是整数，只占一个字节，表示范围较小(-128 ->+127)

   2.字节类型和字符类型互不相干

1.7 短整型变量

    基本语法格式：

    short  变量名 = 初始值;

代码示例：

   short value = 0；

   Sy

stem.out.println(value);

注意事项:

    1.short占用2个字节，表示的范围是 -32768->+32767

    2.这个表示范围比较小，一般不用推荐使用。

1.8 布尔类型变量

    基本语法格式:

    boolean 变量名 = 初始值；

    代码示例:

    boolean value = true;

    System.out.println(value);

    注意事项:

       1.boolean类型的变量只有两种取值，true表示真，false表示假。

       2.Java的boolean类型和int不能相互转换，不存在1表示true，0表示false这样的用法。

       3.boolean 类型有些JVM的实现是占一个字节，有些是占1个比特位，没有明确规定。

1.9 字符串类型变量

      把一些字符放到一起就构成了字符串

      基本语法格式:

      String 变量名 = "初始值"；

      代码示例:

      String name="wxl";

      System.out.println(name);

注意事项：

      1. java使用双引号+若干字符的方式表示字符串字面值

      2.和上面的类型不同，String不是基本类型，而是引用类型

      3.字符串中的一些特定的不方便直接表示的字符需要进行转义

转义字符示例：

    // 创建一个字符串 My name is "张三"

    String naame ="My name is \"张三\"";

转义字符有很多，其中几个比较常见的如下：

       转义字符                                                          解释

          \n                                                                    换行

          \t                                                                     水平制表符

          \'                                                                     单引号

          \''                                                                     双引号

          \\                                                                     反斜杠

字符串 + 操作，表示字符串拼接:

    String a = "hello";

    String b = "world";

    String c = a+b;

    System.out.println(c);

还可以用字符串和整数进行拼接：

   String str = "result=";

   int a=10;int b=20;

  String result = str +a+b;

  System.out.println(result);

   // 执行结构

  result =1020

以上代码说明，当一个+表达式中存在字符串的时候，都是执行字符串拼接行为

因此我们可以很方便的使用 System.out.println("a="+a+",b="+b)

1.10变量的作用域

也就是该变量能生效的范围，一般是变量定义所在的代码块

class Test{
    public static void main（String[]args){
     {
        int x=10;
        System.out.println(x);  //编译通过；
     }
        System.out.println(x);  //编译失败，找不到变量x
   }
}

1.11 变量的命名规则

  硬性指标:

      1.一个变量只能包含数字，字母，下划线

      2.数字不能开头

      3.变量名是大小写敏感的，即num和Num是两个不同的变量

   注意 虽然语法上也允许使用中文/美元符($)命名变量，但是不推荐

  软性指标

    1.变量命名要具有描述性

    2.变量名不宜使用拼音

    3.词性推荐使用名词

 1.12 常量

   上面讨论的都是各种规则的变量，每种类型的变量也对应着一种相同类型的常量

   常量指的是运行时类型不能发生改变

   1.字面值类型

    

    2.final 关键字修饰的常量

       final int a = 10;

       a=20;   //编译出错， 无法为最终变量a分配值

      常量不能在程序运行过程中发生修改。

 1.12 理解类型转换

   java 作为一个强类型编程语言，当不同类型之间的变量相互赋值的时候，会有严格的校验

   先看一下几个代码场景：

      int和long/double 相互赋值

 

    long 表达的范围更大，可以将int赋值给long，但是不能将long值赋给int

    double表示范围更大，可以将int 赋值 double ，但是不能将 double赋值给int

   结论：不同数字类型的变量之间赋值，表示范围更小的类型能隐式转换成范围较大的类型，反之则不行。

int 和 boolean 相互赋值

结论：int和boolean是毫不相干的两种类型，不能相互赋值

int字面值常量给byte赋值

   

byte a=100；  //编译通过
byte b=256；  //编译报错，int转换到byte可能会有损失

  注意  byte表示的数据范围是-128->+127,256已经超过范围，而100还在范围之内

 结论：使用字面值常量赋值的时候，java会自动进行一些查验校验，判断赋值是否合理。

   使用强制类型转换

int a=0;
double b=10.5;
a=(int)b;
int a=10;
boolean b=false;
b=(boolean)a;  //编译出错，提示不兼容类型

结论 ：使用的方式可以将double类型强制转成int，但是

   1.强制类型转换可能会导致精度丢失，如刚才的例子中，赋值之后，10.5变成10了，小数点后面的部分被忽略

   2.强制类型转换不是一定能成功，互不相干类型之间无法强转。

类型转换小结

   1.不同数字类型的变量之间的赋值，表示范围更小的类型能隐式转换成范围较大的类型

   2.如果需要把范围大的类型赋值给范围小的，需要强制类型转换，且有可能精度丢失

   3.将一个字面值常量进行赋值的时候，java会自动针对数字范围进行检查

1.13 理解数值提升

 int 和 long 混合计算

int a= 10;
long b= 20;
int c= a+b; //编译出错，提示将 long 转成 int 会丢失精度
long d =a+b；//编译通过

 结论 ：当int 和 long混合运算的时候，int会提升成long，得到的结构仍然是long类型，需要使用long类型的变量来接收结果，如果非要用int来接收结果，就需要使用强制类型转换

  byte和byte的运算

byte a = 10;
byte b = 20;
byte c = a+b;
System.out.println(c); //编译报错
Test.java:5:错误:不兼容的类型：从int转换到byte可能会有损失

结论：byte和byte都是相同类型，但是出现编译报错。原因是，虽然a和b都是byte，但计算a+b会先将a和b都提升成int，在进行计算，得到的结果也是int，这是赋给c，就会出现上述错误。

由于计算机的cpu通常是按照4个字节为单位从内存中读写数据，为了硬件上实习方便，诸如byte和short这种低于4个字节的类型，会先提升成int，在参与计算。

正确的写法

byte a = 10;
byte b = 20;
byte c= (byte)(a+b);
System.out.println(c)

类型提升小结

     1.不同类型的数据混合运算，范围小的会提升成范围大的。

     2.对于short，byte这种4个字节小的类型，会先提升成4个字节的int，在运算。

1.14int和String之间的相互转换

int转成String

int num =10;
//方法1
String str1=num+"";
//方法2
String str2=string.valueOf(num);

String 转成 int

String str ="100";
int num =Integer.parseInt(str);

 

 

 

 

 

     

 

 

 

 

 

 

 

  

 

1