java-03 变量与运算符

1.java中的变量与常量

　　1.1 变量的定义：

　　　　　　变量，顾名思义就是会变的量，这种思想来源于数学，指的是一个不确定的量或者随时会改变的量。

　　　　　　在我们进行编程的过程中，有一些东西是会随着实际情况而发生变化，例如用户的输入、系统的当前时间等，这些东西并不能唯一确定下来，于是我们想到了一个办法，用一个标记来代替这些会变的东西，我们把这个标记叫做程序中的变量。

　　　　　　同样，与变量相对的量，例如圆周率PI=3.1415926、自然对数E = 2.71828 等，我叫做常量。

　　　　　　其实计算机编程就是将我们所知道的事务抽象成数据，然后对其进行处理并得出结果，由于JAVA是强类型语言 所以JAVA为我们内置了8种基本的变量类型，也叫做数据类型。

　　　　　　这里，大家可以先了解一下强类型与弱类型的区别：强类型与弱类型（也可自行百度了解）

　　1.2 JAVA八大基本变量类型：

　　　　　　java中一共有八种基本变量，分别是 boolean、byte、short、char、int、long、float、double 下面的表格是其描述与在内存中所占的大小

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　这里注意一下  只有被单引号引的才是一个字符，双引号引的，尽管只有一个字符，也不算是字符，而是算字符串。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　还有一个比较特殊的数据类型是引用数据类型 长度占四个字节，存的是一个对象的地址，后续会详细说明。

　　1.3 JAVA 声明变量的几种方式

　　　　　　　声明变量之前先介绍一下标识符：在JAVA中，原则上每一个变量（属性）、常量、方法、类、甚至是语句块都有名字，用来唯一标识自己，我们将其称为标识符；

　　　　　　　标识符的命名规则：由数字、字母、下划线和$/￥组成，但是数字不能作为标识符的第一位，java中的关键字也不能作为标识符；

　　　　　　　一般的命名规则：原则上要求标识符的命名简洁，能一下看出该标识符的意义。命名遵循驼峰式命名规则。常量使用全部大写字母，但此语单词之间下划线分割；

　　　　　　（1） 数据类型 变量名；

　　　　　　（2） 数据类型 变量名1，变量名2，变量名3,....；

　　　　　　（3） 数据类型 变量名 = 值；

　　　　　　（4） 数据类型 变量名1 = 值1，变量名2 = 值2，变量名3 = 值3；

　　　　　　　有几点特殊说明： 如果不加限制，默认的字面量 整数是int类型，所以如果要声明一个long类型的变量要在数值后面加一个大写的L来表示，小数默认是float，要生命double类型的变量要使用大写字母D来表示

 public class Varible {

     public static void main(String[] args) {
         //声明变量的几种方式
         int a;
         int b,c,d;
         int e = 1,f = 2,g = 3;

         //特殊的需要使用 L 或 D 进行声明
         long l = 123L; //声明123为long类型
         double dou = 123.456D; //声明123.456 为double类型
     }

 }

　　1.4 JAVA 中变量的分类

　　　　　　1.4.1 按类型分

　　　　　　　　　　java中的数据类型按类型分可以分为整形和小数型

　　　　　　　　　　其中整形是只能存储整数的，其中包括：byte、short、int、char（unicode码）、long

　　　　　　　　　　小数型是只能存储小数的，包括： float、double

　　　　　　　　　　还有一个比较特殊的  只能存储真假 （true/false）：boolean

　　　　　　1.4.2 按作用域分

　　　　　　　　　　JAVA中的数据类型按作用域可以分为三种： 局部变量、成员变量、静态变量

　　　　　　　　　　局部变量：被定义在方法内部或语句块内部（语句块就是两个花括号之间的部分）或形参上的变量，这一类变量没有默认值，定义以后必须要先赋值以后才能使用，否则编译器会报告一个错误，其生命周期是该语句块或方法

　　　　　　　　　　成员变量：被定义在类中的变量（后面会提到，这里有一个印象），随对象被new而产生，有默认值，整型是 0 ，小数型是0.0， 引用是 null， boolean是false ，其生命周期与对象生命周期相同

　　　　　　　　　　静态变量：静态变量也称作类变量，是被static修饰的变量，该变量属于类，一般有默认值（同成员变量初始化方式），其生命周期是与类的生命周期相同

　　　1.5 常量

　　　　　　　常量的定义： 所谓常量，就是值不变的量，一般使用final 来声明  ，这类常量被赋值一次就不能再被修改。

　　　　　　　声明方式  final 数据类型 常量名 = 值；   注意  一般的常量要求字母全部大写，并且字母与字母之间使用下划线链接

　　　　　　

 public class Varible {

     public static void main(String[] args) {
         //声明一个常量
         final double PI = 3.1415926D;

         错误的 ： PI = 2.0; // 如果再次修改就会产生错误
     }

 }

2. 变量的操作

　　　2.1 赋值操作（类型转换）

　　　　　　　2.1.1 变量赋值（进制问题）

　　　　　　　　　　变量在赋值时，默认都是十进制，但是java为了方便，还向我们提供了一些其他进制的赋值方式

　　　　　　　　　　（1） 直接书写  十进制赋值

　　　　　　　　　　（2） 0b 开头    二进制

　　　　　　　　　　（3） 0 开头      八进制

　　　　　　　　　　（4） 0X开头    十六进制

　　　　　　　　　　　　注意这里面的“0” 是数字零  不是字母o

　　　　　　　　　　　浮点数也可以使用科学计数法的赋值方式  其中幂次使用E指定

 public class Varible {

     public static void main(String[] args) {
         int a = 100; //直接书写  a的值是 100
         int b = 0b0110; //0b开头 代表二进制  b的值是 6
         int c = 011;  //0开头是八进制  c 的值是 9
         int d = 0x1A; //0X 开头是十六进制  d 的值是  26

         float e = (float)3E-2;  //3 * 10的负二次幂  0.03 （科学计数法默认double 需要强转float）
         double f = 3E3; //3 * 10 的3次幂  3000.0

         System.out.println(a+" "+b+ " "+c+" "+d+" "+e+" "+f);
     }

 }

　　　　　　　　　　前面已经说过变量的简单赋值，这里主要是想记录一下变量赋值时所遇到的类型转换问题，当变量进行计算或者相互赋值操作时可能会出现不通类型的数据相互转换的问题，先来了解一下显示转换与隐式转换

　　　　　　　2.1.2 显示转换与隐式转换

　　　　　　　　　　先来说一下隐式转换：一般是指小类型向大类型的转换（这里说的是容量，不是所占字节数），这是由于不会发生溢出或精度丢失的问题，编译器会自动为我们转换，称为隐式转换，是安全的。

　　　　　　　　　　再来说一下显示转换：显示转换还有一个名字叫做强制转换，是指在进行数据类型转换的时候可能会发生溢出或者精度丢失的问题，这是编译器并不能自动为我们进行转换，需要我们指定转换方式，注意，这可能会发生溢出或者精度丢失，

　　　　　　　　　　　　　　　　　　　　所以是不安全的。

　　　　　　　　　　强制转换的语法    目标变量 = （转换类型） 原变量；

 public class Varible {

     public static void main(String[] args) {
         //强制类型转换   目标变量 = （目标类型）原变量;
         int k = (int) 19999999999999999L;
     }

 }

　　　　　　　2.1.3位运算

　　　　　　　　　　java中提供位运算操作，就是对二进制位进行操作    这里简单记录，等用到再提

　　　　　　　　　　1. 左移运算  <<

　　　　　　　　　　2. 右移运算  >>

　　　　　　　　　　3.按位或      |

　　　　　　　　　　4.按位与     &

　　　　　　　　　　5.按位取反  ~

 public class Varible {

     public static void main(String[] args) {
         int a = 2;
         a = a << 1;  //左移一位   4
         System.out.println(a);
         a = a >> 1; //右移一位  2
         System.out.println(a);
         a = a |0;  //与0 或 值不变  2
         System.out.println(a);
         a = a & 0; //与0与 所有位置0  值为0
         System.out.println(a);
         a = ~a; //取反   值  -1 这里与不骂有关  有兴趣的同学可以查阅相关信息看看
         System.out.println(a);
     }

 }

　　　　　　　2.1.4 变量运算与运算规则

　　　　　　　　　　目前接触的变量运算与数学运算没有太大的区别 ， 有 加、减、乘、除、取余、 借助数学工具类还可以平方开方绝对值等（这些后续会专门讲解）

　　　　　　　　　　运算符号  ： 加  +  减  - 乘  *  除  /  取余 %   运算规则与数学运算规则相同 （也存在括号）

　　　　　　　　　　其中  取余数 也叫做取模

　　　　　　　　　　java中的运算规则：

　　　　　　　　　　1. 默认运算级别最低为int，byte  short 都会被自动提升到int进行运算，所以会出现  byte c = a+b ；编译出错的问题（假设a，b正确定义并且有值）。但注意  a = a+1；这种是不会被提升到int的；

　　　　　　　　　　2.运算操作数中有一个数是long类型，运算结果是long。

　　　　　　　　　　3.运算操作数中有float，则运算结果是float ，若运算操作数中有double则结果为double

　　　　　　　　　　4.以上三条互相干扰，也就是说，一个运算中，结果一般是和容量最大的操作数相同（若存在小数，则结果一定是个小数）

　　　　　　　　　　5.取余数操作的符号与被取余数的操作数符号相同 （即与取模符号左侧操作数同号）

　　　　　　　　2.1.5 自加运算及其区别

　　　　　　　　　　1.自加自减运算符  ++/--

　　　　　　　　　　2. 使用方式  ： 让a自加1  ：a++或++a    让a自减1  a--或 --a

　　　　　　　　　　3. ++a 与 a++ 的区别  ：

　　　　　　　　　　　　当二者独立的成为一条语句时，基本没有区别，如果非要说有区别，那就是++a要比a++效率快一点点

　　　　　　　　　　　　当二者作为一个算式嵌入到一个计算中  a++是先用当前值进行运算，运算完毕再自加1 ；++a是先自加一，然后再进行运算  （自减与其同理）

　　　　　　　　　　　　

 public class Varible {

     public static void main(String[] args) {
         int a = 4,b = 4;
         //单独成为一行语句 没有影响
         a++;
         ++b;
         System.out.println(a+" "+b);  // 5    5  此时ab都是5
         //后加  先运算再加
         System.out.println(a++*6); //
         System.out.println(a); //6
         //先加  先加再运算
         System.out.println(++b*6); //
         System.out.println(b); //
     }
 }

3. 逻辑运算符与比较运算

　　　3.1 比较运算符

　　　　　　　　1. 大于运算  ： >       2.小于运算：    <

　　　　　　　　3.等于运算   ： ==     4.不等于运算： !=

　　　　　　　　5.大于等于   ： >=     6.小于等于 ：   <=

　　　　　　　　说明： 大于等于和小于等于运算符 只要有一项满足条件就认为满足条件   例如  5 >=5 是正确的

　　　　　　　　所有的逻辑运算符都会返回一个boolean值。

 public class Varible {

     public static void main(String[] args) {
         System.out.println(1>2); //false
         System.out.println(1<2); //true
         System.out.println(5>=5); //true
         System.out.println(5<=5); //true
         System.out.println(5==5);//true
         System.out.println(5!=5);//false
     }
 }

　　　3.2 逻辑运算

　　　　　　　　1.逻辑短路与   &&  之所以叫做逻辑短路与，是因为该运算符只要得到整个表达式的值，就不会再继续向后计算。

　　　　　　　　2.逻辑短路或    ||   之所以叫做逻辑短路或，是因为该运算符只要得到整个表达式的值，就不会再继续向后计算。

　　　　　　　　3.逻辑与 & 这个与位运算中的与是相同的，要将整个算式计算完毕之后才会得出结果。

　　　　　　　　4.逻辑或 |  这个与位运算中的与是相同的，要将整个算式计算完毕之后才会得出结果。

　　　　　　　　5.逻辑非 ！ 也叫逻辑取反 如果值为true 取反值为false  如果值为false 取反值为true。

　　　　　　　　注意分辨逻辑短路与逻辑的区别。

　　　　　　　　

 public class Varible {

     public static void main(String[] args) {
         int a = 5,b = 5;
         boolean bl1 = (a==5||++b==100);
         System.out.println(a+" "+b); //5   5   短路或 ++b并没有被运算

         a = 5;
         b = 5;
         boolean bl2 = (a==5|++b==100);
         System.out.println(a+" "+b); //5   6   逻辑或 ++b每一项都运算
     }
 }

4. 补充知识 字符串与算式的连接

　　　　当字符串与数值或算式进行连接时，若字符串在前，则后面的算式中的+号会被视为连接符（其他符号不会），若字符串在后，则算式会被算出来一个值，然后与字符串进行连接。

 public class Varible {

     public static void main(String[] args) {
         System.out.println("a"+1+2*3+1); //a161 (乘法不受影响)
         System.out.println(1+2*3+1+"a");//8a
     }
 }

　　　　浮点数运算是会丢失一部分精度的，看下面的例子：

 public class Varible {

     public static void main(String[] args) {
         float f1 = 333333333f;
         float f2 = f1+1;  //f1 加一赋值给 f2
         System.out.println(f1==f2); //true  精度问题
     }
 }

　　　　所以进行小数运算时保证精度可以使用BigDecimal类