java基础语法详解

最新推荐文章于 2024-07-30 20:50:32 发布

宇戰天0910

最新推荐文章于 2024-07-30 20:50:32 发布

阅读量465

点赞数 1

分类专栏： java基础文章标签： java

本文链接：https://blog.csdn.net/qq_46000014/article/details/106503795

版权

java基础专栏收录该内容

3 篇文章 0 订阅

订阅专栏

java基础语法

一，开发环境的搭建

jdk,jre,jvm的关系

在这里插入图片描述

JDK的下载、安装

下载：官网，github
安装：傻瓜式安装：JDK 、JRE
注意问题：安装软件的路径中不能包含中文、空格。

path环境变量的配置

为什么要配置path环境变量？
path环境变量：Windows操作系统执行命令时所需要搜寻的路径。

为什么要配置path环境变量：
希望java的开发工具（javac.exe，java.exe）在任何文件下都可以执行成功。

如何配置环境变量？

JAVA_HOME=D:\jdk1.8.0_131
path=%JAVA_HOME%\bin;

编写自己第一个java程序

创建一个java源文件为HelloWorld.java

class HelloWorld{
	public static void main(String[] args){
		System.out.println("HelloWorld");
	}
}

第一步
编译：javac HelloWorld.java
第二步
运行：java HelloWorld

总结自己的第一个java程序

java程序编写–编译–运行的过程
编写：我们将编写的java代码保存在以“.java”结尾的源文件中
编译：使用javac.exe命令编译我们的java源文件。格式：javac 源文件名.java。
运行：使用java.exe命令解析运行我们的字节码文件。格式：java 类名
在一个java源文件中可以声明多个class。但是，只能最多有一个类声明为public的。而且要求声明为public的类的类名必须与源文件名相同。
程序的入口是main()方法。格式是固定的。
输出语句：
System.out.println();显示输出数据，然后换行。
System.out.print()；只输出数据。
每一行执行语句都以“;”结束。
编译过程：
编译之后会生成一个或多个字节码文件。字节码文件的文件名与java源文件中的类名相同。

java的基本语法

关键字与标识符

java关键字

定义：被java语言赋予了特殊含义，用作专门用途的字符串(单词)
特点：关键字中所有字母小写。

保留字

现Java版本尚未使用，但以后版本可能会作为关键字使用。
注意：自己命名标识符时要避免使用这些保留字。

标识符

定义：凡事自己可以起名字的地方都叫标识符。
涉及到的结构：
包名、类名、接口名、变量名、方法名、常量名
规则：（必须遵守。否则编译不通过。）

由26个字母大小写，0~9,_或者$组成；
数字不能开头；
不能使用关键字和保留字，但能包含关键字和保留字；
java中雅阁区分大小写长度无限制。
标识符不能包含空格。

规范：（可以不遵守，不影响编译和运行。但是要求遵守）

包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
变量名、方法名：多单词组成时，第一个首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
常量名：所有字母大写。多单词时每个单词之间用下划线连接：XXX_YYY_ZZZ
注意：在起名字是为了提高阅读性，要尽量“见名知意”。

变量的分类

按数据类型分类

基本数据类型
整数型：byte(1字节=8bit) \ short(2字节) \ int(4字节) \ long(8字节)

byte范围：-128 ~ 127
声明long型变量，必须以"l"或"L"结尾
通常，定义整型变量时，使用int型。

浮点型：float(4字节) \ double(8字节)

浮点型，表示带小数点的数值
float表示数值的范围比long还大
定义float类型变量时，变量要以"f"或"F"结尾
通常，定义浮点型变量时，使用double型。
浮点型的常量，默认类型为：double

字符型：char (1字符=2字节)

定义char型变量，通常使用一对’’,内部只能写一个字符
表示方式：1.声明一个字符 2.转义字符 3.直接使用 Unicode 值来表示字符型常量

布尔型：boolean

只能取两个值之一：true 、 false
常常在条件判断、循环结构中使用、

按声明位置分类
成员变量

实例变量（不以static修饰）
类变量（以static修饰）

局部变量

形参（方法、构造器中定义的变量）
方法局部变量（在方法中定义）
代码块局部变量（在代码块中定义）

定义变量的格式

数据类型变量名 = 变量值;
或
数据类型变量名;
变量名 = 变量值;

变量使用的注意点：

变量必须先声明，后使用
变量都定义在其作用域内。在作用域内，它是有效的。换句话说，出了作用域，就失效了
同一个作用域内，不可以声明两个同名的变量

基本数据类型变量间的运算规则

涉及到的基本数据类型：除boolean之外的其它七种数据类型。
当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
当byte、char、short三种类型的变量做运算时，结果为int型。

强制类型转换

只涉及7种基本数据类型
自动类型提升运算的逆运算
需要使用强转符：()
强制类型转换，可能导致精度损失。

String与8种基本数据类型间的运算

String属于引用数据类型,翻译为：字符串
声明String类型变量时，使用一对""
String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+
运算的结果仍然是String类型

运算符

算数运算符
在这里插入图片描述
注意

如果对负数取模，可以把模数负号忽略不记，如：7%-2=1。但被模数是
负数则不可忽略。此外，取模运算的结果不一定总是整数。
对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只
保留整数部分而舍弃小数部分。
“+”除字符串相加功能外，还能把非字符串转换成字符串。

赋值运算符
符号：=
当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制
类型转换原则进行处理。

扩展赋值运算符： +=, -=, *=, /=, %=

比较运算符
在这里插入图片描述
比较运算符的结果都是boolean型，也就是要么是true，要么是false。

逻辑运算符
在这里插入图片描述
“&”和“&&”的区别：
单&时，左边无论真假，右边都进行运算；
双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
“|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。
异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。
位运算符
在这里插入图片描述
位运算细节

<< 空位补0，被移除的高位丢弃，空缺位补0。
.>> 被移位的二进制最高位是0，右移后，空缺位补0；
最高位是1，空缺位补1。
.>>> 被移位二进制最高位无论是0或者是1，空缺位都用0补。
& 二进制位进行&运算，只有1&1时结果是1，否则是0;
二进制位进行 | 运算，只有0 | 0时结果是0，否则是1;
^ 相同二进制位进行 ^ 运算，结果是0；1^1=0 , 0^0=0
不相同二进制位 ^ 运算结果是1。1^0=1 , 0^1=1
~ 正数取反，各二进制码按补码各位取反
负数取反，各二进制码按补码各位取反

三元运算符
三元运算符：(条件表达式)? 表达式1 : 表达式2
根据条件表达式真或假，决定执行表达式1，还是表达式2.
如果表达式为true，则执行表达式1。
如果表达式为false，则执行表达式2。

流程控制

分支结构

1. if-else条件判断结构
结构1

if（条件表达式）{
 		执行表达式
 	}

` 结构二：二选一

if(条件表达式){
	执行表达式1
}else{
	执行表达式2
}

`
结构三：N选一

if(条件表达式){
	执行表达式1
}else if(条件表达式){
	执行表达式2
}else if(条件表达式){
	执行表达式3
}
...
else{
	执行表达式n
}

注意：
1.else 结构是可选的
2.针对于条件表达式：
–>如果多个条件表达式之间是“互斥”关系(或没有交集的关系),哪个判断和执行语句声明在上面还是下面，无所谓。
–>如果多个条件表达式之间有交集的关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面。
–>如果多个条件表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没机会执行了。
3.if else 结构是可以相互嵌套的。
4.如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略的。但是，不建议大家省略。
。
2. switch-case选择结构

switch(表达式){
			case 常量1:
					执行语句1;
					break;
			case 常量2:
					执行语句2;
					break;
					...
					default:
					执行语句n;
					break;
			}

注意

根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构末尾结束为止。
break,可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构
switch结构中的表达式，只能是如下的6种数据类型之一：
byte 、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增)
case 之后只能声明常量。不能声明范围。
break关键字是可选的。
default:相当于if-else结构中的else
default结构是可选的，而且位置是灵活的。

循环结构

循环结构的四要素
1.初始化条件 2.循环条件 3. 循环体 4.迭代条件
通常情况下，循环结束都是因为2中的循环条件返回false。

for循环

for(初始化条件;循环条件;迭代条件){
	循环体
}
执行过程：1--2--3--4---2--3--4--...--2

while循环

初始化条件
while(循环条件){
	循环体;
	迭代条件;
}
执行过程：1--2--3--4---2--3--4--...--2
在while循环中丢失迭代条件会导致死循环

for循环和while循环的总结：

开发中，基本上我们都会从for、while中进行选择，实现循环结构。
for循环和while循环是可以相互转换的！
区别：for循环和while循环的初始化条件部分的作用范围不同。
注意迭代条件不可丢失。

do-while循环

初始化条件
do{
	循环体;
	迭代条件;
}while(初始化条件);
执行过程：1--3--4--2--3--4--...--2

do-while循环至少会执行一次循环体

“无限循环”结构:

while(true) 或 for(;;)
总结：如何结束一个循环结构？
方式一：当循环条件是false时
方式二：在循环体中，执行break

嵌套循环
嵌套循环:将一个循环结构A声明在另一个循环结构B的循环体中,就构成了嵌套循环
内层循环：循环结构A
外层循环：循环结构B

//循环结构B
for(int i =0 ;i <= m;i++){
//循环结构A
	for(int j = 0; j<=n;j++){
		循环体A;
	}
}

内层循环结构遍历一遍，只相当于外层循环循环体执行了一次
假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体一共执行了m * n次
外层循环控制行数，内层循环控制列数。

break和continue关键字的使用
在这里插入图片描述

数组

一、数组的概述
1. 数组的理解
数组（array),是多个相同数据类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
2. 数组的相关概念
数组名
元素
角标、下标、索引
数组的长度：元素的个数
3. 数组的特点

数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
数组的长度一旦确定，就不能修改。
创建数组对象会在内存中开辟一整块连续的空间。
数组是有序排列的。

数组的分类
按照维数分类：一维数组，二维数组
按照数组元素的类型分类：基本数据类型的数组、引用数据类型的数组

一维数组

一维数组的初始化和声明

	int num;//声明
		num = 10;//初始化
		int id = 1001;//声明 + 初始化
		
		int[] ids;//声明
		//1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行
		ids = new int[]{1001,1002,1003,1004};
		//1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
		String[] names = new String[5];

	int[] arr4 = {1,2,3,4,5};//类型推断

调用数组的指定位置的元素
通过角标的方式调用，数组的角标（或索引）从0开始，到数组的长度-1结束。

如何获取数组的长度：属性：length

int[] arr = new int[]{1,2,3,5,6,7};
System.out.println(arr.length);

说明：
数组一旦初始化，其长度就是确定的。arr.length
数组长度一旦确定，就不可修改。
一维数组的遍历

for(int i = 0;i < narr.length;i++){
	System.out.println(arr[i]);
}

二维数组
二维数组的初始化和声明

	int[] arr = new int[]{1,2,3};//一维数组
		//静态初始化
		int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
		//动态初始化1
		String[][] arr2 = new String[3][2];
		//动态初始化2
		String[][] arr3 = new String[3][];
	//也是正确的写法：
		int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
		int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};//类型推断

调用二维数组的元素

		System.out.println(arr1[0][1]);
		System.out.println(arr2[1][1]);
		
		arr3[1] = new String[4];
		System.out.println(arr3[1][0]);
		System.out.println(arr3[0]);

二维数组的属性

		System.out.println(arr4.length);
		System.out.println(arr4[0].length);
		System.out.println(arr4[1].length);

遍历二维数组

	for(int i = 0;i < arr4.length;i++){
			
			for(int j = 0;j < arr4[i].length;j++){
				System.out.print(arr4[i][j] + "  ");
			}
			System.out.println();
	}

数组的常见算法

数组的赋值与复制

int[] array1,array2;
array1 = new int[]{1,2,3,4};

//数组的赋值
array2 = array1;
//如何理解：将array1保存的数组的地址值赋给了array2，使得array1和array2共同指向堆空间中的同一个数组实体。
//数组的复制
array2 = new int[array1.length];
for(int i = 0;i < array2.length;i++){
array2[i] = array1[i];
}
//如何理解：我们通过new的方式，给array2在堆空间中新开辟了数组的空间。将array1数组中的元素值一个一个的赋值到array2数组中。

数组元素的反转
方法一

		for(int i = 0;i < arr.length / 2;i++){
			String temp = arr[i];
			arr[i] = arr[arr.length - i -1];
			arr[arr.length - i -1] = temp;
					}

方法二：

		for(int i = 0,j = arr.length - 1;i < j;i++,j--){
			String temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
	}

数组的排序
冒泡排序

	public class Order {
	  public static void main(String [] args){
	      //创建数组arr
	      int[] arr = new int[]{1,22,33,21,45,63,66,22};
	      //循环遍历数组
	      for(int i = 0;i<arr.length;i++){
	         // System.out.println(arr[i]);
	          for(int j = 0;j<arr.length-1-i;j++){
	              if(arr[j]<arr[j+1]){
	                  //创建中间变量
	                  int temp = arr[j];
	                  arr[j] = arr[j+1];
	                  arr[j+1] = temp;
	              }
	          }
	      }
	      //打印排序之后的数组
	      for (int i = 0;i<arr.length;i++){
	          System.out.print(arr[i]+" ");
	      }
	  }
	}

直接排序

		class Order2 {
		  public static void main(String[] args) {
				//创建数组arr
		     int[] arr = new int[]{1,22,33,21,45,63,66,22};
				//遍历数组
		      for (int i = 0; i < arr.length-1; i++) {
					//比较项
		          for (int j = i+1; j < arr.length; j++) {
		              if (arr[i] > arr[j]) {
							//给中间变量
							int temp = arr[i];
							arr[i] = arr[j];
							arr[j] = temp;
		              }
		          }
		      }
				//遍历排序之后的数组
		      for (int i = 0; i < arr.length; i++) {
		          System.out.print(arr[i]+" ");
		      }
		  }
		}

选择排序

		class Order3{
			public static void main(String[] args) {
				//创建数组
				int[] arr = new int[]{1,22,33,21,45,63,66,22};
				//定义数组索引值
				int index;
				for(int i=1;i<arr.length;i++) {
					//初始化数组索引值
					index=0;
					for(int j=1;j<=arr.length-i;j++) {
						if(arr[index]<arr[j]) {
							index=j;
						}
					}
					int temp=arr[arr.length-i];
					arr[arr.length-i]=arr[index];
					arr[index]=temp;
				}
				for(int k : arr) {
					System.out.print(k+" ");
				}
			}
		}

Arrays工具类的使用

//1.boolean equals(int[] a,int[] b):判断两个数组是否相等。
		int[] arr1 = new int[]{1,2,3,4};
		int[] arr2 = new int[]{1,3,2,4};
		boolean isEquals = Arrays.equals(arr1, arr2);
		System.out.println(isEquals);
		
		//2.String toString(int[] a):输出数组信息。
		System.out.println(Arrays.toString(arr1));
		
			
		//3.void fill(int[] a,int val):将指定值填充到数组之中。
		Arrays.fill(arr1,10);
		System.out.println(Arrays.toString(arr1));
		

		//4.void sort(int[] a):对数组进行排序。
		Arrays.sort(arr2);
		System.out.println(Arrays.toString(arr2));
		
		//5.int binarySearch(int[] a,int key)
		int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
		int index = Arrays.binarySearch(arr3, 210);
		if(index >= 0){
			System.out.println(index);
		}else{
			System.out.println("未找到");
		}

数组常见的异常
数组角标越界异常：ArrayIndexOutOfBoundsException


		int[] arr = new int[]{1,2,3,4,5};
		
		for(int i = 0;i <= arr.length;i++){
			System.out.println(arr[i]);
		}
		
		System.out.println(arr[-2]);
		
		System.out.println("hello");

空指针异常：NullPointerException

	//情况一：
		int[] arr1 = new int[]{1,2,3};
		arr1 = null;
		System.out.println(arr1[0]);
		
		//情况二：
		int[][] arr2 = new int[4][];
		System.out.println(arr2[0][0]);
		
		//情况：
		String[] arr3 = new String[]{"AA","BB","CC"};
		arr3[0] = null;
		System.out.println(arr3[0].toString());

宇戰天0910

关注

1
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
java基础语法详解

java基础语法一，开发环境的搭建jdk,jre,jvm的关系JDK的下载、安装下载：官网，github安装：傻瓜式安装：JDK 、JRE注意问题：安装软件的路径中不能包含中文、空格。path环境变量的配置为什么要配置path环境变量？path环境变量：Windows操作系统执行命令时所需要搜寻的路径。为什么要配置path环境变量：希望java的开发工具（javac.exe，java.exe）在任何文件下都可以执行成功。如何配置环境变量？JAVA_HOME=D:\jdk1.8.
复制链接

扫一扫

专栏目录