集大成者之作，Java基础语法和名词解释汇编（升级版），更新更全！

上一篇文章我给大家简单分享了java一些基础语法和名词解释，很多同学给我私信说总结的不够全面和详尽，希望我再总结一下，这样的要求不算过分，不瞒大家，当时确实由于时间关系，没有做到大家想要的效果，心中感到遗憾和惭愧，具体情况就不再多说，希望大家多多谅解。

src=http___yqfile.alicdn.com_89d55c638e04071fd223d285e87e346d1fa89aa7.jpeg&refer=http___yqfile.alicdn.jpg

痛定思痛之后，又马上着手，翻书上网，搜集资料，最后又写下了这篇文章，我想给初学java的同学分享的就是干货，绝对不掺杂任何没用的内容，目的就是你们看完之后，会有实实在在的收获，如果需要也会分享给身边的朋友参阅，这样也不白白浪费大家的时间，再次感谢大家对我长期的支持，定当继续努力，给大家奉献更多的良品佳作。

在此附上原文章，有需要的可以看看：集大成者之作，基础语法和名词解释汇编

对于初学者，大家可以看看：假如你急需一份系统的java学习规划表，不用浪费时间了！

附：2021最新java学习资料：专为初学者而著，口碑极佳。

当然，还有其他几篇文章有时间都可以浏览翻阅一下，绝对会有所收获的。如果还有什么不明白或者需要任何帮助，直接评论留言告诉我，我一定在看到后第一时间给您联系。好了，咱们进入主题了。

首先，写在前面的是，编写程序时需要注意的：

一、命名规范

1、项目名全部小写

2、包名全部小写

3、类名首字母大写，如果类名由多个单词组成，每个单词的首字母都要大写。

如：public class MyFirstClass{}

4、变量名、方法名首字母小写，如果名称由多个单词组成，每个单词的首字母都要大写。

如：int index=0;
       public void toString(){}

5、常量名全部大写

如：public static final String GAME_COLOR=”RED”;

6、所有命名规则必须遵循以下规则：

1)、名称只能由字母、数字、下划线、$符号组成

2)、不能以数字开头

3)、名称不能使用JAVA中的关键字。

4)、坚决不允许出现中文及拼音命名。

二、注释规范

1、 类注释

在每个类前面必须加上类注释，注释模板如下：

/**
* Copyright (C), 2006-2010, ChengDu Lovo info. Co., Ltd.
* FileName: Test.java
* 类的详细说明
*
* @author 类创建者姓名
    * @Date    创建日期
* @version 1.00
*/

2、 属性注释

在每个属性前面必须加上属性注释，注释模板如下：

/** 提示信息 */
private String strMsg = null;

3、 方法注释

在每个方法前面必须加上方法注释，注释模板如下：

/**
* 类方法的详细使用说明
*
* @param 参数1 参数1的使用说明
* @return 返回结果的说明
* @throws 异常类型.错误代码 注明从此类方法中抛出异常的说明
*/

4、 构造方法注释

在每个构造方法前面必须加上注释，注释模板如下：

/**
* 构造方法的详细使用说明
*
* @param 参数1 参数1的使用说明
* @throws 异常类型.错误代码 注明从此类方法中抛出异常的说明
*/

5、 方法内部注释

在方法内部使用单行或者多行注释，该注释根据实际情况添加。

如：//背景颜色
       Color bgColor = Color.RED
大小写敏感
Java是大小写敏感的，这就意味着标识符Hello与hello是不同的。
类名
对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
方法名
所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
源文件名
源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记Java是大小写敏感的），文件名的后缀为.java。（如果文件名和类名不相同则会导致编译错误）。
主方法入口
所有的Java 程序由public static void main(String []args)方法开始执行。

1、标识符

在Java语言中，用来标志类名、对象名、变量名、方法名、类型名、数组名、包名的有效字符序列，称为“标识符”；
标识符由字母、数字、下划线、美元符号组成，且第一个字符不能是数字；
Java语言区分大小写；
标志符命名规则：类名首字母大写，变量名和方法名采用驼峰标志法，常量全大写，多个单词之间用“_”隔开，包名全小写；

2、关键字

在Java语言中，有一些专门的词汇已经被赋予了特殊的含义，不能再使用这些词汇来命名标识符，这些专有词汇，称为“关键字”；
Java有50个关键字和3个保留字，均不能用来命名标识符；
true、false、null不是关键字，是保留字，但是仍不能用来命名标识符，保留字是Java预留的关键字，在以后的升级版本中可能会作为关键字；

这里先大致了解下关键字

abstract
表明类或者成员方法具有抽象属性
assert
用来进行程序调试
boolean
基本数据类型之一，布尔类型
break
提前跳出一个块
byte
基本数据类型之一，字节类型
case
用在switch语句之中，表示其中的一个分支
catch
用在异常处理中，用来捕捉异常
char
基本数据类型之一，字符类型
class
类
const
保留关键字，没有具体含义
continue
回到一个块的开始处
default
默认，例如，用在switch语句中，表明一个默认的分支
do
用在do-while循环结构中
double
基本数据类型之一，双精度浮点数类型
else
用在条件语句中，表明当条件不成立时的分支
enum
枚举
extends
表明一个类型是另一个类型的子类型，这里常见的类型有类和接口
final
用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变
finally
用于处理异常情况，用来声明一个基本肯定会被执行到的语句块
float
基本数据类型之一，单精度浮点数类型
for
一种循环结构的引导词
goto
保留关键字，没有具体含义
if
条件语句的引导词
implements
表明一个类实现了给定的接口
import
表明要访问指定的类或包
instanceof
用来测试一个对象是否是指定类型的实例对象
int
基本数据类型之一，整数类型
interface
接口
long
基本数据类型之一，长整数类型
native
用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的
new
用来创建新实例对象
package
包
private
一种访问控制方式：私用模式
protected
一种访问控制方式：保护模式
public
一种访问控制方式：共用模式
return
从成员方法中返回数据
short
基本数据类型之一,短整数类型
static
表明具有静态属性
strictfp
用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范
super
表明当前对象的父类型的引用或者父类型的构造方法
switch
分支语句结构的引导词
synchronized
表明一段代码需要同步执行
this
指向当前实例对象的引用
throw
抛出一个异常
throws
声明在当前定义的成员方法中所有需要抛出的异常
transient
声明不用序列化的成员域
try
尝试一个可能抛出异常的程序块
void
声明当前成员方法没有返回值
volatile
表明两个或者多个变量必须同步地发生变化
while
用在循环结构中

3、基本数据类型

1. 整数类型（int为默认类型）

2. 浮点类型（double为默认类型）

在给float类型的变量赋值时，如果赋的值有小数部分则一定要在末尾加上“F”或“f”；

3. 字符类型（2字节）

- char ch = 'a'；
- 有些字符不能通过键盘输入到程序当中，这时就需要使用到转义字符；

4. 布尔类型（1字节）

- boolean flag = true；

默认值

- 数值变量：0；
- 字符变量：‘\0’；
- 布尔变量：false；
- 引用数据类型：null；

不同数据类型之间的转换

- 自动类型转换（低到高）

- 强制类型转换（高到低）

public class Test003 {
    public static void main(String[] args) {
        byte b = 100;
        int i = 22;
        float f = 78.98f;
        int res = b + i + (int)f;    //此处对f使用了强制类型转换(int)f，转换后的值为78
        System.out.println("res: "+res);    //res: 200     }
}

4、运算符与表达式

算数运算符

public class Test003 {
    public static void main(String[] args) {
        int i = 5;
        System.out.println(0/i);    //0
        System.out.println(0%i);    //0
        System.out.println(i/0);    //除数不能为零，报异常java.lang.ArithmeticException
        System.out.println(i%0);    //除数不能为零，报异常java.lang.ArithmeticException     }
}

赋值运算符

自增自减运算符（++，--）

public class Test003 {
    public static void main(String[] args) {
        int i = 5;
        System.out.println(i++);    //5
        System.out.println(++i);    //7
        System.out.println(i);    //7
        System.out.println(--i);    //6
        System.out.println(i--);    //6
        System.out.println(i);    //5     }
}

关系运算符

逻辑运算符

public class Test003 {
    public static void main(String[] args) {
        boolean t = true;
        boolean f = false;
        System.out.println(t && f);    //false，短路与运算符，若运算符左侧为false则不计算右侧的表达式
        System.out.println(t || f);    //true，短路或运算符，若运算符左侧为true则不计算右侧的表达式
        System.out.println(t & f);    //false，与运算符，不管左侧是否为false都要计算右侧的表达式
        System.out.println(t | f);    //true，或运算符，不管左侧是否为true都要计算右侧的表达式
        System.out.println(t ^ f);    //true，异或运算符，只要左右两侧不相同则为true，反之为false
        System.out.println(!f);    //true，取反运算符     }
}

位运算符

public class Test003 {
    public static void main(String[] args) {
        //在位运算符中1相当于true，0相当于false int b1 = 6;    //二进制为00000000 00000000 00000000 00000110 int b2 = 11;    //二进制为00000000 00000000 00000000 00001011
        System.out.println(b1 & b2);    //按位与运算符，二进制为00000000 00000000 00000000 00000010，结果为2
        System.out.println(b1 | b2);    //按位或运算符，二进制为00000000 00000000 00000000 00001111，结果为15
        System.out.println(b1 ^ b2);    //按位异或运算符，二进制为00000000 00000000 00000000 00001101，结果为13
        System.out.println(~b1);    //按位取反运算符，二进制为11111111 11111111 11111111 11111001，结果为-7
        System.out.println(b1 << 2);    //左移位运算符，二进制为00000000 00000000 00000000 00011000，结果为24 int b3 = -14;    //二进制为11111111 11111111 11111111 11110010
        System.out.println(b3 >> 2);    //带符号右移位运算符，二进制为11111111 11111111 11111111 11111100，结果为-4
        System.out.println(b3 >>> 2);    //无符号右移位运算符，二进制为00111111 11111111 11111111 11111100，结果为1073741820     }
}

三元运算符

public class Test003 {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        int c = 4;
        int res = c==a+b?++a:c>a+b?++b:++c;    //三元运算符 (表达式)?(值1):(值2)，若表达式为true则取值1，反之取值2
        System.out.println(res);    //++b,结果为3     }
}

运算符优先级

5、数组

　　1. 一维数组

public class Test003 {
    public static void main(String[] args) {
        int[] i;    //声明一个整型的一维数组变量 int ii[];    //声明一个整型的一维数组变量
        i = new int[5]; //创建一个长度为5的一维数组对象，并将变量i指向该对象 float[] f = new float[5];    //直接创建一个长度为5的单精度浮点型一维数组对象，并将变量f指向该对象 double[] d = {1, 2, 3.4, 4.5};    //直接初始化一个一维数组元素         
        System.out.println(d[3]);    //通过数组下标来获取数组内的元素，数组下标从0开始，结果为4.5
        System.out.println(f[0]);    //当创建出一个数组对象时，该对象内的数组元素为该数据类型的默认值，所以此处结果为0.0
        //System.out.println(i[5]);    //当通过数组下标来获取数组内元素时，[]内的值>=数组长度则报异常java.lang.ArrayIndexOutOfBoundsException（数组下标越界）
        //System.out.println(ii[0]);    //若一个数组变量只声明而未指向某一个具体的数组对象时，编译出错
        System.out.println(d.length);    //得到该数组的长度，结果为4     }
}

　　2. 二维数组

public class Test003 {
    public static void main(String[] args) {
        int[][] i;    //声明一个整型的二维数组变量 int ii[][];    //声明一个整型的二维数组变量 int[] iii[];    //声明一个整型的二维数组变量
        i = new int[5][2]; //创建一个长度为5的二维数组对象，并将变量i指向该对象 float[][] f = new float[5][2];    //直接创建一个长度为5的单精度浮点型二维数组对象，并将变量f指向该对象 double[][] d = {{1}, {2,3}, {4,5,6}, {7,8,9,10}};    //直接初始化一个二维数组元素         
        System.out.println(d[3][1]);    //通过数组下标来获取数组内的元素，数组下标从0开始，结果为8
        System.out.println(f[0][0]);    //当创建出二个数组对象时，该对象内的数组元素为该数据类型的默认值，所以此处结果为0.0
        //System.out.println(i[5][0]);    //当通过数组下标来获取数组内元素时，[]内的值>=数组长度则报异常java.lang.ArrayIndexOutOfBoundsException（数组下标越界）
        //System.out.println(ii[0][0]);    //若一个数组变量只声明而未指向某一个具体的数组对象时，编译出错
        System.out.println(d.length);    //得到该数组的长度，结果为4
        System.out.println(d[2].length);    //得到二位数组内的下标为2的那个一维数组的长度     }
}

6、流程控制语句（if,switch,for,while,do...while）

　　1. 条件分支语句

public class Test003 {
    public static void main(String[] args) {
        int[] score = new int[5];
        score[0] = -7;
        score[1] = 65;
        score[2] = 80;
        score[3] = 90;
        score[4] = 59;
        for(int i=0; i<score.length; i++) {
            if(score[i]>=0 && score[i]<60) {
                System.out.println("不及格");
            }else if(score[i]>=60 && score[i]<80) {
                System.out.println("及格");
            }else if(score[i]>=80 && score[i]<90) {
                System.out.println("良");
            }else if(score[i]>=90 && score[i]<100) {
                System.out.println("优");
            }else {
                System.out.println("成绩异常");
            }
        }
        
        char ch = 'a';
        switch(ch) {    //switch括号内只支持 byte,short,int,char,enum五种数据类型，但是JDK1.7版本增加了String类型，所以相对于JDK1.7而言就是六种了 case 'A':    //case为switch语句的入口，break为出口，从入口开始执行，直到遇到出口或代码执行完毕才结束 case 'a':
                System.out.println("优");
                break;
            case 'B':
            case 'b':
                System.out.println("良");
                break;
            case 'C':
            case 'c':
                System.out.println("及格");
                break;
            default:    //若上述条件均不匹配，则进default开始执行语句
                System.out.println("不及格");
        }
    }
}

　　2. 循环语句

public class Test003 {
    public static void main(String[] args) {
        int res = 0;
        out:    //out是一个标号，告诉java从哪里开始执行程序 for(int i=1; i<=10; i++) {
            if(i==3) continue out;    //continue终止本次循环，执行下次循环 if(i==5) break out;    //break跳出循环
            res = res + i;
        }
        System.out.println(res);    //结果为1+2+4=7 int res2 = 0;
        int i = 1;
        in:
        do{
            if(i==3) continue in;    //continue终止本次循环，执行下次循环 if(i==5) break in;    //break跳出循环
            res2 = res2 + i;
            i++;
        }while(i<=10);
        System.out.println(res2);
    }
}

二、名词解释篇

1、Java起源

java 属于Sun公司，后期被甲骨文收购。

Java之父，詹姆斯高斯林， Java语言起初名字叫做：Oak，由C++演变而来；

Java 版本：jdk6 /7 最常用， java8引入流、lambda表达式等重要特性。现在java最新版本是11；

2、JDK、JRE、跨平台、Java平台

JDK：它是Java开发运行环境，在程序员的电脑上当然要安装JDK；

JDK = JRE + 开发工具集（例如Javac编译工具等）

JRE：Java Runtime Environment它是Java运行环境，如果你不需要开发只需要运行Java程序，那么你可以安装JRE

JRE = JVM + JavaSE标准类库

JDK 包含 JRE 包含 JVM
跨平台特性
- 平台指的是操作系统 （Windows，Linux，Mac）。
- Java程序可以在任意操作系统上运行，一次编写到处运行
- 实现跨平台需要依赖Java的虚拟机 JVM （Java Virtual Machine）
  为什么可以跨平台？因为JAVA程序运行依赖虚拟机，而针对不同操作系统有不同版本的虚拟机
- Java语言是跨平台的，Java虚拟机不是跨平台的
Java平台
- Java SE (桌面程序）标准版
- Java EE (Web程序）企业版
- Java ME(移动设备）微型版 -- Android，IOS兴起后就很少使用了

3、JavaAPI

即Java应用程序接口

常用API

4、StringBuffer和StringBuilder用法

StringBuilder(线程不安全)/StringBuffer(线程安全)是可变长度字符对象

使用append方法拼接变量，效率高

两个都默认有16位（bit）缓冲区

使用capacity方法获取所占空间大小，length方法获取真实字符个数； append方法拼接变量；

String类型和StringBuffer的主要性能区别：

String是不可变的对象, 因此在每次对String 变量进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别是当内存中无引用对象多了以后， JVM 频繁 GC ，降低JVM的性能。

使用 StringBuffer 时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。所以多数情况下推荐使用 StringBuffer ，特别是字符串对象经常改变的情况。

在现实的模块化编程中，负责某一模块的程序员不一定能清晰地判断该模块是否会放入多线程的环境中运行，因此，除非确定系统的瓶颈是在 StringBuffer 上，并且确定你的模块不会运行在多线程模式下，才可以采用StringBuilder；否则还是用StringBuffer。

性能：StringBuilder>StringBuffer>String。

5、Math相关

round(double/float) 四舍五入取整返回long/int

floor(double d) 向下取整返回double

ceil(double d) 向上取整返回double

abs(double/long/float/int )获取绝对值

random()获取0-1之间随机小数（double类型），大于等于0.0和小于1.0

6、Random随机数

nextInt(int i)获取0-i之间的随机整数，包括0不包括i

nextDouble()获取0-1之间随机小数，包括0.0不包括1.0

7、java.math.BigDecimal

比double更精确的一种类型；常用于操作金额，汇率等；

常用方法：

add

subtract

multiply

divide

setScale方法用于格式化小数点

setScale(1)表示保留一位小数，默认用四舍五入方式

8、SimpleDateFormat用法

format(日期对象) 将日期格式化为指定格式字符串

parse(指定格式的日期字符串)将字符串转为Date 注意：格式必须跟SimpleDateFormat指定格式一致否则报ParseException

9、[java.util.Date]

将1999-10-10格式字符串转为日期对象

new Date()获取当前系统时间

getTime()获取毫秒数

10、[java.sql.Date]

java.util.Date是它的父类，所以sql.Date功能比util.Date更强大。

11、Calendar

在Calendar类中，月份的值为实际的月份值减1

获得的星期的值和Date类不一样。在Calendar类中，周日是1，周一是2，周二是3，依次类推

12、Java代码的编写执行过程

源文件：编写Java源文件（我们也称之为源代码文件），它的扩展名为.java；
编译：然后通过编译器把源文件编译成字节码文件，字节码文件扩展名为.class；
为什么要编译?JAVA程序是由虚拟机运行的，我们所写的代码虚拟机不认识，我们要把自己写的代码翻译成虚拟机所认识的语言
运行：最后使用解释器来运行字节码文件。

13、注释

定义：用来解释和说明程序的文字，注释是不会被执行的
分类：
- 单行注释： //注释内容
- 多行注释： /注释内容/
- 文档注释： /*注释内容/
注意：
- 对于单行和多行注释，被注释的文字，不会被JVM解释执行
- 对于文档注释，可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档
- 单行注释可以嵌套使用，多行注释不能嵌套使用

14、关键字、标识符

关键字
- 定义：是被Java语言赋予特殊含义，具有专门用途的单词，比如之前接触的class，int，double均为Java已经预设好的
- 特点：字母全部小写, 注意String不是关键字
- 注意事项：goto 与 const 是Java中的保留字，即没有赋予特殊含义却仍被Java占用的单词
标识符
- 定义：就是给类,接口,方法,变量等起名字时使用的字符序列
- 组成规则(只能包含下面的内容,不能有其它内容):
- - 英文大小写字母
  - 数字字符
  - $和_
- 注意事项:
- - 数字不能开头
  - 不可以使用关键字
  - 严格区分大小写，不限制长度
  - 起名时，尽量达到见名知意
- 标识符中常见的命名规则(这些规定是不受语法约束的):
- - 包名：多单词组成时所有字母均小写，使用.连接,域名反写 aaa.bbb.ccc
  - 类名&接口名：大驼峰式 Aaa AaaBbbCcc
  - 变量名&方法名：小驼峰式 aaa aaaBbbCcc
  - 常量名：多单词组成是所有字母均大写，使用_连接 AAA_BBB_CCC

15、Java中的数据类型

为什么有数据类型?
Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型

Java中数据类型的分类
- 基本数据类型：基本数据类型是Java语言中内置的类型，分别是整数类型、小数类型、字符类型、布尔类型。这四类基本类型是最简单、最基础的类型。
- 引用数据类型：是强大的数据类型，它是基于基本数据类型创建的。
- - JavaSE中提供了一个超级类库，类库中包含了近万种引用数据类型。
  - 基本类型：类接口数组枚举

16、Java中的常量

定义：常量就是不变的数据量, 在程序执行的过程中其值不可以发生改变
整形常量默认是 int类型

在Java中，定义长整形数据如果值超过int取值范围后面要+L，否则是错误的

小数常量默认是 double类型

D后缀为double，F后缀为float
定义float类型的数据后面要 + f ,否则默认是double

常量分类：

- 整数类型
- - 十进制表示方式：正常数字。如 13、25等
  - 二进制表示方式：以 0b(0B) 开头。如0b1011 、0B1001
  - 十六进制表示方式：以 0x(0X) 开头。数字以0-9及A-F组成如0x23A2、0xa、0x10
  - 八进制表示方式：以 0 开头。如01、07、0721
- 小数类型：如1.0、-3.15、3.168等
- 布尔类型：true、false ,注意严格区分大小写
- 字符类型:
- - 如 'a'，'A', '0', '家'
  - 字符必须使用 '' 包裹，并且其中只能且仅能包含一个字符
- 字符串类型:
- - 字符串String类型是一种引用类型，我们先了解作为常量类型的使用方式
  - 如 "我爱Java"，"0123"，""，"null"
  - 字符串必须使用 "" 包裹，任意长度
在计算机内，有符号数有3种表示法：原码、反码和补码。所有数据的运算都是采用补码进行的
- 原码： +8: 0 000 1000 -8: 1 000 1000

就是二进制定点表示法，即最高位为符号位，0表示正，1表示负，其余位表示数值的大小。

- 反码： +8: 0 000 1000 -8: 1111 0111

正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。

- 补码： +8: 0 000 1000 -8: 1111 1000

正数的补码与其原码相同；负数的补码是在其反码的末位加 1

17、变量和运算符

1. 变量和计算机存储单元

变量是内存中装载数据的小盒子，你只能用它来存数据和取数据
变量名是标识符，这说明只要是合法的标识符都可以用来做变量名。
变量使用的注意事项
- 变量定义后可以不赋值，使用时再赋值。不赋值不能使用
- 变量使用时有作用域的限制。(局部变量和全局变量)
- 变量不可以重复定义
计算机存储单元
- 计算机中储存和运算的最小单位：一个字节，也就是1个字节（byte）
- 常用储存单位1B（字节） = 8bit（比特位）

1KB = 1024B
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
1PB = 1024TB

18、数据类型转换

自动类型转换：表示范围小的数据类型转换成范围大的数据类型，这种方式称为自动类型转换
自动类型转换格式：范围大的数据类型变量 = 范围小的数据类型值;

默认转换：byte、short、char —> int —> long —> float —> double
byte、short、char 相互之间不转换，他们参与运算首先转换为 int类型

强制类型转换：表示范围大的数据类型转换成范围小的数据类型，这种方式称为强制类型转换

强制类型转换格式：范围小的数据类型变量 = (范围小的数据类型) 范围大的数据类型值;

19、运算符和优先级

算数运算符

+ - * / % ++ --

+ ：正号、加、连接字符串
**++，--**运算符后置时，先使用变量a原有值参与运算操作，运算操作完成后，变量a的值自增1或者自减1；
**++，--**运算符前置时，先将变量a的值自增1或者自减1，然后使用更新后的新值参与运算操作。

注意事项：
- 加法运算符在连接字符串时要注意，只有直接与字符串相加才会转成字符串。
- 除法当两边为整数时，取整数部分，舍余数。当其中一边为浮点型时，按正常规则相除。
- % 为整除取余符号，小数取余没有意义。结果符号与被取余符号相同。
- 整数做被除数，0不能做除数，否则报错。
- 小数做被除数，整除 0 结果为 Infinity，对 0 取模结果为 NaN

赋值运算符

*+= -= = /= %=

**+=, -=, *=, /=**这样的赋值运算符包含了一个 强制转换 的操作，会将左右两边运算后的结果，强制类型转换后赋值给左边
注意：赋值运算符左边必须是变量

int n = 10;
byte by = 20;
by += n; // 运算完毕后，by的值为byte类型30， 相当于代码 by = (byte)(by + n);

比较运算符

== != < > <= >=

结果只能是true 和 false
字符间的比较，比较的是其 ASCII 值
浮点数与整数比较，只要值相等，就返回 true

逻辑运算符

&与-----false&true-----False
|或-----false|true-----True
^异或-----true^flase-----True
!非-----!true-----Flase
&&短路与-----false&&true-----False
||短路或-----false||true-----True

&& : 又叫短路运算符，A&&B，如果A为假，不会去计算B的值，直接得到结果为 false
& : A & B，即使A为假，也会计算B的值。
|| : 也是短路运算符，A || B，如果A为真，不会去计算B的值，直接得到结果为 true
| : A | B，即使A为真，也会计算 B 的值。
异或^ : 左右两边条件结果相同，结果就为false，左右两边条件结果不同，结果就为true；

三目运算符

语法：布尔表达式 ? 表达式1 : 表达式2
当布尔表达式的值为true，则返回表达式1的值，否则返回表达式2的值

运算符优先级

优先级描述运算符
1 括号 ()、[]
2 正负号 +、-
3 自增自减，非 ++、--、!
4 乘除，取余 *、/、%
5 加减 +、-
6 移位运算 <<、>>、>>>
7 大小关系 >、>=、<、<=
8 相等关系 ==、!=
9 按位与 &
10 按位异或 ^
11 按位或 |
12 逻辑与 &&
13 逻辑或 ||
14 条件运算 ?:
15 赋值运算 =、+=、-=、*=、/=、%=
16 位赋值运算 &=、|=、<<=、>>=、>>>=

位运算符

位运算是直接对 二进制 进行运算
在位运算中，操作数必须是整型
位异或运算符的特点：
- 一个数据对另一个数据位异或两次，该数本身不变。
- 任何数和自身异或，结果为0
- 任何数和0异或，结果为本身
- << 左移一位，相当于乘以2： 3 << 2 = 12 --> 322=12
- >> 右移一位，相当于除以2： 3 >> 1 = 1 --> 3/2=1
- 3 >>> 1 = 1 --> 3/2=1
同样的运算，位运算的效率高于算术运算

20、引用数据类型、流程控制语句和数组

1. 引用数据类型

引用数据类型的变量定义及赋值格式：数据类型变量名 = new 数据类型();
调用该类型实例的功能：变量名.方法名();
Scanner类：
- 导包：import java.util.Scanner;
- 创建对象实例：Scanner sc = new Scanner(System.in);
- 调用方法：

int  i = sc.nextInt(); //用来接收控制台录入的数字
String s = sc.next(); //用来接收控制台录入的字符串

随机数类Random
方法简介

public int nextInt(int maxValue)    //产生 [0,maxValue) 范围的随机整数，包含0，不包含maxValue；
public double nextDouble()          //产生 [0,1) 范围的随机小数，包含0.0，不包含1.0。

Random使用方式:

import导包：import java.util.Random
创建实例格式：Random 变量名 = new Random();
赋值：a = 变量名.nextInt(maxValue);

2. 流程控制语句

1. if
2. if...else...
3. if...else if...else...
4. while
5. for
6. do...while...
7. switch case default break
//case 穿透性：如果多个case条件后面的执行语句是一样的，则该执行语句只需书写一次即可，这是一种简写的方式

break语句

作用：跳出所在的循环体
使用方式
- 无法单独使用，必须将break关键字置于 switch 或 循环语句 中
运行规律
- 不需要判断任何条件，只要遇到break变直接跳出执行后续代码。会完全跳出选择或者循环结构
- 只能跳出 最近的 代码块，不能跨越多级代码块
标记
- 当break语句出现在嵌套循环中的内层循环时，它只能跳出内层循环，如果想使用break语句跳出外层循环则需要对外层循环添加标记
- 使用方式：在外层循环外的某行前边使用，后边跟有冒号:的标识符，即定义完毕。
- 使用时当在内层循环使用 break 或 continue 时后边紧跟之前定义的标号即可

itcast: for (i = 1; i <= 9; i++) { // 外层循环,itcast是标记
    for (j = 1; j <= i; j++) { // 内层循环
        if (i > 4) { // 判断i的值是否大于4
        break itcast; // 跳出外层循环
    }
}

continue语句

作用：提前结束本次循环，继续进行下次循环
使用方式: 无法单独使用，必须将continue关键字置于 循环语句 中
运行规律: 不需要判断任何条件，只要遇到continue变直接跳出本轮循环进行下次循环

return 、break、continue 跳出控制语句的区别

break：结束当前整个循环，执行当前循环下边的语句。
continue：结束本次循环，继续进行下次循环
return：用于结束一个方法，返回给上层调用者，如果位于main方法内，相当于结束了程序。

return也可以用于结束循环，因为return用于结束一个方法，如果方法中有循环的话，不管return嵌套于多少层循环之内，循环都结束。
不会再执行循环后面的语句