02）高淇java300集学习笔记
java基础一
- java标识符
- java注释
- java关键字/保留字
- 变量
- 常量
- 数据类型
- 运算符
目标
- 熟知java标识符命名规范
- 熟知java三种注释
- 了解java关键字
- 熟知什么是变量，变量分类有哪几种，变量赋值，使用
- 熟知知道常量的定义，用法
- 熟知并掌握数据类型的分类及使用
- 熟练掌握运算符的使用及优先级
java标识符命名规范
- 标识符定义：用于给包，类，变量，方法进行命名
- 标识符规范：首字符（字母 、$、 _） + 其它字符（字母、 $、 _ 、数字）
- 注意：
- ）标识符也可以是汉字，因为java不采用通常语言使用的ASCII字符集，而是采用Unicode这样标准的固有字符集，但是不建议使用汉字
- ）标识符严格区分大小写，a和A是两个不同的标识符，且标识符长度无限制
- ）标识符不能是java关键字
- ）class修饰的标识符第一个单词首字符大写，其它字符小写,第二个单词同样首字符大写，其它字符小写，如 CommonUtils.class (通用工具类)
- ）变量和方法的标识符采用驼峰命名格式：第一个单词小写，第二个单词首字符大写，如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 |
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~327672.字符型数据类型
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((c13); //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编码字符