(一）Java编译运行过程
编译时间：编译Java源文件生成.class字节码文件
运行时：JVM 加载 .class 并运行 .class
特点：跨平台，一次编译，随处使用（跨平台特点如下图）
(二）JVM、JRE、JDK
JVM：（Java），Java虚拟机
JRE：（Java），Java运行环境，除了JVM，还包括运行Java程序所必需的环境，JRE = JVM + Java Class
JDK：（Java Kit），Java开发工具包，JDK = JRE + 编译运行命令工具
(三）变量名
在程序执行过程中，可以改变值的变量称为变量，不能改变值的变量称为常量。变量和常量都必须使用合法标识符命名
变量的命名应遵循以下规则：
-只能包含字母、数字、_和$符，并且不能以数字开头
-严格区分大小写
-不能使用关键字
-允许中文命名，但不建议，建议"英文的见名知意"、"小驼峰命名法"
(四）代码注释
程序代码的可读性可以通过在程序代码中添加注释来提高它帮助程序员更好地阅读和理解程序。 Java语言提供了3种添加注释的方法，分别是单行注释、多行注释和文档注释。
(五）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、类型之间的数据转换
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 中的运算符
算数运算符自增（++）、自减（--）使用的两种不同情况：
单独使用时：在前在后都是会使值自增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的值:
![图片[1]-Java语言基础-唐朝资源网](https://images.43s.cn/wp-content/uploads//2022/06/1655205345376_3.png)
若为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、…案例陈述
根据不同的语句给出输出，达到多选的效果。相对而言，它效率高，结构清晰，但只能判断整数是否相等。 swich…case 可以作用于 byte、short、int、char 和 等类型的变量。语法如下：
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}; //正确
int[] arr = new int[3];
System.out.println(arr.length); //3
int[] arr = new int[3];
System.out.println(arr[0]); //0，输出第1个元素的值
arr[0] = 100; //给第1个元素赋值为100
![图片[2]-Java语言基础-唐朝资源网](https://images.43s.cn/wp-content/uploads//2022/06/1655205345376_5.jpg)
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中的每一个元素
}
@ >
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[] 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]);
}
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]);
}
© 版权声明
本站下载的源码均来自公开网络收集转发二次开发而来，
若侵犯了您的合法权益，请来信通知我们1413333033@qq.com，
我们会及时删除，给您带来的不便，我们深表歉意。
下载用户仅供学习交流，若使用商业用途，请购买正版授权，否则产生的一切后果将由下载用户自行承担，访问及下载者下载默认同意本站声明的免责申明，请合理使用切勿商用。
THE END
暂无评论内容