实际工作项目开发中最少必要语法知识汇总

前言

当知识体系特别庞大时，先抓最小必要知识进行上手开发，边开发边学习细枝末节

简介

• 在 Java 语言的世界里，所有的 Java 程序都必须要以类的形式存在，这一点也正好体现了Java 的核心思想：面向对象编程。

一、什么是面向过程和面向对象？

程序设计语言分为面向过程和面向对象
对于面向过程，强调的是过程，关心的是我去做
对于面向对象，强调的是对象（万物皆对象），更关心的是我该让谁去做，这里的谁指的就是对象

举例：把大象装进冰箱
大象可以是对象，冰箱也可以是对象；
面向对象强调的，现在不是 “我”来打开冰箱，而是“我去调用冰箱和大象的操作”；
让大象和冰箱去做这些事情，不需要“我”去一步一步地实现这个过程，“我”去调用对象（大象和冰箱）的操作来实现功能；

操作
冰箱：打开冰箱门、关闭冰箱门；
大象：钻进冰箱

总结：
面向对象：目标是让对象去做事情，我是去调用对象的操作来实现功能；只需要去关心你该让谁去做，而不是“我”去做（省去了面向过程的很多步骤）；
面向过程：强调的是“我”应该怎么去做

二、类和对象

1、类和对象的理解

类：可以理解为一类 “大体上相似”的对象；
例如，人，有很多共同的地方
属性：人的姓名、年龄 等
行为：人具体可以做什么事情，吃饭、学习、睡觉 等
要想描述大体上相似的对象，先将这些对象的共同行为和属性给抽象出来存储在一个类中

Person 类：用来描述人，是人的抽象；
Person 类并没有明确具体的姓名是谁，年龄多大；
Person 类对于行为来说也没有明确具体谁在吃饭、谁在睡觉
只是将对象的属性和行为抽象出来，对于类里来说并不知道具体的姓名是谁，年龄多大，谁在吃饭、睡觉

具体是谁在吃饭、谁在睡觉，要在什么时候才体现出来？
在创建对象的时候才实施体现出来
new 一个具体对象后，姓名是张三、年龄为 20，张三在吃饭、张三在学习（通过对象来体现）

2、类的分类

实体类、接口类（边界类）、控制类

实体类的对象表示现实世界中真实的实体，如人、物等；是系统中的某个对象，保存系统中的信息，提供对外用户可以处理信息的操作

接口类的对象为用户（人）提供一种与系统合作交互的方式，分为人和系统两大类
系统外的参与者是用户，用户和系统进行交互
人的接口：显示屏、窗口、Web 窗体、对话框、菜单、等其他显示控制以及二维码、条形码等用户与系统交互的方法
系统的接口：涉及到把数据传送到其他系统或者从其他系统接收数据

控制类的对象用来控制活动流，充当协调者

3、类的基本组成

1、
类名：类的唯一标识，用于定义对象的类型
属性：类的实体拥有的特征
方法：类的实例可以执行的操作，是在类中定义的函数，表示类的行为，方法接受参数并返回结果，可以被类的实例对象调用

如果想要使用某个类里面的方法，需要执行两步
创建该类的具体对象
通过这个对象去调用内部的方法，具体语法为：对象名.方法名

2、
构造函数：创建类的实例（对象）的函数
是一种特殊的方法，用于创建对象的实例
函数名和类名一致，没有返回值，不能被继承，可以接受一个或多个参数
初始化类的实例，在实例被创建的时候自动调用
构造函数可选

3、
内部类：定义在另一个类内部，可以访问外部类的所有成员变量和方法，包括私有的

4、对象

类是对象的抽象，对象是类的实例

new 一个对象后（执行构造函数就创建了一个对象），对象就自动包含了类中的属性和行为（不进行手动赋值的话，对象的属性值为类中默认值），就可以进行属性和方法的调用
初始时，给属性赋值可以通过初始化构造方法赋值，或者手动赋值

对象的属性只能通过对象本身的方法来改变

三、消息

1、什么是消息

给某个对象发消息
作用：消息中包含外界的一些信息，发送给对对象，对象进行执行

举例：
1）对象为：m1
2）发送消息就是调用对象的方法（调用类的方法），消息就是方法（Changelevel），2 就是外界的信息
3）即外界要将对象的等级改为 2

总结：
消息传递即通过：对象名.方法(参数)进行调用
对象之间通信是通过消息进行传递

四、封装

1、什么是封装

将属性和行为封装在一个对象中，实现将信息隐蔽
同时对外提供一些简单的公共接口以供外界调用
例如，遥控器——电视机

对于外界调用者来说，不需要知道方法里面具体是干什么的，只需要知道调用这个方法就可以实现相应的功能即可；

例如，
对象直接调用 eat 方法名即可，具体功能的实现是放在方法中（方法中封装了吃饭的具体实现）
只需要将方法变成一个公共的（public）的接口提供给用户去使用即可，其中public 方法名可以理解为是一个公共的接口，外界只需要调用这个公共的接口即可（具体方法的实现封装在类中的方法中）
用户只需要知道调用这个方法就可以实现相应的功能即可

总结：
1）属性的封装
通过将属性设置为 private，外界不能直接修改和访问；将属性设置为 private 后（属性就只能在当前类中任何地方进行访问；将属性封装起来后，通过 get 和 set 方法（目的是外界传入值来进行修改属性值）提供一个对外的接口，用于获取和修改属性；
如果将属性设置为 public 是可以直接访问的，外界可以随便修改，容易误改，出错

2）方法的封装
具体的实现封装在方法中，将方法的具体实现设置为 public，即对外界提供一个公共的接口，外界只需要调用方法名即可，不需要关心方法具体的实现
一个方法设置为 private 后，只能在当前类中任何地方访问，其它类不能对其进行访问

3） 封装就是将复杂的东西隐蔽起来，给外界提供一个简单的操作入口（公共的接口）
公共接口在代码中就是方法（使得开发人员不需要知道一个组件内部如何工作，只需要使用提供的接口即可，将复杂的一面隐藏起来，将简单的一面提供给外界）；

五、this

1、this 指什么

this：当前对象
this.属性：当前对象的属性
方法中的 this：谁（哪个对象）调用这个方法，谁是就是当前对象，this 就表示谁
等价于将 属性设置为 Public ，然后 对象.属性的形式

this 可以用去区分同名的 对象属性 和 局部变量名 ；因为变量名是就近来取的，如果不加 this，就相当于 形参 = 形参，将形参赋值给形参

六、继承

父类是一般类，子类是特殊类；特殊类也是一种一般类；（is - a 的关系）
例如，一般类 [ 父类 ] 为交通工具类，特殊类 [ 子类 ] 为汽车 （ 只能在陆地）、轮船（只能在海上）、飞机类（只能在天上）
汽车也可以是一个父类，它的子类为轿车（运送人）、货车（运送货物）

一个类继承自另一个类之后，就不用定义父类中已有的属性和方法，自动具有父类公有的属性和方法
因为 private 修改的只能在当前类进行访问，其它类访问不到，所以子类不能继承父类的私有属性/方法
同时，子类可以拥有自己的属性和行为
同时，子类可以重写父类方法

继承的作用：
1）允许程序员将类的属性和方法从一个类复制到另一个类
2）节省时间，不需要写重复的代码

总结：
1）子类可以继承父类中的所有非私有属性和方法（父类中有私有属性和私有方法的情况下不能被继承的）
2）子类可以有自己独有的属性和方法
3）子类可以重写（覆盖）父类的同名方法

七、多态

1、简介

例如， 你有两个打印机（对象），一个打印黑白的（对象），一个打印彩色的，你发送一个通用的消息（打印），你调用打印这个通用方法，对应不同的接收对象（黑、白打印机），会打印出来不同的东西；

高层：父类；
较低层：子类；

通过继承来实现多态；
上层是打印机（父类）中有打印这个通用方法；
子类为黑白打印机和彩色打印机；

发送消息即调用方法
当父类发送一个通用的消息（work()），对于一个具体的对象来说，根据对应的不同的子类名执行对应子类对象的方法；

2、编译时多态和运行时多态

将学生对象当成人类来看也是没有问题（子类对象指向父类）
在编译时，zst 形态是人
在运行时，zst 形态是学生

八、包

Java 中的包是一种组织 Java 类文件的方式，提供了结构和命名空间，使得 Java 类可以在多个不同的应用程序中共享
使用包可以更加合理的去规范不同的 Java 类的存放地址，便于维护
其实 package 更多就是一种约定，在实际开发时，我们通常都会先定义好一个基础的包名称，然后再在这个根目录下进行各种子包的归类

包的定义

package org.idea.java.demo; 

九、接口

接口：定义类的标准，使不同类之间可以交互
是一种特殊类型，定义一系列的方法，但是没有实现任何一个，是用来被实现的
接口实现了多态，可以让类型有不同的行为
多个类可以同时实现一个接口，从而实现功能的重用
是一种抽象层，可以隔离类之间的复杂关系
接口把实现分离，只需要关注接口的定义

实现接口和继承父类的区别：
继承父类是指子类继承父类的属性和方法，父类可以有多个子类
接口是指定义一组规范，可以让多个不同的类来实现这个接口
继承父类只能单继承，接口可以实现多继承
继承父类可以实现代码的复用，接口可以实现函数定义的复用

十、static修饰符

对象属性的访问机制需要通过先 new 一个对象，然后去通过对象来访问属性
static 修饰的变量是属于类的，访问的时候是通过类名的方式来进行访问

public class Student {
    public static String name = "Tom";
}

// 访问
String studentName = Student.name;

static 修改的变量和传统的属性变量有什么区别：
1）static 修改的变量是属于整个类所有，而不是某个对象所有
2）static 修改的变量被所有对象所共享这一个变量，普通变量只能被定义该变量的对象共享

十一、重写和重载

重写：
子类对父类的允许访问的方法进行重新编写，返回值和形参都不能改变
子类覆盖父类方法
在一个父类中定义了一个方法，在子类中可以重写这个方法，实现不同的行为，而不需要改变父类

重载：
一个类中定义了多个同名的方法
重载是一个类中多次定义同一个方法

十二、异常

1、什么是异常

2、异常的捕获

异常处理的意义是保护程序的稳定性，避免因为异常情况而导致程序的瘫痪。它能够使程序发生异常时，能够及时处理异常，从而确保程序的正常运行

try-catch 语法是Java异常处理的基本语法，用于捕获和处理程序运行时可能出现的异常
在try语句块中执行代码，如果发生异常，则在catch语句块中处理异常
此外，Java中的try-catch语法还可以使用finally子句，用于指定不管程序是否抛出异常，都需要执行的代码

try {
    //要执行的代码
} catch(Exception e) {
    //处理异常的代码
} finally {
    //不管是否发生异常，都要执行的代码
}

catch 部分的要求：
1）catch块中的异常类型应该是精确的，不能使用父类的异常类型。比如，如果要捕获IOException，就不能使用Exception类型，应该使用IOException类型
2）catch块中只能捕获一种异常类型，不能捕获多种异常类型。如果要捕获多种异常类型，可以使用多个catch块
3）如果要捕获多个异常类型，那么catch块中的异常类型应该从小到大排列，这样可以避免子类异常被先捕获，而父类异常被后捕获的问题

public void doSomething() {
    try {
        //执行一些代码
    } catch(IOException e) {
        //处理IOException异常 001
    } catch(NullPointerException e) {
        //处理NullPointerException异常 002
    } catch(Exception e) {
        //处理其他所有异常 003
    } finally {
        //不论是否发生异常，都要执行的代码 003
    }
}

十三、反射

有些语言是解释型语言，边解释边执行
有些语言是编译型语言，需要将代码全部编译完之后，再统一执行

例如，一个大型的 C++项目，需要先将整个项目编译完生成一个可执行文件（.exe/二进制文件），再执行
例如，一个大型的 python 项目，分析一条语句，就执行一条语言，不需要全部编译后再执行

Java 是介于 C++和 python 之间的一个语言，并不是完全编译完再执行，也不是一行一行解释执行
首先，将 Java 源码编译成一个中间代码（是字节码并不是二进制文件），由于计算机只能识别二进制并不能识别字节码，最后执行的时候是需要一个虚拟机，字节码在虚拟机上执行
因为 Java 代码都是一个一个的类，需要先将类加载进来，再进行执行

Java 程序的执行过程：
1）源代码编译
Java源代码是程序员用Java编程语言编写的文本文件，通常以.java作为文件扩展名。这些源代码文件包含了类、接口、方法等的定义，以及变量和常量的声明。在编译阶段，Java编译器（如 Javac）将源代码文件转换为字节码文件。字节码是 Java 虚拟机（JVM）能够理解的中间代码，它以 .class 作为文件扩展名。
2）类加载
类加载是 Java 虚拟机执行Java程序的一个重要步骤。当 Java 程序运行时，JVM 通过类加载器（ClassLoader）将字节码文件加载到内存中，并转换为运行时数据区中的数据结构，以便JVM能够执行它。
在类加载完成后，JVM 就可以通过反射机制来访问这个类，并创建它的实例或调用它的方法。
3）执行
执行阶段是指 JVM 按照字节码指令执行 Java 程序的过程。JVM 的执行引擎负责解释或即时编译字节码，并调用本地方法来执行具体的操作。
执行过程中，JVM 会管理程序的运行，包括内存分配、垃圾收集、线程调度等。如果程序在执行过程中需要创建新的对象或调用方法，JVM会再次通过类加载器加载相关的类，并进行相应的初始化。

对于大型 C++项目，想修改其中一段很小代码时，每次修改完后需要重新编译（100 万行代码，想修改其中几行代码）
对于 python 来说，没有这个不方便点
对于 Java 来说，有一个机制，可以修改这几行代码，将修改后的代码加到整个原项目中，并且不需要重新编译整个项目，这个机制就是反射机制
作用：可以动态地修改一些代码

假设下面 Main 中代码有 100 万行，其中我们想动态改变其中一个类的结构（例如下面代码，Main 中想动态地改变 Caculator 这个类，这个类是不存在初始整个项目中，打包上线项目时没有这个类，是后加进来的），修改后不用重新打包整个项目

package org.yjx;

public class Calculator {
    public String name;

    public Calculator() {}

    public Calculator(String name) {
        this.name = name;
    }

    public int add(int a, int b) {
        return a + b;
    }
}

package org.yjx;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        // 通过反射动态执行新加入的Calculator类中的方法
        // 返回一个Class对象
        Class<?> cls = Class.forName("org.yjx.Calculator");  // 类所在的包的路径
        
        Object o = cls.newInstance();  // 生成这个类的实例，其中newInstance调用的是类的无参构造函数

        // 通过add来获取类中对应的方法
        Method method = cls.getMethod("add", int.class, int.class);  //getMethod为获取类中的方法，得到方法
        int res = (int)method.invoke(o, 3, 4);  //invoke是执行的意思，这个执行method这个函数
        System.out.println(res);

        Field field = cls.getField("name");  // getField为获取类中的成员变量
        //操作变量有两种方式：一个是赋值，另一个是获取值
        field.set(o, "myName!");  // set是赋值，将o这个实例的field中的name变量赋值为
        System.out.println(field.get(o));  // get是获取变量值

        Constructor<?> constructor = cls.getConstructor(String.class);  //获取类的构造方法，参数类型为String
        Object new_o = constructor.newInstance("New Calculator!");  // 用带参构造函数来生成实例
        System.out.println(new_o);
    }
}

Class<?> cls：这是一个泛型变量声明。Class<?> 表示一个未知类型的 Class 对象。使用通配符 ? 而不是具体的类型（如 Class）可以让我们更加灵活，因为我们不需要在编译时知道类的具体类型。这在动态加载和反射操作中非常有用

Java 的反射是一种能够在运行时动态获取和操作类、接口、方法和字段的能力
它允许程序在运行时获取类的结构，并且可以分析和调用类中的方法和成员变量
反射应用中，常见是对 Class 类的相关操作

十四、进程与线程

进程：
进程是操作系统资源分配和调度的基本单位，它是一个正在执行的应用程序，由内存和外部资源组成
进程在电脑执行任务的时候具有一定的独立性，进程之间的相互作用可以通过系统调用实现
每个进程都有自己的地址空间，进程可以同时执行多个任务，并且可以访问共享的资源

线程是一种轻量级的进程，它是操作系统在单独的地址空间中管理的一个执行单元
它是操作系统中最小的调度单元，它可以被系统独立调度，即使在同一个进程中也可以被多个线程同时调度
线程可以分配到多个CPU上运行，从而实现多任务同时处理，实现多线程并发处理

以一个简单的图书馆为例，通常图书馆里面都会有许多不同角色的工作人员在同步工作中，有的人负责发书，有的人负责检查书籍是否被正确归还，有的人负责图书馆大门的进出治安，可以看到，这些不同角色的人一起工作，互相协调，从而完整对整个图书馆的维护和管理

这里我们可以将上述的这个图书馆想象成一个进程，在这个环境里面可以同时有多个线程在运行，比如：一个线程负责收取借书人的借书卡，另一个线程负责发书人的还书卡，还有一个线程负责检查书籍是否被正确归还等等。
每个线程都有自己的任务，它们可以同时运行

这种多个线程同时运作的特点，业界被称为叫“多并发”