当前位置：首页 > article >正文

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

article 2026/4/19 5:24:27

前言

本笔记是学习狂神的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为开发者提供了强大的工具来构建高效、可靠和可扩展的软件系统。

Java开发环境搭建

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

java下载

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

安装java

双击安装JDK
记住安装的路径
配置环境变量
1. 我的电脑-->右键-->属性
2. 点击高级系统设置，选择高级
3. 选择环境变量-->JAVA_HOME
4. 配置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种基础类型，分为整数类型、浮点数类型、字符类型和布尔类型。

整数类型

类型	占用字节数	取值范围	注意事项
`byte`	1字节	-128 到 127	最小的整数类型，适合存储占用空间小的整数值。
`short`	2字节	-32768 到 32767	比`int`小，适合存储较小范围的整数，但使用较少。
`int`	4字节	-2,147,483,648 到 2,147,483,647	最常用的整数类型，适合大多数整数运算。
`long`	8字节	-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字节}
}

浮点数类型

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

注意事项：

浮点数运算可能存在精度问题，不适合用于精确的金融计算（如金额）。对于高精度计算，建议使用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字节}
}

字符类型

类型	占用字节数	注意事项
`char`	2字节	用于存储单个字符，采用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=1KB
1024KB=2^10KB=1M
1024MB=2^10MB=1G
1024GB=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 十六进制0xint i = 10;int i2 = 010; //八进制0int i3 = 0x10; //十六进制0x 0~9 A~F 16System.out.println(i); //10System.out.println(i2); //8System.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.1double d = 1.0/10; //0.1System.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); //aSystem.out.println((int)c1); //强制换行 //97System.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 UFFFFchar 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       WorldSystem.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；除基本类型，其他的均为Noneint 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；除基本类型，其他的均为Noneint 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); //30System.out.println(a-b); //-10System.out.println(a*b); //200System.out.println(a/b); // 0System.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，没有floatSystem.out.println(a+b+c+d);  //123123123123264 //Long  System.out.println(b+c+d); //141 //IntSystem.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 ... 1System.out.println(a>b); //falseSystem.out.println(a<b); //trueSystem.out.println(a==b); //falseSystem.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); //5System.out.println(a); //5System.out.println(b); //3System.out.println(b); //3System.out.println(c); //5System.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.0double 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: falseSystem.out.println("a || b: "+(a||b));          //逻辑或运算:两个变量有一个为真，则结果才为true //a || b: trueSystem.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); //falseSystem.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+ba-=b; //a = a-bSystem.out.println(a); //10//字符串连接符 + , StringSystem.out.println(""+a+b); //1020System.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，否则结果为zint score1 = 50;String type1 = score1 < 60?"不及格":"及格";//score1成立，所以type1=不及格//ifSystem.out.println(type1); //不及格int score2 = 80;String type2 = score2 < 60?"不及格":"及格";///score1不成立，所以type2=及格//ifSystem.out.println(type2); //及格}
}

总结

包机制

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

包语句的语法格式为:

package pkg1[. pkg2[. pkg3...]];

一般利用公司域名倒置作为包名;如 www.baidu.com->com.baidu.www

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

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

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

https://files.cnblogs.com/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，即文档，帮助其他人查看你的包。

🎉 感谢您的观看！

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

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

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

前言

Java简介

相关概念

C语言的优势和劣势

Java特性和优势

Java三大版本

JDK、JRE、JVM

Java开发环境搭建

java下载

安装java

卸载JDK

第一个代码：hello world

新建文件

编写代码

运行代码

idea使用

新建项目

快捷命令

Java基础

注释

标识符

数据类型

强类型语言和弱类型语言

Java的数据类型

基础类型

数据类型扩展

进制

浮点数的计算问题

字符

类型转换

变量、常量、作用域

变量

常量

命名规范

运算符

算术运算符

自增运算符：

幂运算

逻辑运算

字符串的+

三元运算符 x?y:z

总结

包机制

JavaDoc

相关文章：