java基础_0204：运算符

掌握Java中标识符的定义；
掌握Java中数据类型的划分以及基本数据类型的使用原则；
掌握Java运算符的使用；
掌握Java分支结构、循环结构、循环控制语法的使用；
掌握方法的定义结构以及方法重载的概念应用。

Java中的注释

// 注释：单行注释；
/* ... */'：多行注释；
/** ... */：文档注释。

Java中的关键字

Java基本数据类型的大小、范围、默认值

No.|数据类型|大小/位|可表示的数据范围|默认值
----|------|--------|------|----|----|----|
1|byte（字节）|8|-128 ~ 127|0
2|short（短整型）|16|-32768~32767|0
3|int（整型）|32|-2147483648 ~ 2147483647|0
4|long（长整型）|64|-9223372036854775808 ~ 9223372036854775807|0
5|float（单精度）|32|-3.4E38（-3.41038） ~ 3.4E38（3.41038）|0.0
6|double（双精度）|64|-1.7E308（-1.710308）~ 1.7E308（1.710308）|0.0
7|char（字符）|16|0 ~ 255|'\u0000'
8|boolean（布尔）|-|true或false|false

int型常量转换为long型常量，使用“数字L”、“数字l（小写的字母L）”完成；
int型变量转换为long型变量，使用“(long) 变量名称”
将int型变量变为double型变量:(double) 变量名称

类型强转：(目标数据类型) 变量

public class TestDemo {
	public static void main(String args[]) {
		int max = Integer.MAX_VALUE; 	// 取出最大值
		int min = Integer.MIN_VALUE; // 取出最小值
		// int变量 ± long型常量 = long型数据
		System.out.println(max + 1L); // 最大值加1：2147483648
		System.out.println(min - (long) 1); // 最小值减1：-2147483649
		// long变量 ± int型常量 = long型数据
		System.out.println((long) min - 2); // 最小值减2：-2147483650
	}
}
程序执行结果：
2147483648（“System.out.println(max + 1L)”语句输出）
-2147483649（“System.out.println(min - (long) 1)”语句输出）
-2147483650（“System.out.println((long) min - 2)”语句输出）

字符可以和int型互相转换（以编码的形式出现）

public class TestDemo {
	public static void main(String args[]) {
		char c = 'A' ;	// 字符
		int num = c ;// 字符可以和int型互相转换（以编码的形式出现）
		System.out.println(c) ;
		System.out.println(num) ;
	}
}
程序执行结果：

A（“System.out.println(c)”语句输出）
65（“System.out.println(num)”语句输出）

public class TestDemo {
	public static void main(String args[]) {
		char c = 'A'; 	// 大写字母
		int num = c; 	// 需要将字符变为int型才可以使用加法计算
		num = num + 32; 	// 变为小写字母的编码
		c = (char) num; 	// 将int变为char型
		System.out.println(c);
	}
}

程序执行结果：	a

布尔型

布尔型是一种逻辑结果，主要保存两类数据：true、false，这类数据主要用于一些程序的逻辑使用上。

public class TestDemo {
	public static void main(String args[]) {
		boolean flag = false ;	// 布尔只有两种取值：true、false
		if (!flag) {	// if(布尔值) {满足条件的操作}
			System.out.println("Hello World .") ;
		}
	}
}
程序执行结果：
Hello World .

String型

String属于引用数据类型（它属于一个类，在Java里面只要是类名称，每一个单词的首字母都是大写的），但是这个类的使用比较特殊。
String表示的是一个字符串，即：多个字符的集合，String要求使用双引号“"”声明其内容。

public class TestDemo {
	public static void main(String args[]) {
		String str = "Hello World !"; 	// 字符串变量
		System.out.println(str);		// 输出字符串变量
		System.out.println("Hello World !"); 	// 输出字符串常量
	}
}
程序执行结果：
Hello World !
Hello World !

字符串连接

在字符串的操作中，如果要改变内容，则可以使用“+”进行字符串的连接操作。

public class TestDemo {
	public static void main(String args[]) {
		String str = "Hello";
		str = str + " World "; 		// 字符串连接
		str += "!!!"; 		// 字符串连接
		System.out.println(str);
	}
}
程序执行结果：
Hello World !!!

运算符

Java运算符（1）

关系运算符

关系运算符的主要功能是进行数据的大小关系比较，返回的结果是boolean型数据（只有true、false两种取值），常用的关系运算符有：大于（>）、大于等于（>=）、小于（<）、小于等于（<=）、等于（==）、不等于（!=）。

public class TestDemo {
	public static void main(String args[]) {
		System.out.println("3 > 1 = " + (3 > 1));	// 使用大于号
		System.out.println("3 < 1 = " + (3 < 1));	// 使用小于号
		System.out.println("3 >= 1 = " + (3 >= 1));	// 使用大于等于号
		System.out.println("3 <= 1 = " + (3 <= 1));	// 使用小于等于号
		System.out.println("3 == 1 = " + (3 == 1));	// 使用等于号
		System.out.println("3 != 1 = " + (3 == 1));	// 使用不等于号
	}
}

程序执行结果：	
3 > 1 = true
3 < 1 = false
3 >= 1 = true
3 <= 1 = false
3 == 1 = false
3 != 1 = false

数学运算符

数学运算符是在开发之中经常使用到的，例如，进行四则运算、求模、自增等。

public class TestDemo {
	public static void main(String args[]) {
		int numA = 10;
		int numB = 20;
		System.out.println("加法计算：" + (numA + numB));
		System.out.println("减法计算：" + (numA - numB));
		System.out.println("乘法计算：" + (numA * numB));
		System.out.println("除法计算：" + (numA / (double) numB));
	}
}

程序执行结果：	加法计算：30
减法计算：-10
乘法计算：200
除法计算：0.5

模运算

“模”也是在开发之中较为常见的计算，所谓的“模”实际上就是余数的概念，例如：10 ÷ 3的结果是商3余1，其中余数1就是“模”，对于求模，可以使用“%”运算符。

public class TestDemo {
	public static void main(String args[]) {
		int numA = 10;
		int numB = 3;
		System.out.println(numA % numB);
	}
}

程序执行结果：	1

简化运算符

虽然Java提供了四则运算操作，但是为了简化用户的编写，在运算符里面又提供了一些简化运算符：*=、/=、+=、-=、%=，这些运算符表示参与运算后直接进行赋值操作

public class TestDemo {
	public static void main(String args[]) {
		int num = 10;
		num *= 2; 		// 等价：num = num * 2 ;
		System.out.println(num);
	}
}

程序执行结果：	20

自增与自减运算

还有一类运算符是“++”（自增）、“--”（自减），它根据位置不同，执行的顺序也不同；
++变量、--变量：先在前面表示的是先进行变量内容的自增1或自减1之后再使用变量进行数学计算；
变量++、变量--：先使用变量内容进行计算，而后再实现自增或自减的操作。

观察自增一

public class TestDemo {
	public static void main(String args[]) {
		int numA = 10;			// 定义整型变量
		int numB = 20;			// 定义整型变量
		// “++”写在变量前面，表示先对numA的变量内容加1
		// 使用处理后的numA变量的内容 + numB变量的内容
		int result = ++numA + numB;
		System.out.println("numA = " + numA);
		System.out.println("result = " + result);
	}
}

程序执行结果：
numA = 11
result = 31

观察自增二

public class TestDemo {
	public static void main(String args[]) {
		int numA = 10; 			// 定义整型变量
		int numB = 20; 			// 定义整型变量
		// “++”写在后面，表示先使用numA的内容进行加法计算
		// 加法计算完成之后在对numA的内容进行自增
		int result = numA++ + numB;
		System.out.println("numA = " + numA);
		System.out.println("result = " + result);
	}
}
程序执行结果：	
numA = 11
result = 30

三目运算

三目是一种赋值运算的形式，执行三目的时候可以以一个布尔表达式的结果进行赋值，基本的语法结构如下：
数据类型 变量 = 布尔表达式 ? 满足此表达式时设置的内容 : 不满足此表达式时设置的内容 ;

public class TestDemo {
	public static void main(String args[]) {
		int numA = 10;	// 定义int型变量
		int numB = 20;	// 定义int型变量
		// 如果numA大于numB，返回true，则将numA的内容赋值给max
		// 如果numA小于numB，返回false，则将numB的内容赋值给max
		int max = numA > numB ? numA : numB;
		System.out.println(max);
	}
}
程序执行结果：	20

逻辑运算

逻辑运算一共包含三种：与（多个条件一起满足）、或（多个条件有一个满足）、非（使用“!”操作，可以实现true变false与false变true的结果转换），而与和或操作的真值表

No.	条件1	条件2	与	或
1	true	true	true	true
2	true	false	false	true
3	false	true	false	true
4	false	false	false	false

非运算

public class TestDemo {
	public static void main(String args[]) {
		boolean flag = true;		// 定义布尔型变量
		System.out.println(!flag);	// 对变量结果进行非操作
	}
}

程序执行结果：	false

观察普通与“&”

public class TestDemo {
	public static void main(String args[]) {
		if ((1 == 2) & (10 / 0 == 0)) {// 使用普通与判断多个条件
			System.out.println("Hello World !");
		}
	}
}

程序执行结果：
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at com.xusan.TestDemo.main(TestDemo.java:5)

使用短路与（&&）

public class TestDemo {
	public static void main(String args[]) {
		if ((1 == 2) && (10 / 0 == 0)) {
			System.out.println("Hello World !");
		}
	}
}

没有输出，不抛出错误，“&&”执行前面的语句，为假则不执行后面的语句

观察普通或操作（|）

public class TestDemo {
	public static void main(String args[]) {
		if ((1 == 1) | (10 / 0 == 0)) {
			System.out.println("Hello World !");
		}
	}
}
程序执行结果：	
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at TestDemo.main(TestDemo.java:3)

观察短路或操作（||）

public class TestDemo {
	public static void main(String args[]) {
		if ((1 == 1) || (10 / 0 == 0)) {
			System.out.println("Hello World !") ;
		}
	}
}
程序执行结果：	Hello World !

位运算

位运算在Java之中存在：&、|、^、~、>>、<<、>>>，而所有的位运算都是采用二进制数据进行操作的，基本的二进值数据操作结果如表所示。

实现位与操作

public class TestDemo {
	public static void main(String args[]) {
		int numA = 9;		// 定义整型变量
		int numB = 11;			// 定义整型变量
		System.out.println(numA & numB);	// 位与操作 
	}
}
程序执行结果：	9

实现位或操作

public class TestDemo {
	public static void main(String args[]) {
		int numA = 9;	// 定义整型变量
		int numB = 11;	// 定义整型变量
		System.out.println(numA | numB);// 位或操作 
	}
}
程序执行结果：	11