JAVA笔记（初）
20-06-21（到java入门08）
笔记：（陈子豪）
–即使最小的帆也能远航！
前言：
1：
零基础可以学java么？
一张白纸，空白的地方越大，你的可塑性也就越大
英语不好可以学java么？
编程语言并没有那么多的英语单词。毕竟现在翻译软件这么多；
理解慢能学好么？
我觉得对自己的不信任才是最大的障碍，相信自己能行。（勤能补拙）
现在学java晚么？
晚了，所以得使点劲。
2：
Java和python应该选哪个。
原话很有道理，你应该选择先学哪个，而不是只学哪个。
3：
Java能干什么：
手机端 可以写手机程序。
pc端 我的世界，有Java版本。
DS架构 大数据部分。
学习导图。
如何更好的学习java
多写、多练、多分享。 最重要的就是坚持。
4：
就业前景
为什么很多IT公司不喜欢进过培训机构的人呢？？
这个问题。。。
预科部分：
预科01 博客的重要性：
为什么要写博客：用来总结和思考。有时候一直在赶路，却忘了放慢脚步
提升文笔组织能力。
提升学习总结能力
提升逻辑思维能力
帮助他人，结交朋友。
现在想起来，好像确实忘掉了一些很重要的内容。
短期可能没有效果，但是长期坚持，对自己的提升很有帮助。
预科02 MarkDown语法详解：
下载Typora，并且学习语法。
标题：#个数对应标题级数
图片：！【】+图片地址
分割线：—
引用:>
预科03什么是计算机：
computer 全程电子计算机，俗称电脑。
预科04硬件及冯诺依曼结构：
计算机硬件：cpu，主板，内存，电源，主机箱，硬盘，显卡…
一些物理装置按系统结构的要求构成一个有机整体为计算机软件运行提供物质基础。
预科05软件及软件开发：
计算机软件可以使计算机按照事先预定好的顺序完成特定的功能
计算机软件按照功能被分为系统软件和应用软件
预科06Windows常用快捷键：
全选、复制、剪切、粘贴、撤销、重做、保存、ALT + F4（关闭窗口）
Windows + e（打开我的电脑）
shift + Delete（永久删除文件）
Ctrl + Windows + D（创建新的桌面）
win + tab（切换桌面）
补充：
1、Ctrl+C：复制；
2、Ctrl+A：全选；
3、Ctrl+V：粘贴；
5、Ctrl+z：撤销上一步；
6、Ctrl+Esc：显示“开始”菜单；
7、WIN+F1：显示Windows帮助；
8、WIN+U：打开工具管理器；
9、win+D：立即返回桌面；
10、Ctrl+F：查找；
预科07基本的Dos命令：
打开cmd的方式：
1 开始 系统 命令提示符
2 Windows + R
3 文件夹下面按住Shift加上鼠标右键，在此处打开powershell
4 在文件管理器的地址栏前面加上cmd加上一个空格加上想要的路径。
管理员方式运行：选择以管理员方式运行
常用的Dos命令：
盘符切换 C: \D:
查看当前目录下的所有文件 ： dir
切换目录 cd \cd…
清理屏幕 cls
退出终端 exit
查看电脑IP ipconfig
打开一些应用程序 calc（计算器）
ping命令 得到一个网站的IP地址
创建一个文件夹 md test（创建一个名为test的文件夹）
创建一个文件 cd>a.txt（创建一个名为a.txt的文件）
删除一个文件del a.txt （删除一个文件）
删除一个目录rd test （删除一个文件夹）
预科08计算机语言发展史：
第一代语言
机器语言
计算机的基本计算方式都是基于二进制的方式。
第二代语言
汇编语言
解决人类无法读懂机器语言的问题
指令代替二进制
第三代语言
摩尔定律；
高级语言 大体分为面向过程和面向对象两大类
入门部分：
java入门01：Java帝国的产生
初时java
C语言
1972年诞生
贴近硬件、运行极快、效率极高。
操作系统、编译器、数据库、网络系统。
指针和内存管理。
1982年c++诞生
面向对象
兼容c
图形领域、游戏等。
1995
三高：高可用、高性能、高并发。
Java入门02：java特性和优势
简单性
面向对象
可移植性
高性能
分布式
动态性
多线程
安全性
健壮性
Java入门03：Java三大版本
javaSE ：标准版 （桌面程序，控制台，开发）
javaME：嵌入式开发 （手机，小家电）（已经死掉了）
JavaEE：企业版开发（微博端，服务器开发）
Java入门04：JDK、JRE、JVM
JDK :java Development Kit(Java开发者工具)mech
JRE :java Runtime Environment(java运行时环境)
JVM:java VIrtual Machine(java虚拟机)
Java入门05：安装开发环境
jdk卸载
找到jdk的安装目录直接删除整个文件夹
去除系统中保存的环境变量
jdk下载安装
根据系统版本下载对应的版本尽量安装JDK8
双击安装
选择安装路径（记住安装路径）
配置环境变量
在环境变量-系统变量中新建名称JAVA_HOME它的值为jdk的安装路径
配置path变量
在系统变量中新建一个值为%JAVA_HOME%\bin
在系统变量中新建一个%JAVA_HOME%\jre\bin
测试JDK是否安装成功 java -version
Java入门06：HelloWorld详解
这个得闭着眼睛写出来
public class Hello{
public static void main(String[] args){
System.out.println("Hello World !!");
}
}
Java入门07：编译型和解释型
时机不同
编译型d
运行之前需要编译
解释型
边写边运行
Java入门08：使用IDEA进行安装
什么是IDE eclipse 。。。IDEA
集成开发环境
IDEA的下载与安装方法。
idea：java目前最好的开发工具
psvm：主函数
sout：System.out.pritln
idea优化：
20-06-22（基础1 到流程控制12）
笔记：(陈子豪)
基础部分
Java基础01：注释
书写注释是一个非常好的习惯
注释：
comment
java中三种注释方法
单行注释 // 内容
多行注释 /* 内容 */
文档注释：/*内容/
可以进行IDEA的优化
有一个好的书写习惯是比较重要的。
百度 有趣的注释：
作者：yang元祐
链接：https://www.zhihu.com/question/20727260/answer/401192256
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
print(’ ─────▄──────────────▄──── \n’, \ ’ ─ wow ── ▌▒█───────────▄▀▒▌─── \n’, \ ─▌▒▒▀▄───────▄▀▒▒▒▐─── \n’, \ ’ ───▐▄▀▒▒▀▀▀▀▄▄▄▀▒▒▒▒▒▐─── \n’, \ ─▄▄▀▒▒▒▒▒▒▒▒▒▒▒█▒▒▄█▒▐─▄▀▒▒▒▒▒▒──▐▒▒▒▄▄▄▒▒▒▒▒▒▒▒▒▒▒▒▒▀▄▒▒▌\n’,──▌▒▒▐▄█▀▒▒▒▒▄▀█▄▒▒▒▒▒▒▒█▒’▐▒▒▒▒▒▒▒▒▒▒▒▌██▀▒▒▒▒▒▒▒▒▀▄▌─ \n’, \ ’ ─▌▒▀▄██▄▒▒▒▒▒▒▒▒▒▒▒░░░░▒▒▒▒▌─ \n’, \ ’ ─▌▀▐▄█▄█▌▄▒▀▒▒▒▒▒▒░░░░░░▒▒▒▐─ \n’, \ ’ ▐▒▀▐▀▐▀▒▒▄▄▒▄▒▒▒ electrons ▒▌ \n’, \ ’ ▐▒▒▒▀▀▄▄▒▒▒▄▒▒▒▒▒▒░░░░░░▒▒▒▐─ \n’, \ ’ ─▌▒▒▒▒▒▒▀▀▀▒▒▒▒▒▒▒▒░░░░▒▒▒▒▌─ \n’, \ ’ ─▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▐── \n’, \ ’ ──▀ amaze ▒▒▒▒▒▒▒▒▒▒▒▄▒▒▒▒▌── \n’, ’ ────▀▄▒▒▒▒▒▒▒▒▒▒▄▄▄▀▒▒▒▒▄▀─── \n’, \ ’ ───▐▀▒▀▄▄▄▄▄▄▀▀▀▒▒▒▒▒▄▄▀───── \n’, \ ’ ──▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▀▀──────── \n’ )
Java基础02：标识符和关键字
JAVA所有的组成部分都需要名字，类名，变量名以及方法名都被称为标识符
标识符不可以是以数字，井号，星号开头的。
**Java03：**数据类型讲解
数据类型分为两种：
（一个字节（byte） = 8位(bit)）
基本类型：
整数类型byte（一个字节）\short（两个字节）\int（四个字节）\long（八个字节）
浮点数类型\float（四个字节）\double（八个字节）
字符类型char（两个字节）
boolean类型（占一位）
引用类型：
除了基本数据类型，都是引用类型。。
**Java基础04：**数据类型扩展及面试题讲解
进制问题：
整数拓展： 进制 \二进制0b \十进制 \八进制 0 \十六进制0x（开头）
浮点数拓展：
银行业务怎么表示（用BigDecimal 数学工具类）
字符拓展：
可以将字符类型强制转换为整数类型，重点记忆三个位置48’0‘、65’A‘、97’a’
‘\t’ ‘\n’
boolean扩展：
boolean flag = true；
**Java基础05：**类型转换
强制类型转换：
byte i = (byte)128// i = -127;(涉及到内存溢出的问题)
（类型）变量名 高–>低
自动类型转换：
低 -->高
注意：
1 布尔值不能进行进行转换
2 转换的时候可能会遇到内存溢出和精度问题
3 JDK7的特性，数字可以用 ‘_’ 进行分隔，并不会输出
**Java基础06：**变量，常量，作用域
变量：就是可以变化的量，java中最基本的存储单元，其要素包括变量名，变量类型，作用域。
变量代表指一块空间，但空间里存什么不确定
注意事项：
每个变量都有类型，类型可以是基本类型，也可以是引用类型
变量名必须是合法的标识符
变量声明必须是完整的语句，必须用分号结尾
常量：初始化之后不可以变化的值 。
final +类型+名称=值；
一般常量名用大写字符。
变量的命名规范：
小驼峰式：除了首字母之外单词每个字母大写（包名，变量名）
大驼峰式：从首字母开始每个单词首字母大写（类名）
名称见名知意；
变量作用域：
类变量：写在类中，+修饰符static
实例变量：同类变量，但没有static，从属于对象，如果不进行初始化，默认值为0、null、flase
局部变量：写在方法里，必须声明和初始化
修饰符不区分前后
Java基础07：基本运算符（operator）
运算符优先性：算数运算符>关系运算符>逻辑运算符>条件表达式
Notes：
1.ctrl+d，复制到下一行。
2.运算类型有long是long，有double结果是double，剩下的是int
3.关系运算符返回结果：布尔值。
Java基础08：自增自减运算符，初识Math类
++ 自增
– 自减
a++：执行完代码之后，先调用a，再自增。
++a：先自增，再调用a。
Math是一个数学类，里面有很多的数学当中的计算方法，例如乘方、开方；
（abs）：绝对值
（pow）：幂运算
**Java基础09：**逻辑运算符，位运算符
逻辑运算符：非 与 或
重点：短路运算：a&&b
如果a是错的就不会向下运算
位运算符：
位运算效率极高
**Java基础10：**三元运算符及小结
字符串连接符：+，如果+号两边中出现String，如果字符串在前面，则转化为字符串，如果在后面，则前面依旧运算。
Java基础11：包机制
一般利用公司域名倒置作为包名。
用import导入包，import必须放在包名下面
*：导入包下所有的类
Java基础12：javaDoc生成文档
javadoc命令：生成自己的api文档
流程控制部分
Java流程控制01：用户交互Scanner
-
Scanner对象：可以通过Scanner来获取用户的输入。
-
基本语法：Scanner sc=new Scanner（System.in）;
-
通过scanner类的next（），nextLine（）方法来获取输入的字符串，在读取前我们一般需要使用hasNext（）和hasNextLine（）来判断是否还有数据输入。
-
if（Scanner.hasNext()）{
String str =Scanner.next;
}
scanner.close;
凡是使用io流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉
next（）：
- 一定要读取到有效字符后才可以结束输出。
- 对输入有效字符前遇到的空格，next（）方法会自动去掉。
- 只有输入有效字符后才将其后面输入的空白作为分隔符或结束符
- next（）不能得到带有空字符的字符串。
nextline（）：
- 以Enter为结束符，也就是说nextLine()方法返回的是回车之前所有的字符串。
- 可以获得空白。
Java流程02：Scanner的进阶使用
public class Demo{
public static viod main(String[] args){
Scanner sc=new Scanner(System.in);
//从键盘接收数据
int i=0;
float f=0.0f;
if(sc.hasNextInt()){
i=scnextInt();
System.out.println("整数数据额："+i);
}
else{
System.out.println("输入的不是整数数据");
}
sc.close;
}
}
//输入多个数求其和
public class Demo{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
//和
double sum=0;
//计算个数
int m=0;
//通过循环判断是否有输入，并求和
while(Scanner.nextDouble()){
double x=sc.nextDouble();
m+=1;
sum+=x;
}
sc.close)();
}
}
Notes
- 记得要写Scanner.close(); Scanner是对象名
- 按住Ctrl点击类，可以看到类的源码；
Java流程03：顺序结构
顺序结构：
- java的基本机构就是顺序结构，除非特别指明，否则都是按照顺序额结构。
- 顺序结构是最简单的算法结构
- 语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干依次执行的处理步骤组成的，他是任何一个算法都离不开的一种基本算法结构
Java流程04：选择结构
if单选择结构
语法：
if(布尔表达式){
//如果布尔值为true将执行的语句
}
public class Demo{
public static void main(Stringp[] args){
Scanner sc=new Scanner(System.in);
String s=sc.nextLine();
if(s.equals("hello")){
System.out.println(s);
}
sc.close();
}
}
Notes:
equals()：判断字符串是否相等。
if双选择结构
语法：
if(布尔表达式){
//布尔表达式为true
}
else{
//布尔表达式为flase
}
public class Demo{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int score=sc.nextInt();
if(score>60){
System.out.println("及格");
}
else{
System.out.println("不及格");
}
sc.close();
}
}
if多选择结构
语法：
if(布尔表达式1){
//布尔表达式1为true
}
else if(布尔表达式2){
//布尔表达式2为true
}
else ifif(布尔表达式3){
//布尔表达式3为true
}
else{
//布尔都不为true
}
public class Demo{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int score=sc.nextInt();
if(score==100){
System.out.println("满分");
}
else if(score<100&&score>90){
System.out.println("A");
}
else if(score<90&&score>80){
System.out.println("B");
}
else if(score<80&&score>70){
System.out.println("C");
}
else if(score>0&&score<70){
System.out.println("D");
}
else{
System.out.println("成绩不合法");
}
}
}
Notes：
-
if语句至少有一个else语句，else语句在所有的else if语句之后。
-
if语句可以有若干个else if语句，他们必须在else语句之前。
-
一旦其中一个else if语句检测为true，其他的else if以及else语句都将跳过执行
嵌套的if结构
语法：
if(布尔表达式1){
//表达式1为true
if(布尔表达式2){
//表达式2位true
}
}
Notes：
- 通过嵌套if来缩小查找区域，提高效率。
Java流程05：Switch选择结构
语法：
switch(expression){
case value:
//语句
break;
case value:
//语句
break;
default:
//语句
}
Notes：
- switch语句中的变量类型可以是byte，short，int 活着 char；
- case标签必须为字符串常量或字面量；
- case穿透：无break就继续执行；
- java se7 后 switch支持字符串类型了；
字符的本质还是数字
反编译：java-》class（字节码文件）----反编译（idea可实现）
class文件：项目结构-》项目路径-》在idea中打开对应文件夹
字符通过hashCode生成对应的hash值
Java流程06：while循环详解
while循环：
语法：
while(布尔表达式){
//循环内容
}
NOTES:
- 只要布尔表达式为true，就会一直执行
- 大多数情况让代码停下来，需要一个让表达式失效的方式来结束循环
- 少部分情况需要代码一直执行，比如服务器响应监听
- 循环条件一直为true就会造成无限死循环，正常应避免
do…while循环
语法：
do{
//代码块
}while(布尔表达式)
NOTES:
- do…while至少执行一次
- do…while先执行后判断
for循环：
语法：
for(初始化；布尔表达式；更新){
//代码
}
NOTES:
- for循环是支持迭代的一种通用结构，是最有效，最灵活的的循环结构
- 初始化语句可以为空语句，也可以初始化多个循环控制变量
增强for循环
-
java5中引用了一种主要用于数组的增强for循环
-
语法：
for(声明语句：表达式){ //代码句子 } -
public class Test { public static void main(String[] args) { int[] num= { 10,20,30,40,50}; //遍历数组 for(int x:num) { System.out.println(x); } } }
Java流程07：break，continue，goto
- break用于强制退出循环，不执行循环中剩下的语句
- continue用于终止某次循环过程，跳过循环体中尚未执行的语句，接着进行下一次循环是否执行的判断
go to：
-
package test; public class Test { public static void main(String[] args) { int count=0; outer:for(int i=101;i<150;i++) { for(int j=2;j<i/2;j++) { if(i%j==0) { continue outer; } } } } } -
带标签的continue和break；
-
对于java唯一用到标签的地方是在循环语句之前，而在循环语句之前设置标签的唯一理由是：我们希望在其中嵌套 另一个循环，break和continue通常只中断循环，但若随同标签使用，他们就会中断到存标签的地方。
Java流程12：打印三角形及debug
package test;
public class Test {
public static void main(String[] args) {
for(int i=1;i<=5;i++) {
for(int j=5;j>=i;j--) {
System.out.print(" ");
}
for(int j=1;j<=i;j++) {
System.out.print("*");
}
for(int j=1;j<i;j++) {
System.out.print("*");
}
System.out.println();
}
}
}
20-06-23（方法到数组部分）
方法部分
Java方法01：什么是方法
- 方法是语句的集合，他们在一起执行一个功能
- 方法的设计原则：保持方法的原子性，就是一个方法只完成一个功能，有利于后期的拓展
- 方法的命名规则：首字母小写，驼峰规则
- 方法包含于类或对象中
**Java方法02：**方法的定义和调用
方法的定义
- 方法包含一个方法头和一个方法体
- 修饰符
- 返回值类型
- 方法名（命名规范）
- 参数类型：参数像一个占位符，当方法被调用，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型，顺序和个数。参数是可选的，方法可以不包含任何参数
- 形势参数：在方法被调用时用于接收外界输入的数据
- 实参：调用方法时实际传输给方法的数据
- 方法体：具体语句
- return 0//终止方法
方法的调用
- 调用方法：对象名.方法名（实参列表）
- 当方法返回一个值的时候，方法调用通常被当做一个值
- 如果方法返回值是void，方法调用一定是一条语句
- 拓展：值传递，引用传递
java是值传递
**Java方法03：**方法的重载
- 方法的重载：方法名称相同、
- 参数列表必须不同（个数、类型、顺序）、
- 方法的返回类型可以相同，也可以不同。
- 仅仅返回类型不同不足以成为方法的重载
- 实现理论：编译器会根据调用方法的参数个数，参数类型去逐个匹配，已选择对应的方法，如果匹配失败，则编译器报错
Java方法04：命令行传递参数（idea 中 terminal是命令行）
- 有时候希望程序运行的时候再给他传递消息，这时依靠传递命令行参数给main（）函数实现
- 运行class文件要找到包的文件
**Java方法05：**可变参数
- 在方法声明中，在指定参数类型后加上一个省略号（…）
- 一个方法只能指定一个可变参数，他必须是方法的最后一个参数，任何普通的参数必须在它前面声明
- 本质是数组
**Java方法06：**递归讲解
- 方法调用自己；
- 递归结构：
- 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环
- 递归体：什么时候需要调用自身方法
- 边界条件
- 前阶段
- 返回阶段
- 能不用递归就不用
数组部分：
**Java数组01：**什么是数组
- 数组是相同数据类型的有序集合
- 数组描述的是相同类型的若干数据，按照一定的先后次序排列组合而成
- 每一个数据称作一个数组元素，每个数组元素可以通过下标来访问
Java数组02：数组的声明和创建
- 数组的声明：数据类型[]+数组名称，也可以数据类型+数组名称[]，但不是首选
- java用new创建数组：数据类型[] 数组名=new 数据类型[数组长度]
- 获取数组长度：数组名.length
Java数组03：三种初始化以及内存分析
内存分析：
- 堆：存放new的对象和数组，可以被所有线程共享，不会存放别的对象引用
- 栈：存放基本变量类型，引用对象的变量
- 方法区：可以被所有线程共享，包含了所有的class和static变量
三种初始化：
-
静态初始化：创建+赋值
int[] a={ 1,2,3}; Man[] mans=new{ new Man)(1,1),new Man(2,3)} -
动态初始化:包含默认初始化
int[] b=new int[10] -
数组的默认初始化：数组是引用类型，他的元素相当于类的实例变量，因此数组一经分配空间，其中每个元素也按照实例变量同样的方式被隐式初始化
Java数组04：下标越界及小结
- 数组的长度是确定的，一旦被创建，大小不可改变
- 元素类型必须相同
- 元素可以是任何类型，包括基本类型和引用类型
- 数组变量属于引用类型，数组也可以看做是对象，每个元素相当于是该对象的成员变量
- 数组本身就是对象，java中对象是在栈中的，因此无论数组保存原始类型还是其他对象类型，数组对象本身是在栈中的
数组边界
- 下标的合法区间：[0,length-1]
- ArrayIndexOutOfBoundsException:数组下标越界异常
**Java数组05：**数组的使用
**for—each循环：**增强for循环，适合遍历数组
数组作方法入参
public void printArray(int[] arrays){
for(int i=0;i<arrays.length;i++){
System.out.println(arrays[i]);
}
}
数组作返回值
public static int[] reverse(int[] arrays){
int result=new int[arrays.length];
for(int i=0;j=result.length-1;i<arrays.length;i++,j--){
result[j]=arrays[i];
}
}
**Java数组06：**二维数组
- 多维数组可以看做数组的数组
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ktZLFnTo-1618737853908)(C:\Users\bfzs\AppData\Roaming\Typora\typora-user-images\image-20210417082904021.png)]
-
二维数组定义：
int a[][]=new int[2][3]
**Java数组07：**Arrays类讲解
- 数组工具类java.util.Arrays
- API提供了一个工具类Arrays供我们使用，从而对数据对象进行一些基本操作
- Arrays类中的方法都是static修饰的，可以直接使用类名调用
- fill方法：给数组赋值
- sort：升序排序
- equals：比较数组中元素是否相等
- binarySearch方法对排序好的数组进行二分查找
Java数组08：冒泡排序
public static int[] sort(int[] array){
int temp=0;
for(int i=0;i<array.length-1;i++){
for(int j=0;j<array.length-i;j++){
if(array[j]>array[j+1]){
temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
}
}
-
时间复杂度o （n2）
-
优化：
public static int[] sort(int[] array){ int temp=0; bolean flag=false; for(int i=0;i<array.length-1;i++){ for(int j=0;j<array.length-i;j++){ if(array[j]>array[j+1]){ temp=array[j]; array[j]=array[j+1]; array[j+1]=temp; flag=true; } } if(flag==false){ break; } } }
Java09：稀疏数组
- 当一个数组中大部分元素为0或为同一值的数组时，可以使用稀疏数组来保存该数组
- 处理方式：记录数组有几行几列，有多少个不同的值。把具有不同值的元素和行列及值记录在一个小规模数组中，从而缩小程序的规模
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xV3ERmeb-1618737853909)(C:\Users\bfzs\AppData\Roaming\Typora\typora-user-images\image-20210417090653196.png)]
public class Demo{
public static void main(String[] args){
//定义二维数组
int [][] a1 =new int[11][11];
a1[1][2]=1;
a1[2][3]=2;
//计算有效值个数
int sum=0；
for(int i=0;i<11;i++){
for(int j=0;j<11;j++){
if(a1[i][j]!=0){
sum++;
}
}
}
//创建稀疏数组
int[][] a2=new [sum+1][3];
a2[0][0]=11;
a2[0][1]=11;
a2[0][2]=sum;
int count=0;
for(int i=0;i<a1.length;i++){
for(int j=0;j<a1[i].length;j++){
if(a1[i][j]!=0){
count++;
a2[count][0]=i;
a2[count][1]=j;
a2[count][2]=a1[i][j];
}
}
}
//还原稀疏数组
//1.读取稀疏数组
int [][] a3=new int [a2[0][0]][a2[0][1]];
//2.给其中元素还原值
for(int i=1;i<a2.length;i++){
a3[a2[i][0]][a2[i][1]]=a2[i][2];
}
//3.打印
for(int[] ints:a1){
for(int anInt:ints){
System.out.print(anInt+"\t")
}
System.out.println();
}
}
}
面向对象部分：
**Java面向对象01：**什么是面向对象
面向过程：
- 步骤清晰简单
- 适合简单的问题
面向对象
- 分类的思维模式，先分类，在对分类面向过程思考
- oop
- 本质：以类的方式组织代码，以对象的组织数据
- 抽象
- 三大特性：封装，继承，多态
Java面向对象02：回顾方法的定义
- return结束方法，返回一个结果
- 方法名见名知意
- 异常抛出
Java面向对象03：回顾方法的调用
- 静态方法（static）：通过类.方法调用
- 非静态方法：通过实例化调用
static和类一起加载
- 实参和形参类型要一一对应
- 值传递：原本内存的值并不变
- 引用传递：传递对象，本质还是值传递
**Java面向对象04：**类与对象的调用
类与对象的关系
- 类是一种抽象的数据类型，对某一类事物整体的描述
- 对象是类的具体实例
创建与初始化对象
- 使用new关键字创建对象，会分配空间，给创建好的对象初始化，以及对类中构造器的调用
**Java面向对象05：**构造器详解
- 构造器：也叫构造方法创建对象时必须调用
- 构造方法与类的名字相同
- 没有返回类型，也不能写void
- 使用new本质是调用构造器
- 一旦定义了有参构造，无参构造就必须显示定义
- alt+insert快捷键构造器
Java面向对象06：创建对象内存分析
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tAvMnQIl-1618737853910)(C:\Users\bfzs\AppData\Roaming\Typora\typora-user-images\image-20210417151342591.png)]
Java面向对象07：简单小结类与对象
对象的引用
-
引用类型：除了8个基本类型
-
对象是通过引用来操作的：栈—》堆（地址）
-
属性：字段，成员变量，默认初始化：
- 数字：0 0.0；
- char：u0000；
- boolean: false;
- 引用：null；
-
对象的创建和使用
- 对象的属性：.调用
- 对象的方法: .调用
-
类：属性，方法
Java面向对象08：封装讲解
-
程序追求 ：高内聚，（类的内部自己完成，不允许外部干涉）低耦合（仅暴露少部分方法给外部使用）。
-
通常，应禁止直接访问一个对象中数据的实际表示，而应该通过操作接口来访问。这成为信息隐藏。
-
属性私有 ：private
-
提供可以操作的方法：public的get，set方法
-
alt+inser快捷键
封装的意义：
- 提高程序安全性，保护数据
- 隐藏代码实现细节
- 同一接口
- 提高系统可维护性
Java面向对象09：什么是****继承
- 继承的本质是对类的抽象
- extends关键字
- 继承是类与类之间的一种关系，除此之外还有依赖，组合，聚合等
- 子类继承父类就会拥有父类的全部方法
NOTES:
-
private子类无法使用
-
default
-
protected
-
public
-
ctrl+h快捷键打开继承树
-
所有的类都默认直接或间接继承 object类
-
java中只有单继承没有多继承：一个儿子只能有一个爹
Java面向对象10：Super详解
- this：当前的（非继承也可以使用）
- super：父类（只能在继承关系中使用）
- super调用父类的构造器必须要在子类的第一行
- super只能出现在子类的方法中
- super和this不能同时调用构造方法
**Java面向对象11：**方法重写
重写都是方法的重写，和属性无关
重写只和非静态方法有关
- 父类的引用指向了子类
- 静态方法的调用只和左边的数据类型有关
NOTEs
- 重写需要有继承关系，子类重写父类方法
- 方法名，参数列表必须相同
- 修饰符：范围可以扩大（public）
- 抛出的异常：范围可以被缩小但不能扩大
为什么重写？
- 父类的功能子类不需要或不满足
**Java面向对象12：**什么是多态
多态：同一方法根据发送的对象不同而采取多种不同的行为方式
一个对象的实际类型时确定的，但是指向的引用类型就不确定了，父类的引用可以指向子类
- 子类重写了父类的方法 ，执行子类的方法
- 子类型能调用自己的和父类的方法
- 父类型不能调用子类独有的方法，强制转化才能用
注意事项：
- 多态是方法的多态，和属性无关
- 父类子类有联系
- 类型转换异常：ClassCastExpection
- 存在条件：继承关系，方法重写，父类的引用指向子类对象
- static方法不能重写
- final，private不能重写
**Java面向对象13：**instanceof和类型转换
- 判断两个类之间是什么关系
x instanseof y
左边数据类型判断是否编译通过：同级不通过，不同线不通过，右边数据类型判断是否为父子关系
类型之间的转换：
- 父往子转换要强制转换
- 方便方法的调用，减少重复的代码
Java面向对象14：static 关键字详解
-
修饰成员变量，成员方法（静态方法，静态属性）
-
类变量，可直接通过类调用，可以被所有实例共享
-
静态方法不能调用非静态方法
-
匿名代码块 ：赋初始值，和对象一起产生
{ } -
静态代码块：和类一起加载，只执行一次
static{ } -
静态导入包：import static
Java面向对象15：抽象类
- abstract修饰的类
- 抽象方法：只要名字，没有实现
- 抽象类的所有方法，继承了他的子类都必须实现他的方法，除非也是抽象类
- 接口可以多继承
- 抽象类不能new出来
- 抽象类里可以写普通方法，抽象方法必须要在抽象类中
- 意义：制造模板，提高开发效率
**Java面向对象16：**接口的定义与实现
- 接口只有规范（抽象方法），无法写方法，约束和实现分离：面向接口分离
- 接口就是规范
- 接口的本质是契约
- 接口的关键字是interface
- 接口都需要实现类
- 类 implements 接口来实现接口，实现了接口的类就需要重写其中的方法
- 接口可以多继承
作用：
- 约束
- 定义一些方法，让不同的人实现
- 接口不能实例化，没有构造方法
- 可以实现多个
- 必须重写接口中的方法
Java面向对象17：N种内部类
- 在一个类的内部定义一个类
- 通过外部类来实例化内部类:outer.new inner();
- 局部内部类：在方法里写类
- 匿名内部类：没有名字初始化，不用保存到变量中
异常部分
Java异常01：Error和Exception
- 检查性异常：用户错误引起
- 运行时异常
- 错误
异常处理框架：
- java把异常当做类来处理，定义java.lang.throwable作为所有异常的超类
- 分为两大类 Error和Exception
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gFlQ1Mzo-1618737853910)(C:\Users\bfzs\AppData\Roaming\Typora\typora-user-images\image-20210417172829457.png)]
Java异常02：捕获和抛出异常
- 异常处理关键字：try，catch，finally，throw，throws
- try：监控区域
- catch：捕获异常（想要捕获的异常类型），可以叠加，层层递进，由小到大
- finally：处理善后工作
- ctrl+alt+t快捷键
主动抛出异常
- 一般在方法中用throw
- 如果方法中处理不了这个异常，方法上抛出异常throws
**Java异常03：**自定义异常及经验小结
- 创建自定义异常类
- 在方法中通过throw关键字抛出异常对象
- 如果在当前方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws指明要抛出给方法调用者的异常，继续进行下一步操作
- 在异常方法的调用中捕获并处理异常
记：（陈子豪**）**
笔记：（陈子豪****）
–即使最小的帆也能远航！
前言：
1：
零基础可以学java么？
一张白纸，空白的地方越大，你的可塑性也就越大
英语不好可以学java么？
编程语言并没有那么多的英语单词。毕竟现在翻译软件这么多；
理解慢能学好么？
我觉得对自己的不信任才是最大的障碍，相信自己能行。（勤能补拙）
现在学java晚么？
晚了，所以得使点劲。
2：
Java和python应该选哪个。
原话很有道理，你应该选择先学哪个，而不是只学哪个。
3：
Java能干什么：
手机端 可以写手机程序。
pc端 我的世界，有Java版本。
DS架构 大数据部分。
学习导图。
如何更好的学习java
多写、多练、多分享。 最重要的就是坚持。
4：
就业前景
为什么很多IT公司不喜欢进过培训机构的人呢？？
这个问题。。。
预科部分：
预科01 博客的重要性：
为什么要写博客：用来总结和思考。有时候一直在赶路，却忘了放慢脚步
提升文笔组织能力。
提升学习总结能力
提升逻辑思维能力
帮助他人，结交朋友。
现在想起来，好像确实忘掉了一些很重要的内容。
短期可能没有效果，但是长期坚持，对自己的提升很有帮助。
预科02 MarkDown语法详解：
下载Typora，并且学习语法。
标题：#个数对应标题级数
图片：！【】+图片地址
分割线：—
引用:>
预科03什么是计算机：
computer 全程电子计算机，俗称电脑。
预科04硬件及冯诺依曼结构：
计算机硬件：cpu，主板，内存，电源，主机箱，硬盘，显卡…
一些物理装置按系统结构的要求构成一个有机整体为计算机软件运行提供物质基础。
预科05软件及软件开发：
计算机软件可以使计算机按照事先预定好的顺序完成特定的功能
计算机软件按照功能被分为系统软件和应用软件
预科06Windows常用快捷键：
全选、复制、剪切、粘贴、撤销、重做、保存、ALT + F4（关闭窗口）
Windows + e（打开我的电脑）
shift + Delete（永久删除文件）
Ctrl + Windows + D（创建新的桌面）
win + tab（切换桌面）
补充：
1、Ctrl+C：复制；
2、Ctrl+A：全选；
3、Ctrl+V：粘贴；
5、Ctrl+z：撤销上一步；
6、Ctrl+Esc：显示“开始”菜单；
7、WIN+F1：显示Windows帮助；
8、WIN+U：打开工具管理器；
9、win+D：立即返回桌面；
10、Ctrl+F：查找；
预科07基本的Dos命令：
打开cmd的方式：
1 开始 系统 命令提示符
2 Windows + R
3 文件夹下面按住Shift加上鼠标右键，在此处打开powershell
4 在文件管理器的地址栏前面加上cmd加上一个空格加上想要的路径。
管理员方式运行：选择以管理员方式运行
常用的Dos命令：
盘符切换 C: \D:
查看当前目录下的所有文件 ： dir
切换目录 cd \cd…
清理屏幕 cls
退出终端 exit
查看电脑IP ipconfig
打开一些应用程序 calc（计算器）
ping命令 得到一个网站的IP地址
创建一个文件夹 md test（创建一个名为test的文件夹）
创建一个文件 cd>a.txt（创建一个名为a.txt的文件）
删除一个文件del a.txt （删除一个文件）
删除一个目录rd test （删除一个文件夹）
预科08计算机语言发展史：
第一代语言
机器语言
计算机的基本计算方式都是基于二进制的方式。
第二代语言
汇编语言
解决人类无法读懂机器语言的问题
指令代替二进制
第三代语言
摩尔定律；
高级语言 大体分为面向过程和面向对象两大类
入门部分：
java入门01：Java帝国的产生
初时java
C语言
1972年诞生
贴近硬件、运行极快、效率极高。
操作系统、编译器、数据库、网络系统。
指针和内存管理。
1982年c++诞生
面向对象
兼容c
图形领域、游戏等。
1995
三高：高可用、高性能、高并发。
Java入门02：java特性和优势
简单性
面向对象
可移植性
高性能
分布式
动态性
多线程
安全性
健壮性
Java入门03：Java三大版本
javaSE ：标准版 （桌面程序，控制台，开发）
javaME：嵌入式开发 （手机，小家电）（已经死掉了）
JavaEE：企业版开发（微博端，服务器开发）
Java入门04：JDK、JRE、JVM
JDK :java Development Kit(Java开发者工具)mech
JRE :java Runtime Environment(java运行时环境)
JVM:java VIrtual Machine(java虚拟机)
Java入门05：安装开发环境
jdk卸载
找到jdk的安装目录直接删除整个文件夹
去除系统中保存的环境变量
jdk下载安装
根据系统版本下载对应的版本尽量安装JDK8
双击安装
选择安装路径（记住安装路径）
配置环境变量
在环境变量-系统变量中新建名称JAVA_HOME它的值为jdk的安装路径
配置path变量
在系统变量中新建一个值为%JAVA_HOME%\bin
在系统变量中新建一个%JAVA_HOME%\jre\bin
测试JDK是否安装成功 java -version
Java入门06：HelloWorld详解
这个得闭着眼睛写出来

public class Hello{
public static void main(String[] args){
System.out.println(“Hello World !!”);
}
}
Java入门07：编译型和解释型
时机不同
编译型d
运行之前需要编译
解释型
边写边运行
Java入门08：使用IDEA进行安装
什么是IDE eclipse 。。。IDEA
集成开发环境
IDEA的下载与安装方法。
idea：java目前最好的开发工具
psvm：主函数
sout：System.out.pritln
idea优化：
20-06-22（基础1 到流程控制12）
笔记：(陈子豪**)**
基础部分
Java基础01：注释
书写注释是一个非常好的习惯
注释：
comment
java中三种注释方法
单行注释 // 内容
多行注释 /* 内容 */
文档注释：/*内容/
可以进行IDEA的优化
有一个好的书写习惯是比较重要的。
百度 有趣的注释：
作者：yang元祐
链接：https://www.zhihu.com/question/20727260/answer/401192256
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
print(’ ─────▄──────────────▄──── \n’, \ ’ ─ wow ── ▌▒█───────────▄▀▒▌─── \n’, \ ─▌▒▒▀▄───────▄▀▒▒▒▐─── \n’, \ ’ ───▐▄▀▒▒▀▀▀▀▄▄▄▀▒▒▒▒▒▐─── \n’, \ ─▄▄▀▒▒▒▒▒▒▒▒▒▒▒█▒▒▄█▒▐─▄▀▒▒▒▒▒▒──▐▒▒▒▄▄▄▒▒▒▒▒▒▒▒▒▒▒▒▒▀▄▒▒▌\n’,──▌▒▒▐▄█▀▒▒▒▒▄▀█▄▒▒▒▒▒▒▒█▒’▐▒▒▒▒▒▒▒▒▒▒▒▌██▀▒▒▒▒▒▒▒▒▀▄▌─ \n’, \ ’ ─▌▒▀▄██▄▒▒▒▒▒▒▒▒▒▒▒░░░░▒▒▒▒▌─ \n’, \ ’ ─▌▀▐▄█▄█▌▄▒▀▒▒▒▒▒▒░░░░░░▒▒▒▐─ \n’, \ ’ ▐▒▀▐▀▐▀▒▒▄▄▒▄▒▒▒ electrons ▒▌ \n’, \ ’ ▐▒▒▒▀▀▄▄▒▒▒▄▒▒▒▒▒▒░░░░░░▒▒▒▐─ \n’, \ ’ ─▌▒▒▒▒▒▒▀▀▀▒▒▒▒▒▒▒▒░░░░▒▒▒▒▌─ \n’, \ ’ ─▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▐── \n’, \ ’ ──▀ amaze ▒▒▒▒▒▒▒▒▒▒▒▄▒▒▒▒▌── \n’, ’ ────▀▄▒▒▒▒▒▒▒▒▒▒▄▄▄▀▒▒▒▒▄▀─── \n’, \ ’ ───▐▀▒▀▄▄▄▄▄▄▀▀▀▒▒▒▒▒▄▄▀───── \n’, \ ’ ──▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▀▀──────── \n’ )
Java基础02：标识符和关键字

JAVA所有的组成部分都需要名字，类名，变量名以及方法名都被称为标识符
标识符不可以是以数字，井号，星号开头的。

Java03：数据类型讲解
数据类型分为两种：
（一个字节（byte） = 8位(bit)）
基本类型：
整数类型byte（一个字节）\short（两个字节）\int（四个字节）\long（八个字节）
浮点数类型\float（四个字节）\double（八个字节）
字符类型char（两个字节）
boolean类型（占一位）
引用类型：
除了基本数据类型，都是引用类型。。
Java基础04：数据类型扩展及面试题讲解
进制问题：
整数拓展： 进制 \二进制0b \十进制 \八进制 0 \十六进制0x（开头）

浮点数拓展：
银行业务怎么表示（用BigDecimal 数学工具类）
字符拓展：
可以将字符类型强制转换为整数类型，重点记忆三个位置48’0‘、65’A‘、97’a’
‘\t’ ‘\n’
boolean扩展：
boolean flag = true；
Java基础05：类型转换
强制类型转换：
byte i = (byte)128// i = -127;(涉及到内存溢出的问题)
（类型）变量名 高–>低
自动类型转换：
低 -->高
注意：
1 布尔值不能进行进行转换
2 转换的时候可能会遇到内存溢出和精度问题
3 JDK7的特性，数字可以用 ‘_’ 进行分隔，并不会输出
Java基础06：变量，常量，作用域
变量：就是可以变化的量，java中最基本的存储单元，其要素包括变量名，变量类型，作用域。
变量代表指一块空间，但空间里存什么不确定
注意事项：
每个变量都有类型，类型可以是基本类型，也可以是引用类型
变量名必须是合法的标识符
变量声明必须是完整的语句，必须用分号结尾
常量：初始化之后不可以变化的值 。
final +类型+名称=值；
一般常量名用大写字符。
变量的命名规范：
小驼峰式：除了首字母之外单词每个字母大写（包名，变量名）
大驼峰式：从首字母开始每个单词首字母大写（类名）
名称见名知意；
变量作用域：类变量：写在类中，+修饰符static
实例变量：同类变量，但没有static，从属于对象，如果不进行初始化，默认值为0、null、flase
局部变量：写在方法里，必须声明和初始化
修饰符不区分前后
Java基础07：基本运算符**（operator）**

运算符优先性：算数运算符>关系运算符>逻辑运算符>条件表达式
Notes：
1.ctrl+d，复制到下一行。
2.运算类型有long是long，有double结果是double，剩下的是int
3.关系运算符返回结果：布尔值。
Java基础08：自增自减运算符，初识Math类
++ 自增
– 自减
a++：执行完代码之后，先调用a，再自增。
++a：先自增，再调用a。
Math是一个数学类，里面有很多的数学当中的计算方法，例如乘方、开方；
（abs）：绝对值
（pow）：幂运算
Java基础09：逻辑运算符，位运算符
逻辑运算符：非 与 或
重点：短路运算：a&&b
如果a是错的就不会向下运算

位运算符：
位运算效率极高


Java基础10：三元运算符及小结
字符串连接符：+，如果+号两边中出现String，如果字符串在前面，则转化为字符串，如果在后面，则前面依旧运算。

Java基础11：包机制
一般利用公司域名倒置作为包名。
用import导入包，import必须放在包名下面
*：导入包下所有的类
Java基础12：javaDoc生成文档
javadoc命令：生成自己的api文档

流程控制部分
Java流程控制01：用户交互Scanner
Scanner对象：可以通过Scanner来获取用户的输入。
基本语法：Scanner sc=new Scanner（System.in）;
通过scanner类的next（），nextLine（）方法来获取输入的字符串，在读取前我们一般需要使用hasNext（）和hasNextLine（）来判断是否还有数据输入。
if（Scanner.hasNext()）{
String str =Scanner.next;
}
scanner.close;
凡是使用io流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉
next（）：
一定要读取到有效字符后才可以结束输出。
对输入有效字符前遇到的空格，next（）方法会自动去掉。
只有输入有效字符后才将其后面输入的空白作为分隔符或结束符
next（）不能得到带有空字符的字符串。
nextline（）：
以Enter为结束符，也就是说nextLine()方法返回的是回车之前所有的字符串。
可以获得空白。
Java流程02：Scanner的进阶使用

public class Demo{
public static viod main(String[] args){
Scanner sc=new Scanner(System.in);
//从键盘接收数据
int i=0;
float f=0.0f;
if(sc.hasNextInt()){
i=scnextInt();
System.out.println(“整数数据额：”+i);
}
else{
System.out.println(“输入的不是整数数据”);
}
sc.close;
}
}

//输入多个数求其和
public class Demo{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
//和
double sum=0;
//计算个数
int m=0;
//通过循环判断是否有输入，并求和
while(Scanner.nextDouble()){
double x=sc.nextDouble();
m+=1;
sum+=x;
}
sc.close)();
}
}
Notes
记得要写Scanner.close(); Scanner是对象名
按住Ctrl点击类，可以看到类的源码；
Java流程03：顺序结构
顺序结构：
java的基本机构就是顺序结构，除非特别指明，否则都是按照顺序额结构。
顺序结构是最简单的算法结构
语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干依次执行的处理步骤组成的，他是任何一个算法都离不开的一种基本算法结构
Java流程04：选择结构
if单选择结构
语法：

if(布尔表达式){
//如果布尔值为true将执行的语句
}

public class Demo{
public static void main(Stringp[] args){
Scanner sc=new Scanner(System.in);
String s=sc.nextLine();
if(s.equals(“hello”)){
System.out.println(s);
}
sc.close();
}
}
Notes:
equals()：判断字符串是否相等。
if双选择结构
语法：

if(布尔表达式){
//布尔表达式为true
}
else{
//布尔表达式为flase
}

public class Demo{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int score=sc.nextInt();
if(score>60){
System.out.println(“及格”);
}
else{
System.out.println(“不及格”);
}
sc.close();
}
}
if多选择结构
语法：

if(布尔表达式1){
//布尔表达式1为true
}
else if(布尔表达式2){
//布尔表达式2为true
}
else ifif(布尔表达式3){
//布尔表达式3为true
}
else{
//布尔都不为true
}

public class Demo{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int score=sc.nextInt();
if(score==100){
System.out.println(“满分”);
}
else if(score<100&&score>90){
System.out.println(“A”);
}
else if(score<90&&score>80){
System.out.println(“B”);
}
else if(score<80&&score>70){
System.out.println(“C”);
}
else if(score>0&&score<70){
System.out.println(“D”);
}
else{
System.out.println(“成绩不合法”);
}
}
}
Notes：
if语句至少有一个else语句，else语句在所有的else if语句之后。
if语句可以有若干个else if语句，他们必须在else语句之前。
一旦其中一个else if语句检测为true，其他的else if以及else语句都将跳过执行
嵌套的if结构
语法：

if(布尔表达式1){
//表达式1为true
if(布尔表达式2){
//表达式2位true
}
}
Notes：
通过嵌套if来缩小查找区域，提高效率。
Java流程05：Switch选择结构
语法：

switch(expression){
case value:
//语句
break;
case value:
//语句
break;
default:
//语句
}
Notes：
switch语句中的变量类型可以是byte，short，int 活着 char；
case标签必须为字符串常量或字面量；
case穿透：无break就继续执行；
java se7 后 switch支持字符串类型了；
字符的本质还是数字
反编译：java-》class（字节码文件）----反编译（idea可实现）
class文件：项目结构-》项目路径-》在idea中打开对应文件夹
字符通过hashCode生成对应的hash值
Java流程06：while循环详解