1.概述

定义：Java是一种高级语言。它被设计为一种通用的、面向对象的编程语言，具有跨平台性和可移植性
特点：简单易学、面向对象编程、平台无关性、安全性、高性能、多线程支持、开源免费
跨平台原理：针对于不同的操作系统，Java提供了不同的虚拟机，对于不同的操作系统，安装不同的虚拟机
三大版本：
- JavaSE：SE即标准版，包含了Java核心类库，主要用来开发桌面应用
- JavaME：ME即微型版，包含了SE中部分类库，又有自己扩展部分，主要用来做移动类嵌入式开发
- JavaEE：EE即企业版，包含SE，又有扩展部分（Servlet，JDBC等），主要用来开发分布式网络程序
JRE、JVM、JDK：
- JVM（Java Virtual Machine），Java虚拟机
- JRE（Java Runtime Environment），Java运行环境，包含了JVM和Java的核心类库（Java API）
- JDK（Java Development Kit）称为Java开发工具，包含了JRE和开发工具
下载和安装
目录介绍
环境变量配置

特点

面向对象
跨平台性：Java程序在不同平台上可以运行，这是因为Java程序通过JVM（Java虚拟机）来运行，JVM能够在不同平台上执行相同的Java代码，操作系统本身其实是不认识Java语言的，但是针对于不同的操作系统，Java提供了不同的虚拟机。
高性能：尽管Java是一种解释型语言，但它可以通过JIT（即时编译）技术提高性能。
安全性：Java是一种安全性较高的编程语言，因为它具有内置的安全机制，如内存管理、异常处理和访问控制。
多线程支持：Java提供了内置的多线程支持，使得程序员可以很方便地编写多线程程序。

JDK JRK

JVM（Java Virtual Machine），Java虚拟机
JRE（Java Runtime Environment），Java运行环境，包含了JVM和Java的核心类库（Java API）
JDK（Java Development Kit）称为Java开发工具，包含了JRE和开发工具

基本用例-HelloWorld

Java程序开发运行流程需要三个步骤：编写程序，编译程序，运行程序

步骤一：创建Java程序
新建HelloWorld.class文件，并编写

class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!"); 
    }
}

编译Java程序
打开命令行窗口执行javac命令
1
javac HelloWorld.java
步骤三：执行字节码文件
打开命令行窗口执行当前目录下java命令
1
java HelloWorld
- 注意：运行class文件时，不需要加.class后缀

语法

总结：

注释：单行注释、多行注释、文档注释
关键字：

定义：被Java赋予了特定含义的英文单词
class、static、……
字面量：

定义：数据在程序中的书写格式
666、”MySoul“、……
变量：

定义：临时存储数据的容器
int a = 16;、double b = 10.1;、……
注意：Java中变量需要有变量类型、变量名以及分号结束
数据类型：

基本数据类型：byte、short、int、long、float、double、char和boolean
引用数据类型：字符串、数组、类和接口、……
区别：
基本数据类型存储在栈中，而引用数据类型存储在堆中
基本数据类型的变量之间是相互独立的，而引用数据类型的变量之间可能共享同一个对象
标识符：

定义：标识符是用来命名变量、方法、类、接口等程序元素的名称
注意：
必须由数字、字母、**下划线_、美元符号$**组成。
数字不能开头
不能是关键字
区分大小写的
权限修饰符：

定义：权限修饰符是Java中的一种关键字，用于控制类、方法和变量的访问权限
权限范围：private<默认/空着不写<protected<public
包：

定义：包是一种用于组织和管理 Java 类的机制

命名规范：

路径名.路径名.xxx.xxx
// 例如：com.itheima.oa

导包：不是在java.lang包下，都需要导包。因为Java开发环境，默认为lang包

注释

单行注释：
1
// 这是单行注释文字

多行注释：(不能嵌套使用！)

/*
这是多行注释文字
这是多行注释文字
这是多行注释文字
*/

文档注释：

/*
这是多行注释文字
这是多行注释文字
这是多行注释文字
*/

关键字

字面量

Java 字面量是程序中直接使用的常量值，它表示各种数据类型的固定值。字面量可以是整数、浮点数、字符、字符串等数据类型的常量值，它们在代码中直接出现，不需要进行计算或转换。
有：整数字浮点数字字符字符串布尔 null 转义序列数组枚举常量字符编码
转义序列：一些特殊的字符序列，以反斜线 \ 开头，用于表示无法直接输入的字符，如换行符 \n、制表符 \t 等

字符编码字面量：表示字符的Unicode编码，以 \u 开头，后面跟着四个十六进制数字。例如：\u0041 表示字符 ‘A’。

public class Demo {
    public static void main(String[] args) {
        System.out.println(10); // 输出一个整数
        System.out.println(5.5); // 输出一个小数
        System.out.println('a'); // 输出一个字符
        System.out.println(true); // 输出boolean值true
        System.out.println("字面量"); // 输出字符串
    }
}

补充：

不带小数点的数字都是整数类型的字面量
只要带了小数点，那么就是小数类型的字面量
只要用双引号引起来的，不管里面的内容是什么，不管里面有没有内容，都是字符串类型的字面量。
字符类型的字面量必须用单引号引起来，不管内容是什么，但是个数有且只能有一个
布尔类型的字面量只有两个值，true、false
空类型的字面量只有一个值，null

变量

public class VariableDemo2{
	public static void main(String[] args){
		//1.变量名不允许重复
		//int a = 10;
		//int a = 20;
		//System.out.println(a);
		
		//2.一条语句可以定义多个变量
		//了解。
		//int a = 10, b = 20, c = 20,d = 20;
		//System.out.println(a);//?
		//System.out.println(b);//?
		
		
		//3.变量在使用之前必须要赋值
		int a = 30;
		System.out.println(a);
	}
}

数据类型

整数类型（Integer Types）：byte：8位，范围为 -128 到 127、short：16位，范围为 -32,768 到 32,767、int：32位，范围为 -2^31 到 2^31 - 1、long：64位，范围为 -2^63 到 2^63 - 1
浮点类型（Floating-Point Types）：float：32位，用于表示单精度浮点数、double：64位，用于表示双精度浮点数
字符类型（Character Type）：char：16位，用于存储一个 Unicode 字符

布尔类型（Boolean Type）：boolean：用于表示布尔值，只有两个取值：true 和 false

public class VariableDemo3{
    public static void main(String[] args){
        //1.定义byte类型的变量
        //数据类型 变量名 = 数据值;
        byte a = 10;
        System.out.println(a);

        //2.定义short类型的变量
        short b = 20;
        System.out.println(b);

        //3.定义int类型的变量
        int c = 30;
        System.out.println(c);

        //4.定义long类型的变量
        long d = 123456789123456789L;
        System.out.println(d);

        //5.定义float类型的变量
        float e = 10.1F;
        System.out.println(e);

        //6.定义double类型的变量
        double f = 20.3;
        System.out.println(f);

        //7.定义char类型的变量
        char g = 'a';
        System.out.println(g);

        //8.定义boolean类型的变量
        boolean h = true;
        System.out.println(h);

    }
}

注意：
- 如果要定义一个整数类型的变量，不知道选择哪种数据类型了，默认使用int。
- 如果要定义一个小数类型的变量，不知道选择哪种数据类型了，默认使用double。
- 如果要定义一个long类型的变量，那么在数据值的后面需要加上L后缀。（大小写都可以，建议大写。）

引用数据类型

类（Class）：类是用来创建对象的模板。它定义了对象的属性（成员变量）和方法（成员方法）。通过实例化类，可以创建类的对象，并使用对象调用类的方法。
接口（Interface）：接口定义了一组方法的规范，但没有实际的方法体。类可以实现一个或多个接口，从而获得接口定义的方法，并在类中实现这些方法。
数组（Array）：数组是一种用于存储相同类型元素的数据结构。它可以是一维数组或多维数组，用于在内存中连续存储多个元素。
枚举（Enum）：枚举是一种特殊的类，用于表示一组预定义的常量。枚举常常用于表示一组相关的值。
字符串（String）：字符串是一种引用数据类型，但它具有特殊的性质，可以像基本数据类型一样进行操作。字符串实际上是一个字符序列，它有许多方法用于处理字符串操作。
自定义引用类型：除了上述内置的引用数据类型，开发人员还可以创建自定义的类和接口，以及它们的实例，从而构建更复杂的数据结构和功能。

基本数据类型和引用数据类型区别

基本数据类型：基本数据类型是按值传递的，它们在Java虚拟机栈中分配内存空间，并直接存储值本身。当基本数据类型的变量被赋值时，实际上是将该变量中的值复制到另一个变量中，这两个变量之间没有任何关联。

引用数据类型：引用数据类型是按引用传递的，它们在Java虚拟机堆中分配内存空间，存储的是对象的引用（内存地址）。当引用数据类型的变量被赋值时，实际上是将该变量中的引用复制到另一个变量中，这两个变量指向同一个对象。

 // 使用引用数据类型创建一个对象
String message = new String("Hello, World!");

// 创建一个数组
int[] numbers = new int[5];

// 使用自定义类创建对象
class Person {
    String name;
    int age;
}
Person person = new Person();
person.name = "Alice";
person.age = 30;

// 枚举类型
enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}
Day today = Day.WEDNESDAY;

标识符

注意一下命名规范就好了

权限修饰符

在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限，我们之前已经学习过了public 和 private，接下来我们研究一下protected和默认修饰符的作用。

public：公共的，所有地方都可以访问。
protected：本类，本包，其他包中的子类都可以访问。
默认（没有修饰符）：本类，本包可以访问。
注意：默认是空着不写，不是default
private：私有的，当前类可以访问。
public > protected > 默认 > private

包

在Java中，包（Package）是一种用于组织类和接口的方式，它们通过逻辑上的组织将相关的类和接口归类到一个命名空间中。包的主要目的是避免命名冲突，并提供更好的代码管理和组织结构
- 包在操作系统中其实就是一个文件夹。包是用来分门别类的管理技术，不同的技术类放在不同的包下，方便管理和维护。

运算符和表达式

笔记小结：
概述：

Java运算符是用于对一个或多个操作数执行操作的特殊符号

表达式是由变量、常量、运算符和方法调用组成的符合语法规则的语句

运算符和表达式区别：
1. 运算符就是对常量或者变量进行操作的符号
2. 表达式就是符合Java语法的式子就是表达式
算术运算符：

定义：算术运算符是用来执行基本的数学运算的

例如：
1
+、-、 *、 /
自增自减运算符：

定义：自增自减运算符是一种特殊的算数运算符，用于对变量的值进行加1或减1操作

例如：
1
++、--
赋值运算符：

定义：赋值运算符是Java中用于给变量赋值的运算符

例如：
1
b = 20;
扩展赋值运算符：

定义：扩展赋值运算符是将算术运算符和赋值运算符组合在一起的运算符

例如：
1
"+="、 "-="、 "*="、 "/="、 "%="
特点：扩展的赋值运算符中隐层还包含了一个强制转换
关系运算符：

含义：关系运算符是用于比较两个值之间的大小关系

例如：
1
a > b
注意：区分 == 和 = 赋值运算符和关系运算符
逻辑运算符：

含义：用于多个布尔表达式组合在一起，以生成新的布尔表达式

例如：
1
true & true、false & false
注意：逻辑运算符还有
1
！、& 、 |、^
短路逻辑运算符：

含义：如果已经可以确定整个表达式的结果时，就不再继续计算剩下的表达式

例如：
1
用户名正确 && 密码正确
三元运算符：

含义：被称为条件运算符，它是Java中唯一的具有三个操作数的运算符

格式：

关系表达式？表达式1 ：表达式2 ；

例如：
1
a > b ? a : b
运算符优先级：小括号优先( )
隐式转换与强制转换
1. 隐式转换：自动类型提升
取值关系：byte < short < int < long < float < double
注意：float类型的存储空间比long类型小，但float类型的表示范围比long类型大
2. 强制转换：强制类型提升

格式：
1
目标数据类型变量名 = （目标数据类型）被强转的数据
字符串的+操作（特例）：

含义：当+操作中出现了字符，会拿着字符到计算机内置的ASCII码表中去查对应的数字，然后再进行计算

例如：
1
2
3
char c = 'a';
int result = c + 0;
System.out.println(result);//9

这里只列举与C++不同的地方

逻辑运算符
1. &：逻辑与（而且）
  两边都为真，结果才是真，只要有一个为假，那么结果就是假
2. |：逻辑或（或者）
  两边都为假，结果才是假，只要有一个为真，那么结果就是真。

// &  //两边都是真，结果才是真。
System.out.println(true & true);//true
System.out.println(false & false);//false
System.out.println(true & false);//false
System.out.println(false & true);//false

System.out.println("===================================");

// | 或  //两边都是假，结果才是假，如果有一个为真，那么结果就是真。
System.out.println(true | true);//true
System.out.println(false | false);//false
System.out.println(true | false);//true
System.out.println(false | true);//true

短路逻辑运算符
1. &&
  运算结果跟&是一模一样的，只不过具有短路效果。
2. ||
  运算结果跟|是一模一样的。只不过具有短路效果。
无符号右移（>>>）：将一个数的二进制表示向右移动指定的位数，无论最高位的符号位是什么，都用零填充。无符号右移操作会将符号位当作普通位处理，因此适用于无符号数的位移操作

控制语句

笔记小结：

流程控制语句

顺序结构：
含义：按照编写顺序依次执行的结构
判断和选择结构

含义：根据条件的不同而选择执行不同代码块的结构

例如：

if、switch
循环结构

含义：重复执行某段代码的结构

例如：

while、do…while、for
循环间的区别：1.for和while循环，是先判断，再执行。2.do…while是先执行，再判断
条件控制语句

含义：是一种程序控制结构，用于基于某些条件来执行或跳过代码块

例如：

break、continue
注意：条件控制语句在非循环结构中，不能使用

和C++没啥区别啊

数组

笔记小结：

定义：数组指的是一种容器，可以同来存储同种数据类型的多个值
定义方式：
1. 格式一：
  1
  2
  3
  数据类型 [] 数组名;
  //例如
  int [] array;
2. 格式二：
  1
  2
  3
  数据类型数组名 [];
  //例如
  int array [];
  注意：不同的数据类型对应不同的默认值
整数类型：0
小数类型：0.0
布尔类型：false
字符类型：‘\u0000’
引用类型：null

静态数组初始化：

格式一：

1
2
3

数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3，元素4...};
//例如
double[] arr = new double[]{1.1,1.2,1.3};

格式二：

1
2
3

数据类型[] 数组名 = {元素1，元素2，元素3，元素4...};
//例如
int[] array = {1,2,3,4,5}; //   仅仅在这有区别，其他的正常用起来没区别

动态数组初始化：

格式：

1
2
3

数据类型[] 数组名 = new 数据类型[数组的长度];
//例如
double[] arr = new double[10];

数组动态初始化与数组的静态初始化的区别：

语法不同
数组长度不同
赋值时机不同
注意：无论是何种数组，数组的最大长度为，数组的长度-1。例如：arr.length - 1

地址值：

含义：数组的地址值是指向数组对象的指针或引用

例如：

int[] arr = {1,2,3,4,5};
System.out.println(arr);	//[I@6d03e736
/*
[ ：表示现在打印的是一个数组。
I：表示现在打印的数组是int类型的。
@：仅仅是一个间隔符号而已。
6d03e736：就是数组在内存中真正的地址值。（十六进制的）
*/

索引：

含义：用来标识它在数组中的位置

例如：
1
arr[0]、arr[1]、……
特点：

起始值为 0
连续不间断
逐个+1增长。
数组元素访问

含义：根据索引访问数组中的值
格式：数组名[索引];

遍历

含义：依次取出元组中的元素

格式：

for(int i = 0; i < arr.length; i++){
   //在循环的过程中，i依次表示数组中的每一个索引
    sout(arr[i]);//就可以把数组里面的每一个元素都获取出来，并打印在控制台上了。
}

说明：arr.length 表示获取数组的长度

代码块

局部代码块

public class CodeBlockLearn {
    public static void main(String[] args) {
        {
            int a=10;
            System.out.println(a);
        }
    }
}

应用场景：那么当超出了方括号，变量a也就不存在了，有着提前释放变量的作用

构造代码块

静态代码块（重点）

/*格式：
static{}，需要通过static关键字修饰 */
public class MyClass {
    static {
        System.out.println("静态代码块执行了");
    }
 
    public static void main(String[] args) {
        System.out.println("主方法执行了");
    }
}

说明：

执行时机：随着类的加载而加载，并且自动出发，只执行一次
使用场景：在类加载时，做一些初始化的操作

关键字

this关键字

定义：当我们在一个类中使用 this 时，它指的是该类的当前对象。

 public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
                  this.name = name; //使用this关键字引用当前对象的成员变量name
        this.age = age; //使用this关键字引用当前对象的成员变量age
    }
}

static关键字

定义：static是一个关键字，用于修饰类的成员变量、成员方法和代码块，其作用是将这些成员变量、成员方法和代码块与类本身关联，而不是与类的实例对象关联

静态变量及其访问

含义：static修饰类的成员变量

定义：

1
2
3

/* 格式：
修饰符 static 数据类型 变量名 = 初始值；*/
public static String Name = "帅"；

访问：

1
2
3

/* 格式：
	类名.静态变量 */
System.out.println(Student.Name); // 帅

实例变量及其访问
1. 含义：无static修饰类的成员变量
2. 定义：
  1
  2
  3
  /* 格式：
  修饰符数据类型变量名 = 初始值； */
  public String Name = "帅"；
3. 访问：
  1
  2
  3
  4
  /* 格式：
  对象.方法名 */
  Student stu = new Student();
  System.out.println(stu.Name);
  注意：
  实例变量是属于每个对象，必须创建类的对象才可以访问
  静态变量不属于成员对象，属于类。该静态变量的加载随着类的加载而加载，优先于对象存在

静态方法及其访问

含义：static修饰类的成员方法

定义：

/* 格式：
	修饰符 static 类型 方法名() */
public static void study(){ // 类方法或者静态方法。
    System.out.println("study");   
}

访问：通过类名.方法名()
1
2
3
/* 格式：
类名.方法名() */
Student.study();
注意：实例方法是属于每个对象，必须创建类的对象才可以访问

实例方法及其访问

含义：无static修饰类的成员方法

定义：

/* 格式：
	修饰符 类型 方法名()*/
public void study(){ // 类方法或者静态方法。
    System.out.println("study");   
}

访问：需要new对象

/* 格式：
	对象.方法名 */
Student stu = new Student();
System.out.println(stu.study());

内存图：
1. 当使用了static关键字，会在堆内存中开辟一个名叫“静态存储位置”的内存空间
2. 静态方法不能访问非静态资源
3. 静态方法不能调用实例变量
4. 非静态资源可以访问所有
5. 注意，静态成员的生命周期与类的生命周期一样长

小结

当 static 修饰成员变量或者成员方法时，该变量称为静态变量，该方法称为静态方法。该类的每个对象都共享同一个类的静态变量和静态方法。任何对象都可以更改该静态变量的值或者访问静态方法。但是不推荐这种方式去访问。因为静态变量或者静态方法直接通过类名访问即可，完全没有必要用对象去访问。
无static修饰的成员变量或者成员方法，称为实例变量，实例方法，实例变量和实例方法必须创建类的对象，然后通过对象来访问。
static修饰的成员属于类，会存储在静态区，是随着类的加载而加载的，且只加载一次，所以只有一份，节省内存。存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。它优先于对象存在，所以，可以被所有对象共享。
无static修饰的成员，是属于对象，对象有多少个，他们就会出现多少份。所以必须由对象调用。
静态变量生命周期过长：静态变量在整个程序运行期间都存在，可能会导致占用大量的内存空间，影响程序的性能
静态变量的并发访问问题：多个线程同时访问静态变量时可能会发生并发访问的问题，导致数据不一致或其他错误
静态方法不能被子类覆盖：由于静态方法是属于类的，而非对象的，因此它们不能被子类覆盖，这限制了程序的灵活性
静态方法调用非静态方法或变量时需要创建对象：由于静态方法属于类，无法直接访问非静态的方法或变量，因此需要通过创建对象来访问
静态代码块无法处理异常：静态代码块中的语句无法处理异常，只能通过抛出异常来处理。

final关键字

笔记小结：

定义：final 是一个关键字，它可以用来修饰变量、方法和类，表示不可改变的、终态的。
修饰变量：

局部变量：表示它的值不能被改变，即该变量为常量。变量值不可被修改
1
2
final int a;
a = 10;
成员变量：表示它的值不能被改变，即该变量为常量。变量只可在定义成员变量的时候立马赋值
1
final int num = 10;
变量明明规范：单个单词全部大写，多个单词间使用下划线隔开

修饰方法：表示该方法不能被子类重写（覆盖）

1
2
3

final public void show1() {
		System.out.println("Fu2 show1");
}

修饰类：表示该类被称为称为最终类（或不可扩展类），因为不能被其余类继承
1
2
final class Fu {
}
细节：

final修饰的变量是基本类型:那么变量存储的数据值不能发生改变
final修饰的变量是引用类型:那么变量存储的地址值不能发生改变，是其指向的对象的内容可以被修改

private关键字

概述：用于修饰类的成员变量和方法的修饰符
作用：防止外部程序对对象的数据进行非法访问和操作

JAVA 学习笔记

1.概述

特点

JDK JRK

基本用例-HelloWorld

语法

注释

关键字

字面量

变量

数据类型

引用数据类型

基本数据类型和引用数据类型区别

标识符

权限修饰符

包

运算符和表达式

这里只列举与C++不同的地方

控制语句

数组

代码块

局部代码块

构造代码块

静态代码块（重点）

关键字

this关键字

static关键字

final关键字

private关键字

super关键字