Java学习笔记--Java基础语法

Java笔记--Java基础语法

目录

一、Java概述&基本语法

• 1、Java的不同版本
• 2、jdk & jre & jvm
• 3、jdk环境配置
• 4、常用的dos命令
• 5、注释
• 6、计算机存储单元
• 7、基本数据类型
• 8、类型转换
• 9、关键字

二、运算符

• 1、算术运算符结果类型问题
• 2、拓展的赋值运算符
• 3、逻辑运算符

三、流程控制语句

• 1、if和switch的区别

四、数组

• 1、数组的声明和初始化
• 2、数组的内存分配
• 3、二维数组
• 4、排序算法

---

一、Java概述&基本语法

1、Java的不同版本

JavaSE

是为开发普通桌面和商务应用程序提供的解决方案
该技术体系是基础，主要用于完成一些桌面应用程序的开发

JavaME

是为开发电子消费产品和嵌入式设备提供的解决方案，已经被安卓 IOS

JavaEE

是为开发企业环境下的应用程序提供的一套解决方案，主要用于开发企业级的web应用

2、jdk & jre & jvm

jdk（Java development kit）

jdk:Java开发工具包，包含jre和jvm

其中的开发工具有 编译工具（javac.exe）、执行工具（java.exe）、打包工具（jar.exe）

jre（Java Runtime Environment）

jre:java运行环境，包括Java虚拟机(JVM Java Virtual Machine)和Java程序所需的核心类库等

jvm（Java virtual machine）

整个java实现跨平台的最核心的部分,保证程序的跨平台性，以及编译执行写好的java程序！

不同的操作系统下载不同jvm

3、jdk的环境配置

1.新建系统变量JAVA_HOME，值为jdk的安装路径，不带bin

2.path系统变量新增%JAVA_HOME%/bin

4、常用的dos命令

操作	说明
盘符名称:	E:回车，表示切换到E盘。
dir	查看当前路径下的内容。
cd	目录 进入单级目录。cd JavaSE
cd..	回退到上一级目录。
cd 目录1\目录2...	进入多级目录。cd JavaSE\baiyunshan
cd\或cd/	回退到盘符目录。
cls	清屏。
exit	退出命令提示符窗口。

5、注释

//		单行注释

/*
		多行注释
*/

/**
		文档注释
*/

6、计算机的存储单元

单位	所占空间	描述
bit（位）	1位	只能存储一个零或者一个一，计算机存储的最小单位
byte（字节 简称b）	1byte=8bit	...
K	1k=1024b	...
M	1M=1024K	...
G	1G=1024M	...

7、基本数据类型（四类八种）

类型名称	种类名称	类型所占空间	表示范围
整形	byte	1B（B表示byte）	10000000(即-128)~01111111(即127)
	short	2B	-2的15次方~2的15次方-1
	int	4B	-2的31次方~2的31次方-1
	long	8B	-2的63次方~2的63次方-1
浮点型	float	4B
	double	8B
字符型	char	2B	0~65535
布尔型	boolean	1B	true、false

//浮点数表示方法：(符号)尾数E底数指数
//浮点型	float	4B	00000000 00000000 00000000 00000000
//				    | 符号位1位 | | 指数位8位 | | 尾数位23位 |
//		  表示的负数范围是-1

8、类型转换

8-1、自动类型转换

当把一个表数范围较小的数值或变量直接赋给另外一个表数范围比较大的变量时，系统将可以自动类型转换，否则需要强制转换。

8-2、强制类型转换

将表数范围大的数值或变量赋值给另外一个表数范围比较小的变量时，系统会编译不通过，这时需要进行强制类型转

//强制类型转换语法
//小类型 变量名 = （小类型）大类型数值或变量
int a = (int)123L;

8-3、常见问题

public class LXZH{
	public static void main(String [] args){
		byte b = 130;
		System.out.println(b);
	}
}
//报错为错误: 不兼容的类型: 从int转换到byte可能会有损失

public class LXZH{
	public static void main(String [] args){
		byte b = (byte)130;
		System.out.println(b);
	}
}
//将130强制转为byte型后输出为-126
//130的二进制数为10000010，因为int为8B
//130即00000000 00000000 00000000 10000010
//强制转为byte，截取后八位 10000010
//首位为符号位，1表示负数，因为计算机中数值都是用补码来存储的，负数的补码是原码取反加一
//即 11111110 转为十进制为-126

在计算机系统中，数值一律用补码来表示和存储。原因在于，使用补码，可以将符号位和数值域统一处理；同时，加法和减法也可以统一处理。

正数的补码：是它本身

负数的补码：除符号位外数值取反后加一

0:00000000（原码）= 00000000（反码）= 00000000（补码)

public class LXZH{
	public static void main(String [] args){
		long l = 123L;
		float f = l;
		//float f2 = 123.0;
		//long l2 = f2;
		System.out.println(f);
		//System.out.println(l2);
	}
}
//f值输出为123.0，long类型可以自动转换为float
//	虽然long类型在存储时占8B,float类型占4B,但float的存储结构不同
//	float的表数范围大于long

//将float转为long时报错，错误: 不兼容的类型: 从float转换到long可能会有损失

9、关键字

51+2

51个关键字+2个保留字（goto、const）

保留字为系统保留的，因为以后可能会用的到；

goto是用来跳转的、const是用来定义变量的

返回顶部

二、运算符

1、算术运算结果类型问题

提升规则

• byte、short、char类型之间的运算，结果将被提升到int类型

• 运算结果类型会自动提升到参与运算元素的最高等级类型

  等级顺序：byte|short|char| --> int --> long --> float --> double

代码

public class YSF{
	public static void main(String [] args){
		char c = 'a';
		byte b = 1;
		short s = 2;
		int i = 3;
		long l = 4L;
		float f = 5.0f;
		double d = 6.0;
		//short res1 = c + b;//错误: 不兼容的类型: 从int转换到short可能会有损失,可见运算结果为int
		//System.out.println(res1);
		int res2 = c + b + s;
		System.out.println(res2);//100
		//int res3 = i + l;//错误: 不兼容的类型: 从long转换到int可能会有损失
		//System.out.println(res3);
		long res4 = i + l;
		System.out.println(res4);//7
		//float res5 = f + d;//错误: 不兼容的类型: 从double转换到float可能会有损失
		//System.out.println(res5);
		double res6 = f + d;
		System.out.println(res6);//11.0
	}
}

2、拓展的赋值运算符

拓展的赋值运算符隐含了强制类型转换

// +=  -=  *=  /=  %=
short s = 10;
s = s + 10; // 此行代码报出，因为运算中s提升为int类型，运算结果int赋值给short可能损失精度

s += 10; // 此行代码没有问题，隐含了强制类型转换，相当于 s = (short) (s + 10);

3、逻辑运算符

符号	名称	描述
&	逻辑与	A&B,A和B都执行到判断真假，两者都为真时表达式为真，否则为假
&&	短路与	A&&B,先判断A的真假，A为假则不判断B，表达式为假，否者判断B
|	逻辑或	A|B,A和B都执行到判断真假，两者都为假时表达式为假，否则为真
||	短路或	A||B,先判断A的真假，A为真则不判断B，表达式为真，否者判断B
^	逻辑异或	A^B,A、B不同为真，相同为假

返回顶部

三、流程控制语句

1、if和switch的区别

1.语法不同

2.if为条件判断，switch为值匹配

switch底层使用的是boolean值来判断是否执行语句体，默认值为false，匹配到对应的值后变为true，匹配不到不对boolean做任何改变，因此若不使用break结束，则会从匹配到的地方一直执行到switch结束

返回顶部

四、数组

1、数组的声明和初始化

//数组的声明
//数据类型[] 数组名;
//数据类型 数组名[];

//数组的初始化
//1.静态初始化：数组定义时就确定数组元素的值；
//数据类型[] 数组名 = new 数据类型[]{元素，元素，...，元素};	简写为 数据类型[] 数组名 = {元素，元素，...，元素};
int[] arr = new int[]{1,1,1,2,2,3,4,5,6,9,10};
int[] arr1 = {1,1,1,2,2,3,4,5,6,9,10};

//2.动态初始化：必须指定数组的长度，元素的值可以等下动态的赋予
//数据类型[] 数组名 = new 数据类型[数组长度];
int[] arr2 = new int[10];

数组的默认值

• int类型数组：默认值为0
• double类型数组：默认值为0.0
• boolean类型数组：默认值为false
• char类型数组：默认值为'/u0000'--->' '(空)
• 引用类型数组：默认值为null

2、数组的内存分配

3、二维数组

//数据类型[][] 变量名 = new 数据类型[m][n];
//m表示二维数组中有几个一维数组
//n表示一维数组的元素个数，n在定义时可省略

4、排序算法

1.冒泡排序

基本思想：从第一个元素开始，依次每个元素和下一个元素两两比较，并交换位置使大值放在后面，一次循环后，最大的值就放在了最后面，循环n次后即由小到大排序完毕

核心代码

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

2.选择排序

基本思想：从第一个元素开始，依次和后面所有元素进行比较，如果比第一个元素小，则和第一个元素交换值，一趟下来将最小的元素放在了第一个；然后第二个元素和后面的元素进行比较......

核心代码

for (int i = 0; i < arr.length; i++) {
 int index = i;
 for (int j = i+1; j < arr.length; j++) {
     if (arr[index]>arr[j]){
         index = j;//找到值最小元素的索引
     }
 }
 int temp = arr[i];
 arr[i]=arr[index];
 arr[index]=temp;
}

3.插入排序

基本思想：是将一个记录插入到已经排好序的有序表中，从而一个新的、记录数增1的有序表。在其实现过程使用双层循环，外层循环对除了第一个元素之外的所有元素，内层循环对当前元素前面有序表进行待插入位置查找，并进行移动

核心代码

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

过程图解

4.希尔排序

基本思想：希尔排序（ShellSort）又称缩小增量排序，该算法是一个泛化的插入排序。希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止

核心代码

for (int g = (arr.length+1)/2; g > 0; g = g/2) {
    System.out.println(g);
    for (int i = g; i < arr.length; i++) {
        if (arr[i]<arr[i-g]){
            int temp = arr[i];
            arr[i] = arr[i-g];
            arr[i-g] = temp;
        }
    }
    if(g%2==1&&g!=1)
        g++;
}

5.查找算法

1.顺序查找

• 基本思想：按顺序比较每个元素，直到找到关键字为止
• 时间复杂度：O(n)

什么是时间复杂度，时间复杂度就是当数据量增大时，完成功能所耗时间的增加规律

2.二分查找

• 基本思想：对于有序序列，先从序列的中间元素开始查找，如果刚好为中间元素则结束查找，否则比较和中间元素的大小；如果大于中间元素则从中间元素的右边进行查找，查找方式和开始一样先查找中间元素；如果小于则从左边进行查找；直到找到或查完为止
• 时间复杂度：O(logn)
• 核心代码

int index=-1;//记录查找到元素在序列中的位置
int count = 0;
int min = 0;
int max = arr.length;
while(count<arr.length){
    int mid = (min+max)/2;
    if (f == arr[mid]){
        index = mid;
        break;
    }else if (f < arr[mid]){
        max = mid;
    }else{
        min = mid;
    }
    count++;
}

3.二叉树查找

4.哈希查找

返回顶部

学习到的工具类

一、Scanner工具类

用于扫描和接收用户的输入

用法

//1.导包
import Java.util.Scanner;
//2.创建对象
Scanner scanner = new Scanner();
//3.使用相关方法接收输入
scanner.nextInt();

二、Random工具类

用于生成随机数

用法

//1.导包
import Java.util.Random;
//2.创建对象
Random random = new Random();
//3.使用相关方法
random.nexInt(100);//生成100以内的整数，不包含100

循环:减少代码冗余，提高代码复用性，增强程序的可维护性