【狂神说Java】Java零基础学习视频通俗易懂

学习路线

写博客的重要性

DOS：Disk Operation System

alt+f4 关闭窗口

shift+del 永久删除

运行窗口下新建任务：explorer //显示桌面

shitf+右键 打开powershell

JavaSE服务端

Java EE企业端

Java ME移动端

java优势：

简单性、面向对象、可移植、高性能、分布式、动态性、多线程、安全性、健壮性

学习Java的特性，主动爱上Java的魅力

Write once，Run anywhere

JDK、JRE、JVM的关系

编译javac xx.java

运行Java xx

文件名和类名必须保持一致

Java程序运行机制

编译型：一次编译，随时运行

解释型：每次从头运行

idea中

#生成一个main方法 psvm

#打印 sout

书写注释是一个非常好的习惯

三种注释：

• 单行注释 //
• 多行注释 /* */
• 多行注释/** */
• 文档注释

标识符：类名、变量名和方法名都被称为标识符

关键字

标识符：数字、字母、下划线组成，其中数字不能作为开头，不能使用关键字作为变量名和方法名，标识符大小写敏感

Java是一种强类型语言，先定义后使用

数据类型：基本类型（byte、short、int、long、float、double、Boolean、char）、引用类型（接口、类、数组）

float后面的参数要加F，因为浮点数默认是double

long后面的参数要加L

浮点数尽量避免比较，使用Big Decimal数学工具类比较

所有字符本质都是数字

Unicode编码给每个字符一个编号

#转义字符 \u

#换行 \n

#制表符 \t

Boolean默认为true

多字节强制转换成低字节会照成内存溢出

#（类型）变量名

强制转换：高->低 //可能会照成损失精度或内存溢出，比如int转char就不会错误

自动转换：低->高 //自动填充

强制类型转换可以在定义时强转，也可以在输出时强转

shift+F10自动运行

数字可以这样表示1000_0000_000

三种变量：

常量：final double PI=3.14;

# 运算符

CTRL+D复制当前行到下一行

【cast：V.转换】

运算符

++ 自增

--自减

a++ //a先赋值再自增1

++a //a先自增1再赋值

#幂函数计算 double pow =Math.pow(2,3) //8，很多运算会使用一些工具类来运算

#输出字符串加结果：System.out.println("a&&b的结果："+（a&&b）);

短路运算

异或：相同为0，不同为1

面试题：2^4怎么算最快

答：位运算往左移2位

位运算

a+=b //等价于a=a+b

面试题：int+String和String+int的不同

三元运算符

x?a:b X为true返回a,否则返回b

包机制

公司利用域名倒置作为包名，如com.baidu.www

#定义包 package 包名

#导包import package

import java.util.Date //导入Date包

【param:参数】

/**+Enter //输出参数

Java Doc参数信息

#生成文件 javadoc -encoding UTF-8 -charset UTF-8 xx.java

# java流程控制

Scanner对象

#获取用户输入：java.util.Scanner

【util】全称utility，一种实用的包

Scanner s=new Scanner(System.in);

通过next()和nextLine()方法获取输入的字符串，读取前用hasNext()和hasNextLine判断是否还有输入的数据

区别：

Summary:

Ctrl+左键，点击类名查看它的方法

# 顺序结构

#选择结果

#if多选择结构：

规则：

#if嵌套结构

if(){ if() }else

#switch case结构

switch(条件){

case'A':

break; //可选，如果满足A则不输出后面的内容

case‘B’:

default: //可选，如果都不满足则输出此条件下的内容

}

//case后可跟字符串，Jdk7新特性

#idea反编译：把class文件和放在源Java所对应的工程文件夹下，在idea下打开class文件

#while循环

• 只要布尔表达式为true，循环会一直执行下去
• 大部分情况需要让循环停止下来
• 小部分情况需要一直执行，比如服务器的请求监听

#do...while：至少会执行一次

while和do...while的区别：

• do...while至少会执行一次
• while先判断后执行，do...while先执行后判断
• do...while总是保证循环体至少执行一次

#for循环

关于for:

1、最先执行初始化步骤，可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句

2、中间是布尔表达式

3、执行一次循环，更新循环控制变量

4、再次检查布尔表达式，循环执行上面的过程

#简化，如for(int i; i<100;i++),简化后for( ;i<100;i++); //简化后要提前声明并赋值给i

#死循环for( ; ; ){ }

#增强for循环：用于数组或集合

#break用于强行退出循环，不执行循环剩余的语句（break也可在switch语句中使用）

#continue语句用在循环体中，跳过尚未执行的语句，并进行下一次是否执行循环的判定

#两个作业：九九乘法表和打印正三角形（5行）

# 学会打断点：能够知道程序的运行机制

步过：一行一行的往下走，不会进入到其他方法的内部。

步入：如果当前行有方法执行，可以进入方法的内部（不会进入官方定义的方法，仅能进入自定义的方法）。

强制步入：如果当前行有方法执行，可以进入方法的内部（可以进入官方定义的方法，这在查看底层源码时非常有用）。

智能步入：如果当前行有多个方法同时被执行，IDEA 将会询问你要进入哪个方法。

步出：从步入的方法内执行完该方法，然后退出到方法调用处。

重置 Frame：恢复到上一个断点的开始处。

————————————————

#方法

如：System.out.println() //System是类，out是对象，println是方法 ，即调用System类下out对象的一个方法println

形参：用来定义作用的

实参：实际调用传递给他的参数

Java是值传递

#方法的重载：在一个类中，有相同的函数名称，但形参不同的函数

规则：

• 方法名称必须相同
• 参数列表必须不同（个数不同、或类型不同等）

# 用命令行给方法传递参数

在src目录下运行，同时后面跟上参数

# 可变参数

指定参数类型后加一个省略号（...)

一个方法只能指定一个可变参数，它必须是方法的最后一个参数，如何普通的参数必须在它之前申明。

public static void main(String args[]){ int 1,2,3,4}

public static void a(int...i){ }

#递归结构：

• 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
• 递归体：什么时候调用自身方法。

边界条件：递归有一个尽头边界

前阶段：未达到边界条件前的阶段

返回阶段：n*(n-1)

原理：栈机制

小点的数可以用栈机制可以快速解决问题，大量数据不要使用栈机制，这样会照成内存溢出

#写一个计算器

思路：

• 写4个方法：加减乘除
• 利用循环+switch进行用户交互
• 传递需要操作的两个数
• 输出结果

[链接]（https://blog.csdn.net/EasonYoung1/article/details/131495075?spm=1001.2014.3001.5501）

# 数组

• 数组声明：int[ ] nums;
• 使用new创建数组，分配空间：

nums=new int[3];//存放3个int类型的数字,这里的3是空间大小，不是数组下标

• 声明同时创建int[ ] nums=new int[3]
• 给数组元素赋值

nums[0]=1;

nums[1]=3;

nums[2]=5;

nums[3]=7;

• 数组长度 nums.length

## 数组特点：

1、长度不可变

2、元素必须相同

3、元素可以是基本类型和引用类型

4、数组对象属于引用类型，数组可看作对象，每个元素相当于成员变量

数组本身就是对象，Java中对象是在堆中的，无论数组保存原始类型还是其他对象类型，数组本身是在堆中的。

#内存分析（堆、栈和方法区）

声明数组放入栈

创建数组放入堆，在堆中开辟一块区域

## 三种初始化

• 静态初始化

int[ ] a={1,3,5};//创建直接赋值

• 动态初始化

int[ ] a=new int[3];//创建并分配3个空间

• 默认初始化

数组是引用类型，其元素相当于类的实例变量，一旦数组被分配空间，数组每个元素被按照实例变量同样的方式被隐式初始化

## 数组使用

• For-Each循环
• 数组作方法入参
• 数组作返回值

## 二维数组

在一维数组的基础上，每一个元素都是一个数组

int a[ ][ ]=new int [1][2];//可看作一个两行三列的数组

int[ ] [ ] array={{1,2}，{3，2}，{2，0}};//看作3行两列的数组

#Arrays类

• 先导包import java.util.Arrays；
• 再使用Arrays.toString(类型【】 数组名)；

Arrays.fill(int[] 数组名）//填充数组

# 稀疏数组

当一个数组中大部分元素是0，或为同一值的数组时，可以使用稀疏数组来保存该数组

• 处理方式：
• 记录几行几列，有多少不同值
• 把不同值元素和行列及值记录在一个小规模数组中，从而缩小程序的规模

#打印一个稀疏数组

#面向对象

return:结束方法，返回一个结果

break：跳出当前循环

属性+方法就是一个类

面向过程：步骤清晰简单，适合处理简单问题

面向对象：物以类聚，分类思维模式，适合处理复杂问题

#面向对象的本质：

以类的方式组织代码，以对像的组织（封装）数据

三大特性：封装、继承、多态

类分静态类和非静态类，非静态类要实例化才能使用

public class Student{

String name;

}

public static void main{

Student student=new Student(); //实例化

student.name="ian";//赋值

sout+student.name //(伪代码)输出

}

## 创建与初始化对象

使用new关键字创建对象：

• 使用new关键字创建，除了分配内存空间，还会给创建好的对象进行默认的初始化，以及对类中构造器的调用。
• 类中的构造器也称为构造方法，是在进行创建对象时必须要调用的，特点如下

1、必须和类名相同

2、必须没有返回类型，不能写void

* 作用：
* 1、new本质在调用构造方法
* 2、初始化对象的值
* 注意：定义有参构造后，如果使用无参构造，可以定义一个无参构造
*
* 创建构造器快捷键：ALT+Insect
* this.对象 //this指当前类

#内存分析：

小结:

1、类与对象

类是一个模板：抽象

对象是一个具体实例

2、方法：定义与调用

3、对象的引用

引用类型：基本类型

对象是提高引用来操作的：栈->堆

4、属性：字段field 成员变量

默认初始化：

数字 0 0.0

char: u0000

boolean: false

引用：null

5、对象的创建与使用

必须使用new创建对象，建立构造器

对象的属性 ian.name

对象的方法 ian.fx()

6、类

静态的属性 属性

动态的行为 方法

# 封装：

高内聚、低耦合

高内聚：类的内部操作细节自己完成，不允许外部干涉

低耦合：仅暴露少量的方法给外部使用

属性私有,get/set

set中可以对接收的数据判断是否合法，进行操作

Alt+Insect 快捷生成

意义：

1、提高程序的安全性，保护数据

2、隐藏代码实现的细节

3、统一接口

4、系统的可维护性增加了

# 继承

子类在类定义时：

public class Person(){} //父类

public class extends Person(){} //子类

Ctrl+H //查看层次结构

所有的类，都直接或间接继承object类

知识点：

• java中只有单继承，没有多继承。一个儿子只有一个爸爸，一个爸爸可以有多个儿子
• 继承是类和类之间的一种关系。除此之外，类和类之间还有依赖、组合、聚合等。

object类

super

方法重写

# super

注意点：

1、super调用父类的构造方法，必须在构造方法的第一个

2、super必须只能在子类的方法或构造方法中！

3、super和this不能同时调用方法！

对比this：

1、代表的对象不同：

• this:本身调用这个对象
• super代表父类对象的引用

2、前提：

• this：没有继承也可以使用
• super：只能在继承条件下才可以使用

3、构造方法

• this（）：本类的构造
• super（）：父类的构造

方法的重写：重写的方法的重写，与属性无关

//静态方法的调用只和左边，定义的数据类型有关
//非静态的方法能重写

• 重写：需要有继承关系，子类重写父类的方法：

1、方法名必须相同

2、参数列表必须相同

3、修饰符：范围可以扩大，不能缩小：

private<Default<protected<public

4、抛出的异常：范围，可以缩小，但不能扩大：

ClassNotFoundException->Exception(大）

5、子类的方法和父类要一致，方法体不同。

重写的意义:父类的功能，子类不一定需要，或不一定满足！

Alt+O；override

多态：

同一个方法可以根据发送对象的不同而采取多种不同的行为方式

一个对象的实际类型的确定的，但可以指向对象的引用类型有很多（父类，有关系的类）

多态存在的条件

1、有继承关系

2、子类重写父类方法

3、父类引用指向子类对象

注意：多态是方法的多态，属性没有多态性

instanceof 判断两个对象是否有联系

（类型转换）引用类型

eg: ((Student) s2). fx();

抽象类：abstract

1、不能new这个抽象类，只能在子类去实现它：约束！

2、抽象类可以写普通方法

3、抽象方法必须在抽象类中

4、new,存在构造器

# 接口

普通类：只有具体实现

抽象类：具体实现和规范（抽象方法）都有

接口：只有规范！自己无法写方法~专业的约束！约束和实现分离：面向接口编程

• 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是...则必须能...”的思想
• 接口的本质是契约
• oo的精髓，是对对象的抽象

接口关键字：interface

实现类关键字：implement

内部类

内部类就是在一个类的内部再定义一个类，如，A类定义一个B类，那么B类相对于A类来说称为内部类，A类相对于B类来说就是外部类

1、成员内部类

2、静态内部类

3、局部内部类

4、匿名内部类

# 异常

异常体系结构：

Error:

Error类对象由Java虚拟机生成并抛出，大多数错误与代码执行者所执行的操作无关

Exception：

在Exception分支中有一个中有一个重要的子类RuntimeException(运行时异常）

Alt+Enter 处理波浪线