02）高淇java300集学习笔记

最新推荐文章于 2022-02-23 13:42:51 发布

common77zwq

最新推荐文章于 2022-02-23 13:42:51 发布

阅读量2.1k

点赞数 5

分类专栏： Java 文章标签： java eclipse idea jdk

本文链接：https://blog.csdn.net/common77zwq/article/details/81988676

版权

Java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

java基础一

java标识符
java注释
java关键字/保留字
变量
常量
数据类型
运算符

目标

熟知java标识符命名规范
熟知java三种注释
了解java关键字
熟知什么是变量，变量分类有哪几种，变量赋值，使用
熟知知道常量的定义，用法
熟知并掌握数据类型的分类及使用
熟练掌握运算符的使用及优先级

java标识符命名规范

标识符定义：用于给包，类，变量，方法进行命名
标识符规范：首字符（字母、$、 _） + 其它字符（字母、 $、 _ 、数字）
注意：
1. ）标识符也可以是汉字，因为java不采用通常语言使用的ASCII字符集，而是采用Unicode这样标准的固有字符集，但是不建议使用汉字
2. ）标识符严格区分大小写，a和A是两个不同的标识符，且标识符长度无限制
3. ）标识符不能是java关键字
4. ）class修饰的标识符第一个单词首字符大写，其它字符小写,第二个单词同样首字符大写，其它字符小写，如 CommonUtils.class (通用工具类)
5. ）变量和方法的标识符采用驼峰命名格式：第一个单词小写，第二个单词首字符大写，如stuName,setAge，findPerson()

科普：

Unicode（统一码，万国码，单一码）是计算机科学领域里的一项业界标准，包括字符集、编码方案等。Unicode 是为了解决传统的字符编码方案的局限而产生的，它为每种语言中的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本转换、处理的要求。1990年开始研发，1994年正式公布。

ASCII字符集：最早的计算机在设计时采用8个比特（bit）作为一个字节（byte），所以，一个字节能表示的最大的整数就是2^8=255（二进制11111111=十进制255），0 - 255被用来表示大小写英文字母、数字和一些符号，这个编码表被称为ASCII编码

示例代码

/**
 * 标识符：用于给包，类，变量，方法进行命名
 * 标识符规范：
 * 			首字符（字母 $ _）	+ 	其它字符（字母 $ _ 数字）
 * 注意：
 * 		1.标识符也可以是汉字，因为java不采用通常语言使用的ASCII字符集，而是采用Unicode这样标准的固有字符集，但是不建议使用汉字
 * 		2.标识符严格区分大小写，a和A是两个不同的标识符，且标识符长度无限制
 * 		3.标识符不能是java关键字
 * 		4. class修饰的标识符首字符大写，其它字符小写
 * 		5. 变量和方法的标识符采用驼峰命名格式：第一个单词小写，第二个单词首字符大写，如stuName,setAge，findPerson()
 * 
 * 科普：
 * 		
 * 		Unicode（统一码，万国码，单一码）是计算机科学领域里的一项业界标准，包括字符集、编码方案等。
 * 		Unicode 是为了解决传统的字符编码方案的局限而产生的，它为每种语言中的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本转换、处理的要求。
 * 		1990年开始研发，1994年正式公布。
 * 
 * 			
 * 		ASCII字符集：最早的计算机在设计时采用8个比特（bit）作为一个字节（byte），所以，一个字节能表示的最大的整数就是255（二进制11111111=十进制255），
 * 		0 - 255被用来表示大小写英文字母、数字和一些符号，这个编码表被称为ASCII编码
 * 
 * @author zwq
 *
 */
public class Identifier {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int i = 1; // 规范
		int @i ; // 标识符不规范，首字符只能是 字母， $ ，_
		int $i; // 规范
		int 1a;  // 标识符不规范，首字符字母开头
		int _b; // 规范
		int 汉字; //不报错，但标识符不规范，不建议这样写
		int xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx; //标识符长度无限制
		int class; //标识符不能是java关键字
		String stuName; // 字符串变量采用驼峰命名格式
	}
	
	// 方法名findPerson 第一个单词find小写，第二个单词Persion的首字符大写
	public void findPerson() {}

}

java三种注释

*     分类：
*         1.单行注释
*         2.多行注释
*         3.文档注释: 一般用于类，方法

/**
 * java 注释
 *  	分类：
 *  		1.单行注释
 *  		2.多行注释
 *  		3.文档注释: 一般用于类，方法
 * 
 * @author zwq
 *
 */
public class DocTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("我是单行注释"); //1.单行注释
		
		/*
		System.out.println("我是多行注释"); 
		System.out.println("我是多行注释");

		*/
		
		Test();
		
	}
	
	/**
	 * 文档注释 一般用于类，方法
	 * 
	 * static 修饰的方法为静态方法
	 * 
	 * @param args
	 */
	public static void Test() {
		System.out.println("Test()方法");
	}

}

java关键字

常常听到，java关键字，java保留字，其实都是指一个意思，比如修饰类的关键字 class ，修饰变量类型的 int，都属于关键字，比如后续会学到的 if-else while for 语句都是属于java关键字

变量

变量定义：变量实质是一个“可操作的存储空间”，位置是固定的，但是里面放什么值不确定，可以通过变量名来访问“对应的存储空间”，从而操作这个“存储空间”存储的值。
变量要素：1.变量名 2.变量类型 3.作用域
变量类型：8个基本数据类型（byte,short,char,int,float,double,long,boolean） + 引用数据类型（类，String，数组，接口）
变量分类：1.局部变量 2.成员变量（也称为实例变量） 3.静态变量（也称为类变量）

变量-局部变量

1. 作用域

方法或语句块内部定义的变量，生命周期是从束声明位置开始，到方法，语句块执行完毕结束。

2. 局部变量访问方式

方法或语句块中直接访问变量名

/**
 * 变量分类-局部变量
 * 
 * 定义：
 * 		方法或语句块 内部定义的变量，生命周期是从声明位置开始，到方法，语句块执行完毕结束。
 * 
 * 访问局部变量：
 * 		只能在 方法或语句块 中调用
 * 		
 * 
 * 注意：局部变量必须声明并赋值后再使用
 * 
 */
public class LocalVar {

	public static void main(String[] args) {
		// 定义语句块
		{
			System.out.println("我是语句块");
			int a=1;
			System.out.println("我是语句块a="+a);
		}
		System.out.println("我是语句块a="+a); // 变量a作用域范围在 语句块 中，此时 语句块 代码已执行结束，此处报错，a未被声明
	
		prints(6); // 方法内部的变量b，其作用域范围在prints()方法执行完时，被销毁，释放了内存

	}
	/**
	 * 定义一个方法 用于 打印数据
	 * @param b
	 */
	public static void prints(int b) {
		System.out.println(b);
	}

}

注意：局部变量没有声明，不能使用（包括不能初始化或赋值），局部变量没有初始化或赋值不能使用。

变量-成员变量

1.作用域

方法外部、类的内部定义的变量为成员变量，也称为实例变量，从属于对象，生命周期为对象的始终。成员变量不赋值，可以使用，会取默认值，即会自动初始化，如 int i ，i的默认值为0；

2. 成员变量访问方式

先创建对象通过 new 对象
通过对象.成员变量访问

/**
 * 变量分类-成员变量
 * 
 * 定义：
 * 		方法外部、类的内部定义的变量为成员变量，也称为实例变量，从属于对象，生命周期为对象的始终
 * 
 * 输出 成员变量：
 * 		1.先创建对象 通过 new 对象
 * 		2.通过 对象名.成员变量 访问
 * 
 * 注意：
 * 		成员变量不赋值，可以使用，会取默认值，即会自动初始化，如 
 * 			int 默认值为0
 * 
 * 
 */
public class MemberVar {

	byte b; // 声明 byte 类型变量
	short s; // 声明 short 类型变量
	char c; // 声明 char 类型变量
	int i; // 声明 int 类型变量
	float f; // 声明 float 类型变量
	double d; // 声明 double 类型变量
	long l; // 声明 long 类型变量
	boolean bo; // 声明 boolean 类型变量
	String str; // 声明 String 类型变量
	
	public static void main(String[] args) {
		/**
		 * 输出 成员变量
		 * 1.先创建对象 通过 new 对象
		 * 2.通过 对象名.成员变量 访问
		 * 
		 */
		MemberVar vt = new MemberVar();
		System.out.println(vt.b); // 默认值为 0
		System.out.println(vt.s); // 默认值为 0
		System.out.println(vt.c); // 默认值为   
		System.out.println(vt.i); // 默认值为 0
		System.out.println(vt.f); // 默认值为 0.0
		System.out.println(vt.d); // 默认值为 0.0
		System.out.println(vt.l); // 默认值为 0
		System.out.println(vt.bo); // 默认值为 false
		System.out.println(vt.str); // 默认值为 null
	}

}

变量-静态变量

1.作用域

static 修饰的变量为静态变量，从属于类，生命周期为类的始终，从类加载到卸载

2.静态变量访问方式

静态变量属于类，访问方式是类名.静态变量，若在同一个类中，则可以直接输出静态变量不用类名调用

/**
 * 变量分类-静态变量
 * 
 * 定义：
 * 		static 修饰的变量为静态变量，从属于 类 ，生命周期为 类的始终，从类加载到卸载
 * 
 * 输出静态变量：
 * 		 静态变量属于类，访问方式是 类名.静态变量，若在同一个类中，则可以直接输出静态变量不用类名调用
 * 
 * @param args
 */
public class StaticVar {
	// 声明一个 static 变量
	static int size ;
		
	public static void main(String[] args) {
		/**
		 * 输出静态变量
		 * 	 静态变量属于类，访问方式是 类名.静态变量，若在同一个类中，则可以直接输出静态变量不用类名调用
		 * 
		 */
		System.out.println("静态变量输出："+size);
		System.out.println("静态变量输出："+VariableTest.size); // 若访问的静态变量不在本类中需要 通过 类.静态变量 访问

	}

}

问：静态变量能否在 main()，或自定义方法中声明？

答：静态变量不能在mainI()，或自定义的方法中声明，因为静态变量是属于类的，也称为类变量。或者可以这样解释，如果静态变量能在方法中定义，那么其作用域就是方法体内了，生命周期会随着方法执行完后结束。

常量

定义

java中 final 修饰的变量称为常量;其值一旦初始化就不能再次改变其值；

分类

字面常量：如 1，3.14，true，'a' 是固定的值，不变的值，这种称为字面常量

符号常量：fianl修饰的常量如 final int MAX_VALUE = 100; //MAX_VALUE为符号常量

语法

final 类型常量名 = 值；

final int MAX_VALUE = 100;

规范

常量的变量名字母需全部大写，且多个单词用 _ 分割如：MAX_VALUE，MIN_VALUE
常量值必须初始化
常量值一旦被赋值，不能再次更改其值
常量一般定义在类下面或所有方法上面，或者定义一个单独的常量类如Constants.java,java中一般会根据业务不同，定义不同的常量类

如下代码片段：final是定义在方法内部的，正常项目编码中一般不建议这样写


public class FinalTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		final int MAX_VALUE = 100;
		MAX_VALUE = 1000; // 报错，常量一旦被赋值，不能再改变其值

	}

}

如下代码片段编码比较符合规范，即使编码规范就要尽量去遵守，养成好的编码习惯是程序员必备的素质之一

/**
 * 常量：final修饰的变量叫常量，其值是固定的
 * 
 * 注意：
 * 		1.final的值必须初始化，不然报错
 * 		2.常量一旦被赋值，不能再改变其值
 * 
 * @author zwq
 *
 */
public class FinalTest {
	final int MAX_VALUE = 100; // java编码规范-final 修饰的变量一般放在 类下面，方法之上，或者使用一个常量类存放常量 如Constants.java
	final int FACE_CODE; // 错误，final的值必须初始化
	final String CHANNEL_CODE = "Alipay"; // 正确，final的值初始化
	
	public static void main(String[] args) {
		
		 CHANNEL_CODE = "MoBai"; // 报错，常量一旦被赋值，不能再改变其值

	}

}

数据类型

定义

不同的类型的变量有不同的存储空间，存储数据的范围不一，所有有了数据类型

分类

基本数据类型（byte，short，char，int，float，double，long，boolean）

数据类型	分类	所占字节数	存储数据的范围		示例值
byte	数值型	1byte	2^8=256（包括正负数）	-2^7~2^7-1 -128~127	byte b=127;
short	数值型	2btte	2^16=65 536 （包括正负数）	-2^15~2^15-1 -32768~32767 约3万+	short s=23;
char	数值型	2byte	是用来表示在 unicode编码中的字符，unicode是万国码，统一处理各国语言的编码，它占2个字节，可允许有2^16=65536个字符，unicode只有从0到65536之间的编码，它们通常从【'\u0000'】到'【\uFFFF'】之间的十六进制表示	1. 0 ~ 65535 2.u0000 ~ \uFFFF	1.char c = 'a',cc = '?'; 2.char c2 = 65536; // 65536错误超出数字存储范围 0 ~ 65535 3.char c3 = -11; // -11错误超出数字存储范围 0 ~ 65535 4.char c4 = 65535; // 正确 5.char c5 = '\uFFFF'; // 正确也可以用十六进制表示存储范围 \u0000 ~ \uFFFF 6.char c6 = '\u0000'; // 正确也可以用十六进制表示存储范围 \u0000 ~ \uFFFF
int	数值型	4byte	2^32=4 294 967 296 （包括正负数）约42亿+	-2^31~2^31-1 -2 147 483 648~2 147 483 647 约21亿+	int i =100;
float	单精度浮点型	4byte	2^32=4 294 967 296 （包括正负数）约42亿+	-2^31~2^31-1 -2 147 483 648~2 147 483 647 约21亿+	float f =1.2f 值后无f时默认为double
double	双精度浮点型	8byte	2^64=18446744073709551616	-2^63~2^63-1 约74亿	double b =2.2
long	长整型	8byte	2^64=18446744073709551616	-2^63~2^63-1 约74亿	long l = 100000L;
boolean	布尔型	1bit(1byte=8bit)		true或false	boolean b = false;

1.整型数值类型

int型数据的表现方式：

十进制：默认类型如 0，300，-99

八进制：要求以 0 开头如 012，016

十六进制：要求以 0x 后 0X 开头如 0x15

二进制：要求以 0b 或 0B 开头如 0b01110111

		// 测试 int型数据的表现形式
		int i = 2; //十进制，默认进制类型
		int i1 = 015; // 八进制
		int i2 = 0x12; //十六进制
		int i3 = 0b1101; //二进制
		System.out.println(i+"\t"+i1+"\t"+i2+"\t"+i3+"\t");//2	13	18	13
		
		// 测试 基本数据类型的存储范围
		byte b = 128; // 编译报错 byte的数据存储范围是-127~128
		short s = 32768; //编译报错 byte的数据存储范围是-32768~32767

2.字符型数据类型

char是用来表示在unicode编码中的字符，unicode编码被设计用来处理各种语言的文字，它占2个字节，可许允许有2^16=65536个字符，unicode只有从0到65536之间的编码，它们通常从'\u0000' 到'\uFFFF'之间的十六进制表示（前缀为u表示unicode）

字符型数据的表现形式：十六进制如 \u0061

// 测试 char型数据的表现形式
		char c = '\u0061';
		System.out.println(c); //a
		char a = 'a';
		char b = 2; //十进制
		char d = 'A';
		System.out.println(a>d); // true
		System.out.println(0+a); //97
		System.out.println("a"+a);//aa
		System.out.println(d+0);//65
		System.out.println(d+"a");//Aa
		System.out.println(a+b);// 2 + 'A' = 99
		System.out.println(1+'a'); // 98

		/**
		 * char 是用来表示在 unicode编码中的字符，unicode是万国码，统一处理各国语言的编码，
		 * 		它占2个字节，可允许有2^16=65536个字符，unicode只有从0到65536之间的编码
		 * 		它们通常从【'\u0000'】 到'【\uFFFF'】之间的十六进制表示
		 * 
		 */
		// 测试  0到65536
		char c = 32767;
		char c1 = 32768; // 
//		char c2 = 65536; // 65536错误  超出数字存储范围  0 ~ 65535
//		char c3 = -11; // -11错误 超出数字存储范围  0 ~ 65535
		char c4 = 65535; // 正确
		
		// 测试  \u0000 ~ \uFFFF
		char c5 = '\uFFFF'; // 正确 也可以用十六进制表示 存储范围 \u0000 ~ \uFFFF
		char c6 = '\u0000'; // 正确 也可以用十六进制表示 存储范围 \u0000 ~ \uFFFF
		System.out.println("c="+c); // c=翿
		System.out.println("c1="+c1); // c1=耀
		System.out.println("c4="+c4); // c4=?
		System.out.println("c5="+c5); // c5=?
		System.out.println("c6="+c6); // c6=

3.浮点型数据类型

浮点型数据类型的表现形式

		//测试 浮点型数据的表现形式 - 十进制
		float f = 111; // 不带小数点的值后不加f正确，默认double类型
		float f1 = 11.1;// 带小数点的值后不加f错误，必须加f 或 F
		float f3 = 11.1F;
		double d1 = 11; // double类型加不加d，D都可以，规范不用加
		double d2 = 11.1;
		double d3 = 11d;
		double d4 = 11.1D;
		
		//测试 浮点型数据的表现形式 - 科学记数
		float f4 = 314E2; // 科学记数的值后不加f错误，必须加f 或 F
		float f5 = 314E2F; // 正确
		double d5 = 314e-2; // 正确

浮点数字面意思就是浮动的，值有误差

		//测试 浮点数的精度误差
		float ff = 0.1f;
		double ff1 = 1.0/10;
		System.out.println(ff==ff1);// false 精度误差
		System.out.println(ff); // 0.1
		System.out.println(ff1); // 0.1
		
		float ff2 = 0.1f;
		float ff3 = 1.0f/10;
		System.out.println(ff2==ff3);// true 精度误差
		System.out.println(ff2); // 0.1
		System.out.println(ff3); // 0.1
		
		// 观察 下面三组测试结果 
		float ff4 = 42343243f;
		double ff5 = ff4+1;
		System.out.println((ff4==ff5)+"\t"+ff4+"\t"+ff5); // true	4.2343244E7	4.2343244E7
		
		float ff8 = 42343243.1f;
		double ff9 = ff8+1;
		System.out.println((ff9==ff8)+"\t"+ff9+"\t"+ff8); // true	4.2343244E7	4.2343244E7
		
		float ff6 = 4234f;
		double ff7 = ff6+1;
		System.out.println((ff6==ff7)+"\t"+ff6+"\t"+ff7); // false	4234.0	4235.0

金融计算领域不容许有舍入误差存在，所以float，double不适合使用，应该使用任意精度的整型，浮点型运算如BigInteger,BigDecimal(java.lang.Math)

import java.math.BigDecimal;
import java.math.BigInteger;

public class BigDecimalTest {

	public static void main(String[] args) {
		BigDecimal bd = new BigDecimal(42343243.1);
		System.out.println(bd);//42343243.100000001490116119384765625
		
		BigInteger bi = new BigInteger("42343243");
		System.out.println(bi);//42343243
	}

}

4.布尔数据类型

		// boolean 一般用于流程控制，只有两个值 true false
		boolean flag = false;
		System.out.println(flag+"\t"+!flag); //false	true

转义符

转义符	含义	unicode值
\b	退格	u008
\n	换行	u00a
\r	回车	u00d
\t	制表位（tab）	u009
\"	双引号	u0022
\'	单引号	u0027
\\	反斜杠	u005c

引用数据类型（类，String，接口，数组）

运算符

定义

用来操作变量执行数学运算的符号

分类

算术运算符：+，-，/，*，%，+=，-=，*=，/=，%=
赋值运算符：=
关系运算符：>， <， >=， =<， ==， !=
逻辑运算符：&& & || | ！^
位运算符：&， |， ^， ~ ，>>， <<
条件运算符：也叫三目运算符如 1>2 ? "错误":"正确" ;
字符串运算符：+

注意：+ 有两种理解（既可以作为字符串链接符号，还可以用来计算两个变量的值）

记忆小诀窍：七七算错了一个负数值，被关到小黑屋，小黑屋被罗动了位置，搬到了一张字条上 = 7个分类(算，赋，关，逻，位，条，字)

运算符优先级

注意：

1. （）优先级最高

2. 逻辑与，逻辑或，逻辑非的优先级顺序为：逻辑或》逻辑与》逻辑非
如：a || b && c 运算结果是：a || (b && c) 而不是 (a || b) && c

		/**
		 * 运算符优先级
		 * （） 优先级最高
		 *  逻辑与，逻辑或，逻辑非 的优先级顺序为：逻辑或 》 逻辑与》逻辑非
		 *  a || b && c 运算结果是：a || (b && c) 而不是 (a || b) && c
		 */
		int a =1;
		int b =2;
		int c =5;
		System.out.println((a>b)||(b>3) && c>b); // false 先计算 b>3 && c>b 得到 false 然后与 a>b=false 进行 || 运算
		System.out.println((a>b)||(b>0) && c>b); // true

算术运算符

1.分类
1.1 一元：一个操作进行数学运算（++，--）

/*
 * 一元运算符（++，--）自增或自减
 * 规则：
 * 		++，--在变量前，则变量先自增/自减，然后再赋值
 * 		++，--在变量后，则变量先赋值，然后再自增/自减
 * 		
 */
int a = 2;
int a1 = a++; // a在++前，则a先赋值给a1,所以a1=2,然后a再自增，则a=3
a = 3;
int a2 = ++a; // ++z在a前，则a先自增，所以a=4,然后将a的值赋值给变量a2,则a2=4

int a3 =0;
a3++; //该代码执行完毕后，a3=1
int a4 = a3; // a3=1，直接赋值a4
System.out.println(a3);
System.out.println(a4);
a3 = 8;
System.out.println(a3++); // 打印8 a3++ 是一个表达式，而print输出的是变量的值，此时变量被先赋值，而后执行的++操作
System.out.println(a3); // 打印9
a3 = 6;
System.out.println(++a3); // 打印7
System.out.println(a3); // 打印7
System.out.println(a3++); // 打印7

1.2 二元：两个操作符进行数学运算（+，-，*，/，%）
1.2.1.整型运算符

byte b = 1;
short s = 1;
char c = '1';

/**
 * 整型运算
 * int 型作为分割线，此注释以上的类型byte short char 进行整数运算时结果会自动转换为int
 * 
 * 					此注释以下的类型long 进行整数运算时，结果都为long
 * 
 * 注意：
 * 		1.byte，short，char 与 int 进行运算时，结果会自动转换为 int 类型， +=运算时，是什么类型，结果类型就是什么类型
 * 		2.byte，short，char，int 与 long 进行运算时，结果会自动转换为long类型
 *
 */
int i = 1;

long l = 1;

byte b1 = b+i; // 报错，结果类型为int
s = s+b; // 报错，结果类型为int
i = b+s; // 正确，结果类型为int

short s1 = s+i; // 报错，结果类型为int
short s2 = s+2; // 报错，2默认是int型，结果类型为int
s = s+1; // 报错，运算时，结果类型会自动类型提升为int
s += 1; // 正确 += 是java语言中规定的运算符，java编译器会对它进行特殊处理，所以编译时不会报错
b += 1; // 正确 += 是java语言中规定的运算符，java编译器会对它进行特殊处理，所以编译时不会报错

c = c+1; // 报错，2默认是int型，结果类型为int
s= (c+s); // 报错，2默认是int型，结果类型为int,此处结果类型s为short型，可强制转换为short即正确
c = (char)(c+s); // 正确，强制类型转换为char

long l1 = l+i; // 正确
l = l + b; // 正确
l += b; // 正确
l = s + b; // 正确
l += 1;

1.2.2.浮点运算符

		/**
		 * 浮点型算术运算
		 * 1.若只有一个操作符是double，则结果类型为double
		 * 2.只有当两个操作符都是float时，结果类型才为float
		 */
		float f = 2; // 不带f，F时默认为 double类型
		double d =3;
		double d1 =f+d; //正确
		float f1 = 2f; //float类型
		float f2 = f1 + d;// 错误
		double d2 = f1 + d; // 正确

1.2.3.取余运算符

		// 取余运算符
		/**
		 * 取余运算符 :
		 * 注意：
		 * 		1.操作符可以是整形，浮点型，正负均可
		 * 		2.取余结果的正负取决于左边操作的正负，与右边操作符的正负无关
		 */
		System.out.println(7%2); // 1
		System.out.println(-7%2); // -1
		System.out.println(7%-2); // 1
		System.out.println(7%2); // 1

赋值运算符

为变量赋值的运算符，如 =

		/**
		 * 赋值运算符 =
		 * 
		 */
		int z = 1; // 1 赋值给变量 z
		z = 1+3; // z = 4

关系运算符

用来比较操作变量的关系情况如>,<,>=， =<， ==， !=

		/**
		 * 关系运算符
		 * 用来比较操作变量的关系情况 如>,<,>=， =<， ==， !=
		 * 
		 */
		System.out.println(1>2); // false
		System.out.println(1<2); //  true
		System.out.println(1==2); // false
		System.out.println(3>=3); // true
		System.out.println(3<=3); // true
		System.out.println(5==5); // true
		System.out.println(5!=5); // false

逻辑运算符

与，或，非等如 && & || | ！^

		/**
		 * 逻辑运算符
		 * 与，或，非 等 如 && & || | ！^
		 * 
		 */
		System.out.println((1<2) && (3>4)); //		false
		System.out.println((1<2) || (3>4)); //		true
		System.out.println(!true); //		false
		System.out.println(!false); //		true
		System.out.println((1<2) & (3>4));//		false
		System.out.println((1<2) | (3>4)); //		true
		System.out.println(2^2); //		0
		System.out.println(2^3); //		1
		
		int a = 1;
		int b = 2;
		int c = 3;
		System.out.println((1>2) && (++c)>1); // 1>2为false，则整个表达式都为false，&&具有短路的作用，此时(++c)+1表达式并不会被执行，所以c还是3
		System.out.println(c); //c=3 
		
		short c1 = 1;
		short c2 = 2;
		short c3 = 3;
		System.out.println((c1<c2)||(++c3)>3); //1<2为true，则整个表达式都为true，||具有短路作用，此时(++c3)>3表达式将不会被执行，c3仍为3
		System.out.println(c3);//c3=3

位运算符
&， |， ^， ~ ，>>， <<

<< ：左移运算符，左移一位相当于乘以2 ，左移两位相当于乘以两个2

<< ：右移运算符，左移一位相当于除以2 ，左移两位相当于除以两个2

		/**
		 * 位运算符
		 *	&， |， ^， ~ ，>>， << 
		 * 
		 * 注意 ：
		 * 		&，| 即是逻辑运算符，也是位运算符
		 * 		如果两侧操作数都是 boolean 则作为 逻辑运算符
		 * 		如果两侧操作数都是 整数类型 则作为 位运算符
		 *
		 */
		System.out.println((1<2) & (3>4)); //		false
		System.out.println((1<2) | (3>4)); //		true
		System.out.println((1<2) & (3>4));//		false
		System.out.println((1<2) | (3>4)); //		true
		System.out.println(2^2); //		0
		System.out.println(2^3); //		1
		System.out.println(5<<2); //	20 表示 5*2*2 = 20
		System.out.println(5>>2); //	1 表示 5/2/2 = 1
		System.out.println(-5>>2); //	-2
		System.out.println("3*2:左移1 表示 3<<1="+(3<<1)); // 3*2 = 6
		System.out.println("3*4:左移2 表示3<<2="+(3<<2)); // 3*2*2 = 12
		System.out.println("7:左移1 表示 7<<1="+(7>>1)); // 7/2 = 3
		System.out.println("7:左移2 表示7<<2="+(7>>2)); // 7/2/2 = 1
		System.out.println("^ 表示异或并不是乘方："+(3^4)); // ^ 表示异或并不是乘方：7
		System.out.println("~ 去码：~4 ="+(~4)); // -5
		System.out.println("~ 去码：~3 ="+(~3)); // -4

条件运算符

也叫三目运算符如 1>2 ? "错误":"正确" ;

语法： x ? a : b ; // 说明 x为true时执行 a ; x为false时执行 b ;

		int age = 18;
		System.out.println(age>=18 ? "成年人" : "非未成年人"); //成年人

字符串运算符

用于连接符使用如+

		/**
		 * 字符串运算符 
		 * 用于连接符使用 如+
		 * 
		 * 注意：+ 既可以作算术运算符 也可以 作 字符串运算符
		 * 		作字符串拼接时 为 字符串运算符
		 * 		作整数类型计算时 为 算术运算符
		 * 
		 */
		System.out.println('a'+0); // a = 97 b= 98
		System.out.println('a'+ 1); // 97+1 说明： 表达式中的 +1 操作 结果类型为int
		System.out.println('a'+'b'); // 97+98 = 195 此处用于计算值
		System.out.println('a'+",hello "
				+ ",java"); // 打印 a,hello ,java 拼接字符串
		System.out.println(3+4); //7 // 作算术运算符
		System.out.println(3+"4"); //34 //作 字符串运算符

注意：
1. 作字符串拼接时为字符串运算符
2. 作整数类型计算时为算术运算符

本节不清晰知识点：进制之前的转换，unicode编码字符及ACSII编码字符

common77zwq

关注

5
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
02）高淇java300集学习笔记

java基础一java标识符 java注释 java关键字/保留字变量常量数据类型运算符目标熟知java标识符命名规范熟知java三种注释了解java关键字熟知什么是变量，变量分类有哪几种，变量赋值，使用熟知知道常量的定义，用法熟知并掌握数据类型的分类及使用熟练掌握运算符的使用及优先级java标识符命名规范标识符定义：用于给包，类，变量，...
复制链接

扫一扫