java学习笔记1

java学习

参考视频：https://www.bilibili.com/video/BV1Kb411W75N?p=167
注意：其中代码部分可能有错，没有运行

第一章java语言概述

对第一个Java程序进行总结
编写：我们将编写的java代码保存在以“.java”结尾的源文件中
编译：使用javac.exe命令编译我们保存的java源文件，格式： javac 原文件名.java
运行：使用java.exe命令解释运行我们的字节码文件 格式 java 类名

1. java程序编写-编译-运行的过程。

2. 在一个java源文件中可以声明多个class 但是，只能最多有一个类声明为public的，而且要求声明为public的类的类名必须与源文件名相同。

3. 程序的入口是main（）方法。格式是固定的。

4. 输出语句：区别是一个换行一个不换行。

System.out.println();
System.out.print();

5. 每一行执行语句都以“；”结束。

6. 编译的过程：编译之后，会生成一个或者多个字节码文件，字节码文件的文件名和java源文件中的类名相同。

第二章 基本语法

2.1 关键字与保留字

保留字
goto const

标识符规则

• 由英文字母 0-9 或者$组成。
• 数字不能开头
• Java严格区分大小写
• 不可以使用关键字和保留字

java中的名称命名规范

• 包名：多单词组成时所有字母都小写xxyyaa
• 类名、接口名：多单词时，所有单词的首字母大写
• 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写
• 常量名：所有字母都大写，多单词时每个单词用下划线连接：XXX_YYY_ZZZ

注意：java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用。

2.3 变量

变量是程序中最基本的存储单元，包含变量类型，变量名和存储变量的值。

说明

• 变量先声明后使用
• 变量都定义在其作用域内，在作用域内才有效
• 同一个作用于内，不能定义两个相同的变量名

java定义的数据类型

整形：byte（1字节）、short（2字节）、int（4字节）、long（8字节）

byte：范围： -128-127
long型变量必须以“L”或者“l”结尾，可能会报错也可能不会，如果数比较小，可能以int为类型，就不会报错

浮点型

float（4字节）尾数可以精确到7位有效数字、double（8字节）
java 的浮点型常量默认为double型，声明float型常量，需在后面加上“f”，或者“F”。这个必须加f，F

float f1 = 12.3F;
System.out.println(fl);

通常使用double类型

字符型

char（2字节）
定义char类型变量，通常使用一对‘ ’
内部只能写一个字符中日韩等等都行

char c1 = 'a';
char c2 = '中';

布尔型

boolean
只能取两个值：true false
常常在条件判断 循环判断中使用

数据类型之间的运算规则

前提：不包含布尔类型

• 自动类型提升：
  当容量小的变量和容量大的做运算，自动提升为容量的数据类型
  容量大小指的是表示数的范围的大和小
  char byte short —> int --> long --> float —> double
  注意 byte char short 做运算 结果为int型

• 强制类型转换：
  自动类型提升的逆运算
  需要使用强转符：（）
  可能会导致精度损失

class Test{
	public static void main(string[] agrv){
		
		byte b1 = 2;
		int a1 = 12;
		int i2 = b1 + a1;//可以
		float f = b1 + a1;//可以，输出14.0
		char c1 = 'a';
		int i3 = 10;
		int i4 = c1 + i3;//可以 i4结果为107
		short s2 = 10;
		char c2 = s3 + c1;//编译不通过
		
	}
}

注意
整形常量 默认类型为int型
浮点型常量 默认为double型

byte b = 12;
byte b1 = b + 1;//编译失败

字符串类型 ：String

• String是引用数据类型
• 声明String类型变量时，使用一对“”
• Srting可以和8种基本数据类型做运算
• 运算结果为String类型

int number = 1001;
String numberStr = "学号";
String info = numberStr + number;//+ 连接运算

进制

2.4 运算符

• 算术运算符
• 赋值运算符
• 比较运算符
• 逻辑运算符
• 位运算符
• 三元运算符

算数运算符

注意
取余运算—结果的符号与被模数的符号相同

这里不再赘述其他知识，基础知识和c语言类似

赋值运算符

支持连续赋值

short s1 = 10;
s1 = s1 + 2;//编译失败
s1 +=c2;//12 不会改变变量本身数据类型

比较运算符

逻辑运算符

说明

逻辑运算符操作的都是boolean类型
区分&和&&：

• 相同点：运算结果相同
• 不同点：当符号左边是false时，&继续执行符号右边的运算，&&不再执行符号右边的运算。
  |与||同理

位运算符

结论

1. 位运算操作的都是整形的数据
2. 在一定范围内，每向左移一位，相当于*2，每向右移一位/2

三元运算符

运算符的优先级

2.5程序流程控制

顺序结构
分支结构
循环结构
（注：其实也和C语言差不多，不多赘述，有重点，遗漏点就提一下）

if-else结构

在这之前，先考虑如何从键盘获取不同类型的变量：
需要使用Scanner类具体实现步骤

• 导包：

import java.util.Scanner;

• Scanner的实例化：

Scanner scan = new Scanner(System.in);

• 调用Scanner类的相关方法，来获取指定类型的变量

int num = scan.nextInt();
String name = scan.next();
double weight = scan.nextDouble();
boolean isLove = scan.nextBoolean();

注意

• 对于char类型的获取，Scanner没有提供相关方法，只能能获取一个字符串
• 要根据相应的方法，来输入指定类型，如果输入的数据类型和要求的不匹配时，会报异常，导致程序终止。

if-else-结构

说明

1. else 结构是可选的。
2. if-else结构可以嵌套。
3. 如果if-else的执行语句只有一行时，{}可以省略（不建议省略）。
4. 就近原则

如何获取一个随机数10-99

int value =int(Math.random()*90+10);//[10-100)--->[10,99]

switch-case结构

说明

格式与C语言一样

• 根据switch表达式的值，依次匹配各个case的值，一旦匹配成功，则进入到相关case中，调用执行语句，直到遇到break或者到结构末尾结束为止。
• switch结构的表达式，只能是6种数据结构之一：byte char int 枚举类型 String类型。
• case之后只能声明常量。
• default结构也是可选的，位置也是灵活的。
• 凡是可以使用switch-case的结构，都可以转换成if-else，反之，不成立。

循环结构

• for循环
• while循环
• do-while循环
  循环结构的四个要素
  1初始化条件
  2循环条件---->是boolean类型,与C语言不同。
  3循环体
  4迭代条件

for循环

for循环结构与C语言一样

在这里，sum没有初始化，所以运行会报错。

while循环

注意：写while循坏千万小心不要丢了迭代条件，一旦丢了，可能导致死循环。
for循环和while循环可以相互转化。

do-while循环

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

不在循环条件部分限制次数的结构

for(;;)
while(true)

嵌套循环

经典例题
打印三角形，冒泡排序，九九乘法表，100内质数输出。

特殊关键字的使用

break：结束当前循环
continue：结束当次循环

带标签的break与continue

技巧：外层控制行数，内层控制列数。

**补充：**衡量一个功能代码的优劣：

1. 正确性
2. 可读性
3. 健壮性
4. 高效率与低存储： 时间复杂度，空间复杂度

第三章数组

数组的概述

数组（array），是多个相同类型的数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对数组进行统一管理。

• 数组属于引用数据类型的变量，数组的元素既可以是基本数据类型，也可以是引用数据类型。
• 数组是有序排列的
• 数组的长度一旦确定，不能修改
• 创建数组对象会在内存中开辟一整块连续的空间

一维数组的使用

1.一维数组的声明与初始化
静态初始化：数组的初始化和数组元素的赋值操作同时进行
动态初始化：数组的初始化和数组元素的赋值操作分开进行

int[] ids;//声明
ids = new int[]{1001,1002,1003,1004};//静态初始化
String[] names = new String[5];//动态初始化

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

数组一旦初始化完成，其长度就确定了。
2.如何调用数组指定位置的元素

names[0] = "张三";
names[1] = "李四";
names[2] = "王二";
names[3] = "麻子";
names[4] = "小陈";

3.如何获得数组的长度

#属性：length
System.out.println(names.length);//5

```java

4.如何遍历数组
可以for循环遍历

5.数组元素的默认初始化值

• 数组元素是整形：0
• 数组元素是浮点型：0.0
• 数组元素是char型：0或者‘\u0000’,而非‘0’
• 数组元素是布尔类型：false
• 数组元素是引用数据类型：null

6.数组的内存解析
栈和堆

多维数组的使用（二维数组的使用）

从数组的底层机制来看，其实没有多维数组

二维数组的使用

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

```java

int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};//静态初始化
int arr1[][] = new int[][]{{1,2,3},{4,5},{6,7,8}};//静态初始化

String[][] arr2 = new String[3][2];//动态初始化1
String[][] arr3 = new String[3][];//动态初始化2

2.如何调用数组中的指定元素

System.out.println(arr1[0][1]);//2
System.out.println(arr2[1][1]);//null
System.out.println(arr3[1][0]);//报错

3.获取数组的长度
也是用length

4.如何遍历二维数组

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

5.数组元素的默认初始化值
规定：二维数组分为外层数组的元素，内层数组的元素

int[][] arr = new int[4][3];
System.out.println(arr[0]);//打印的结果是一个地址值
System.out.println(arr[0][0]);//0

其他类型的同理

double[][] arr3 = new double[4][];
System.out.println(arr3[1]);//null

数组中常见的算法

数组的赋值（杨辉三角，回形数）

public class ArrayTest{
	public static void main(String[] args){
		int[] arr = new int[10];
		for(int i =0;i < arr.length;i++){
			arr[i] = int(Math.random()*(99-10+1)+10);
		}
		int maxValue = arr[0];
		for(int i = 1;i < arr.length;i++){
			if(arr[i] > maxValue){
				maxValue = arr[i];
			}
		}
		System.out.println("最大值为" + maxValue);
	}
}

有关数组的复制

int[] arry1,arry2;
array1 = new int[]{2,3,5,7,11,17,19};
array2=array1;

提问：array1和array2是什么关系？
array1和array2的地址值相同，都指向了堆空间的唯一的一个数组实体。

线性查找

String[] arr = new String[]{"AA","BB","CC","DD","EE"};
String dest = "BB";
boolean isFlag = true;
for(int i = 0;i < arr.length;i++){
	if(dest.equals(arr[i]){
		System.out.println("fing! 位置在：" + i);
		isFlag = false;
		break;
	}
}
if(isFlag){
	System.out.println("NOT Find");
}

二分查找
前提:所要查找的数组必须有序

int[] arr2 = new int[]{1,2,4,5,6,7,12,34,56,78};

int dest = 4;
int head = 0;
int end = arr2.length - 1;
while(head <= end){
	int middle = (head + end)/2;
	if(dest == arr2[middle]){
		System.out.println("zhaodaole");
		break;
	}else if(arr2[middle] > dest){
		end = middle - 1;
	}else{
		head = middle + 1;
	}
}

排序

冒泡排序

public class Main{
	public static void main(String[] args){
		int[] arr = new int[]{4,3,2,45,7,8,956,88};
		for(int i = 0;i < arr.length - 1;i++){
			if(int j = 0;j < arr.length - 1 - i;j++){
				if(arr[j] > arr[j+1]){
					int temp = a[j];
					arr[j] = arr[j+1];
					a[j+1] = temp;
				}
			}
		}
	}
}
					

Arrays工具类的使用

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);//false

System.out.println(Arrays.toString(arr1));//[1,2,3,4]

Arrays.fill(arr1,10);
System.out.println(Arrays.toString(arr1));//[10,10,10,10]

Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));//[1,2,3,4]

数组使用中的常见异常

1. 数组角标越界的异常
2. 空指针异常

//空指针异常
//请况1
int[] arr = new int[]{1,2,3};
arr1 = null;
System.out.println(arr[0]);
//情况2
String[] arr1 = new String[]{"AA","BB","CC"};
arr1[0] = null;
System.out.println(arr1[0].toString());