Java零基础入门笔记：(1-2)入门（简介、基础知识）

前言

本笔记是学习狂神的java教程，建议配合视频，学习体验更佳。

【狂神说Java】Java零基础学习视频通俗易懂_哔哩哔哩_bilibili

-

Java简介

Java是一种广泛使用的高级编程语言，具有简单、面向对象、分布式、多线程、动态性、健壮性和安全性等特点。它由Sun Microsystems公司（现为Oracle公司的一部分）于1995年正式发布，并迅速成为全球最受欢迎的编程语言之一。Java的设计理念是“一次编写，到处运行”（Write Once, Run Anywhere），通过Java虚拟机（JVM）实现跨平台运行，使得Java程序可以在任何支持JVM的操作系统上运行，无需重新编译。

Java语言的语法简洁明了，继承了C++的许多特性，但去除了指针等复杂和容易出错的部分，从而降低了开发难度并提高了代码的安全性。它通过垃圾回收机制自动管理内存，减轻了程序员的负担。Java的应用范围非常广泛，从桌面应用程序到企业级服务器应用，从移动应用开发（如Android）到云计算和大数据处理等领域，都有Java的身影。凭借其强大的库支持、丰富的框架和社区资源，Java为开发者提供了强大的工具来构建高效、可靠和可扩展的软件系统。

-

相关概念 C语言的优势和劣势

优势：C语言贴近硬件，运行极快，效率极高

劣势：指针和内存管理给C语言的使用戴上了沉重的枷锁，由于C语言不提供越界检查以及指针检查，导致程序员必须花不必要的时间来处理这些东西可能造成的问题。

因此，要建立一个新的语言：它的语法有点像C，没有指针，没有内存管理。它具有真正的可移植性，编写一次，可以在任何系统上运行。提供面向对象、类型安全，拥有高质量的类库。

三高：高可用，高性能，高并发

-

Java特性和优势

简单性、面向对象、可移植性、高性能、分布式、动态性、多线程、安全性、健壮性

简单性：Java通过去除复杂特性（如指针运算和内存手动管理）简化了编程模型，降低了开发难度，使代码更易读、易写和易维护。

面向对象：Java是一种面向对象的语言，它将数据和操作封装在对象中，通过类和继承等机制实现代码的复用和模块化，提高了软件的可维护性和可扩展性。

可移植性：Java通过Java虚拟机（JVM）实现了“一次编写，到处运行”的目标，使得Java程序可以在任何支持JVM的操作系统上运行，无需重新编译。

高性能：Java通过即时编译（JIT）技术和高效的内存管理机制，能够实现接近本地代码的运行性能，同时保持跨平台的灵活性。

分布式：Java提供了丰富的网络编程支持，允许开发者轻松构建分布式系统，通过RMI（远程方法调用）等技术实现跨网络的对象通信。

动态性：Java能够在运行时动态加载和链接类，支持动态扩展和修改程序的行为，增强了程序的灵活性和适应性。

多线程：Java内置了多线程支持，允许程序同时执行多个任务，通过线程同步机制实现高效的并发处理，提升了程序的响应速度和性能。

安全性：Java通过沙箱机制、字节码验证和访问控制等技术，确保程序运行的安全性，防止恶意代码对系统资源的访问和破坏。

健壮性：Java通过严格的类型检查、异常处理机制和垃圾回收机制，减少了程序出现错误和崩溃的可能性，提高了程序的稳定性和可靠性。

-

Java三大版本

Java主要有三大版本，分别是Java SE（Java Standard Edition）、Java EE（Java Enterprise Edition）和Java ME（Java Micro Edition）。每个版本针对不同的应用场景和开发需求，具有各自的特点和用途。

1. Java SE（Java Standard Edition）

Java SE是Java平台的标准版，是Java技术的核心。它提供了Java语言的基础类库、运行环境（JRE）和开发工具（JDK）。Java SE包括了基本的数据结构、网络编程、文件操作、图形用户界面（GUI）开发等功能，是学习Java语言的基础。它的用途非常广泛，例如开发桌面应用程序、命令行工具、简单的网络服务等。Java SE是其他Java版本的基础，许多高级功能和框架都依赖于它提供的核心API。

2. Java EE（Java Enterprise Edition）

Java EE是Java平台的企业版，主要用于开发大型、分布式、高可用的企业级应用程序。它在Java SE的基础上，提供了许多高级功能和规范，例如Servlet、JSP（JavaServer Pages）、EJB（Enterprise JavaBeans）、JPA（Java Persistence API）、JTA（Java Transaction API）等。Java EE专注于解决企业级应用的复杂需求，如事务管理、安全性、多层架构、分布式计算等。它广泛应用于电子商务、金融、ERP（企业资源规划）系统等领域，能够帮助企业构建高效、可靠和可扩展的软件解决方案。

3. Java ME（Java Micro Edition）

Java ME是Java平台的微型版，主要用于开发运行在资源受限设备上的应用程序，如移动电话、嵌入式设备、智能卡等。Java ME通过裁剪Java SE的功能，提供了适合小型设备的轻量级运行环境和API。它支持基本的图形用户界面、网络通信和数据存储功能，能够满足移动设备和嵌入式系统对低功耗、小内存和高性能的要求。Java ME在移动应用开发领域曾经非常流行，尤其是在智能手机兴起之前，许多手机应用都是基于Java ME开发的。随着Android等现代移动开发平台的出现，Java ME的市场份额逐渐缩小，但它仍然在一些特定的嵌入式领域中发挥着重要作用。

总结来说，Java SE是Java的基础，适用于通用编程；Java EE专注于企业级应用开发，提供强大的功能和规范；Java ME则针对资源受限的设备，适合开发轻量级的移动和嵌入式应用。

-

JDK、JRE、JVM

JDK：Java Development Kit，开发工具

JRE：Java Runtime Environment，运行环境

JVM：JAVA Virtual Machine，虚拟机

-

-

Java开发环境搭建

在浏览器搜索jdk下载，选择Java SE8

java下载

选择适合自己电脑的版本，如Windows x64

安装java 双击安装JDK记住安装的路径配置环境变量 我的电脑-->右键-->属性点击高级系统设置，选择高级选择环境变量-->JAVA_HOME配置path变量

配置环境的步骤图示：

在系统变量新建一个JAVA_HOME，然后复制jdk安装路径到变量值(V)

接着配置系统变量里面的path（见上上张图右边）

-

测试是否安装成功

打开cmd，输入：

java -version

如果出现版本信息，表示安装成功

-

卸载JDK 删除Java的安装目录删除JAVA_HOME删除path下关于Java的目录java -version，提示没有java，表示卸载成功

-

-

第一个代码：hello world 新建文件

新建一个txt文件，然后把后缀改成java

系统可能没有显示文件后缀名，我们需要手动打开（查看->显示->文件扩展名）

【注意点】 

文件名和类名必须保证一致，并且首字母大写每个单词的大小不能出现问题，Java是大小写敏感的 编写代码

将上面的代码复制到文件里，命名为Hello.java

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

运行代码

在上面的栏中输入cmd，然后回车，打开命令行

在命令行中分别输入

javac Hello.java java Hello

结果如下：

出现Hello world！说明运行成功了

-

-

idea使用 新建项目

左上角，文件->新建->项目

这个页面没有爆红就不用管

填写名字和地址,然后确定

一般在src文件夹的下面写代码，右键新建文件，选择Java Class（即文件）

快捷命令

如在代码中输入psvm，然后按下回车，可以快速建立main函数

psvm：快速建立main函数 cout：快速生成print

Ctrl+D 复制本行到下一行

-

-

Java基础 注释

平时我们编写代码，在代码量比较少的时候，我们还可以看懂自己写的，但是当项目结构一旦复杂起来，我们就需要用到注释了。书写注释是一个非常好的习惯。

在编程中，注释的主要作用是帮助开发者更好地理解代码的逻辑、功能和实现方式。它可以在代码中明确指出变量的用途、函数的作用、算法的思路以及代码的运行流程等，从而提高代码的可读性和可维护性。对于其他开发者来说，注释能够帮助他们快速了解代码的意图，减少阅读和理解代码的时间，便于协作开发和后续的代码修改。此外，注释还可以用于标记代码中的待办事项、注意事项以及调试信息等，方便开发者在开发过程中跟踪问题和优化代码。

总之，注释是代码的“说明书”，它不仅有助于提高开发效率，还能提升代码的质量和可维护性。

注释并不会被执行，是给我们写代码的人看的

Java中的提供的注释有三种:

单行注释： // 注释 （只能注释一行文字）多行注释： /* 注释 */ （可以注释一段文字）文档注释： /** 注释 */ // 单行注释 /* 多行注释 多行注释 */ /** * 文档注释，可以添加一些选项 * @Description Helloworld */

-

-

标识符

标识符是用来命名程序中的各种元素（如变量、方法、类、接口、包等）的符号或字符串。它是程序员为代码中的对象赋予的唯一名称，用于在代码中唯一标识和引用这些对象。

标识符注意点

所有的标识符都应该以字母（A-Z或者a-z），美元符（$）、或者下划线（_）开始首字符之后可以是字母（A-Z或者a-z），美元符（$）、下划线（_）或数字的任何字符组合不能使用关键字作为变量名或方法名。标识符是大小写敏感的合法标识符举例: age、$salary、_value、__1_value非法标识符举例:123abc、-salary、#abc可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音

java中的关键字：

代码示例： 

public class Hello { public static void main(String[] args) { String teacher = "David"; } }

--

-

数据类型 强类型语言和弱类型语言

强类型语言和弱类型语言是编程语言中关于类型系统（Type System）的两种主要分类方式，它们的区别主要体现在变量的类型检查、类型转换和运行时行为上。

强类型语言：

强类型语言要求变量在声明时必须明确指定其类型，并且在程序运行过程中，变量的类型是严格固定的。这种语言会在编译或运行时对类型进行严格的检查，不允许隐式的类型转换，除非显式地进行类型转换操作。强类型语言的优点是能够减少类型错误，提高代码的安全性和可维护性，但可能会增加开发的复杂性。如java。

弱类型语言：

弱类型语言不要求变量在声明时明确指定类型，或者允许变量在运行时动态改变类型。这种语言通常允许隐式的类型转换，即在某些操作中会自动将一种类型转换为另一种类型。弱类型语言的优点是开发灵活性高，编写代码的速度更快，但可能会导致类型错误难以发现，增加运行时出错的风险。如Python

-

Java的数据类型

Java的数据类型分为两大类：

基本类型(primitive type)引用类型(reference type)

 -

基础类型

在Java中，基础类型（也称为原始类型或基本数据类型）是语言内置的类型，用于存储简单的数据值。Java共有8种基础类型，分为整数类型、浮点数类型、字符类型和布尔类型。

整数类型

类型占用字节数取值范围注意事项byte1字节-128 到 127最小的整数类型，适合存储占用空间小的整数值。short2字节-32768 到 32767比int小，适合存储较小范围的整数，但使用较少。int4字节-2,147,483,648 到 2,147,483,647最常用的整数类型，适合大多数整数运算。long8字节-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807用于存储大整数，常用于时间戳等场景。声明时需在数字后加L或l（推荐大写L，避免与数字1混淆）。

 注意事项

默认整数类型是int，如果需要存储大整数，必须显式声明为long并加上L。

使用byte和short时需注意范围限制，超出范围会导致编译错误或运行时错误。

代码示例：

public class Hello { public static void main(String[] args) { //整数 int num1 = 10; //最常用 4字节 byte num2 = 20; // 1字节 short num3 = 30; //2 字节 long num4 = 30L; // Long类型要在数字后面加个L，8字节 } }

浮点数类型

类型占用字节数注意事项float4字节单精度浮点数，适合精度要求不高的场景。声明时需在数字后加F或f。double8字节双精度浮点数，精度高，是浮点数的默认类型。

注意事项：

浮点数运算可能存在精度问题，不适合用于精确的金融计算（如金额）。对于高精度计算，建议使用BigDecimal。

默认浮点数类型是double，如果需要使用float，必须显式声明并加上F。

public class Hello { public static void main(String[] args) { //小数：浮点数 float num5 = 50.1F; //Lfloat类型要在数字后面加个F 4字节 double num6 = 3.141592653589793238462643; // 8字节 } }

字符类型

类型占用字节数注意事项char2字节用于存储单个字符，采用Unicode编码，范围是'\u0000'到'\uFFFF'（共65536个字符）。

 注意事项：

字符类型用单引号'表示，例如'A'。

可以通过转义字符\表示特殊字符，如\n（换行）、\t（制表符）等。

字符类型在某些情况下可以与整数类型相互转换，因为字符本质上是Unicode编码值。

字符串类型（非基础类型）

虽然String不是基础类型，但它在Java中非常常用，且具有特殊性：

类型：String是类，位于java.lang包中。

占用空间：每个字符占用2字节（UTF-16编码），字符串总长度取决于字符数量。

注意事项：

字符串是不可变对象，一旦创建，内容不能修改。任何修改操作都会返回一个新的字符串对象。

字符串可以用双引号"表示，例如"Hello"。

字符串支持多种操作，如拼接（+）、比较（equals()）、查找等。

注意字符串比较时，==比较的是对象引用，equals()比较的是字符串内容。

public class Hello { public static void main(String[] args) { //字符 char name = '国'; // 单引号,2字节 //字符串，string不是关键字，类 String namea = "秦疆"; // 双引号，每个字符2字节 } }

布尔类型

类型占用空间取值范围注意事项boolean不确定（取决于JVM实现，通常为1字节或4字节）true 或 false用于逻辑判断，只有两个值。

注意事项：

布尔类型不能与整数类型相互转换，不能将0或1直接赋值给布尔变量。

布尔类型常用于条件判断和逻辑运算。

什么是字节

字节（Byte）是计算机中存储信息的基本单位，由8个连续的位（bit）组成。一个字节可以表示256种不同的状态（从0到255），因为2的8次方等于256。字节是计算机存储和处理数据的最小可寻址单位，通常用于表示字符、数字或其他数据类型。

位(bit)：位（bit）是计算机中最小的存储单位，表示一个二进制位（0或1），是计算机内部数据储存的最小单位，11001100是一个八位二进制数。字节(B，byte)：是计算机中数据处理的基本单位，习惯上用大写B来表示。1B (byte,字节) = 8bit (位)

1024B=2^10B=1KB1024KB=2^10KB=1M1024MB=2^10MB=1G1024GB=2^10GB=1T

-

-

数据类型扩展 进制

Java支持多种进制表示整数，包括十进制、八进制、十六进制和二进制。

十进制

十进制是最常用的进制，直接书写数字即可。

示例：int i = 10;（表示十进制的10）。

八进制

八进制以0（数字零）开头。

示例：int i2 = 010;（表示八进制的10，转换为十进制是8）。

注意：八进制数字只能包含0-7的数字。

十六进制

十六进制以0x或0X开头，支持数字0-9和字母A-F（不区分大小写）。

示例：int i3 = 0x10;（表示十六进制的10，转换为十进制是16）。

二进制

二进制以0b或0B开头，支持数字0和1。

示例：int i4 = 0b1010;（表示二进制的1010，转换为十进制是10）。

注意：二进制是Java 7及更高版本支持的特性。

-

另外需注意：八进制和十六进制的数字在赋值时会被自动转换为十进制。

示例代码如下：

public class Hello { public static void main(String[] args) { //整数拓展 ?进制 二进制0b 十进制 八进制0 十六进制0x int i = 10; int i2 = 010; //八进制0 int i3 = 0x10; //十六进制0x 0~9 A~F 16 System.out.println(i); //10 System.out.println(i2); //8 System.out.println(i3); //16 } }

-

浮点数的计算问题

如下：很显然f、d二者都是0.1，但Java中却判断二者不等

public class Hello { public static void main(String[] args) { //浮点数拓展 //float 能表现的范围有限，浮点数只是对小数的舍入误差离散表示 //double //最好完全使用浮点数进行比较 float f = 0.1f; //0.1 double d = 1.0/10; //0.1 System.out.println(f==d); //false } }

原因：浮点数（float和double）在计算机中是以二进制形式存储的，因此无法精确表示某些十进制小数。这会导致精度误差。虽然f和d的值看似相同（都是0.1），但由于float和double的精度不同，d的精度更高，因此它们在内存中的表示并不完全相同。

-

在这段代码中d2应该比d1大1，但二者却被判定为相等

public class Hello { public static void main(String[] args) { float d1 = 23131312312312313f; float d2 = d1 + 1; System.out.println(d1==d2); //true } }

原因：d1的值非常大，超出了float的精确表示范围。float类型在处理大数值时会丢失精度，导致d1 + 1的结果仍然是d1。

结果：比较d1 == d2时返回true，因为d2的值并没有真正增加。

-

字符

在Java中，字符本质上是数字（基于Unicode编码）。可以通过强制类型转换将字符转换为对应的数字（ASCII或Unicode码值），也可以将数字转换为字符。

字符到数字的转换：通过强制类型转换（int），可以获取字符的Unicode码值。

数字到字符的转换：通过强制类型转换（char），可以将数字（Unicode码值）转换为对应的字符。

public class Hello { public static void main(String[] args) { //字符拓展? char c1 = 'a'; char c2 = '中'; System.out.println(c1); //a System.out.println((int)c1); //强制换行 //97 System.out.println(c2); //中 System.out.println((int)c2); //强制换行 //20013 } }

Unicode是一种国际标准的字符编码，用于统一表示世界上各种语言的字符。在Java中，char类型采用Unicode编码，每个字符占用2字节。

Unicode编码的范围是从'\u0000'到'\uFFFF'。

Unicode编码可以表示几乎所有语言的字符，包括ASCII字符、中文字符、日文字符等。

public class Hello { public static void main(String[] args) { //所有的字符本质还是数字 //编码 Unicode 表：(97 = a 65 = A) 2字节 0 - 65536 Excel 2的16次方=65536 //U0000 UFFFF char c3 = '\u0061'; System.out.println(c3); //a } }

在Java中，某些特殊字符（如换行符、制表符等）不能直接在字符串中表示，需要使用转义字符。转义字符以反斜杠\开头，后跟特定的字符或数字。

常见的转义字符：

\n：换行符

\t：制表符

\r：回车符

\\：反斜杠本身

\"：双引号

\'：单引号

public class Hello { public static void main(String[] args) { //转义字符 // \t 制表符 // \n 换行 //... System.out.println("Hello\tWorld"); //Hello World System.out.println("Hello\nWorld"); // 输出结果如下： /* Hello World */ } }

 -

下面代码中展示了两种条件判断的写法，分别是新手写法和老手写法：

flag == true是一个布尔表达式，它会检查flag的值是否等于true。这种写法虽然逻辑上没有错误，但显得冗余。flag本身就是一个布尔变量，直接使用flag即可，无需再与true进行比较。

if语句的条件部分本身就是布尔表达式，flag的值（true或false）可以直接作为条件。第2种写法更简洁、更直观，是更推荐的写法。

public class Hello { public static void main(String[] args) { //布尔值扩展 boolean flag = true; if (flag==true){} //新手 if (flag){} //老手 } }

-

-

类型转换

由于Java是强类型语言，所以要进行有些运算的时候的，需要用到类型转换。

运算中，不同类型的数据先转化为同一类型（由低转高），然后进行运算

低---------------------------------------------------------->高 byte=short=char -> int -> long -> float -> double

强制类型转换（一般用于高转低）

下面这段代码演示了溢出部分：这里将int类型的变量i强制转换为byte类型。byte类型是8位的有符号整数，其范围是从-128到127。由于128超出了byte类型的最大值127，因此会发生溢出。打印变量b的值，结果是-128。

int i = 128; byte b = (byte)i; //内存溢出 System.out.println(i); //128 system.out.println(b); //-128

自动转换 低--高

-

注意点：

不能对布尔值进行转换不能把对象类型转换为不相干的类型在把高容量转换到低容量的时候，强制转换转换的时候可能存在内存溢出，或者精度问题（舍弃小数点后的数）!

下面的代码演示了：强转时是直接抹除小数，而非四舍五入。

System.out.println((int)23.7); //23 System.out.println((int)-45.89f); //-45

-

下面这段代码演示了字符类型和整数的转换关系

char c = 'a'; int d = c+1; System.out.println(d); //98 System.out.println((char)d); //b

-

JDK7新特性，数字之间可以用下划线分割，方便数字大小

//JDK7新特性，数字之间可以用下划线分割 int money = 10_0000_0000;

-

操作比较大的数的时候，注意溢出问题 

错误做法：直接计算或计算完后转long类型

//操作比较大的数的时候，注意溢出问题 int money = 10_0000_0000; int years = 20; int total = money*years; //-1474836480,计算的时候溢出了 long total2 = money*years; //默认是int，转换之前已经是int了!

正确做法：先转long类型再计算

long total3 = money*((long)years); //先把一个数转换为long,再计算 System.out.println(total3); //20000000000

尽量使用L，而不是l去表示long类型

-

-

变量、常量、作用域 变量

变量是编程中用于存储和表示数据的基本概念，它是程序运行过程中可以改变的量。在计算机程序中，变量就像是一个有标签的容器，用来存放数据值。这个标签就是变量名，通过它可以在程序中引用和操作存储在其中的数据。

变量的值可以在程序执行的过程中根据需要进行修改，这也是“变量”这个名字的由来。通过赋值操作，可以将新的数据值存储到变量中，从而改变它的内容。这种灵活性使得变量成为实现程序逻辑和处理数据的关键工具。

Java是一种强类型语言，每个变量都必须声明其类型。

注意事项：

每个变量都有类型，类型可以是基本类型，也可以是引用类型。变量名必须是合法的标识符。变量声明是一条完整的语句，因此每一个声明都必须以分号结束 type varName [=value] [{,varName[=value]}]; //数据类型 变量名 = 值；可以使用逗号隔开来声明多个同类型变量。 // 示例： int a=1,b=2,c=3; String name = "qinjiang"; char x = 'X'; double pi = 3.14;

以下代码演示了对象的实例变量：

其中age是一个实例变量，属于demo7类的对象d。在代码中，age没有被显式初始化，因此它会被自动赋予默认值0。

可以通过对象d访问实例变量age，即d.age。

public class demo7 { //类变量 static double salary = 2500; // 实例变量，从属于对象 String name; // 不自行初始化，默认为0，布尔默认为false；除基本类型，其他的均为None int age; public static void main(String[] args) { // main方法 // 局部变量 int i = 1; System.out.println(i); demo7 d = new demo7(); System.out.println(d.age); // 0 } public void add(){ int j = 1; } }

在这段代码中，static关键字用于修饰类变量salary。static是Java中的一个重要关键字，用于表示“静态”的概念，static关键字用于修饰类的成员（变量或方法），表示该成员属于类本身，而不是类的某个具体对象。

类变量（静态变量）：被static修饰的变量称为类变量，它属于类，而不是某个对象。类变量在类加载时初始化，并且所有对象共享同一个类变量。在类中可以直接使用

public class demo7 { //类变量 static double salary = 2500; // 实例变量，从属于对象 String name; // 不自行初始化，默认为0，布尔默认为false；除基本类型，其他的均为None int age; public static void main(String[] args) { // main方法 System.out.println(salary); // 2500 } public void add(){ int j = 1; } } 常量

常量是指在程序运行过程中其值不能被改变的量。在Java中，常量通常通过关键字final来声明，表示该变量的值不可更改。常量的使用可以提高代码的可读性和安全性，避免因意外修改重要值而导致的错误。

当声明一个常量时，需要在声明时立即赋值，因为后续无法再改变它的值。常量的值在程序的整个生命周期中保持不变，这使得它在处理固定不变的值时非常有用，例如数学常数（如π）、配置参数、状态码等。常量的命名通常使用全大写字母，单词之间用下划线分隔，这种命名方式有助于在代码中快速识别常量。

所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

常量名一般使用大写字符。 public class demo7 { // 常量 final 常量名=值; final static double PI=3.14; static final double PI1=3.14; // static和final顺序可以换，修饰符不区分前后顺序 public static void main(String[] args) { // main方法 System.out.println(PI); // 3.14 } }

-

-

命名规范 所有变量、方法、类名：见名知意类成员变量：首字母小写和驼峰原则：monthSalary 除了第一个单词以外，后面的单词首字母大写 lastname lastName局部变量：首字母小写和驼峰原则常量：大写字母和下划线：MAX_VALUE类名：首字母大写和驼峰原则：Man，GoodMan方法名：首字母小写和驼峰原则：run()，runRun()

-

-

运算符

Java语言支持如下运算符：

算术运算符：+，-，*，l，%，++，--赋值运算符：=关系运算符：>，<，>=，<=，==，!= instanceof逻辑运算符：&&，||，!位运算符：&，|，^，~，>>，<<，>>>(了解！！！)条件运算符：? :扩展赋值运算符：+=，-=，*=，/= 算术运算符

其中除法部分：

a和b都是整数类型，在Java中，当两个整数相除时，结果仍然是整数。这意味着结果会进行截断，小数部分会被舍弃。因此，1 / 2的结果是0，因为0.5的小数部分被舍弃了。

可以通过将b强制转换为double类型（即(double) b），使得除法运算变为浮点数除法。当一个整数和一个浮点数相除时，结果是浮点数。这允许结果包含小数部分。因此，1 / 2.0的结果是0.5，因为1被转换为1.0，然后进行浮点数除法。

package operator; public class Demo1 { public static void main(String[] args) { int a = 10; int b = 20; System.out.println(a+b); //30 System.out.println(a-b); //-10 System.out.println(a*b); //200 System.out.println(a/b); // 0 System.out.println(a/(double)b); //0.5 } }

这段代码演示了Java的类型提升规则

在Java中，当进行多个类型的算术运算时，参与运算的变量类型会根据以下规则自动提升：

byte和short类型会被提升为int

存在long类型时，结果为long

存在float类型时，结果为float

存在double类型时，结果为double

package operator; public class Demo1 { public static void main(String[] args) { long a = 123123123123123L; int b = 123; short c = 10; byte d = 8; // 有long转long，没有转int // 有double转double，没有float System.out.println(a+b+c+d); //123123123123264 //Long System.out.println(b+c+d); //141 //Int System.out.println(c+d); //18 //Int } } 模运算：即取余数大于、小于：等于：在Java中，=表示赋值，==表示判断是否相等 不等于：!=表示判断是否不相等  package operator; public class Demo1 { public static void main(String[] args) { //关系运算符返回的结果：正确，错误 布尔值 int a = 10; int b = 20; int c = 21; //取余，模运算 System.out.println(c%a); //1 21 / 10 = 2 ... 1 System.out.println(a>b); //false System.out.println(a<b); //true System.out.println(a==b); //false System.out.println(a!=b); //true } }  自增运算符： 后缀形式（a++ 和 a--）：后缀形式的自增或自减操作会在表达式计算完成后再对变量进行加1或减1操作。先使用变量的当前值参与运算，然后再对变量进行自增或自减。

前缀形式（++a 和 --a）：前缀形式的自增或自减操作会在表达式计算之前先对变量进行加1或减1操作。特点：先对变量进行自增或自减，再使用变量的新值参与运算。

package operator; public class Demo1 { public static void main(String[] args) { //++ -- 自增，自减 一元运算符 int a = 3; int b = a++; //执行完这行代码后，先给b赋值，再自增 //a++ a = a + 1 先赋值再加 System.out.println(a); // 4 //++a a = a + 1 先加再赋值 int c = ++a; 执行完这行代码前，先自增，再给c赋值 System.out.println(a); //5 System.out.println(a); //5 System.out.println(b); //3 System.out.println(b); //3 System.out.println(c); //5 System.out.println(c); //5 } } 幂运算 package operator; public class Demo1 { public static void main(String[] args) { //幂运算 2^3 2*2*2 = 8 double pow1 = Math.pow(2, 3); System.out.println(pow1); //8.0 double pow2 = Math.pow(3, 2); System.out.println(pow2); //9.0 } }  逻辑运算

逻辑与（&&）：只有两个操作数都为true时，结果才为true。

逻辑或（||）：只要有一个操作数为true，结果就为true。

逻辑非（!）：对布尔值取反，true变false，false变true。

package operator; public class Demo1 { public static void main(String[] args) { //与(and) 或(or) 非(取反) boolean a = true; boolean b = false; System.out.println("a && b: "+(b&&a)); //逻辑与运算:两个变量都为真，结果才为true //a && b: false System.out.println("a || b: "+(a||b)); //逻辑或运算:两个变量有一个为真，则结果才为true //a || b: true System.out.println("! (a && b): "+! (a&&b)); //如果是真，则变为假，如果是假则变为真 //! (a && b): true } }

短路运算

逻辑与（&&）的短路特性：如果第一个操作数为false，则不会计算第二个操作数，直接返回false。

示例：false && anything的结果总是false，不会计算anything。

逻辑或（||）的短路特性：如果第一个操作数为true，则不会计算第二个操作数，直接返回true。

示例：true || anything的结果总是true，不会计算anything。

package operator; public class Demo1 { public static void main(String[] args) { //短路运算 int c = 5; boolean d = (c<4)&&(c++<4); // 第一个为假，第二个就不需要算了 System.out.println(d); //false System.out.println(c); //5，如果第二个执行了，c应该为6，现任没执行 } }  字符串的+

在Java中，当+运算符的其中一个操作数是字符串时，+会被解释为字符串拼接操作，即拼接成字符串。

package operator; public class Demo1 { public static void main(String[] args) { int a = 10; int b = 20; a+=b; //a = a+b a-=b; //a = a-b System.out.println(a); //10 //字符串连接符 + , String System.out.println(""+a+b); //1020 System.out.println(a+b+""); //30 } } 三元运算符 x?y:z 

如果x==true，则结果为y，否则结果为z

package operator; public class Demo1 { public static void main(String[] args) { //x ? y : z //如果x==true，则结果为y，否则结果为z int score1 = 50; String type1 = score1 < 60?"不及格":"及格";//score1成立，所以type1=不及格 //if System.out.println(type1); //不及格 int score2 = 80; String type2 = score2 < 60?"不及格":"及格";///score1不成立，所以type2=及格 //if System.out.println(type2); //及格 } }

-

总结 

-

-

包机制

包机制（Package Mechanism）是Java语言中用于组织和管理代码的一种重要机制。它通过将类和接口组织到逻辑相关的分组中，帮助开发者更好地管理代码结构，避免命名冲突，并控制类和成员的访问权限。

包语句的语法格式为:

package pkg1[. pkg2[. pkg3...]]; 一般利用公司域名倒置作为包名;如  .baidu ->com.baidu.

-

为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用"import"语句可完成此功能

import package1[.package2...].(classname|*);

可参考阿里巴巴 Java 开发手册

files blogs /files/blogs/796938/%E9%98%BF%E9%87%8C%E5%B7%B4%E5%B7%B4Java%E5%BC%80%E5%8F%91%E6%89%8B%E5%86%8C.zip?t=1688485433&download=true

-

-

JavaDoc

JavaDoc是Java语言中用于生成API文档的一种工具和注释规范。通过在代码中嵌入JavaDoc注释，开发者可以为代码添加详细的说明，这些注释可以被javadoc工具解析并生成结构化的HTML文档。JavaDoc不仅提高了代码的可读性和可维护性，还为团队协作和代码复用提供了便利。

参数信息

@author作者名@version版本号@since指明需要最早使用的jdk版本@param 参数名@return返回值情况@throws异常抛出情况

package com.kuang.base; /** 可以加在类上 *@author Kuangshen *@version 1.0 *since 1.8 */ public class Doc { string name; /** 可以加在方法上 *@author Kuangshen *@param name *@return *@throws Exception */ public String test(String name) throws Exception{ return name; } }

接着可以使用命令行生成帮助文档

javadoc --encoding UTF-8 --charset UTF-8 Doc.java

会生成index.html，即文档，帮助其他人查看你的包。

-

-

---

🎉 感谢您的观看！

如果这段内容对您有所帮助，或者让您感到愉悦，希望您能给我一个小小的鼓励：

👍 点赞 —— 让我知道您喜欢我的内容！ 🔔 关注 —— 锁定更多精彩，不错过每一次更新！ ⭐ 收藏 —— 方便您随时回顾，也方便分享给更多朋友！

您的支持是我不断进步的动力，感谢您的陪伴！❤️