Java

Java基础 -> Java 8……-> ?

Java基础

​ 这是我自学Java基础的部分，参考了韩顺平老师的视频课程【零基础 快速学Java】韩顺平 零基础30天学会Java_哔哩哔哩_bilibili，因为有一点点在学校学的C++基础，因此从头到尾xx便天刷完了，完全小白跟着课一点一点走是完全没问题的。感觉讲的很细很实用而且有项目实战，受益匪浅。

​ And以下的内容仅是依据我个人的能力、习惯等编写的，有些我认为不重要的或者说我已经掌握了的内容就没有再重复写到这篇笔记中，请前来阅读参考的小伙伴们注意一下。

Chapter1 简介

Java特点

  • 面向对象的
  • 强类型机制、异常处理、垃圾自动收集等保证Java程序的健壮
  • 跨平台的
  • 解释型的
  • 对字符大小写、输出时空格敏感
  • ；结束不可省
  • 一个源文件最多一个public类，其他类个数不限
  • 文件名按public类名命名
  • 源文件以.java为扩展名，源文件的基本组成部分是类（class）
  • 执行程序的入口是main（）方法，且入口可以是非public的main（）方法

Java开发环境、工具等

​ JDK（java开发工具包，开发者必备）=JRE+java开发工具（java、javac、javadoc等等）

​ JRE（java运行环境，非开发者只需此即可运行java程序）=JVM（java虚拟机，能在不同操作系统上跑出来就靠它了）+java核心类库

转义字符

​ · 回车：光标回到原来位置，继续输出。eg：

1
2
3
4
	public static void main(String[] args) {
		System.out.println("Hello\rworld!");
	}
}

​ 显示结果：

​ 而如果加入“\n”换行符一起使用，则可以起到普遍意义上“回车”的效果（\n\r顺序先后无影响）

1
2
3
4
	public static void main(String[] args) {
		System.out.println("Hello\n\rworld!");
	}
}

​ 显示结果：

文档注释（类和方法的注释）

​ 文档说明注释允许你在程序中嵌入关于程序的信息，通常以 /** 开始，结构体中以 * 开启每一行，以 */ 结束。结构体部分写入注释信息，常见的有@author，@version，@see等等（这部分可参考开发文档）

​ 调用语法：javadoc -d 目录（最后一步缩小到文件夹） -author（更换为你写的内容） -version（更换为你写的内容） Hello.java（替换为你的java源文件名称）

本章作业

Chapter2 变量

整型

​ Java里默认整型为int类型，转换成别的类型时要加相应的开头字母（如Long就加上L）：

​ “Long a = 188L”

浮点型

​ 浮点数=符号位+指数位+尾数位

​ Java里默认浮点数为double类型，转换情况同整型

1
* 对浮点数的运算结果要小心，尤其是在做两个浮点数的运算结果的比较的时候，因为不同的数据类型会得到不同的答案（如double num = 8.1/3 得到的不是2.7而是十分接近2.7的一个小数），因此在比较时，我们使用两数之差的绝对值是否小于一个很小的值来判断两数是否相等。

字符型

​ 字符型用单引号引用。

​ 字符型可以参与运算（‘a’+10 输出107）

各种编码

类型转换

强制转换

​ · 强制转换是将高精度=>低精度，大数=>小数

​ · 强制转换优先级是就近原则

字符串型

​ · 数字=>字符串：加引号“”

​ · 字符串=>数字：使用相应的转换类

​ 输出为：

本章作业

​ 1. 字符型拼接得到的是数字而非字符串

  1. 自行修改快捷键

    首选项=>快捷键

    ctrl+f后输入你想寻找的快捷键组合

    找到后复制整行到用户代码中

    修改相应功能后保存，运行即可

  2. ​

Chapter3 运算符

算术运算符

1
* 注意，double a = 10/4 输出2.0

自增与自减

​ i++和++i的原则：作为独立语句使用时效果相同，作为表达式使用时效果不同

​ 此时输出为 j=k=9（先j++，再j=k）

​ 此时输出为 k=8，j=9（先j=k，再j++）

1
* 此时输出为1（临时变量temp保存了i的值，temp没有被改写因此i仍旧为1，这里在后面条件判断时还会涉及到，谨记！），但i实际已经为2了

逻辑运算符（后期可以画一个表格）

  • 与运算

​ 逻辑与&：a&b 不论什么情况a和b都要执行

​ 短路与&&：a&&b a结果错误就不执行b，直接跳出；a和b结果均正确则ab都执行；a正确b错误，ab均执行

  • 或运算

​ 逻辑或| : a|b 不论什么情况a和b都执行

​ 短路或||： a||b a结果正确直接跳出；a结果不正确看b

练习：

​ 1.区别逻辑与短路

​ 2.输出为50（注意“=”和“==”）

赋值运算符

​ 赋值运算符会进行类型转换 byte b = 2; b+=3; b++(按理来说后两步都是int赋给byte会报错，但是这里因为自带强制转换而没有) //byte类型和short类型在参与运算时会自动变为int类型

标识符命名规范

​ 包名：全小写

​ 类、接口名：大驼峰

​ 变量、方法名：小驼峰

​ 常量名：所有字母都大写，多单词时下划线连接

​ ……

位运算符（补码运算）

​ “>>” 算数左移，低位溢出、高位符号位不变，本质为除/几次2

​ “<<” 算数右移，符号位不变，低位补0，本质为乘*几次2

​ “>>>”逻辑右移，低位溢出，高位补零

​ 无逻辑左移

本章作业

​ 输出输入的内容

chapter4 控制结构

chapter5 数组

​ 数组是可以存放多个同一类型的数据，是引用类型。

1
2
double[]: double类型的数组
char[] chars = new char[26]

​ eg：数组打印大写字母A~Z

  • java中不用引入交换变量temp

数组赋值机制

​ 基本数据类型赋值是拷贝，n2不会影响n1的值

1
2
3
int n1 = 10;
int n2 = n1;
n2 = 70;                      //最终得到n1为10，n2为70

​ 但数组赋值是地址，引用传递（指针）

1
2
3
int[] arr1 = {1,2,3};
int[] arr2 = arr1;
arr[0] = 10;                 //最终arr1为10，2，3

​ 解释：

1
2
3
4
5
6
7
8
9
10
11
//创建新地址：
int[] arr2 = new int[arr1.length]；

//遍历拷贝打印
for(int i=0; i<arr1.length; i++){
	arr2[i] = arr1[i];
}

//修改值
arr2[0] = 100;

小技巧1

​ 设置参数法

1
2
3
4
5
6
int index = -1;
在接下来代码中遇到不同情况改变index的值；
if（index = -1）{
	说明没有遇到上述改变
}

字符串/数字相等的判断

内容输入

1
2
3
4
5
import java.util.Scanner;
Scanner myScanner = new Scanner(System.in);
System.out.print("请输入名称:");
String FindName = myScanner.next();

二维数组

定义

1
2
3
1. int[][] arr = {{0,0,1},{0,1,0},{1,0,0}}
2. int arr[][] = new int[2][3]        //产生两行三列（不同于索引号的从零开始计算）

输出

1
2
3
4
5
6
7
for(int i=0; i<arr.length; i++){
	for(int j=0; j<arr[i].length; j++){
		Syystem.out.print(arr[i][j] + "\t");
	}
	System.out.println();        //换行输出
}

二维数组元素个数：arr.length

访问第3行第四列元素：arr[2] [3]

开空间

1
2
arr[i] = new int[i+1]

chapter6 类和对象

引子

​ 单独变量解决面临数据量大的问题

​ 利用数组面临数据类型单一、变量名和命名的内在联系对应关系不明确的问题（只能通过下标）

创建类

1
2
3
4
5
6
class Cat{
	int age；
	char sex；
	String name；
}

创建对象

1
2
3
4
Cat cat1 = new Cat();    //Cat cat产生一个空的栈，new Cat（）分配堆内存且栈不再为空
cat1.name = "xiaobai";   //属性
System.out.print(cat1.name)     //调用

​ 类是对象的模板，对象是类的个体；类是抽象的，对象是具体的。

对象的内存布局

属性注意细节

​ 访问修饰符

1
2
public、private、protected、默认

方法

添加
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//class Person{
//	String name;
//	int m;
	
    public void speak(){
        system.out.print("我是一个好人")；
    };

    public void cal02(int n){
        int result = 0;
        for(int i=1; i<=n; i++){
            result += i;
        }
        system.out.println("result")
    };
    
    public int getSum(int num1, int num2){       //返回一个int的值
    	result = num1+num2;
    	return result;
    }

//}

调用
1
2
3
4
5
6
7
Person p1 = new Person;
p1.person;
p1.cal02(5);

int resturnSum = p1.getSum(3,4);     //把return的值付给returnSum
system.out.println(resturnSum);		 //输出

优势

​ 1.复用

​ 2.将细节封装起来，利于开发

细节

​ 1. 一个方法最多有一个返回值，但可以用数组返回多个

​ 用数组类型来接收

​ 2. 有返回类型必须以return语句结尾

​ 3. 没有返回类型和不用return语句

经典方法——递归

走迷宫

​ 代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
public class MiGong{
	public static void main(String[] args) {

		int[][] map = new int[8][7];
		for(int i=0; i<6; i++){				//首尾行为障碍物（0可通行，1为障碍）
			map [0][i] = 1;
			map [7][i] = 1;
		}

		for(int i=0; i<8; i++){				//首尾列为障碍物
			map[i][0] = 1;
			map[i][6] = 1;
		}
		map[3][1] = 1;						//没有规律的点单独设置
		map[3][2] = 1;

		System.out.println("初始地图");		//!print()之后需要分号
		for(int i=0; i<map.length; i++){			//打印
			for(int j=0; j<map[i].length; j++){
				System.out.print(map[i][j]+" ");
			}
			System.out.println();
		}



		class T{

		/* 1.findway方法找路
		   2.如果找到，返回true，否则返回false
		   3.map是二维数组，表示迷宫
		   4.1是障碍物，2表示探测过可以走的路，3表示探测过但不能走的路，0代表通路
		   5.找路策略：右->下->上->左
		*/
			public boolean findway(int[][] map, int i, int j){		//!函数中以逗号相隔

				if(map[6][5] == 2){									//当终点为2时跳出递归
					return true;
				}
				else{											//当终点不是2时，执行如下代码

					if(map[i][j] == 0){							//首先起点要在通路，即可以走
						map [i][j] = 2;							//设某点（起点）是2
						if(findway(map, i, j+1)){				//执行递归，先向右探索
							return true;
						}
						else if(findway(map, i+1, j)){					//再向上
							return true;
						}
						else if(findway(map, i-1, j)){					//再向上
							return true;
						}
						else if(findway(map, i, j-1)){					//最后向左
							return true;
						}
						else{							//如果都走不通，此路标记为3，跳出递归
							map [i][j] = 3;
							return false;
						}
					}
					else{								//其他点(1，2，3)也无法走出迷宫
						return false;

					}
				}
			}
		}

		T t1 = new T();									//生成类
		t1.findway(map, 1, 1);							//把地图、起始点传入函数
		System.out.println("成功走出");
		for(int i=0; i<map.length; i++){				//打印
			for(int j=0; j<map[i].length; j++){
				System.out.print(map[i][j]+" ");
			}
			System.out.println();
		}

	}
}

​ 实现效果：