【Java基础】全网最详细 - 从入门到转行

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, float, double
布尔型	boolean
字符型	char

整型： 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

数组的默认初始化值

类型	初始化值
基本类型	0
引用类型	null

Java 运算符

算术运算符	描述
+	加法: 进行两侧变量\值相加
-	减法: 进两侧变量\值相减
*	乘法: 进行两侧变量\值相乘
\	除法: 左侧变量\值除以右侧变量
%	取模: 左侧变量\值除以右侧变量取余数
++	自增: 自身+1
–	自减: 自身-1

Java算术运算符操作

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

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

关系运算符	描述
==	判断两侧的变量\值是否相等，如果相等条件为真
!=	判断两侧变量\值是否不相等，如果不相等条件为真
>	判断左侧变量\ 值是否大于右侧变量\值， 如果大于条件为真
<	判断左侧变量\ 值是否小于右侧变量\值， 如果小于条件为真
>=	判断左侧变量\ 值是否大于或者等于右侧变量\值， 如果大于或者等于条件为真
<=	判断左侧变量\ 值是否小于或者等于右侧变量\值， 如果小于或者等于条件为真

逻辑运算符	描述
&&	称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。
||	称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。
!	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。

Java 修饰符

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

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

访问修饰符

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

修饰符	当前类	同一包内	子孙类	其他包
public	Yes	Yes	Yes	Yes
protected	Yes	Yes	Yes	No
default	Yes	Yes	No	No
private	Yes	No	No	No

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

前缀不带修饰符
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.java
public 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数组，每一个元素为item
			System.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类的对象array
		  Check(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）是指同一种类型的对象在不同情况下表现出不同的行为。多态分为编译时多态和运行时多态。编译时多态指方法重载，即同一个类中的方法名相同但参数列表不同的方法；运行时多态指方法覆盖，即子类重写了父类的同名方法，并且在调用时只知道父类的引用，而具体调用哪个方法要根据实际对象来决定。

• 多态：多态~~ click me

Java 封装

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

Java中的封装是指将类的属性和方法进行访问控制，以保证数据的安全性和代码的可维护性。具体来说，封装包括三个访问控制修饰符：public、private和protected，分别表示公开、私有和受保护的访问级别。

下面是一个简单的Java封装案例，其中定义了一个Person类，包含了姓名和年龄两个私有属性，以及对这两个属性进行访问的公开方法。

public class Person {
    private String name;    // 姓名，私有属性
    private int age;        // 年龄，私有属性

    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 公开方法，获取姓名
    public String getName() {
        return name;
    }

    // 公开方法，设置姓名
    public void setName(String name) {
        this.name = name;
    }

    // 公开方法，获取年龄
    public int getAge() {
        return age;
    }

    // 公开方法，设置年龄
    public void setAge(int age) {
        this.age = age;
    }
}

Person类的属性name和age都被声明为private，外部无法直接访问。而对于这两个属性的访问，通过公开的getName、setName、getAge和setAge方法来实现。这样，外部就可以通过这些方法来获取和设置Person对象的属性，而无法直接访问这些属性，从而保证了数据的安全性和代码的可维护性。

例如，我们可以通过以下代码来创建一个Person对象，并通过公开方法来获取和设置其属性：

public class Main {
    public static void main(String[] args) {
        Person person = new Person("张三", 20);
        System.out.println("姓名：" + person.getName() + "，年龄：" + person.getAge());
        person.setName("李四");
        person.setAge(25);
        System.out.println("姓名：" + person.getName() + "，年龄：" + person.getAge());
    }
}

输出结果为：

姓名：张三，年龄：20
姓名：李四，年龄：25

可以看到，通过公开方法来获取和设置Person对象的属性，而无法直接访问这些属性，从而保证了数据的安全性和代码的可维护性。

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

Java static 关键字

在Java中，static关键字可以用于变量、方法和代码块中。它的作用是将这些元素与类相关联，而不是与类的实例相关联。这意味着，无论创建多少个类的实例，这些元素都只有一份副本。

具体来说，有static和无static的区别如下：

1. 静态变量：有static关键字的变量是类变量，也称为静态变量。它们在类加载时被初始化，可以通过类名直接访问，不需要创建类的实例。而无static的变量是实例变量，每个类的实例都有自己的一份副本。

2. 静态方法：有static关键字的方法是类方法，也称为静态方法。它们可以通过类名直接调用，不需要创建类的实例。而无static的方法是实例方法，只能通过类的实例调用。

3. 静态代码块：有static关键字的代码块是静态代码块。它们在类加载时执行，只执行一次。而无static的代码块是实例代码块，每次创建类的实例时都会执行。

总之，static关键字可以将变量、方法和代码块与类相关联，使它们在类加载时被初始化，而不是在创建类的实例时被初始化。这样可以节省内存空间，提高程序的执行效率。

嵌套 & 内部类

Java中的嵌套类指的是一个类定义在另一个类的内部，可以分为静态嵌套类和非静态嵌套类（也称为内部类）。内部类可以访问外部类的成员变量和方法，而外部类不能访问内部类的成员变量和方法。

class OuterClass {
    // 外部类的成员变量和方法

    class InnerClass {
        // 内部类的成员变量和方法
    }
}

OuterClass是外部类的名称，InnerClass是内部类的名称。内部类可以访问外部类的成员变量和方法，可以使用OuterClass.this来引用外部类的实例。

public class OuterClass {
    private int x = 10;

    // 非静态内部类
    class InnerClass {
        private int y = 5;

        public void print() {
            System.out.println("x = " + x); // 访问外部类的成员变量
            System.out.println("y = " + y); // 访问内部类的成员变量
        }
    }

    // 静态内部类
    static class StaticInnerClass {
        private int z = 3;

        public void print() {
            System.out.println("z = " + z); // 访问内部类的成员变量
        }
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        InnerClass inner = outer.new InnerClass(); // 创建内部类的实例
        inner.print(); // 调用内部类的方法

        StaticInnerClass staticInner = new StaticInnerClass(); // 创建静态内部类的实例
        staticInner.print(); // 调用静态内部类的方法
    }
}

在上面的案例中，OuterClass是外部类，包含一个非静态内部类InnerClass和一个静态内部类StaticInnerClass。InnerClass可以访问外部类的成员变量x，StaticInnerClass不能访问外部类的成员变量。在main方法中，首先创建了外部类的实例outer，然后通过outer.new InnerClass()创建了内部类的实例inner，最后调用了inner.print()方法，输出了x和y的值。同时，还创建了静态内部类的实例staticInner，并调用了staticInner.print()方法，输出了z的值。

Java 匿名内部类

Java中的匿名内部类是一种特殊的内部类，它没有名字，可以直接在代码中定义和使用。通常情况下，匿名内部类用于创建实现某个接口或继承某个类的对象，可以简化代码的编写，解决取名的烦恼

public class Calculator {
    public static void main(String[] args) {
        // 创建一个匿名内部类实现加法运算
        Operation add = new Operation() {
            @Override
            public int operate(int a, int b) {
                return a + b;
            }
        };
        // 创建一个匿名内部类实现减法运算
        Operation subtract = new Operation() {
            @Override
            public int operate(int a, int b) {
                return a - b;
            }
        };
        // 使用匿名内部类实现的加法运算
        int result1 = add.operate(10, 5);
        System.out.println("10 + 5 = " + result1);
        // 使用匿名内部类实现的减法运算
        int result2 = subtract.operate(10, 5);
        System.out.println("10 - 5 = " + result2);
    }
}

// 定义一个接口，用于实现不同的运算
interface Operation {
    int operate(int a, int b);
}

我们定义了一个接口Operation，用于实现不同的运算。然后我们使用匿名内部类实现了加法和减法运算
在匿名内部类中，我们需要重写接口中的方法，并且在创建匿名内部类的时候，需要使用new关键字来创建一个对象

Java 单例(Singleton)

单例模式，是一种常见的设计模式，在 Java 应用中，单例对象能保证在一个 JVM 中，该对象只有一个实例存在
单例模式分为两类：饿汉式，懒汉式

1. 饿汉式

饿汉式是一种单例设计模式，它的实现方式是在类加载的时候就创建一个实例对象，因此也被称为“饿汉式单例模式”

public class Demo {
	// 单例第一步 构造器私有
	private Demo() {
	
	}
	// 定义静态变量
	private static Singleton instance = new Singleton();
	// 
	public static Singleton getInstance() {
        return instance;
    }
}

Singleton类中定义了一个静态变量instance，用于保存类的唯一实例对象, 在类加载的时候，静态变量instance就会被初始化

2. 懒汉式

懒汉式是一种常见的单例模式实现方式，它的特点是在第一次使用时才会创建实例

public class Demo {
	// 单例第一步 构造器私有
	private Demo() {
	
	}
	
}

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）

---

--------------------------------------------------------------------------

后话

规划学习路线以及建议