一文搞懂 Java 基础：新手入门必备

于 2024-07-21 16:11:07 发布
阅读量720 收藏 10
点赞数 16
分类专栏： Java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_82095378/article/details/140589429
版权

目录

📝 Java基础

Java起源

Java programming language具有大部分编程语言所共有的一些特征，被特意设计用于互联网的分布式环境。Java具有类似于C++语言的"形式和感觉"，但它要比C++语言更易于使用，而且在编程时彻底采用了一种"以对象为导向"的方式。使用Java编写的应用程序，既可以在一台单独的电脑上运行，也可以被分布在一个网络的服务器端和客户端运行。

另外，Java还可以被用来编写容量很小的应用程序模块或者applet，做为网页的一部分使用。applet可使网页使用者和网页之间进行交互式操作，但 Applet 很早之前就被无情地拍死在了沙滩上。（已被弃用）

Java是Sun公司在1995年推出的，推出之后马上给互联网的交互式应用带来了新面貌。最常用的两种互联网浏览器软件中都包括一个Java虚拟机。几乎所有的操作系统中都增添了Java编译程序。后来 Sun 公司被 Oracle （甲骨文）公司收购，Java 也随之成为 Oracle 公司的产品。

Java分为三个体系：

  • JavaSE（J2SE)(Java2 Platform Standard Edition，java平台标准版）

  • JavaEE (J2EE) (Java 2 Platform,Enterprise Edition，java平台企业版)

  • JavaME (J2ME) (Java 2 Platform Micro Edition，java平台微型版)

Java的一些相关术语：

  • JDK（Java Development Kit）是用于开发 Java 应用程序的软件环境。里面包含运行时环境（JRE）和其他 Java 开发所需的工具，比如说解释器（java）、编译器（javac）、文档生成器（javadoc）等等。

  • JRE（Java Runtime Environment）是用于运行 Java 应用程序的软件环境。也就是说，如果只想运行 Java 程序而不需要开发 Java 程序的话，只需要安装 JRE 就可以了。

  • JVM (Java Virtual Machine) ，也就是 Java 虚拟机，由一套字节码指令集、一组寄存器、一个栈、一个垃圾回收堆和一个存储方法域等组成，屏蔽了不同操作系统（macOS、Windows、Linux）的差异性，使得 Java 能够“一次编译，到处运行”。

在这里插入图片描述

第一个Java程序

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}
//String args[] 与 String[] args 都可以执行，但推荐使用 String[] args，这样可以避免歧义.

java程序的执行基础命令的解析。 依次执行以下命令

javac HelloWord.java //先Java 源码编译成字节码
java HelloWord //  java 命令运行字节码

在这里提一下，参数args的作用：

参数args是Java编译器要求必须做的，用来存储命令行参数的。

在这里插入图片描述

  • 注意点

    1. Java对大小写特别敏感。A和a不相同。

    2. 类名，类名首字母大写，若是由若干单词组成，每个单词的首字母大写。HelloWord

    3. 方法名，**所有方法名以小写字母开头，如果方法名含有若干单词，则后面的每个单词首字母大写。**myAction

    4. 源文件名，源文件名必须与类名相同，文件名必须与public的类名相同。

    public class test{
    public static void main(String[] args){
        ......
    }
}

该文件名需为test.java

    所有的Java程序都由 public static void main(String[] args)方法开始执行。

基础语法

Java标识符

简单来记，自己起了名字的都可以称为标识符，如类名，方法名，变量名。

命名规范（驼峰命名法）

  • 项目的命名：项目的命名全部小写

  • 包的命名：package 的名字由全部小写的字母组成，例如：com.test

  • 类名和接口名：每个单词首字母大写，其余小写，例如：public class MyClass{}

  • 方法名：方法的名字用一个小写字母开头，后面的单词用大写字母开头,例如：run()，getBalance()。

  • 变量名：变量的名字用一个小写字母开头，后面的单词用大写字母开头,例如：index，currentImage。

  • 常量名：基本数据类型的常量名使用全部大写，单词之间使用下划线分割。例如：public static final String GAME_COLOR=“RED”;

注意点：

  • 所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开始

  • 首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合

  • 关键字不能用作标识符

  • 标识符是大小写敏感的

  • 合法标识符举例：age、$salary、_value、__1_value

  • 非法标识符举例：123abc、-salary

  • " " 尽量不要在代码中出现。（是由于在后面内部类中，编译后会出现 "尽量不要在代码中出现。（是由于在后面内部类中，编译后会出现 "尽量不要在代码中出现。（是由于在后面内部类中，编译后会出现符号）

命名时，尽量不要使用中文及拼音命名。😆😆😆

这里列举一些常见的Java关键字。

类别关键字说明
访问控制private私有的，表示方法或变量只对当前类可见。
protected受保护的，表示方法或变量对同一包内的类和所有子类可见。
public除了可以声明方法和变量（所有类可见），还可以声明类。main() 方法必须声明为 public。
default默认
类、方法和变量修饰符abstract声明抽象类，抽象方法
class类
enum定义一组固定的常量（枚举)
extends一个类是从另一个类或接口继承的。
final最终值、不可改变的.
final 变量：表示一个常量，一旦被赋值，其值就不能再被修改。
final 方法表示一个不能被子类重写的方法。
final 类表示一个不能被继承的类。这在设计类时，确保其不会被其他类继承时非常有用。
String类就是final的。
implements实现（接口）
interface用于声明接口。会定义一组方法的签名（即方法名、参数列表和返回值类型），但没有方法体。其他类可以实现接口，并提供方法的具体实现。
native本地、原生方法（非 Java 实现），本地方法是指在 Java 代码中声明但在本地代码（通常是 C 或 C++ 代码）中实现的方法，它通常用于与操作系统或其他本地库进行交互。
public native void Method();
new创建一个新的对象。
static静态，表示该变量或方法是是静态方法或静态变量
strictfp严格浮点、精准浮点，通常用于修饰一个方法，用于限制浮点数计算的精度和舍入行为。
synchronized线程、同步，用于指定多线程代码中的同步方法。变量或代码块。
transient修饰的字段不会被序列化。
volatile保证不同线程对它修饰的变量进行操作时的可见性，即一个线程修改了某个变量的值，新值对其他线程来说是立即可见的。
程序控制语句break跳出循环，程序将立即跳出当前循环或 switch 语句，继续执行紧跟在循环或 switch 语句后面的代码。
case定义一个值以供 switch 选择
continue继续，用于继续下一个循环，可以在指定条件下跳过其余代码。
do运行，通常和 while 关键字配合使用，do 后紧跟循环体。不同之处在于 do-while 循环会先执行循环体中的代码，然后再检查循环条件。因此，do-while 循环至少会执行一次循环体中的代码
else否则
for循环
if如果，如果条件为真，则执行对应代码。
instanceof实例，用于判断对象是否属于某个类型或者子类的实例。
return返回，从方法中返回一个值或终止方法的执行
return 语句可以将方法的计算结果返回给调用者，或者在方法执行到某个特定条件时提前结束方法。
switch根据值选择执行，switch 语句通常与 case 和 default 一起使用。每个 case 子句表示一个可能的值和对应的代码块，而 default 子句用于处理不在 case 子句中的值。
while循环
错误处理assert断言表达式是否为真
catch捕捉异常，在 try 块中可能会抛出异常，而在 catch 块中可以捕获这些异常并进行处理。catch 块可以有多个，每个 catch 块可以捕获特定类型的异常。
finally和 try-catch 配合使用，表示无论是否处理异常，总是执行 finally 块中的代码。
throw抛出一个异常对象，主动抛出。
throws声明一个异常可能被抛出
try捕获异常
包相关import引入，用于导入对应的类或者接口。
package包
基本类型boolean布尔型，即真或假
byte字节型，用于表示一个 8 位（1 字节）有符号整数。它的值范围是 -128（-2^7）到 127（2^7 - 1）。
charchar 类型的变量可以存储任意的 Unicode 字符，可以使用单引号将字符括起来来表示。char c = ‘A’;
double双精度浮点。
在 Java 中，浮点数默认是 double 类型，如果要使用 float 类型的数据，需要在数字后面加上一个 f 或者 F，表示这是一个 float 类型的字面量。另外，也可以使用科学计数法表示浮点数，例如 1.23e-4 表示 0.000123。
float单精度浮点
int整型
long长整型
short短整型，占用 2 个字节（16 位）的内存空间。
变量引用super父类、超类，调用父类的方法或者字段。
this本类，用于在方法中引用当前对象。
void无返回值
保留关键字goto是关键字，但不能使用
const是关键字，但不能使用，在 Java 中可以使用 public static final 三个关键字的组合来达到常量的效果。

Java 的 null 不是关键字，类似于 true 和 false，它是一个字面常量，不允许作为标识符使用。

Java变量

变量就是指代在内存中开辟的存储空间，用于存放运算过程中需要用到的数据。

  • 声明变量

    变量必须先声明后使用，相同的变量只能声明一次。

    变量类型 变量名=变量值

int x=1;

int y=10,z=10;

    未经声明的变量不能使用，直接使用会有编译错误。

    在这里插入图片描述
    同时声明变量后，该变量只能存储制定好的数据类型的的数据，否则会产生编译错误。
    在这里插入图片描述

  • 变量的命名

    命名规则：

    1. 满足标识符的命名规则；

    2. 符合驼峰法命名规范；

    3. 尽量简单，做到见名知意；

  • 变量的类型

    成员变量

    • 成员变量定义在类中，在整个类中都可以被访问。

    • 成员变量随着对象的建立而建立，随着对象的消失而消失，存在于对象所在的堆内存中。

    • 成员变量有默认初始化值。

    局部变量

    • 局部变量只定义在局部范围内，如：函数内，语句内等，只在所属的区域有效。

    • 局部变量存在于栈内存中，作用的范围结束，变量空间会自动释放。

    • 局部变量没有默认初始化值

    静态变量

    • 静态变量随着类的加载而存在，随着类的消失而消失。

    • 静态变量可以被对象调用，还可以被类名调用。

    • 静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

    在使用变量时需要遵循的原则为：就近原则. 首先在局部范围找，有就使用；接着在成员位置找。

    class Test{
    private String name;//成员变量，实例变量
    private int age;
    static String country="CN";//静态变量

    public Test(){};

    //name，age 为成员变量
    public Test(String name,int age){
        this.name=name;
        this.age=age;
    }

    public void start(){
        String tests="hello"; //局部变量
        System.out.println("姓名："+name +" 年龄："+age);
    }

//i为局部变量
	for(int i=0;i<36;i++){
  	......
  }

}

public class StaticDemo{
    public static void main(String[]args){
        Test test = new Test();
        System. out.println(test.country);
        //可以用类名直接调用
        System. out.println(Test.country);
    }
}
    成员变量局部变量静态变量
    定义位置在类中,方法外方法中,或者方法的形式参数在类中,方法外
    初始化值有默认初始化值无,先定义,赋值后才能使用有默认初始化值
    调用方式对象调用—对象调用，类名调用
    存储位置堆中栈中方法区
    生命周期与对象共存亡与方法共存亡与类共存亡
    别名实例变量—类变量

    初始化值如下图：

    数据类型默认值大小
    booleanfalse1 比特
    char‘\u0000’2 字节
    byte01 字节
    short02 字节
    int04 字节
    long0L8 字节
    float0.0f4 字节
    double0.08 字节

Java注释

在这里插入图片描述

  • 单行注释

    单行注释通常用于解释方法内某单行代码的作用。

    public void method() {
		// age 用于表示年龄
    int age = 18; 
}

// ~~int age = 18; //age 用于表示年龄~~
//注释写在行尾的话，是不符合阿里巴巴的开发规约的。咋就是说，事真多

  • 多行注释

    多行注释通常用于解释一段代码的作用,以 /* 开始，以 */ 结束。（一般用的很少，都用这了，不如选择用文档注释哈哈。）

    /*
age 用于表示年纪
name 用于表示姓名
*/
int age = 18;
String name = "alice";

  • 文档注释

    文档注释可用在三个地方，类、字段和方法，也是解释一段代码的作用。

    /**
 * 测试类
 */
public class Test {
    /**
     * 姓名
     */
    private int age;

    /**
     * main 方法作为程序的入口
     *
     * @param args 参数
     */
    public static void main(String[] args) {

    }
}

    • 创建文档注释

      1.在终端找到对应文件的路径。

      2.执行javadoc命令，

      javadoc Test.java -encoding utf-8

      在这里插入图片描述

      3.生成了许多的代码文件，通过浏览器打开看文档注释。

      在这里插入图片描述
      在这里插入图片描述

    文档注释注意点：

    • javadoc 命令只能为 public 和 protected 修饰的字段、方法和类生成文档。default 和 private 修饰的字段和方法的注释将会被忽略掉。

    • 文档注释中可以插入一些 @ 注解，比如说 @see 引用其他类，@version 版本号，@param 参数标识符，@author 作者标识符，@deprecated 已废弃标识符等等。

  • 注释规约

    1. 类、字段、方法必须使用文档注释，不能使用单行注释和多行注释。因为注释文档在 IDE 编辑窗口中可以悬浮提示，提高编码效率。

    2. 所有的抽象方法(包括接口中的方法)必须要用 Javadoc 注释、除了返回值、参数、 异常说明外，还必须指出该方法做什么事情，实现什么功能。

    3. 所有的类都必须添加创建者和创建日期。

    4. 所有的枚举类型字段必须要有注释，说明每个数据项的用途。

    5. 代码修改的同时，注释也要进行相应的修改。

Java数据类型

在这里插入图片描述

基本数据类型

    1. 布尔型

      布尔（boolean）仅用于存储两个值：true 和 false，也就是真和假，通常用于条件的判断。

      boolean flag = true;

    2. char

      char 用于表示 Unicode 字符，占 16 位（2 字节）的存储空间，取值范围为 0 到 65,535。

      char n = 'A';
//字符字面量应该用单引号（''）包围，而不是双引号（""）,双引号表示字符串变量。

      在这里插入图片描述

    3. byte

      一个字节可以表示 2^8 = 256 个不同的值。由于 byte 是有符号的，它的值可以是负数或正数。(一般在网络传输过程中，采用字节来作为数据的传输方式。)

      byte b = 1;
byte a = -1;

    4. short

      short也是有符号的，可以表示负数或正数，其取值范围在 -32,768 和 32,767 之间。

      short s = 32767;

    5. int

      最为常用的整型类型，int 的取值范围在 -2,147,483,648（-2 ^ 31）和 2,147,483,647（2 ^ 31 -1）（含）之间。

      int i = 2147483647;

      为什么 32 位的有符号整数的取值范围是从 -2^31 到 2^31 - 1 呢？

      这是因为其中一位用于表示符号（正或负），剩下的 31 位用于表示数值，这意味着其范围是 -2,147,483,648（即 -2^31）到 2,147,483,647（即 2^31 - 1）。

      在二进制系统中，每个位（bit）可以表示两个状态，通常是 0 和 1。对于 32 位得正二进制数，除去符号位，从右到左的每一位分别代表 2^0, 2^1, 2^2, …, 2^30，这个二进制数转换为十进制就是 2^0 + 2^1 + 2^2 + … + 2^30，也就是 2,147,483,647.

    6. long

      long 型变量在声明的时候，末尾要带上大写的“L”，以便于和int 区分。

      long取值范围为 -9,223,372,036,854,775,808(-2^63) 和 9,223,372,036,854,775,807(2^63 -1)（含）之间。

      long l = 500000000000L;

      在这里插入图片描述

    7. float

      float 是单精度的浮点数（单精度浮点数的有效数字大约为 6 到 7 位），32 位（4 字节）.

      float型变量在声明的时候，末尾要带上小写的“f”。

      float a = 3.1415f;

    8. double

      double 是双精度浮点数（双精度浮点数的有效数字大约为 15 到 17 位），占 64 位（8 字节）.

      double myDouble = 3.141592653589793;

      在这里插入图片描述

      double float 都不适合用于精确的数值，例如金额，交易这种。 一般采用 BigDecimal类来避免浮点数舍入误差。BigDecimal 可以表示一个任意大小且精度完全准确的浮点数。 如果是精确到小数点两位这种（0.01），可以乘以100，转换成整型处理。

基本数据类型转换

Java 提供了以下包装器类型，与基本数据类型一一对应：

  • Byte（对应 byte）

  • Short（对应 short）

  • Integer（对应 int）

  • Long（对应 long）

  • Float（对应 float）

  • Double（对应 double）

  • Character（对应 char）

  • Boolean（对应 boolean）

1、自动类型转换

自动类型转换（自动类型提升）是 Java 编译器在不需要显式转换的情况下，将一种基本数据类型自动转换为另一种基本数据类型的过程。

一般情况下，自动类型转换只发生在兼容类型之间.(较小的数据类型转换成较大的数据类型，或者精度值较低的数据类型转换为较高的数据类型，当然也存在大类型转换为小类型的，只要也在小类型的取值范围内)

byte -> short -> int -> long -> float -> double
char -> int -> long -> float -> double

//示例
byte b = 50;
b *= 2;//true 
b = (byte) b*2;//true 强制类型转换
b = b * 2;//false

自动类型转换规则（隐式提升）：

  • 算术运算

    如果任一操作数是 double 类型，其他操作数将被转换为 double 类型。

    否则，如果任一操作数是 float 类型，其他操作数将被转换为 float 类型。

    否则，如果任一操作数是 long 类型，其他操作数将被转换为 long 类型。

    否则，所有操作数将被转换为 int 类型。

  • 方法调用

    当方法参数类型与传递的参数类型不一致时，也会发生隐式提升。如果方法期望较高精度的类型，而传递了较低精度的类型，传递的参数会被提升。

2、强制类型转换

强制类型转换是 Java 中将一种数据类型显式转换为另一种数据类型的过程。与自动类型转换不同，强制类型转换需要程序员显式地指定要执行的转换。

一般情况下，将较大数据类型转换为较小数据类型，或者件字符类型转换为数值类型都需要强制类型转换。需要注意的是，强制类型转换可能会导致数据丢失或精度降低，因为目标类型可能无法容纳原始类型的所有可能值。

double -> float -> long -> int -> char -> short -> byte

//示例
double d = 40.999090;
int a = (int) d ;//a = 40

//示例：int 转换 char
//1.强制性类型转换
int test = 65;
char charTest = (char) test;
//2.利用Character.forDigit()方法将整型 int 转换为字符 char，参数 radix 为基数，十进制为 10，十六进制为 16.
int test1 = 1;
int radix = 10;
char charTest1 = Character.forDigit(test1,radix);
//3.toString()方法
 int test2 = 1;
 char charTest2 = Integer.toString(test2);
 
// char 转换 int
	int a = 'a';
	int a = '1';//a=49
	int b = Character.getNumericValue('1'); // b=1
	int c = Character.digit('1',10); // c=1
	int d = '1' - '0'; // d =1

基本数据类型缓存池

基本数据类型的包装类除了 Float 和 Double 之外，其他六个包装器类（Byte、Short、Integer、Long、Character、Boolean）都有常量缓存池。

  • Byte：-128~127，也就是所有的 byte 值

  • Short：-128~127

  • Long：-128~127

  • Character：\u0000 - \u007F

  • Boolean：true 和 false

Integer a = new Integer(1);
Integer b = new Integer(1);
System.out.println(a == b);//false

Integer a1 =Integer.valueOf(1);
Integer b1 =Integer.valueOf(1);
System.out.println(a1 == b1);//true

Integer a2 =Integer.valueOf(288);
Integer b2 =Integer.valueOf(288);
System.out.println(a2 == b2);//false

/**
Integer 类内部中内置了 256 个 Integer 类型的缓存数据，
当使用的数据范围在 -128~127 之间时，会直接返回常量池中数据的引用，而不是创建对象，
超过这个范围时会创建新的对象。

当我们通过 Integer.valueOf() 方法获取整数对象时，会先检查该整数是否在 IntegerCache
如果在，则返回缓存中的对象，否则创建一个新的对象并缓存起来。
需要注意的是，如果使用 new Integer() 创建对象，即使值在 -128 到 127 范围内，
也不会被缓存，每次都会创建新的对象。因此，推荐使用 Integer.valueOf() 方法获取整数对象
**/

Java运算符

在这里插入图片描述
在这里插入图片描述

1、算术运算符

算术运算符包括常见的加法（+）、减法（-）、乘法（*）、除法（/），还有取余(模)运算符（%）。

在这里插入图片描述

int a = 1;
int b = 2;
System.out.println(a + b) // 3 整型与整型的算术运算结果都是整型2、
System.out.println(b - a) // 1
System.out.println(a * b) // 2
System.out.println(b / a) // 2
System.out.println(b % a) // 0

double c = 5.0
System.out.println(c % b) // 1.0

//整数除以0的情况
System.out.println(1/0) //程序抛出异常 

//浮点数除以0的情况
System.out.println(5.0/0.0) // Infinity(无穷大)
System.out.println(0.0/0.0) // NaN

2、关系运算符

关系运算符用来比较两个操作数，返回结果为 true 或者 false。

在这里插入图片描述

int a = 1, b = 2;
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a > b); // false
System.out.println(a < b); // true
System.out.println(a >= b); // false
System.out.println(a <= b); // true

3、位运算符

在Java中，位运算符用于直接操作整数类型的数据（如 int 和 long）的二进制表示。一般情况下，我们所使用的都是十进制的数值，在程序操作时，都需要转换为二进制数值。

int a = 5;   // 0101

在这里插入图片描述

按位与(并)（&）：按位与操作会将两个整数的每一位进行与运算，只有当对应的位都为1时，结果位才为1。

int a = 5;   // 0101
int b = 3;   // 0011
int result = a & b; // 0001 -> 1

按位或（|）：按位或操作会将两个整数的每一位进行或运算，只要对应的位有一个为1，结果位就为1。

int a = 5;   // 0101
int b = 3;   // 0011
int result = a | b; // 0111 -> 7

按位异或（^）：按位异或操作会将两个整数的每一位进行异或运算，当对应的位不相同时，结果位为1。

int a = 5;   // 0101
int b = 3;   // 0011
int result = a ^ b; // 0110 -> 6

按位非（~）：按位非操作会将整数的每一位取反，即0变1，1变0。

int a = 5;   // 0101
int result = ~a; // 1010 -> -6
/**
(在32位整数中为11111111111111111111111111111010) -> -6
11111111 11111111 11111111 11111010
取反得到 00000000 00000000 00000000 00000101
加一得到 00000000 00000000 00000000 00000110 -> 6
**/

在这里插入图片描述

右移（>>）：将一个数的所有二进制位向右移动指定的位数，左边用符号位填充（即正数填充0，负数填充1），右移一位相当于除以2。

int a = 5;   // 0101
int result = a >> 1; // 0010 -> 2  5/2^1

无符号右移（>>>）：将一个数的所有二进制位向右移动指定的位数，左边用0填充，不考虑符号位。

int a = -5;   // 11111111 11111111 11111111 11111011
int result = a >>> 1; // 01111111 11111111 11111111 11111101 -> 2147483645

左移（<<）：将一个数的所有二进制位向左移动指定的位数，右边用0填充，左移一位相当于乘以2。

int a = 5;   // 0101
int result = a << 1; // 1010 -> 10 5*2^1

4、逻辑运算符(布尔运算符)

在这里插入图片描述

int a=10;
int b=5;
int c=20;
System.out.println(a<b&&a<c);//false && true = false

System.out.println(a>b||a<c);//true || true = true

单逻辑与运算符（&）和单逻辑或运算符（|）：不管第一个条件为 true 还是 false，依然会检查第二个。

5、赋值运算符

在这里插入图片描述

int a=10;
int b=20;
a+=4;//a=a+4 (a=10+4)  
b-=4;//b=b-4 (b=20-4)

= 右侧的算术表达式默认为 int 类型，左侧是 short 类型的时候需要进行强转。

在这里插入图片描述

short a = 10;
short b = 10;
//a+=b;//a=a+b internally so fine
a = (short)(a + b);

6、三元运算符
三元运算符（也称为条件运算符）是一种简洁的条件语句，用于根据布尔表达式的结果选择值。

result = condition ? value1 : value2;

注意：

  • value1 和 value2 的类型必须兼容或可以进行隐式转换。例如，不能返回一个整数和一个字符串。

  • 三元运算符的优先级较低，因此在复杂表达式中可能需要使用括号来明确运算顺序。

int a = 10;
int b = 20;
int max = (a > b) ? a : b;
System.out.println( max); // 20

Java流程控制语句

1、if 相关语句

  • if 语句

    if(布尔表达式){  
// 如果条件为 true，则执行这块代码
} 
//如果条件为false，则跳过if中的代码，执行后续的的代码
.....

  • if - else 语句

    if(布尔表达式){  
// 条件为 true 时执行的代码块
}else{  
// 条件为 false  时执行的代码块
}

  • if - else-if 语句

    if(条件1){  
// 条件1 为 true 时执行的代码
}else if(条件2){  
// 条件2 为 true 时执行的代码
}  
else if(条件3){  
// 条件3 为 true 时执行的代码
}  
...  
else{  
// 以上条件均为 false 时执行的代码
}

    在这里插入图片描述

  • if 嵌套语句

if(外侧条件){    
     // 外侧条件为 true 时执行的代码 
    if(内侧条件){  
        // 内侧条件为 true 时执行的代码
    }    
}

2、switch 语句

switch语句用于根据多个条件执行一条语句，类似于if-else-if阶梯语句。

switch(变量) {    
case 可选值1:    
 // 可选值1匹配后执行的代码;    
 break;  // 该关键字是可选项
case 可选值2:    
 // 可选值2匹配后执行的代码;    
 break;  // 该关键字是可选项
......    
    
default: // 该关键字是可选项     
 // 所有可选值都不匹配后执行的代码 
}

switch中变量类型可以为以下的变量类型：

1、byte、short、int、char 基本数据类型

2、String 字符串类型

3、枚举类型

4、包装类： Byte、Short、Integer、Character

但 switch 不支持 long、float、double 类型，这是因为：

  • long 是 64 位整数，不在 switch 一开始设计的范围内（32 位的 int 在大多数情况下就够用了）。

  • float 和 double 是浮点数，浮点数的比较不如整数简单和直接，存在精度误差。

  • switch表达式可以有一个或多个case值。不允许使用变量作为case值。值类型和变量类型必须是一致的。

  • 每个case值必须是唯一的，重复的case值会导致编译错误。

  • 每个case语句可以包含一个可选的break语句。当控制流程到达break语句时，会跳出switch语句。如果没有break语句，将会继续执行后续所有的case语句(不论它们是否与表达式的值匹配。)。

    
public class SwitchExample {
    public static void main(String[] args) {
        int day = 3;
        
        switch (day) {
            case 1:
                System.out.println("Monday");
            case 2:
                System.out.println("Tuesday");
            case 3:
                System.out.println("Wednesday");
            case 4:
                System.out.println("Thursday");
            case 5:
                System.out.println("Friday");
            case 6:
                System.out.println("Saturday");
            case 7:
                System.out.println("Sunday");
            default:
                System.out.println("Invalid day");
        }
    }
}
/**
在该实例中，因为没有 break 语句的情况下，
程序会继续执行后续的所有 case 语句，
不论它们是否与表达式的值匹配。
程序最终会输出 "Thursday"、"Friday"、"Saturday"、
"Sunday" 和 "Invalid day"。
**/

  • switch语句可以有一个可选的default标签，用于处理所有未匹配到的情况。

在这里插入图片描述

Switch 枚举示例：

public class SwitchEnumExample {
    public enum Day {
    MONDAY, 
    TUESDAY,
    WEDNESDAY, 
    THURSDAY, 
    FRIDAY, 
    SATURDAY, 
    SUNDAY
    }

    public static void main(String[] args) {
        Day day = Day.WEDNESDAY;
        
        switch (day) {
            case MONDAY:
                System.out.println("Today is Monday");
                break;
            case TUESDAY:
                System.out.println("Today is Tuesday");
                break;
            case WEDNESDAY:
                System.out.println("Today is Wednesday");
                break;
            case THURSDAY:
                System.out.println("Today is Thursday");
                break;
            case FRIDAY:
                System.out.println("Today is Friday");
                break;
            case SATURDAY:
                System.out.println("Today is Saturday");
                break;
            case SUNDAY:
                System.out.println("Today is Sunday");
                break;
            default:
                System.out.println("Invalid day");
                break;
        }
    }
}//Today is Wednesday

3、for 循环语句

1、for循环

  • 初始变量：循环开始执行时的初始条件。

  • 条件：循环每次执行时要判断的条件，如果为 true，就执行循环体；如果为 false，就跳出循环。当然了，条件是可选的，如果没有条件，则会一直循环。

    //死循环
for(;;){
    System.out.println("......");
}

  • 循环体：循环每次要执行的代码块，直到条件变为 false。

  • 自增/自减：初始变量变化的方式。

for(初始变量;条件;自增/自减){  
// 循环体
}

2、for-each 循环（增强型for循环）

for-each 循环通常用于遍历数组和集合。

for(元素类型 元素 : 数组或集合){  
// 要执行的代码
}  

//示例
public class ForEachExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        
        for (int number : numbers) {
            System.out.println(number);
        }
    }
}
💢
break 关键字通常用于中断循环或 switch 语句，它在指定条件下中断程序的当前流程。如果是内部循环，则仅中断内部循环。 
public class BreakExample {
    public static void main(String[] args) {
        for (int i = 1; i <= 3; i++) {
            System.out.println("Outer loop iteration: " + i);
            
            for (int j = 1; j <= 2; j++) {
                System.out.println("    Inner loop iteration: " + j);
                
                if (j == 2) {
                    break;  // 中断内部循环
                }
            }
        }
    }
}
/**
Outer loop iteration: 1
    Inner loop iteration: 1
    Inner loop iteration: 2
Outer loop iteration: 2
    Inner loop iteration: 1
    Inner loop iteration: 2
Outer loop iteration: 3
    Inner loop iteration: 1
    Inner loop iteration: 2
**/
/**
内部循环在 j 等于 2 时会中断，
但外部循环不受影响，继续执行下一次迭代。
**/

4、while循环相关语句

1、while循环

while(条件){  
//循环体  
}

2、do-while循环

do{  
// 循环体
}while(条件);

在这里插入图片描述

💡
continue 关键字用于立即结束当前循环的本次迭代，并继续执行下一次循环的开始部分。 
for (int i = 1; i <= 10; i++) {
    if (i == 5) {
        // 使用 continue 关键字
        continue;// 5 将会被跳过
    }
    System.out.println(i);
}

Java 中的 continue; 语句表示跳过当前循环的剩余部分，并开始下一次循环。它必须是循环体内的最后一条语句，不能在它之后有其他代码。

//示例：
public class WhileContinueExample {
    public static void main(String[] args) {
        int i = 1;
        while (i <= 10) {
            if (i == 5) {
                i++; // 在 continue 前增加 i 的值
                continue;
            }
            System.out.println(i);
            i++; // 移至 if 之后，确保在 continue 后也会执行
        }
    }
}

在这里插入图片描述

天马行空的程序猿
关注
  • 16
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java学习资料整理(开发必备)
m0_67537062的博客
03-30 1万+
收集的java学习资料整理了下，里面包含了计算机基础、算法和数据结构、常用工具、java核心知识、性能优化、基础框架、数据库、消息队列、缓存中间件、搜索引擎、大数据、RPC、网关、容器、面试等知识
一文搞懂全链路监控：方案概述与比较
01-27
谷歌的Dapper论文提出了分布式跟踪系统的基础概念，它强调了监控系统需要具备低性能损耗、低代码侵入性、可扩展性和高效数据分析能力。全链路监控的目标包括： 1. 请求链路追踪：通过调用链结合业务日志，迅速定位...
【新手必备】一文读懂Ubuntu：Linux新手的全方位使用说明操作手册
科技改变人类，技术成就未来
06-15 2125
Ubuntu不仅是最好的入门选择之一，也是通往开源世界的绝佳门户。本篇技术博客将带你深入了解Ubuntu，从安装到日常使用，再到高级技巧，力求覆盖所有基础知识点，让你能够自信地驾驭这个操作系统。我们将会逐步解析，确保即使是完全的小白也能轻松上手。
Python 基础（一）：入门必备知识
Nero_czh的博客
11-03 5300
原创 Python 基础（一）：入门必备知识 ...
牛逼！Java 从入门到精通，超全汇总版
程序员cxuan的个人主页
05-06 7万+
文章目录Java 基础Head First JavaJava 核心技术卷一Java 编程思想设计模式Head First 设计模式图解设计模式设计模式重学 Java 设计模式Java 进阶Java 并发编程实战Java 并发编程艺术Java 并发编程之美图解Java多线程设计模式JVM深入理解 Java 虚拟机Java 虚拟机规范HotSpot 实战自己动手写 Java 虚拟机MySQLMySQL 基础教程SQL 基础教程深入浅出 MySQLMySQL 必知必会SQL 必知必会高性能 MySQLMySQL
Java后端工程师必备书单（从Java基础到分布式）
Java技术江湖
10-15 2090
Java开发工程师一般负责后端开发，当然也有专门做Java Web的工程师，但是随着前后端的分离，越来越多的Java工程师需要往大后端方向发展。 今天我们就来介绍一下Java后端开发者的书单。 首先要感谢一下江南白衣大大的后端书架，让我在初学阶段读到了很多好书，直到现在都印象深刻。 我在两年的学习历程中看了很多的书，其中不乏XXX入门到精通，XXX王者归来，XXX指南什么的。 虽然这类书确实毛病很...
【超全汇总】学习数据结构与算法，计算机基础知识，看这篇就够了
热门推荐
帅地
01-18 10万+
由于文章有点多，并且发的文章也不是一个系列一个系列发的，不过我的文章大部分都是围绕着 数据结构 + 算法 + 计算机网络 + 操作系统 + Linux + 数据库 这几个方面发的，为了方便大家阅读，我整理了一波。不过公众号可以说是不支持修改文章，因为我决定每两三个月就整理一次，会非常详细着按照类别整理出来哦，并且也给出了目录哦。大家记得多看看哦，好多文章都是面试中常问滴 文章目录一、经验/经历/所...
轻松易懂，一文带你http协议入门？
<sdffdsfsdfdfs>sfsfsfsdfsdffds</sdfsDS>Fsd
05-26 148
????????关注后回复“进群”，拉你进程序员交流群????????作者丨土豆居士来源丨一口Linux（ID：yikoulinux）一、什么是http？ Http协议即超文本传送协议 (HTTP-Hypertext transfer protocol) 。它定义了浏览器（即万维网客户进程）怎样向万维网服务器请求万维网文档，以及服务器怎样把文档传送给浏览器。从层次的角度看，HTTP是面向（t...
新手入门：目前为止最透彻的的Netty高性能原理和框架架构解析
zjp的博客
09-20 297
1、引言 Netty是一个广受欢迎的异步事件驱动的Java开源网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。 本文基于Netty 4.1展开介绍相关理论模型，使用场景，基本组件、整体架构，知其然且知其所以然，希望给大家在实际开发实践、学习开源项目方面提供参考。 本文作者的另两篇《高性能网络编程(五)：一文读懂高性能网络编程中的I/O模型》、《高性能网络编程(六)：一文...
Java技术好文精选整理：Java基础+Spring全家桶+并发+容器+面题面经
F1814397的博客
05-05 607
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
一文搞懂JAVA 修饰符
08-19
JAVA 修饰符详解 JAVA 语言提供了许多修饰符，主要分为两类：访问修饰符和非访问修饰符。修饰符用来定义类、方法或者变量，通常放在语句的最前端。 访问控制修饰符 访问控制修饰符是用来保护对类、变量、方法和...
一文搞懂C语言回调函数
01-27
回调函数在C语言中是一种强大的编程机制，它允许我们将函数作为参数传递给其他函数，然后在特定条件下由这些函数调用。回调函数的核心是函数指针，它存储了函数的地址，使得其他函数可以通过这个地址来执行指定的...
一文搞懂java的String类和Date类
12-21
Java中的`String`类是我们在编程中经常遇到的基础类，它用于表示不可变的字符序列。`String`类的重要性在于它的频繁使用以及其在内存管理上的特殊性。这篇文章将深入探讨`String`类的一些核心概念，包括对象创建、...
Java内存模型
weixin_44267758的博客
07-19 557
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
最新发布
山重水复疑无路，柳暗花明又一村。
07-20 475
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 979
JVM-垃圾回收与内存分配
java算法day19
TOMOT77的博客
07-20 121
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
【Java算法】前缀和 下
2302_79806056的博客
07-18 1030
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

天马行空的程序猿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值