变量，作用域，运算符

变量，作用域，运算符

1. 变量

1.1 变量定义格式【重点】

格式:
	数据类型 变量名 = 初始化数据;

数据类型:
	明确当前变量可以保存的数据类型是什么
	例如：
		数据类型为char类型，当前变量，有且只能保存字符类型
		数据类型为int类型，当前变量，有且只能保存一定范围以内的整数类型
		【数据类型一致化要求】

变量名:
	要求符合AJCG命名规范。见名知意，动宾结构
	变量名是操作当前变量使用的一个名称，具有一定范围以内的唯一性。
	变量名保存程序运行过中，赋值给变量的数据

=:
	赋值号 将赋值号右侧的数据，赋值给左侧的【变量】。

初始化数据:
	需要对应当前数据类型，赋值当前程序要求初始化数据。

1.2 变量定义代码演示

class Demo1 {
	public static void main(String[] args) {
		/* 整型变量 */
		byte byteNumber = 10;
		short shortNumber = 20;
		int intNumber = 30;
		long longNumber = 40L;
		
		System.out.println(byteNumber);
		System.out.println(shortNumber);
		System.out.println(intNumber);
		System.out.println(longNumber);
		
		/* 浮点型变量 */
		float floatNumber = 5.5F;
		double doubleNumber = 3.14;
		
		System.out.println(floatNumber);
		System.out.println(doubleNumber);
		
		/* 字符类型变量 */
		char ch1 = 'A';
		char ch2 = '我';
		
		System.out.println(ch1);
		System.out.println(ch2);
		
		/* 布尔类型 ret ==> result 结果 */
		boolean ret1 = true;
		boolean ret2 = false;
		
		System.out.println(ret1);
		System.out.println(ret2);
	}
}

1.3 变量定义过程中的问题

1.3.1 浮点常量默认数据类型

Demo1.java:15: 错误: 不兼容的类型: 从double转换到float可能会有损失
                float floatNumber = 5.5;
                                    ^
1 个错误

	在计算机中，计算机为了保证数据的精度问题，所有的常量浮点类型数据，都看作是double类型。double数据类型占用内存空间是8个字节，float占用4个。这里因为数据类型不一致，导致报错。我们需要告知编译器，当前浮点类型常量数据类型为float类型。
	在常量之后加上大写 F 
	float floatNumber = 5.5F;

1.3.2 long整数数据赋值建议

	在开发中，整数默认的采用的形式都是int类型。赋值给long类型变量，是可以执行，没有报错。但是为了数据类型一致化要求，我们可以告知编译器，当前常量为long类型
	在常量之后加入一个大写 L
	long longNumber = 40L;

1.3.3 字符类型常量有且只能使用字符本身

1.3.4 Java中变量未初始化不能使用

int num;

System.out.println(num);

Demo1.java:38: 错误: 可能尚未初始化变量num
                System.out.println(num);
                                   ^
1 个错误

	num定义之后并没有进行赋值操作。当前num中保存的数据，对于Java程序而言是无效的，无法明确当前num保存的数据内容是什么。Java通过编译器提示，避免了【野值】问题。
	Java中的一个变量未赋值的情况下，不得参与其他代码执行操作。

1.3.5 找不到符号问题

1. 当前使用的变量未定义！！！
	Java中变量未定义不能使用。
2. 变量名/方法名 拼写错误

1.3.6 浮点数拓展

银行业务使用float还是double？ 应该使用BigDecimal类表示

float f1 = 0.1F;
double d1 = 1.0/10;

System.out.println(f1); // 输出结果 0.1
System.out.println(d1); // 输出结果 0.1
System.out.println(d1 == f1); // 输出结果 false

float f2 = 34561321651231F;
float f3 = f2 + 1;

System.out.println(f2 == f3); // 输出结果 true

1.3.7 字符拓展

char c1 = 'a';
        char c2 = '中';

        System.out.println(c1); // 输出结果 a
        System.out.println((int)c1); // 输出结果 97

        System.out.println(c2); // 输出结果 中
        System.out.println((int)c2); // 输出结果 20013
// 所有字符本质还是数字  编码 Unicode
        char c3 = '\u0061';
        System.out.println(c3); // 输出结果 a

1.3.8 new对象跟直接创建对象区别

String s1 = "95827";
String s2 = "95827";

System.out.println(s1 == s2); // 输出结果 true

String s3 = new String("95827");
String s4 = new String("95827");
    
System.out.println(s3 == s4); // 输出结果 false
// jvm在堆区为对象分配完内存后，产生一个引用指向这个对象在内存中的地址
// s3、s4实际是引用对象的地址 (有new就有堆，每次new都创建一个新的对象，不论对象的值是否相等)

1.3.9 类型转换

int a = 128;
byte b = (byte)a;

System.out.println(a); // 输出结果 128
System.out.println(b); // 输出结果 -128
// 二进制128 ：10000000
   // Java中：1表示符号位（为1时正数，0代表负数）后七位表示数值

System.out.println((int)23.8); // 输出结果 23
System.out.println((int)-23.72); // 输出结果 -23
// 强制类型转换可能会丢失精度

类型转换：强制装换（高到低）   自动转换（低到高）    

1.4 变量作用域

/*
类变量
实例变量
局部变量
*/
public class Test {

    static int anInt = 18; // 类变量（全局变量）

    int a; // 实例变量:从属于对象，不初始化值为默认值

    public static void main(String[] args) {
       //  test--> Test类的对象
        Test test = new Test();

        System.out.println(test.a);// 输出结果为0
        // 类变量
        System.out.println(test.anInt);// 输出结果为18
    }
    public void method() {
        int a = 18; // 局部变量:必须声明和初始化值
    }
}
// 默认值：boolean: 默认false
// int short long float double 默认为0
// 除了基本类型，其他类型都为null

2. 运算符

补充：转义字符

对于字符使用，有且只允许使用【字符本身】，不允许使用对应编码值
	转义字符：
		\" 		// 表示斜杠后的"
		\' 		// 表示斜杠后的'
		\\ 		// 表示斜杠后的\
		\\\\ 	// 表示斜杠后的\，相当于两个\\ 	
		\n		// 换行
    	\t		// 一个制表符

2.1 算术运算符

数学中
	+ - × ÷ ()
	注意事项:
		1. 先乘除，后加减
		2. 有括号先处理括号里面的内容
		3. 从左至右计算内容
		4. 除数不能为0

开发中
	+ - * / % () =
	% 取余[只能操作整数]
	5 ÷ 2 = 2 ... 1 商为 2 余数为 1 取余操作需要的结果为1
		10 % 12 ==> 10
		5 % 4 ==> 1
		6 % 2 ==> 0
		4 % 5 ==> 4
	
优先级问题:
	在运算过程中，如果出现了优先级问题，简单粗暴加括号

/* 算术运算符演示 */
class Demo2 {
	public static void main(String[] args) {
		int num1 = 20;
		int num2 = 30;
		
		num1 = num1 + num2; // num1 = 50 num2 = 30
		num1 = num1 * num2; // num1 = 1500 num2 = 30
		num1 = num1 - num2; // num1 = 1470 num2 = 30
		num1 = num1 / num2; // num1 = 49 num2 = 30
		num1 = num1 % num2; // num1 = 19 num2 = 30
		
		System.out.println("num1 : " + num1);
		System.out.println("num1 : " + num2);
	}
}

public class test {
    public static void main(String[] args) {

        long a = 7894564321L;
        int b = 123456;
        short c = 123;
        byte d = 10;
// 数值提升，运算时有高类型结果向上提升
        System.out.println(a + b + c + d); // 输出结果为 7894687910 long类型
        System.out.println(b + c + d); // 输出结果为 123589 int类型
        System.out.println(c + d); // 输出结果为 133 int类型
    }
}

2.2 自增自减运算符

格式:
	++ --
	1. 自增自减运算符，有且只能操作变量
	2. ++ 自增操作，当前变量数据 + 1 -- 自减操作，当前变量数据 - 1

基本的语法
	在变量之后，首先取出当前变量数据，参与当前行代码执行，然后在执行自增/自减操作
	在变量之前，首先执行自增/自减操作，然后当前变量再来参与当前代码行执行

【来自16岁程序员的建议】
	使用 += 1 替代++ 
	使用 -= 1 替代--
	来自 Swift iOS开发语言
	自增自减运算符单独成行
	
	【补充知识点】
		+= -= *= /= %=
		num1 = num1 + 10; ==> num1 += 10; 

1. 
	int num = 5;
	int ret = num++ * ++num;
	
	num = 7
	ret = 35
	num++ * ++num
		num++ : 5 num ==> 6
		++num : num ==> 7 7
        5 * 7
	
2. 
	int num = 5;
	++(num++)++;
	
	num = ?
	编译错误
	自增自减运算符，有且只能操作变量
	(num++) 对于整个代码运行过程中,(num++)对外是一个整体，可以看做是一个常量，已经不再是操作num内容
	
	int num = 10;
	++num;
	num++;

2.3 关系运算符

数学中:
	> < ≥ ≤ ≠ =

开发中的关系运算符:
	> < >= <= != ==
	关系运算符判断表达式两边的数据是否满足关系运算符要求，如果满足返回true，不满足返回false

/* 关系运算符演示 */
class Demo4 {
	public static void main(String[] args) {
		boolean ret = 5 > 3;
		System.out.println("ret : " + ret);
		
		ret = 5 < 3;
		System.out.println("ret : " + ret);
		
		ret = 5 >= 5;
		System.out.println("ret : " + ret);
		
		ret = 5 <= 10;
		System.out.println("ret : " + ret);
		
		ret = 5 != 5;
		System.out.println("ret : " + ret);
		
		ret = 5 == 5;
		System.out.println("ret : " + ret);
	}
}

补充：

Java的Math类封装了很多与数学有关的属性和方法。 例如: 幂运算等

2.4 逻辑运算符

与
	&&
	同真为真，有假【即】假
	银行保险柜 需要保险柜持有者和管理员同时在场 才可以打开
或
	||
	有真【即】真，同假为假
	自己家门，只要有人带有钥匙，就可以回家
非
	!
	取反 

/* 逻辑运算符 */
class Demo5 {
	public static void main(String[] args) {
		boolean ret = 5 > 3 && 5 > 2;
		System.out.println("ret : " + ret);
		
		ret = 5 > 10 && 5 > 2;
		System.out.println("ret : " + ret);
		
		ret = 5 > 20 || 5 > 2;
		System.out.println("ret : " + ret);
		
		ret = 5 > 20 || 5 > 30;
		System.out.println("ret : " + ret);
		
		ret = !(5 > 3);
		System.out.println("ret : " + ret);
		
		ret = !(5 < 3);
		System.out.println("ret : " + ret);
	}
}

**位运算：>> --> /2， 相当于除二 << --> *2 ,相当于乘二 **

2.5 计算时内存溢出

		int a = 10_0000_0000; // jdk7新特性数字可以加下划线表示
        int b = 30;
        int total = a * b; // 内存溢出
        long total1 = a * b; 

        System.out.println(total); // 结果 -64771072
        System.out.println(total1); //   结果 -64771072    a,b 类型都为int，计算后还为int类型，转换之前已经存在问题

		long total2 = a *(long)b;
		long total3 = (long)a * b;
		System.out.println(total2); // 结果为 30000000000
        System.out.println(total3); // 结果为 30000000000

2.6 小练习

条件完成
	1. 字符类型变量是否英文字符
		char ch;
		'A' <= ch <= 'Z' 开发中无法使用
		ch >= 'A' && ch <= 'Z' 大写字母条件
		ch >= 'a' && ch <= 'z' 小写字母条件
		(ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z')
		
	2. 字符类型变量是否是数字字符
		char ch 
		ch >= '0' && ch <= 9
	
	3. 闰年条件
		能被4整数，但是不能被100整除，或者能被400整除
		int year
		year % 4 == 0;
		year % 100 != 0
		year % 400 == 0
		
		(year % 4 == 0 && year % 100 != 0) || year % 400 == 0
	
	4. 
		int num = 5;
		boolean ret = 10 < 5 && ++num > 2;
		ret = ?
		num = ?
	
	5. 
		int num = 5;
		boolean ret = 10 > 5 || ++num > 2;
		ret = ?
		num = ?

2.6 短路原则

int num = 5;
boolean ret = 10 < 5 && ++num > 2;
ret = false
num = 5
同真为真，有假【即】假
逻辑与短路原则:
	10 < 5 && ++num > 2; 
	10 < 5 不成立，为false，当前整个逻辑与表达式结果已经明确为false。计算机为了节约系统资源，提供运行效率，从false条件开始，之后的表达式都不在运行。++num > 2是没有执行的，无效代码。
	
int num = 5;
boolean ret = 10 > 5 || ++num > 2;
ret = true
num = 5
有真【即】真，同假为假
逻辑或短路原则:
	10 > 5 || ++num > 2; 
	10 > 5 成立，为true，当前整个逻辑或表达式结果明确为true，从true条件开始，之后的内容不再执行。++num > 2没有执行，无效代码。