这篇笔记详尽地涵盖了Java的基础知识，包括跨平台原理、JDK、JRE、JVM的关系，环境变量配置，以及HelloWorld案例。深入讲解了数据类型、变量、运算符、流程控制、面向对象特性如继承、多态、接口，并涉及数组、内存分配、异常处理、集合框架、IO流、多线程等核心概念。同时，还介绍了Lambda表达式、反射等进阶主题，是Java初学者的全面指南。
目录
一.前期引入
1.JAVA实现跨平台的原理
2.JDK/JRE/JVM 三者的关系
3.JAVA中的重要命令
4.如何配置环境变量
5.HelloWorld案例
6.注释的种类
7.数据类型
8.变量的定义格式及命名规则
9.作用域
10.运算符和表达式
11.类型转换
12.流程控制语句
13.在idea中创建一个空项目以及添加新模块
14.数组
15.内存分配
16.方法
17.面向对象
18.在堆内存中的变量是有默认值
19.成员变量和局部变量的区别
20.标准类(JAVA Bean)的制作
21.API
二.基础进阶
1.继承
2.多态
3.抽象类
4.接口
5.多态中的形参和返回值
6.内部类
7.冒泡排序
8.Arrays数组工具类
9.包装类
10.日期类
11.异常
12.集合 (collection)
13.list集合
14.并发修改异常
15.Set集合
16.可变参数
17.Map集合
18.File类
19.递归
20.IO流
21.propertyies
22.多线程
23.同步代码块
24.网络编程
25.Lambda表达式
26.函数式接口
27.stream流
28.反射
一.前期引入
1.JAVA实现跨平台的原理
因为Java提供了对应系统版本的JVM(运行Java程序的虚拟机),这是Java跨平台的本质
2.JDK/JRE/JVM 三者的关系
JDK>JRE>JVM
3.JAVA中的重要命令
javac 编译
java 运行
4.如何配置环境变量
*此电脑右键属性–高级系统设置–环境变量
*新建JAVA_HOME,路径填写JDK安装路径不包括bin
*在Path中编辑,添加%JAVA_HOME%\bin
*向上移动至第一行
5.HelloWorld案例
public class HelloWorld{
public static void main(String[] args){
System.out.println(“HelloWorld!老王真帅!”);
}
}
6.注释的种类
*单行注释
*多行注释
*文档注释
7.数据类型(int double为默认类型)
*常量
*字符串常量 //String 同时还是引用类型
*整数常量
*浮点数常量
*字符常量
*布尔常量
*空常量
*基本数据类型
*整数型 byte short int long(后缀加上大写的 L )
注意取值范围
*小数型 float(后缀加上大写的 F ) double
*字符型 char
*布尔型 boolean
*引用数据类型
*数组
*字符串
*类
*lambda
8.变量的定义格式及命名规则
*见名知意,驼峰命名
*变量/方法名 一个单词,全都小写,多个单词,从第二个开始首字母大写
*类名 一个单词首字母大写,多个单词,每个单词首字母大写
9.作用域(作用范围)
*一对大括号
10.运算符和表达式
*算数运算符 + - * / %
*自增自减运算符 ++ --(注意位置 在前面先加/先减再用 在后面先用后加/后减)
*逻辑运算符 & && | || ! ^ (注意 && || 的短路效应)
*字符串的拼接 +
*比较运算符 > < >= <= == !=
*赋值运算符 =
*三元运算符 数据类型 变量名 = 条件判断 ? 表达式1 : 表达式2 (结果必须被调用,否则将没有意义)
*+= -= *= /= %=
11.类型转换
*自动转换
*强制转换
12.流程控制语句
*顺序结构:从上到下,一行行执行
*选择结构:根据条件执行对应的语句 switch...catch...default / if / if...else / if...else if...else
*循环结构:for/while/增强for/do...while循环 (区别)
13.在idea中创建一个空项目以及添加新模块(一定要会)
*注意命名规则
*java文件和class文件：
java文件：源代码文件
作用：提供给程序员进行编写或者修改使用的。
但是java文件并不能直接运行，因为jvm不认识。
class文件：字节码文件 (在运行过程中是不变的)
是提供给jvm进行运行用的。
从java文件到class文件需要编译(javac)
14.数组 (就是一个容器)
*动态初始化 数据类型[] 数组名 = new 数据类型[长度];
*静态初始化 直接赋值 数据类型[] 数组名称 = {元素1,元素2...};
*索引 从0开始,而且连续不间断
数组的最大索引：数组.length - 1;
可以获取数组中的元素个数：length属性
*、数组中存在的两个问题
1、数组索引越界 ArrayIndexOutOfBoundsException
访问了，数组中不存在的索引。
2、空指针异常 NullPointerException
访问了本身就不存在的内容。
*数组的遍历(重点)
15.内存分配
*栈：存放的是局部的东西，局部变量(局部就是方法)/ / / / 局部变量 对象的引用 方法
*堆：只要是new出来的，都在堆中。
*方法区:存放的是被加载之后的class文件。/ / / /常量池 静态区 字节码文件
*本地方法栈 和系统相关的东西
*寄存器 和cpu相关的东西
16.方法 (代码集，一个完整的功能。方法 === 具体的功能模块)
*方法的基本定义 public static void 方法名(){ 方法体; }
*注意:方法在定义完成之后，不能自己执行，需要被调用,同时,在main方法所在的类中定义的方法必须使用static
修饰,因为静态只能访问静态,具体请参考static关键字的使用
*参数:方法中的参数是可以有多个的，如果有多个中间使用逗号分隔,目的是接收数据
*形参和实参
*形参：形式参数,用来接收实参。
*实参：实际参与运算的数据。
*返回值:方法执行完成后,返回给调用者的数据
*返回值类型:作用是用来确定返回的数据是什么类型的,返回值类型和参数列表中的数据类型并没有关系
*return：返回，将数据返回给调用者并结束方法。
*注意:返回值不同的方法的调用方法
*方法重载
在同一个类中，出现了方法名称相同，参数列表不同。
参数列表不同:个数不同/类型不同（顺序不同）
17.面向对象
*强调的完成某件事情，我该找谁去做
*什么是类 :是对具体事物描述
属性 --> 成员变量
行为 --> 成员方法
*什么是对象
就是客观存在的实体(事物)
*类与对象的关系
对象就是类的具体体现,类是对象的抽象描写
*类的定义
在同一个java文件中可以定义多个类，但是这些类都是平级。
这些类 public 修饰的只能有一个
*面向对象的三大特征
继承 / 多态 / 封装
*构造方法的注意事项
*如果我们没有提供任何的构造方法，系统会默认提供一个无参构造方法。
*如果我们提供了任何一个构造方法，系统将不再提供构造方法。
*构造方法是可以重载的。
无参构造方法
满参(全参)构造方法
*构造方法名称必须要和类名一致。不要提供任何的返回类型
18.在堆内存中的变量是有默认值
所有引用数据类型的默认值：null
基本数据类型：
整数 --> 0
小数 --> 0.0
布尔 --> false
字符 --> \u0000
19.成员变量和局部变量的区别
局部就是方法
*定义的位置
局部变量：定义在方法内，或者方法的声明上(就是形参)
成员变量：定义在类中，方法外。
*在内存中的位置
局部变量：在栈中，当方法调用的时候，局部变量定义成功，当方法执行完成之后，局部变量消失
成员变量：在堆中，跟着对象的。当对象创建成功之后，成员变量定义，当对象消失，成员变量消失。
*生命周期
局部变量：随着方法的调用而产生，随着方法的完成而结束
成员变量：随着对象的创建而产生，随着对象的消失而消失。
*初始化赋值
局部变量：没有默认初始化，在使用之前必须要赋值。
成员变量：有默认初始化。
20.标准类(JAVA Bean)的制作
*私有成员变量
*提供无参构造方法
*提供满参构造方法
*给每一个成员变量提供getter和setter方法
*重写toString方法
21.API
*应用程序编程接口/ /API是java提供的一些类或者接口
*常用的java类(方法可查api手册,就不详细赘述)
/ / / / 但凡不是Java.lang包下的类,使用的的时候都是需要导包的
*Scanner 键盘输入类
*Random 随机数类
*String 字符串类
注意 如果一个对象打印输出的时候，不再是地址值。那么他打印输出的是该对象中的内容
String是引用数据类型,但是同时也是常量
或者重写了toString方法
*StringBuilder 字符串操作类
*StringBuffer 字符串操作类
*Math 数学计算类
*System 系统类
*Date 日期类
*Object 所有类的根类
*SimpleDateFormat 日期格式化类
*Calendar 日历类
Collections 集合操作工具类
二.基础进阶
1.继承
*为了消除不同类中相同的代码,简单地说，就是子类可以使用父类的东西
*继承的好处和弊端
*好处：
*提高了代码的复用性(多个类相同的成员可以放到同一个类中)
*提高了代码的维护性(如果方法的代码需要修改，修改一处即可)//是它的好处也是它的弊端
*弊端
*继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性
*开发原则：
*高内聚：内聚就是一个代码独立完成某个功能的能力
*低耦合：藕断丝连 指的是完成一个功能需要依赖其他的类
*使用继承，需要考虑类与类之间是否存在is..a的关系，不能盲目使用继承
is..a的关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类 //共性
*继承中变量的访问特点
*回顾this关键字
*变量的访问特点
"就近原则"
首先从局部位置找-------成员位置找-----------父类的成员位置
//如果找到最后也找不到 ，那么就报错
*super关键字
super：代表父类存储空间的标识(可以理解为父类对象引用) //本质上并不是父类对象的引用
*继承中构造方法的访问特点
*子类中所有的构造方法默认都会访问父类中无参的构造方法
子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化
*注意事项
（1）每一个子类构造方法的"第一条语句"默认都是：super() //只是我们看不到而已
public Zi(){
System.out.println("Zi的无参构造方法");
super(); //编译报错 super()必须在子类构造方法的第一行
}
(2)当我们显示的给出了访问父类的构造方法（也就是已经写了super）,就不会再提供默认的super()
public Zi(){
// super();
System.out.println("Zi的无参构造方法");
super(12); //编译报错，因为我们给出了带参的super，这个时候就没有了默认的super(),这个时候，super(12)必须放在第一行
}
（3）就是super()和this()不能同时使用，因为父类只能被初始化一次
public Zi(){
super();
this(12);//编译报错，因为父类只能被初始化一次，super()已经初始化了一次，this(12)就不能再次取用初始化父类了
System.out.println("Zi的无参构造方法");
}
*继承中成员方法的访问特点
this
先去本类的成员位置--------父类的成员位置 //一直找不到就报错
super
先去父类的成员位置--------父类的父类。。。 //一直找不到就报错
*方法重写
*概念
子类出现了和父类中一模一样的方法声明（方法名一样，参数列表、返回值也必须一样）
//前提：要有继承关系
*方法重写的应用场景
当子类需要父类的功能，而功能主体子类有自己特有内容时，
可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容
//子类想要在父类的方法基础上增加一点功能
//对于父类中的方法，我们不能去改变他，因为可能其他的子类需要使用，
//我们的做法是自己写一个和父类一模一样的方法
//在这个方法中加入我们自己想要的功能
*注解和注释
注解：是给JVM看的 @Override
注释：给程序员看的 // /* */ /** */
*方法重写的两个注意事项
（1）父类中的私有的方法不能被子类重写
//因为私有的方法根本就不能被继承过来，何谈重写
（2）子类重写父类的方法，访问权限不能更低
//访问修饰符和父类保持一致
*Java中继承的注意事项
*Java中只支持单继承，不支持多继承
*Java中支持多层继承
A>B>C //一个父亲可以有多个儿子，一个儿子只能有一个父亲
*权限修饰符
private：只能在本类中使用
默认 ：只能在同一个包下使用
protected：必须是子类使用
public：不通包下、无关类
2.多态
*多态的概述
*什么是多态
"同一个对象"，在不同时刻表现出来的"不同形态"
猫是猫
猫是动物
*多态的前提条件有哪些
要有继承/实现关系
要有方法重写
要有父类引用指向子类对象
Fu f = new Zi();
*多态中的成员访问特点
*多态中成员变量的访问特点
编译看左边、运行看左边
*多态中成员方法的访问特点
编译看左边、运行看右边
//问题：成员变量---编译看左边、运行看左边，左边到底是看什么？
编译看左边，指的是Fu类中有没有这个变量
运行看左边，指的是取值取得的Fu类中的成员变量值
//成员方法-----编译看左边、运行看右边
编译看左边：指的是Fu类中有没有这个方法
运行看右边：运行的方法是子类的方法
举例：孔子装爹
class 孔子爹{
int age = 50；
String name = "孔子老爹";
public void teach(){
System.out.println("Java")
}
}
class 孔子 extends 孔子爹{
int age= 20；
String name = "孔子"；
public void teach(){
System.out.println("论语")
}
}
class Demo{
public static void main(String[] args) {
孔子爹 kzd = new 孔子(); //相当于 孔子穿上了他老爸的衣服、粘上了他老爸的胡子 出去浪了
System.out.println(kzd.age)； //50 你表现出来的形态是孔子爹 所以人家就认为你是50岁
kzd.teach(); //真正的对象是孔子 他只会教论语 不会教java
}
}
*多态的好处和弊端
好处：
提高了代码的扩展性
定义方法时，如果将父类型作为参数，在使用方法时，可以传递任意子类对象
弊端：
不能使用子类的特有功能
//多态的成员方法访问特点是：编译看左边，这个时候左边没有子类的特有方法，直接报错
*多态中的转型
*向上转型
//指的是把小的类型转成大的类型
Fu f = new Zi(); //向上
举例：
int i = 10；
long l = i；
*向下转型
//指的是把大的类型转成小的类型
Zi zi = （Zi）f;
举例：
long l = 10L;
int i = (int)l;
*多态中转型的注意事项
Animal a = new Cat();
Animal a1 = new Dog();
Dog d = (Dog)a; //绝对不行
//多态中的转型，需要遵循只能将子类转成它本身或者其父类（父类的父类。。。。）
//绝对不能在两个子类之间进行相互转换
3.抽象类
*概念
*什么是抽象类
抽象：看不懂、不是具体的
*怎么出现的？
出现的场景：在多态中，父类的方法虽然被重写了，但是父类中的方法体永远不糊被执行，我就觉得方法体是多余的
*关键字
abstract ： 被赋予的含义是表明是一个抽象的东西 可以修饰类和方法
*格式
抽象类：
public abstract class {
xxxxxxxxx
}
抽象方法：
public abstract void method();
//在多态中抽象类是用来替代父类的
*抽象类的特点
public abstract class 类名{}
public abstract 返回值类型 方法名();
*抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类 //单选题
*抽象类不能实例化，但是可以通过多态的方式创建子类对象
//抽象类为什么不能实例化？
//因为抽类中很有可能出现抽象方法，抽象方法是没有方法体的，你创建了抽象类对象，调用抽象方法没有任何意义
*抽象类的子类
要么重写抽象父类中 "所有的" 抽象方法 //以后推荐使用
要么子类本身也是一个抽象类 //基本我们不会写这样的代码
*抽象类的成员特点
*成员变量
*可以是常量
*可以是变量
*构造方法
*有构造方法
因为抽象类是用来替代多态中的父类的，是为了完成子类初始化时先完成父类的初始化
*成员方法
*非抽象方法
*抽象方法
*多态的分类（截止到目前为止）
*普通类多态
//父类是一个普通类
*抽象类多态
//父类是一个抽象类
4.接口
*接口的概念
接口就是一种 "公共的"(public) 规范标准，只要符合规范标准，都可以使用
java中的接口更多的体现在对 "行为"(方法) 的抽象
*接口的特点
*如何定义接口
public interface 接口名{}
interface关键字：表明是在定义一个接口
*如何实现接口
public class 类名 implements 接口名{}
*因为接口是一个规范，而这里用类去实现了接口，所以其实接口是用来规范类的
*implements 关键字 ： 表示一个类去实现了一个某个接口
*请问接口是不是实现类的父类？
不是 接口和类之间是不能继承的
*接口不能被实例化，可以通过多态形式创建实现类对象
*Fu f = new Zi(); //Fu是Zi的亲爹
*MyInterfac
最低0.47元/天 解锁文章
1542
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
