Java基础入门 – 坚持

• Java 基本介绍
• Java 学习须知
• Java 学习文档
• README
• Java 基础
• • Java Hello World
  • Java 变量
  • Java 数据类型
  • • 基本数据类型
    • 引用数据类型
  • Java 运算符
  • Java 修饰符
  • • 访问修饰符
    • 非访问修饰符
  • Java 表达式 & 语句 & 代码块
  • • 表达式
    • 语句
    • 代码块
  • Java 注释
  • ————————————————————————–
  • Java 控制语句
  • • Java if | else if | else 条件
    • Java switch case 条件
    • Java for 循环
    • Java while 循环
    • • Java break 与 continue 语句
  • ————————————————————————–
  • Java 数组 ✨
  • ————————————————————————–
  • Java 日期与时间（Java8新增）
  • Java 正则表达式 ✨
  • Java Scanner(获取用户输入)
  • ————————————————————————–
  • Java 面向对象详解
  • • Java 面向对象 第一大部分
    • • Java 类与对象
      • Java 方法
      • Java 方法重载 ✨
      • Java 构造方法 ✨
      • Java 字符串
      • Java this 关键字 ✨
      • Java 递归(恐怖故事) ✨
      • Java instanceof 操作符
    • Java 面向对象 第二大部分
    • • Java 继承 ✨
      • Java 方法重写 ✨
      • 抽象类 & 抽象方法 ✨
      • Java 接口 ✨
      • Java 多态
      • Java 封装
    • Java 面向对象高级(第三大部分)
    • • 嵌套 & 内部类
      • Java static 关键字
      • Java 匿名内部类
      • Java 单例(两种)
      • Java 枚举类
      • Java 枚举构造方法
      • Java 枚举字符串
      • Java 反射
  • ————————————————————————–
  • Java 异常处理 ✨
  • ————————————————————————–
  • Java 集合
  • • Java 集合框架
    • Java 集合接口
    • Java List 接口
    • Java ArrayList
    • Java Vector
    • Java Stack
  • ————————————————————————–
  • Java 队列
  • • Java 队列接口
    • Java 优先级队列
    • Java 双端队列接口
    • Java LinkedList
    • Java 数组队列
    • Java 阻塞队列接口
    • Java ArrayBlockingQueue
    • Java LinkedBlockingQueue
  • ————————————————————————–
  • Java Map
  • • Java Map 接口
    • Java HashMap
    • Java LinkedHashMap
    • Java WeakHashMap
    • Java EnumMap
    • Java SortedMap 接口
    • Java NavigableMap 接口
    • Java TreeMap
    • Java ConcurrentMap 接口
    • Java ConcurrentHashMap
  • ————————————————————————–
  • Java Set
  • • Java Set 接口
    • Java HashSet
    • Java EnumSet
    • Java LinkedHashSet
    • Java SortedSet 接口
    • Java NavigableSet
    • Java TreeSet
    • Java 集合算法
    • Java 迭代器接口
    • Java Listlterator 接口
  • ————————————————————————–
  • Java 字节流
  • • Java IO流简介
    • Java InputStream
    • Java OutputStream
    • Java FileInputStream
    • Java FileOutputStream
    • Java ByteArrayInputStream
    • Java ByteArrayOutputStream
    • Java ObjectInputStream
    • Java ObjectOutputStream
    • Java BufferedReader
    • Java BufferedWriter
    • Java StringWriter
    • Java PrintWriter
  • ————————————————————————–
  • Java 并发编程
  • • 进程与线
    • 多线程的入门类和接口
    • 线程组和线程优先级
    • 线程的状态及主要转化方法
    • 线程间的通信
  • 重排序和 happens-before
  • • volatile
    • synchronized 与锁
    • CAS 与原子操作
    • AQS
    • 计划任务
    • Stream 并行计算原理
    • Frok/Join
    • 通信工具类
    • CopyOnWrite
    • 并发集合容器
    • 锁接口和类
    • 阻塞队列
    • 线程池原理
  • ————————————————————————–
  • Java 虚拟机
  • • Java 内存结构
    • 堆
    • 栈
    • Java 垃圾回收
    • JVM 内存区域
    • Java 虚拟机栈
    • class 文件
    • 字节码指令
    • JVM 参数调优
    • Java 对象模型
    • HotSpot
    • 类加载机制
    • 编译和反编译
    • 反编译工具（javap）
    • JIT
    • 虚拟机性能监控和故障处理工具（jps、jstack、jmap、jstat、jconsole、javap）
  • ————————————————————————–
  • 后话

Java 基本介绍

Java是一种通用的、高级的、面向对象的编程语言，最初由Sun Microsystems（目前为Oracle公司）于1995年发布。它被设计成一种可以在各种不同的环境中运行的语言，不论是桌面应用程序、企业级应用程序、移动设备或集群服务器，都可以使用Java来开发。

Java的特点包括：

• 简单性：Java的语法相对于其他编程语言比较简单，易于学习和理解。

• 面向对象：Java是一种完全的面向对象编程语言，支持类、继承、封装和多态等核心特性。

• 平台无关性：Java编写的程序可以在不同的操作系统和硬件平台上运行。这得益于Java虚拟机（JVM），它可以把Java代码翻译成可以在任何计算机上运行的字节码。

• 安全性：Java具有严格的安全机制，基于运行时的检查和验证机制来保证程序的安全性，防止恶意程序对系统造成损害。

• 可移植性：Java语言的跨平台性保证了程序的可移植性，使得程序无需针对不同平台重新编写，只需编写一次即可在不同平台上运行。

• 多线程：Java在语言层面就支持多线程编程，并且提供了丰富的库函数，有效地支持并发编程。

Java编写的程序可以划分为两个部分：Java编译器将源代码转换成字节码文件，JVM则将字节码解释、编译并执行。Java有着广泛的应用领域，包括Web开发、移动应用开发、游戏开发、企业级应用开发等。

Java 学习须知

本篇文章可以实现轻松带你入门Java， 在你认真学习的前提下， 一切都不成问题。
任何一门语言的学习都是漫长且枯燥的，读者本人要有足够的自制力。

---

学习周期： 7-15天不等（有足够时间）
学习目标： Java基础， Java高级
学习规划（建议）： 不建议上班过程中学习，推荐下班回家空余时间进行学习， 如果你是学生请随意！

---

如果您觉得本教程有某些地方存在一些问题，欢迎评论区指正！
如果您觉的本教程晦涩难懂，请立马更换教程，选择适合自己的教程进行观看，避免走弯路

Java 学习文档

在此，我为大家整理了一小部分的Java学习文档
韩信带净化，如果您有更好的学习文档，提前感谢您上贡 贡献到评论区！~

Java API 中文文档（百度网盘）: Java基础材料， 提取码: 0621
API简单使用：点击索引tab，输入关键字，回车，点击显示
失效评论找我，随叫随到

README

目录中带✨的都是有快捷方式跳转的~

Java 基础

至2023年，Java语言仍是主流后端语言，与其他后端语言占比为：12.22%，位列第三，其中第一与第二分别为：Python，C

如果你正处于初学Java，并未配置Java环境变量，下面是推荐的Java配置环境变量的博客，配置Java环境变量为学习Java语言的首发站，希望大家都能用心学习，一起学习，一起坐大牢_(:з」∠)_

---

Java配置环境变量: Java配置环境变量
作者： 心猿意马归

Java Hello World

输出 Hello World

public class HelloWorld { // 类名必须与文件名相同public static viod main(string[] args) { // main方法为程序入口system.out.println("Hello World"); // Java的每个输出与条件语句后面必须带;结束字段}}

使用javac HelloWorld.java，即可输出Hello World

Hello World

Java 变量

Java是一种强类型语言，在Java中，有不同类型的变量，变量一般都是这样被定义的

type * = *;

其中type为类型，type后面紧跟着的为变量名，变量名可自定义。
如：

int num = 1;float f1 = 1.22f;boolean b1 = true;

Java 数据类型

基本数据类型

在Java中，有8中基本数据类型，8中基本数据类型可以分为三类，分别为：数值型，字符型，布尔型。

整型： byte（字节型）、short（短整型）、int（整型）、long（长整型）

byte numA = 100;short numB = 1000;int numC = 100000; long numD = 100000L; 

声明长整型时必须在结尾加L或l。

浮点型：float（单精度型/浮点型） 、double（双精度型）

float fA = 1.1f;double fB = 1.2;

声明浮点型时在结尾加F或f。

字符： char（字符型）

char cA = 'a';

声明字符型时，要加单引号，并且单引号内只能放一个符号。

布尔型：Boolean

布尔型为 true/false，一般用来做逻辑判断

引用数据类型

数组，类，接口被称为引用数据类型，共同特点：值映射一段地址，于内存中。

• 首先为 Object， 它可以由我们自己来创造，Object是一个非常重要的类型，Object类是Javajava.lang包下的核心类，Object类是所有类的父类，何一个类时候如果没有明确的继承一个父类的话，那么它就是Object的子类。

class Person {}class People {}public class OObject {public static void main(String[] args) {Object object = new Person();}}

关于Object类型的API， 在此列举出一个，方便大家的参考，详情查看JDK1.8 API文档
大家可以在IDEA中尝试，自己做扩展才是学习的必要步骤

// toString(); 这是一个很常用的方法，该方法是为了获取对象的信息（返回对象的字符串表示形式）

• 1、数组(Array)，是多个相同类型数据按一定顺序排列 的集合，并使用一个名字命名，并通过编号的方式 对这些数据进行统一管理。
  2、数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括 基本数据类型和引用数据类型。
  3、创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是 这块连续空间的首地址。
  5、数组的长度一旦确定，就不能修改。
  6、我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。

创建数组以及数组的基本使用方法

1. type[] *;
2. type *[];
3. String[] *;
4. Double *[];

// 数组的基本使用int[] arr = new int[3];以上这段话的意思是： 声明一个名称为arr的数组，类型为int型，并且长度最多为3.在输入时[3]称之为数组的动态初始化.// 为数组下标位置赋值在这里讲一句： 下方arr[0,1,2] 中的 0， 1， 2为数组的索引，从0开始.比如：new int[5]； 它的索引为：0， 1， 2， 3， 4， 长度为5.arr[0] = 1;arr[1] = 2;arr[2] = 3;// 数组的静态初始化int[] arr = new int[]{5,7,8};或者int[] arr = {5,7,8};静态初始化: 提前写好数据，{}内部的元素为数组元素

获取数组的长度

array.length 为获取数组的长度(数组元素的个数)， 任何一个对象都有自己的length。

String[] arr = new String[]{"1","2","3"};system.out.println(arr.length); // 3

数组的默认初始化值

Java 运算符

Java算术运算符操作

public class Demo {public static void main(String[] args) {int a = 1;int b = 2;System.out.println(a + b); // 3System.out.println(a \ b); // 0.5System.out.println(a - b); // -1System.out.println(a * b); // 2System.out.println(a++); // 2System.out.println(a--); // 0}}

以下运算符就不贴代码了，减少刷新，本博客字数一多就开始卡了

Java 修饰符

初学者看一下public和private就行了...，以后需要用到再翻回来看别的修饰符，不急，记得多敲代码哦

Java语言提供了很多修饰符，主要分为以下两类：
访问修饰符
非访问修饰符
修饰符用来定义类、方法或者变量，通常放在语句的最前端
Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java支持4种不同的访问权限。

访问修饰符

访问控制修饰符
默认的，也称为 default，在同一包内可见，不使用任何修饰符。
私有的，以 private 修饰符指定，在同一类内可见。
共有的，以 public 修饰符指定，对所有类可见。
受保护的，以 protected 修饰符指定，对同一包内的类和所有子类可见。

默认访问修饰符-不使用任何关键字

前缀不带修饰符String version = "0.0.1";boolean processOrder() {return true;}

私有访问修饰符-private

私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为private。
声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。
Private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。

public class Logger {// 对于某些敏感数据的获取以及赋值，需要用到private修饰符private String format;// 其他类不能直接得到和设置该变量的值。为了使其他类能够操作该变量，定义了两个 public 方法public String getFormat() { // getFormat() （返回 format的值）return this.format;}public void setFormat(String format) {// setFormat(String)（设置 format 的值）this.format = format;}}

(｡･∀･)ﾉﾞ嗨
公有访问修饰符-public

被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问 =-=

// Java 程序的 main() 方法必须设置成公有的，否则，Java 解释器将不能运行该类public static void main(String[] arguments) {...}

“

被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问，也能够被不同包中的子类访问
Protected 访问修饰符不能修饰类和接口 TvT
方法和成员变量能够声明为 protected，但是接口的成员变量和成员方法不能声明为 protected。

---

子类能访问 Protected 修饰符声明的方法和变量，这样就能保护不相关的类使用这些方法和变量。

下面的父类使用了 protected 访问修饰符，子类重载了父类的 openSpeaker() 方法class AudioPlayer { protected boolean openSpeaker(Speaker sp) {// 实现细节 }} class StreamingAudioPlayer {boolean openSpeaker(Speaker sp) {// 实现细节 }}

非访问修饰符

非访问修饰符可以先不用看，先把Java基础语法之类的看会了，回来再了解什么意思

为了实现一些其他功能，Java也提供了许多非访问修饰符。

静态变量声明符-static

static表示“静态的”，它也是一种修饰符，可以修饰属性、方法、代码块和内部类.static修饰成员变量，表示该成员变量只在内存中存储一份，可以被访问，修改(共享).static修饰的成员变量，归属于类.被static修饰的属性(成员变量)称为静态变量，也叫做类变量.被static修饰的常量称为静态常量.被static修饰的方法称为静态方法，也叫做类方法.被static修饰的代码块叫做静态代码块.被static修饰符的内部类，叫做静态内部类.

// 只存储一份，比如：在线人数// Num类public class Num {public static int onlineNum = 100;}// 推荐使用 类名.成员变量 进行访问// Demo.javapublic class Demo {public static void main(String[] args) {// 访问static修饰的成员变量System.out.println(Num.onlineNum);// 不推荐使用对象访问, 虽然是可以的Num n = new Num();System.out.println(n.onlineNum);}}

实例成员变量与静态成员变量到底有什么区别？

---

静态成员变量：（有static修饰，归属于类，内存中只加载一次），通常表示一些可以被共享的信息，比如：人数，热度。。。 静态成员变量可以被共享访问

---

实例成员变量：（无static修饰，存在于每个对象中），通常表示姓名，年龄之类的个人（每个对象）的信息

常量声明符-final

final 用在变量的前面表示变量的值不可以改变，此时该变量可以被称为常量final 修饰的变量即成为常量，只能赋值一次，但是 final 所修饰局部变量和成员变量有所不同。final 修饰的局部变量必须使用之前被赋值一次才能使用。final 修饰的成员变量在声明时没有赋值的叫“空白 final 变量”。空白 final 变量必须在构造方法或静态代码块中初始化。

注意：final 修饰的变量不可被改变，一旦获得了初始值，该 final 变量的值就不能被重新赋值

// 此处代码为摘抄public class FinalDemo {void doSomething() {// 1.声明常量时并没有被直接赋值final int e;// 如果未赋值，只能赋值一次e = 100;System.out.print(e);// 2.声明常量时赋值final int f = 200;}// 实例常量final int a = 5; // 直接赋值final int b; // 空白final变量// 静态常量final static int c = 12;// 直接赋值final static int d; // 空白final变量// 静态代码块static {// 初始化静态变量d = 32;}// 构造方法FinalDemo() {// 初始化实例变量b = 3;// 第二次赋值，会发生编译错误// b = 4;}}

当使用 final 修饰基本类型变量时，不能对基本类型变量重新赋值，因此基本类型变量不能被改变。 但对于引用类型变量而言，它保存的仅仅是一个引用，final 只保证这个引用类型变量所引用的地址不会改变，即一直引用同一个对象，但这个对象完全可以发生改变

---

不要忘记引用类型是存在于内存中

Java 表达式 & 语句 & 代码块

表达式

表达式，是由数字、运算符、数字分组符号（括号）、自由变量和约束变量等以能求得数值的有意义排列方法所得的组合。
约束变量是在表达式中已被指定数值，而自由变量则可以在表达式之外另行指定数值。

在 Java 中，表达式是根据 Java 语法由 变量 、 运算符 和 方法调用 组成的结构，表达式的结算结果为 单个值 。

public class Demo {public static void main(String[] args) {int a = 10;int b = 14;int c = a / (b - 1); // a / (b - 1) 为算术表达式 if (c < b) { // if语句将在下一小节讲到，此处只需知道 c > b 是一个布尔表达式即可System.out.println("c小于b");}}}

语句

类似于平时说话时的一句话，由表达式组成，以 ; 结束。int a = 3; y = a + 9; System.out.println(y); 都是语句。

代码块

一对大括号括起来的内容就是一个代码块。

Java 注释

Java 注释分为几种: 单行注释，多行注释，文档注释
被注释的代码不会被运行

1. 单行注释

// 单行注释

2. 多行注释

/*多行注释*/

3. 文档注释

文档注释通常是对程序中某个类或类中的方法进行的系统性的解释说明，开发人员可以使用JDK提供的javadoc工具将文档注释提取出来生成一份API帮助文档。文档注释以符号“/**”开头，并以符号“*/”结尾。

/*** 功能：**** 作者：xxx* 日期： */

————————————————————————–

Java 控制语句

控制语句

Java if | else if | else 条件

针对if | else if | else嘛… 欸嘿嘿，可以这么理解， if 就是如果的意思， else if就是再如果的意思， else显而易见，当if 与 else 都不为真的情况下，才会走 else

---

我觉得应该注意的点: 规范建议大家写 if 的时候都要带 else，这是一种避免有安全隐患的方法

---

我的理解: 其实if 后面带不带 else，要取决于实际应用场景，如果只有一种情况的话，我觉得使用return;来替代else，可以使代码看起来更加整洁

---

但是: 代码这东西仁者见仁，希望大家都能具备良好的编码风格

下面是一个 if | else if | else 的代码块

public class Demo {public static void main(String[] args) {int a = 10;int b = 14;int c = 20 if (a < b) { // 如果 a 小于 b，那么就执行 if 代码块的内容System.out.println("a小于b");} else if (a == b) { // 如果 a 等于 b，那么就执行 else if 代码块的内容System.out.println("a等于b");} else { // 如果 a既不小于b也不等于b，就执行 System.out.println("a大于b");}}}

Java switch case 条件

switch case 也是一种条件判断语句，用于判断一个变量或是一个系列内的值是否相等，是一种多分支结构，如果switch与某个case相匹配，就从该条件分支开始执行，直到遇到 break 跳出执行

执行流程： switch表达式中的值与case分支与条件进行逐条匹配，如果某个分支相匹配就会执行对应case语句的内容，若都不匹配，则执行Default语句中的内容，执行完毕跳出

switch(条件语句) {case 1:System.out.println("1");break; // break的意思为跳出case 2:System.out.println("2");break;default:System.out.println("default");}

Java for 循环

for (循环变量类型 循环变量名称；循环条件；更新语句) 循环体

注意: for循环本身就是用来循环的，循环某个数组的长度，根据长度循环多少次

public class Demo {public static void main(String[] args) {int arr = new int[]{1, 3, 4, 5};// for循环，打印出数组的每个元素// 下面小括号内循环多少次表达式是基于数组的长度循环多少次，就是循环数组for(int a = 0; a < arr.length; a++) {System.out.println(arr[a]); // a为arr每一项的下标，所以arr[a]就是循环arr的每一项}}}

增强型for循环

public class Demo {public static void main(String[] args) {int arr = new int[]{1, 3, 4, 5};// 增强for循环，意义与前端的forEach不能说是完全一致，只能说是一模一样for(int item: arr) { // 循环arr数组，每一个元素为itemSystem.out.println(item); // 循环item，输出为: 1 3 4 5}}}

Java while 循环

while是最基本的循环

while(条件控制语句) {循环体;条件控制语句;}

比如说：打印 5 次 HelloWorld

public class Demo {public static void main(String[] args) {int count = 5;while(i <= 5) {System.out.println("HelloWorld");}}}

while循环作业: 以下是一个非常简单的while循环小作业，想做的话可以做一做，并且希望你把作业发送到评论区，以供小白参考

public class Demo {public static void main(String[] args) {// 1. 定义一个变量，表示一栋楼的高度// 2. 定义一个变量，表示一个人的身高// 3. 定义一个计数器，用来统计次数// 长高高// 每次循环人的身高都会长高至自身原身高的2倍// 楼的高度 > 人的身高 循环才继续， 否则循环就会停止while() {// 请作答}// 4. 打印一下一共长高了多少次System.out.println();}}

Java break 与 continue 语句

break和continue都是用来控制循环结构的，主要作用是停止循环

break： break用于跳出一个循环体或者完全结束一个循环，不仅可以结束其所在的循环，还可结束其外层循环。
continue： 只跳过本次循环

break的例子：
一个简单的例子，一天又34小时，如果到了晚上12点，就要睡觉了

public class Demo{public static void main(String[] args){for (int i = 1; i <= 24; i++) {System.out.println("正在度过一天！！");if(i == 24) { // 24点了System.out.println("24点啦，睡觉啦~~");break; // 跳出并结束当前循环的执行}}}}

continue 小作业： 在学校，一个小周期为7天，每当周六周天的时候，都为休息时间，要求：只跳过周六周天，并打印周一到周五的日期，控制台输入示例：

周1周2周3周4周5周六啦！周天啦！

public class Demo{public static void main(String[] args){for (int i = 1; i <= 7; i++) { // 请作答 }}}

小案例别忘了发到评论区哦！

————————————————————————–

Java 数组 ✨

• 数组详细文章：数组详细介绍

————————————————————————–

Java 日期与时间（Java8新增）

看了看，这个博主的时间写的挺好的，先推荐，以后时间专门出个专栏吧！
Java 时间与日期

Java 正则表达式 ✨

嗯.... 我的专栏我记得之前写过正则表达式，不过那个写的比较烂，当时分在前端专栏里了.写一个新的，正好学一学，正则这个东西对我来说，可以算得上是魔鬼了 = -=

• Java 正则表达式：Java 正则表达式

Java Scanner(获取用户输入)

java.util.Scanner 是 Java5 的新特征，我们可以通过 Scanner 类来获取用户的输入。
下面是创建 Scanner 对象的基本语法：

// 构造一个Scanner 类的对象，并且与标准输入流System.in关联Scanner s = new Scanner(System.in); //创建了一个Scanner对象，Scanner为类名，s为对象名。

接下来我们演示一个最简单的数据输入，并通过 Scanner 类的 nextInt(), nextLine() 方法获取输入的字符串.

nextLine()可以扫描到一行内容(当前行，光标所在行的内容，包括空格、回车)并作为一个字符串而被获取到 next()获得有效字符串后遇到的第一个空格就会结束读取。比如，输入hello world.最终的输出结果为hello

import java.util.Scanner;public class demo04 {public static void main(String[] args) {//创建一个扫描器对象，用于接收键盘数据Scanner scan = new Scanner(Scanner.in);System.out.println("使用next方式接收：");//使用next方式接收String str = Scanner.nextLine();System.out.println("输出的内容为："+str);//及时关闭IO流的类，否则会一直占用资源Scanner.close();}}

nextInt()只读取数值，读取完后 没有读取并且光标放在本行。nextDouble()的用法同理nextInt()，注意：nextInt无法读取小数，否则会报错

Scanner scan=new Scanner(System.in);int i = scan.nextInt();double d = scan.nextDouble();

这个博主的文章不错的，代码就抄下来了 嘻嘻
———————————————— 版权声明：(Java Scanner(获取用户输入))本文为CSDN博主「海螺炒面」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/hailuochaofan/article/details/125885322

————————————————————————–

Java 面向对象详解

Java语言作为面向对象的编程语言，提供了面向对象的四种基本性质：抽象性、封装性、继承性和多态性。万事万物皆对象，Java面向对象编程是以人类最好理解的方向去编程(客观世界中的对象为中心)

什么是面向对象？

《Java编程思想》中提到“万物皆为对象”的概念。它将对象视为一种奇特的变量，它除了可以存储数据之外还可以对它自身进行操作。它能够直接反映现实生活中的事物，例如人、车、小鸟等，将其表示为程序中的对象。每个对象都具有各自的状态特征（也可以称为属性）及行为特征（方法），java就是通过对象之间行为的交互来解决问题的。

面向对象就是把构成问题的事物分解成一个个对象，建立对象不是为了实现一个步骤，而是为了描述某个事物在解决问题中的行为。

面向过程和面向对象的区别

面向过程

---

优点：性能比面向对象好，因为类调用时需要实例化，开销比较大，比较消耗资源。
缺点：不易维护、不易复用、不易扩展

面向对象

---

优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统 更加灵活、更加易于维护
缺点：性能比面向过程差

Java 面向对象 第一大部分

Java 类与对象

类: 是抽象的概念集合,表示的是一个共性的产物,类之中定义的是属性和行为(方法).
对象: 类可以表示是一个独立的个体,也可以表示为一个集体,每个对象都有自己的属性.

例如: 一个人, 就等于一个对象, 脸,身体,腿部为这个对象的属性. 说话,动作为这个对象的一些方法.

类是如何定义的?

class ClassName {...属性;...方法;}

类中包含的内容称为类的成员。属性主要是用来描述类的，称之为类的成员属性或者类成员变量。方法主要说明类具有哪些功能，称为类的成员方法。

定义一个学生类

class Students {int age = 16;String name = "xiaoming";int id = 1;public void getInfo() {System.out..println("姓名：" + name + "，年龄：" + age + "，学号：" + id)}}

通过 javac 编译为 .class 文件，在JVM的基础上计算机就可以识别

• 声明并实例化对象

类名称 对象名称 = new 类名称();

引用数据类型与基本数据类型最大的不同在于：引用数据类型需要内存的分配和使用。所以，关键字new的主要功能就是分配内存空间，也就是说，只要使用引用数据类型，就要使用关键字new来分配内存空间。

当一个实例化对象产生之后，可以按照如下的方式进行类的操作：
对象.属性：表示调用类之中的属性；
对象.方法()：表示调用类之中的方法。

下面我们来操作上方提到的那个Students类

class Student {int age;String name;int id = 1;public void getInfo() {System.out..println("姓名：" + name + "，年龄：" + age + "，学号：" + id)}}public class GetInfo() {public static void main(String[] args) {Student student = new Student(); // 实例化对象student.name = "张三"; // 声明属性student.age = 15;student.getInfo(); // 调用类方法}}

执行之后，终端应该输入这样一句

姓名：张三，年龄：15，学号：1

Java 方法

首先，什么是方法？
java的方法相当于其他语言的函数(func)，使用方法来完成一些特定的功能

---

方法有什么好处呢？

1. 提高代码可读性
2. 提高代码可维护性
3. 代码的重用

注意： 方法必须在main方法里调用运行，因为main方法是程序的入口方法，你不调用在main方法里，你就没有程序运行，而其他方法与方法之间可以相互调用使用

方法 的 语法：

访问权限修饰符 其他修饰符 返回值类型 方法名称(参数...) {...操作// 如果返回值类型为 void， 则不用写return// 如果为方法体(函数体) 则 return 返回值;}

比如说。。。我要写一个计算一个数是否为奇数或偶数

公司电脑太卡，实在受不了了

Java 方法重载 ✨

✨ 下面文章介绍了 Java方法重载 使用以及注意事项 ✨

• 方法重载：Java方法的重载示例

Java 构造方法 ✨

✨ 下面文章介绍了 Java构造方法 使用以及注意事项 ✨

• 构造方法：Java 构造方法

Java 字符串

在Java中，字符串是一种引用数据类型，它是由零个或多个字符组成的序列。Java中的字符串是不可变的，也就是说，一旦字符串对象被创建，它的值就不能被修改。如果需要修改字符串，需要创建一个新的字符串对象。

---

字符串是使用Unicode字符集来表示的。Unicode字符集是一种可以表示几乎所有已知语言的字符集。因此，Java字符串可以处理多种语言的字符。

Java中的字符串有两种方式可以创建：

• 使用字符串字面量

使用字符串字面量创建一个新的字符串对象，并在运行时对其进行初始化。字符串字面量是放在双引号内的字符序列，例如：

// 字面量创建字符串String str = "Hello World!";

• 使用String类的构造函数

可以通过使用String类的构造函数来创建字符串对象。例如：

// String类的构造函数来创建字符串对象String str = new String("Hello World!");

注意: 这种方式将创建一个新的字符串对象，即使存在相同的字符串字面量。

Java字符串中常用的方法有许多，以下是一些常见的方法：

• length()：返回字符串的长度。

String str = "Hello World!"; int len = str.length(); // len的值将是12

• charAt()：返回指定索引处的字符。

String str = "Hello World!"; char c = str.charAt(4); // c的值将是o

• concat()：将两个字符串连接起来。

 String str1 = "Hello"; String str2 = "World"; String str3 = str1.concat(str2); // str3的值将是HelloWorld

• substring()：返回一个新的字符串，该字符串从指定的开始索引到指定的结束索引（不包括结束索引）之间的字符。

 String str = "Hello World!"; String subStr = str.substring(6,11); // subStr的值将是World

• replace()：返回一个新的字符串，其中所有出现的旧字符串被替换为新字符串。

String str = "Hello World!";String newStr = str.replace("World","Java"); // newStr的值将是Hello Java!

• toUpperCase() 和 toLowerCase()：将字符串转换为大写或小写。

 String str = "Hello World!"; String upStr = str.toUpperCase(); // upStr的值将是HELLO WORLD! String lowStr = str.toLowerCase(); // lowStr的值将是hello world!

• contains()：返回一个布尔值，表示是否包含指定的子字符串。

String str = "Hello World!";boolean containsStr = str.contains("World"); // containsStr的值将是true

以上只是Java字符串中的一部分常用方法，更多的方法可以参见Java官方文档。

在使用字符串时，需要注意以下事项：

1. Java中的字符串是不可变的，因此在对字符串进行操作时，总是会创建新的字符串对象。如果需要对字符串进行大量操作，最好使用StringBuilder或StringBuffer类， 因为它们比字符串更高效。
2. 在使用字符串时，应注意区分大小写。
3. 在使用字符串时，应避免使用==运算符。相反，应使用equals()方法进行比较。

Java this 关键字 ✨

• Java this关键字: Java this

Java 递归(恐怖故事) ✨

• Java 递归: Java递归
• 本篇文章详细介绍Java中的递归用法，注意点，使用场景

Java instanceof 操作符

instanceof是Java中的二元运算符，作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型；左边是对象，右边是类；当左边的对象是右边的类或子类所创建的对象时，返回true；否则，返回false。

import java.util.ArrayList;import java.util.Vector;// java.util.Vector类是Java中的一个集合类，它实现了可调整大小的数组，可以动态地添加或删除元素。Vector类可以用来存储任何类型的对象，而不只是基本数据类型。 public class Main {public static void main(String[] args) {Object array = new ArrayList();//创建ArrayList类的对象arrayCheck(array);//调用函数判断}public static void Check(Object array) {//判断对象 是哪个类实例化产生的 if (array instanceof Vector){System.out.println("对象array 是 java.util.Vector 类的实例");} if (array instanceof ArrayList){ System.out.println("对象array 是 java.util.ArrayList 类的实例");}}}

Java 面向对象 第二大部分

Java 继承 ✨

继承（Inheritance）是指子类继承父类的特征和行为，使得子类具有父类的所有属性和方法。继承可以减少代码量，提高代码的复用性。在Java中，使用关键字“extends”来表示一个类继承自另一个类。

• Java 继承详细文章: Java继承（click me）

Java 方法重写 ✨

方法重写（Method Overriding）是指在子类中重新定义与父类中同名、同参数列表的方法，以实现子类对该方法的自定义实现。通常情况下，方法重写的目的是为了实现多态性，即在运行时根据对象的实际类型来调用相应的方法。

• Java 方法重写: Java 方法の重写（click me）

抽象类 & 抽象方法 ✨

• Java抽象类&抽象方法：抽象类&抽象方法

Java 接口 ✨

• Java 接口：Java 接口

Java 多态

多态（Polymorphism）是指同一种类型的对象在不同情况下表现出不同的行为。多态分为编译时多态和运行时多态。编译时多态指方法重载，即同一个类中的方法名相同但参数列表不同的方法；运行时多态指方法覆盖，即子类重写了父类的同名方法，并且在调用时只知道父类的引用，而具体调用哪个方法要根据实际对象来决定。

Java 封装

封转是指属性私有化，根据需要提供setter和getter方法来访问属性，隐藏具体属性和实现细节，仅对外开放接口，控制程序中属性的访问级别。继承是指将多个相同的属性和方法提取出来，新建一个父类，java中一个类只能继承一个父类，且只能继承访问权限非private属性和方法，子类可以重写父类中的方法，命名与父类中同名的属性。

Java 面向对象高级(第三大部分)

嵌套 & 内部类

Java static 关键字

Java 匿名内部类

Java 单例(两种)

Java 枚举类

Java 枚举构造方法

Java 枚举字符串

Java 反射

————————————————————————–

Java 异常处理 ✨

• Java的异常处理详细文章：Java异常处理

————————————————————————–

Java 集合

集合

Java 集合框架

Java 集合接口

Java List 接口

Java ArrayList

Java Vector

Java Stack

————————————————————————–

Java 队列

队列

Java 队列接口

Java 优先级队列

Java 双端队列接口

Java LinkedList

Java 数组队列

Java 阻塞队列接口

Java ArrayBlockingQueue

Java LinkedBlockingQueue

————————————————————————–

Java Map

JavaMap

Java Map 接口

Java HashMap

Java LinkedHashMap

Java WeakHashMap

Java EnumMap

Java SortedMap 接口

Java NavigableMap 接口

Java TreeMap

Java ConcurrentMap 接口

Java ConcurrentHashMap

————————————————————————–

Java Set

Set

Java Set 接口

Java HashSet

Java EnumSet

Java LinkedHashSet

Java SortedSet 接口

Java NavigableSet

Java TreeSet

Java 集合算法

Java 迭代器接口

Java Listlterator 接口

————————————————————————–

Java 字节流

IO流

Java IO流简介

Java InputStream

Java OutputStream

Java FileInputStream

Java FileOutputStream

Java ByteArrayInputStream

Java ByteArrayOutputStream

Java ObjectInputStream

Java ObjectOutputStream

Java BufferedReader

Java BufferedWriter

Java StringWriter

Java PrintWriter

————————————————————————–

Java 并发编程

并发

进程与线

多线程的入门类和接口

线程组和线程优先级

线程的状态及主要转化方法

线程间的通信

重排序和 happens-before

volatile

synchronized 与锁

CAS 与原子操作

AQS

计划任务

Stream 并行计算原理

Frok/Join

通信工具类

CopyOnWrite

并发集合容器

锁接口和类

阻塞队列

线程池原理

————————————————————————–

Java 虚拟机

虚拟机

Java 内存结构

堆

栈

Java 垃圾回收

JVM 内存区域

Java 虚拟机栈

class 文件

字节码指令

JVM 参数调优

Java 对象模型

HotSpot

类加载机制

编译和反编译

反编译工具（javap）

JIT

虚拟机性能监控和故障处理工具（jps、jstack、jmap、jstat、jconsole、javap）

————————————————————————–

后话

规划学习路线以及建议