类别：程序开发
日期：2022-05-08 浏览：1645 评论：0
（一）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选14、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，只能执行其中之一---------多选15、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]);
}
您阅读本篇文章共花了： 
发表评论 / 取消回复