Java语言基础
（一）Java编译运行过程
编译期：Java源文件经过编译生成.class字节码文件
运行期：JVM加载.class并运行.class
特点：跨平台，一次编译到处使用(跨平台特性如下图)
（二）JVM、JRE、JDK
JVM：(Java Virtual Machine）,Java虚拟机
JRE：(Java Runtime Environment）,Java运行环境，除包含JVM外还包含运行Java程序所必须的环境，JRE = JVM + Java系统类库
JDK：(Java Development Kit）,Java开发工具包，JDK = JRE + 编译运行等命令工具
- 说明:
- 运行Java程序最小环境为JRE
- 开发Java程序最小的环境为JDK
（三）变量的命名
在程序执行过程中，其值能被改变的量称为变量，其值不能改变的量称为常量。变量与常量的命名都必须使用合法的标识符。
变量的命名应遵循以下规则： -只能包含字母、数字、_和$符，并且不能以数字开头 -严格区分大小写 -不能使用关键字 -允许中文命名，但不建议，建议英文的见名知意、小驼峰命名法 （四）代码注释
通过在程序代码中添加注释可以提高程序代码的可读性和可维护性，帮助程序员更好的阅读和理解程序。Java语言提供 3 种添加注释的方法，分别为单行注释、多行注释和文档注释。
-
单行注释
“//”为单行注释标记，从符号“//”开始直到换行为止的所有内容均为注释而被编译器忽略。语法如下：//注释内容 例如，以下代码为声明 int 型变量添加注释： int age; //声明 int 变量用于保存年龄信息 -
多行注释
“/* */”为多行注释标记，符号“/*”与“*/”之间的所有内容均为注释内容。注释中的内容可以换行。语法如下：/* 注释内容 1 注释内容 2 ... */ //多行注释中可以嵌套单行注释，但是多行注释中不可以嵌套多行注释 -
文档注释
“/** */”为文档注释标记，符号“/**”与“*/”之间的所有内容均为注释内容。注释中的内容可以换行。在文档注释出现在声明（如类的声明、类的成员变量的声明、类的成员方法的声明、类的成员方法的声明等）之前时，会被Javadoc文档工具读取作为Javadoc的文档内容。文档注释的格式与多行注释的格式相同。
（五）Java数据类型
1、Java语言提供了四类八种基本数据类型：
整数类型：byte、short、int、long 浮点数类型：float、double 布尔类型：boolean 字符类型：char 2、简述java的8种基本数据类型：
byte: 字节型，用于存储整数，占用 1 个字节，范围 -128 ~ 127，默认值是 0 short： 短整型，用于存储整数，占用 2 个字节，范围 -32768 ~ 32767，默认值是 0 int： 整型，用于存储整数，占用 4 个字节，范围 -2^31 ~ 2^31-1，默认值是 0 long： 长整型，用于存储较大的整数，占用 8 个字节，范围 -2^63 ~ 2^63-1，默认值是 0L float: 单精度浮点数，用于存储小数，占用 4 个字节，不能表示精确的值，默认值是 0.0F double： 双精度浮点数，用于存储小数，占用 8 个字节，不能表示精确的值，默认值是 0.0D boolean： 布尔型，用于存储 true 和 false，占用 1 个字节，默认值是 false char： 字符型，采用 Unicode 字符集编码，用于存储单个字符，占用 2 个字节，范围 0 ~ 65535 举个栗子： byte a = 100;byte b = -50; short s = 1000;short r = -20000; int a = 100000;int b = -200000; //1)整数直接量默认为int类型，但不能超出范围，若超出范围则发生编译错误 2)两个整数相除，结果还是整数,小数位无条件舍弃 3)运算时若超出范围，则发生溢出，溢出是需要避免的 long a = 100000L;Long b = -200000L; //长整型直接量需要在数字后加 L 或者 l,运算时若可能溢出，建议在第一个数字后加L //浮点数直接量默认为double类型，若想表示float，需在数字后加F 或 f //double 或 float型数据参与运算时，有可能出现舍入误差，精确场合不能使用 float f = 3.14F; //3.14F为float型直接量 double d = 3.14; //3.14为浮点数直接量，默认为double型 boolean b1 = true;boolean b2 = false; //true 和 false 都是布尔类型的直接量 char letter = 'A'; //char类型，字符型直接量必须放到单引号里面，单引号里面必须有字符，只能有一个字符,特殊符号需要通过\来转义，例如：char c = '\\' 表示字符 \ ; 3、数据类型间的转换
- 小到大依次为:byte-short/char-int-long-float-double
- 自动/隐式类型转换：由小到大
- 强制类型转换：语法（要转换成为的数据类型）变量，由大到小，强转有可能发生溢出或丢失精度
int a = 5; long b = a; //自动类型转换 int c = (int) b; //强制类型转换 long d = 5; double e = 5; long f = 10000000000L; int g = (int) f; System.out.println(g); //1410065408 强转有可能会内存溢出 double h = 23.34545; int i = (int) h; System.out.println(i); //23 强转有可能会丢失精度 //整数直接量可以直接赋值给byte、short、char，但是不能超出范围 //byte、short、char型的数据参与运算，系统会将其自动转换为int再运算 byte b = 3; byte b1 = 5; byte b2 = (byte) (b + b1); System.out.println(b2); System.out.println('2' + '2');//100.'2'的码50 加上 '2'的码50 ，得100 （六）Java中的运算符
- 算数运算符：+、——、*、/、%、++、--
- 关系运算符：>、<、>=、<=、==、!=
- 逻辑运算符：&&、||、！
- 赋值运算符：=、+=、-=、*=、/=、%=
- 字符串连接符：+
- 条件运算符：boolean ？ 数1 : 数2
算数运算符自增（++）、自减（--）使用的两种不同情况： 单独使用时：在前在后都是会使值自增1 被使用时：a++/a-- ————————先赋值，再运算 ++a/--a ————————先运算，再赋值 public class OperatorDemo { public static void main(String[] args) { //自增、自减运算演示 //单独使用时，都会自增/自减1 int a = 5, b = 10; a++; b++; System.out.println(a = + a); //6 System.out.println(b = + b); //11 //被使用时。运算符在前，先运算后赋值；运算符在后，先赋值后运算 int c = 20, d = 20; int e = c++; int f = ++d; System.out.println(e = + e); //20 System.out.println(f = + f); //21 } } （七）Java中的流程控制
1、程序结构
- 顺序结构：按照书写顺序执行的语句构成的程序段,从上往下执行，每句必走
- 分支结构：有条件的执行不同的语句，并非每句都走
- 循环结构：循环条件满足的情况下，反复执行一段相同或相似的代码
2、if条件语句
主要用于告诉程序在某个条件成立的情况下执行某段语句。语法结构和执行过程如下：
1)语法: if(boolean){ 语句块; } 2)执行过程: 判断boolean的值: 若为true，则执行语句块(if结束) 若为false，则if直接结束 3、if...else语句
如果满足某种条件，就进行某种处理，否则就进行另一种处理。语法结构和执行过程如下：
1)语法: if(boolean){ 语句块1 }else{ 语句块2 } 2)执行过程: 判断boolean的值: 若为true，则执行语句块1(整个结束) 若为false，则执行语句块2(整个结束) 3)说明: 语句块1和语句块2，必走其中之一-----------2选1 4、if...else...if语句
针对某一事物的多种情况进行处理，通常表现为“如果满足某种条件就进行某种处理，如果满足另一种条件就进行另一种处理”。语法结构和执行过程如下：
1)语法: if(boolean-1){ 语句块1 }else if(boolean-2){ 语句块2 }else if(boolean-3){ 语句块3 }else{ 语句块4 } 2)执行过程: 判断boolean-1，若为true则执行语句块1(结束)，若为false则 再判断boolean-2，若为true则执行语句块2(结束)，若为false则 再判断boolean-3，若为true则执行语句块3(结束)，若为false则执行语句块4(结束) 3)说明: 语句块1/2/3/4，只能执行其中之一---------多选1 5、switch...case语句
根据不同的值给出输出语句，实现多选一的效果。相比较而言，效率高，结构清晰，但是只能对整数判断相等。swich...case能作用在byte、short、int、char、String、枚举等类型的变量上。语法如下：
switch(用于判断的参数){ case 常量表达式1: 语句1; break; case 常量表达式2: 语句2; break; ... case 常量表达式n: 语句n; break; default: 语句n+1; break; } 6、while循环语句
利用一个条件来控制是否要继续反复执行一个语句。先判断后执行，有可能一次也不执行。语法如下：
1)语法: while(boolean){ 语句块-------------反复执行的代码 } 2)执行过程: 先判断boolean的值，若为true则执行语句块， 再判断boolean的值，若为true则再执行语句块， 再判断boolean的值，若为true则再执行语句块， 如此反复，直到boolean的值为false时，while循环结束 7、do...while循环语句
类似于while语句。但是do...while语句是先执行再判断，语句块至少执行一次。语法如下：
语法: do{ 语句块-------------反复执行的代码 }while(boolean)； 8、for循环语句
用来重复执行某条语句，知道条件得到满足(应用率最高)。语法如下：
1)语法: // 1 2 3 for(要素1;要素2;要素3){ 语句块/循环体--------------反复执行的代码 4 } 2)执行过程: 1243243243243243...2 说明：break 和 continue 关键字的区别： break：跳出循环，结束整个循环，开始执行循环之后的语句。可应用在Switch和循环语句中。 continue：跳过循环体中剩余语句，进入下一次循环，只能应用在循环中。 （八）数组
- 数组是一种引用类型，是相同数据类型元素的集合
//声明整型数组arr，包含10个元素，每个元素都是int类型，默认值为0 int[] arr = new int[10]; - 初始化：----初始化数组中的数据
int[] arr = new int[3]; int[] arr = {1,4,7}; int[] arr = new int[]{1,4,7}; int[] arr; //arr = {1,4,7}; //编译错误，此方式只能声明同时初始化 arr = new int[]{1,4,7}; //正确 - 访问：----访问的是数组中的元素
通过(数组名.length)可以获取数组的长度(元素个数)
int[] arr = new int[3]; System.out.println(arr.length); //3 - 通过下标/索引来访问数组中的元素，下标从0开始，最大到(数组长度-1)
int[] arr = new int[3]; System.out.println(arr[0]); //0，输出第1个元素的值 arr[0] = 100; //给第1个元素赋值为100 arr[1] = 200; //给第2个元素赋值为200 arr[2] = 300; //给第3个元素赋值为300 //arr[3] = 400; //运行时会发生数组下标越界异常 System.out.println(arr[arr.length-1]); //300，输出最后一个元素的值 - 数组的遍历/迭代：从头到尾挨个走一遍
int[] arr = new int[10]; for(int i=0;i<arr.length;i++){ //遍历arr数组 arr[i] = (int)(Math.random()*100); //给每个元素赋值为0到99之间的随机数 System.out.println(arr[i]); //输出每个元素的值 //arr[i]:代表的是arr中的每一个元素 } - 数组的复制
System.arraycopy(a,1,b,0,4);
int[] a = {10,20,30,40,50}; int[] b = new int[6]; //0,0,0,0,0,0 //a:源数组 //1:源数组的起始下标 //b:目标数组 //0:目标数组的起始下标 //4:要复制的元素个数 System.arraycopy(a,1,b,0,4); //灵活性好 for(int i=0;i<b.length;i++){ System.out.println(b[i]); } - 数组的扩容
int[] b = Arrays.copyOf(a,6);
a = Arrays.copyOf(a,a.length+1);
//数组的扩容 int[] a = {10,20,30,40,50}; //数组的扩容(创建了一个更大的新的数组，并将数据复制进去了) a = Arrays.copyOf(a,a.length+1); for(int i=0;i<a.length;i++){ System.out.println(a[i]); } - 数组的排序: Arrays.sort(arr);
int[] arr = new int[10]; for(int i=0;i<arr.length;i++){ arr[i] = (int)(Math.random()*100); System.out.println(arr[i]); } Arrays.sort(arr); //对arr进行升序排列 System.out.println(排序后:); for(int i=0;i<arr.length;i++){ System.out.println(arr[i]); }