Java基础：变量，常量、运算符

变量（variable）

    变量是什么：就是可以变化的量！

    我们通过变量来操纵存储空间中的数据，变量就是指代这个存储空间！空间位置是确定的，但是里面放置什么值不确定！ 打个比方：

    这就好像我们家里有一个大衣柜，里面有十分多的小格子，我们给格子上贴上标签，放衣服，放鞋子，放手表等等，此时我们知道了哪里该放什么，但是，我们并不知道里面到底放的是什么牌子的鞋子，是衣服还是裤子。那个标签就相当于我们的变量，我们给他起了个名字，但是里面要放什么需要我们自己去放。

    Java是一种强类型语言，每个变量都必须声明其类型。

    Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

    变量在使用前必须对其声明, 只有在变量声明以后，才能为其分配相应长度的存储单元，声明格式为：

type varName  [=value] [{,varName[=value]}] ；
//数据类型  变量名 = 值；可以使用逗号隔开来声明多个同类型变量。

    注意事项：

• 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
• 变量名必须是合法的标识符。
• 变量声明是一条完整的语句，因此每一个声明都必须以分号结束

    【演示】

int a, b, c;         // 声明三个int型整数：a、 b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22;         // 声明并初始化 z
String s = "runoob";  // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x';        // 声明变量 x 的值是字符 'x'。

    【编码规范】

    虽然可以在一行声明多个变量，但是不提倡这个风格，逐一声明每一个变量可以提高程序可读性。

变量作用域

    变量根据作用域可划分为三种：

• 类变量（静态变量： static variable）：独立于方法之外的变量，用 static 修饰。
• 实例变量（成员变量：member variable）：独立于方法之外的变量，不过没有 static 修饰。
• 局部变量（lacal variable）：类的方法中的变量。

public class Variable{
    static int allClicks=0;    // 类变量
    String str="hello world";  // 实例变量
 
    public void method(){
        int i =0;  // 局部变量
    }
}

    局部变量

---

    方法或语句块内部定义的变量。生命周期是从声明位置开始到”}”为止。

    在使用前必须先声明和初始化(赋初值)。

    局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

public static void main(String[] args) {
    int i;
    int j = i+5 ; // 编译出错，变量i还未被初始化
    System.out.println(j);
}

    修改为：

public static void main(String[] args) {
    int i=10;
    int j = i+5 ; 
    System.out.println(j);
}

    实例变量

---

    方法外部、类的内部定义的变量。

    从属于对象，生命周期伴随对象始终。

    如果不自行初始化，他会自动初始化成该类型的默认初始值

    （数值型变量初始化成0或0.0，字符型变量的初始化值是16位的0，布尔型默认是false）

public class Test {
    // 这个实例变量对子类可见
    public String name;
    // 私有变量，仅在该类可见
    private double salary;
    ...
}

    静态变量

---

    使用static定义。

    从属于类，生命周期伴随类始终，从类加载到卸载。

    (注：讲完内存分析后我们再深入！先放一放这个概念！)

    如果不自行初始化，他会自动初始化成该类型的默认初始值

    （数值型变量初始化成0或0.0，字符型变量的初始化值是16位的0，布尔型默认是false）

public class Employee {
    //salary是静态的私有变量
    private static double salary;
    // DEPARTMENT是一个常量
    public static final String DEPARTMENT = "开发人员";
    public static void main(String[] args){
        salary = 10000;
        System.out.println(DEPARTMENT+"平均工资:"+salary);
    }
}

常量

    常量(Constant)：初始化(initialize)后不能再改变值！不会变动的值。

    所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

final 常量名=值;
final double PI=3.14; final String LOVE="hello";

    常量名一般使用大写字符。
    程序中使用常量可以提高代码的可维护性。例如，在项目开发时，我们需要指定用户的性别，此时可以定义一个常量 SEX，赋值为 “男”，在需要指定用户性别的地方直接调用此常量即可，避免了由于用户的不规范赋值导致程序出错的情况。

变量的命名规范

1. 所有变量、方法、类名：见名知意
2. 类成员变量：首字母小写和驼峰原则 : monthSalary
3. 局部变量：首字母小写和驼峰原则
4. 常量：大写字母和下划线：MAX_VALUE
5. 类名：首字母大写和驼峰原则: Man, GoodMan
6. 方法名：首字母小写和驼峰原则: run(), runRun()

运算符

    运算符operator

    Java 语言支持如下运算符：

• 算术运算符: +，-，*，/，%，++，–
• 赋值运算符 =，+=，-=，*=，/=
• 关系运算符: >，<，>=，<=，==，!= instanceof
• 逻辑运算符: &&，||，!
• 位运算符: &，|，^，~ ， >>，<<，>>> (了解！！！)
• 条件运算符 ？：

二元运算符

    两个操作数，来看看我们小时候的数学运算；

public static void main(String[] args) {
    int a = 10;
    int b = 20;
    int c = 25;
    int d = 25;
    System.out.println("a + b = " + (a + b) );
    System.out.println("a - b = " + (a - b) );
    System.out.println("a * b = " + (a * b) );
    System.out.println("b / a = " + (b / a) );
}

    整数运算

    如果两个操作数有一个为Long, 则结果也为long

    没有long时，结果为int。即使操作数全为shot,byte，结果也是int.

public static void main(String[] args) {
    long a = 1231321311231231L;
    int b = 1213;
    short c = 10;
    byte d = 8;

    System.out.println((a+b+c+d));  //Long类型
    System.out.println((b + c + d));//Int类型
    System.out.println((c + d));//Int类型
}

    浮点运算

    如果两个操作数有一个为double, 则结果为double.

    只有两个操作数都是float, 则结果才为float.

public static void main(String[] args) {
    float a = 3.14565F;
    double b = 3.194546464;
    float c = 1.3123123F;

    System.out.println(a+b); //double类型
    System.out.println(b+c); //double类型
    System.out.println(a+c); //float类型
}

    关系运算符

    返回布尔值！

取模运算

    就是我们小学的取余；5%3 余 2

    其操作数可以为浮点数,一般使用整数。如：5.9%3.9=2.000000004

    要点：

    负数%负数＝负数；
    负数%正数＝负数；
    正数%负数＝正数；

public static void main(String[] args) {
    System.out.println(9 % 4); //1
    System.out.println(-9 % -4); //-1
    System.out.println(-10 % 4); //-2
    System.out.println(9 % -4); //1
}

    【注：一般都是正整数运算，进行结果的判断！】

一元运算符

    自增（++）自减（–）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数，分为前缀和后缀两种。

public static void main(String[] args) {
    int a = 3;
    int b = a++;   //执行完后,b=3。先给b赋值，再自增。
    int c = ++a;   //执行完后,c=5。先自增,再给b赋值
}

    注意：java中的乘幂处理

public static void main(String[] args) {
    int a = 3^2;    //java中不能这么处理， ^是异或符号。
    double b = Math.pow(3, 2);
}

    Math类提供了很多科学和工程计算需要的方法和常数。特殊的运算都需要运用到方法!

逻辑运算符

    逻辑与：&&和&，逻辑或：||和|，逻辑非：！。

    【演示】

public static void main(String[] args) {
    boolean a = true;
    boolean b = false;
    System.out.println("a && b = " + (a&&b));
    System.out.println("a || b = " + (a||b) );
    System.out.println("!(a && b) = " + !(a && b));
}

    逻辑与和逻辑或采用短路的方式。从左到右计算，如果确定值则不会再计算下去。在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。

    逻辑与只要有一个为false, 则直接返回false.

    逻辑或只要有一个为true, 则直接返回true;

    【演示】

public static void main(String[] args){
    int a = 5;//定义一个变量；
    boolean b = (a<4)&&(a++<10);
    System.out.println("使用短路逻辑运算符的结果为"+b);
    System.out.println("a的结果为"+a);
}

    解析： 该程序使用到了短路逻辑运算符(&&)，首先判断 a<4 的结果为 false，则 b 的结果必定是 false，所以不再执行第二个操作 a++<10 的判断，所以 a 的值为 5。

赋值运算符

public static void main(String[] args) {
    int a=10;
    int b=20;

    a+=b; // a = a + b

    System.out.println(a+":"+b);
}

字符串连接符

    “+” 运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将另一个操作数转换为字符串然后再进行连接。

//字符串
String s1="Hello 中文!";
String s2=1+"";  //转换成String
//int
int c = 12;
System.out.println("c=" + c);

三目条件运算符

    三目条件运算符，语法格式：

x ? y : z

    其中x为boolean类型表达式，先计算x的值，若为true，则整个三目运算的结果为表达式y的值，否则整个运算结果为表达式z的值。

    【演示】

public static void main(String[] args) {
    int score = 80;
    String type = score < 60 ? "不及格" : "及格";
    System.out.println("type= " + type);
}

    三元运算符在真实开发中十分的常见，大家可以多练习使用，之后我们会讲解分支语句，可以利用三元运算符做到更加精简代码！便于理解！

运算符优先级

    我们小学都学过：先加减，后乘除，所以优先级我们并不陌生。

    当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中，运算符优先级不同会导致最后得出的结果差别甚大。

    下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。

    大家不需要去刻意的记住，表达式里面优先使用小括号来组织！！方便理解和使用，不建议写非常冗余的代码运算！

public static void main(String[] args) {
    boolean flag = 1<4*5&&122>3||'q'+3<5;
    System.out.println(flag);
}