Java方法参数和运算符Java核心基础之多变量类型和作用域变量是用来存储数据的容器。每个变量都有一个特定的类型，该

Java核心基础之多变量类型和作用域

变量
- 是用来存储数据的容器。每个变量都有一个特定的类型，该类型决定了变量可以存储什么类型的数据以及可以对它执行哪些操作
- 变量的使用必须遵循“先声明，后使用”的原则。
- 变量的声明包括指定变量的名称和类型，而变量的初始化则是为变量分配内存空间并设置初始值
- 变量类型可以分为两大类：基本类型（Primitive Types）和引用类型（Reference Types）
变量的作用域
- 类变量（静态变量）：作用域为整个类，可以在类的任何方法中访问。
- 实例变量：作用域为类的实例（对象），可以在类的任何非静态方法以及类的构造器中访问。
- 局部变量：作用域为方法或代码块，只能在声明它的方法或代码块中访问。
- 参数变量：作用域为方法内部，用于传递数据给方法
类变量(静态变量)
- 使用static声明的变量，可以直接使用类名.变量名访问
- 一个类不管创建了多少个对象，类只拥有类变量的一份拷贝，数值默认值是0，布尔型默认值是false，引用类型默认值是null
- 生命周期：在第一次被访问时创建，在程序结束时销毁
- 声明为public类型，一般这样声明 public static final
```
public class Student {
    public static final String PREFIX = "我叫";
}
```
实例变量(属性)
- 需要使用对象.变量名才可以访问
- 对象被实例化之后，实例变量的值就跟着确定，可以是赋值，也可以是默认值
- 生命周期：在对象创建的时候创建，在对象被销毁的时候销毁
- 访问修饰符可以修饰实例变量，一般是私有的，private修饰，然后通过方法来进行查看或者修改
局部变量
- 方法中的变量
- 声明在方法、构造方法、语句块、形式参数等
- 生命周期：当它们执行完成后，变量将会被销毁
- 访问修饰符不能用于局部变量
- 局部变量没有初始值，必须初始化后才可以被使用

public class Student {
    public static final String PREFIX = "我叫";
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String introduce() {
        return PREFIX + name + "，年龄" + age;
    }
}

Java核心基础之方法入参和返回值

方法入参和返回类型
- 在Java编程中，方法是执行特定任务的可重用代码块。
- 可以接收数据作为输入（即入参）并返回数据作为输出（即返回值）
方法入参
- 方法入参可以是Java中的任何数据类型
- 包括基本数据类型（如int、double、boolean等）和引用数据类型（如类、接口、数组等）
- 在定义方法时，需要明确指定每个入参的类型和名称。
```
修饰符 返回类型 方法名(参数类型 参数名, 参数类型 参数名...) {
    //方法体
    return 
}
```
- 传递方式，在Java中，方法的入参传递方式有两种：值传递和引用传递
  - 值传递：对于基本数据类型，传递的是数据的值，方法内部对入参的修改不会影响原始数据。
  - 引用传递：对于引用数据类型，传递的是对象的引用（即内存地址），方法内部对对象的修改会影响原始对象。
方法返回类型
- 返回值是方法执行完毕后返回给调用者的数据。
- 方法的返回值类型是在方法签名中指定的，如果方法没有返回值，则其返回类型应为void。
- 返回值的类型可以是Java中的任何数据类型，包括基本数据类型和引用数据类型。在定义方法时，需要明确指定返回值的类型。
- return xxx 具体类型
- 如果不用返回，则方法返回类型上写 void
```
修饰符 void 方法名(参数类型 参数名, 参数类型 参数名...) {
    //方法体
}
```

Java核心基础之多类型运算符

算术运算符, 用于执行基本的数学运算。
- 加法运算符 (+) : 用于将两个数相加。
- 减法运算符 (-) : 用于从一个数中减去另一个数。
- 乘法运算符 (*) : 用于将两个数相乘。
- 除法运算符 (/) : 用于将一个数除以另一个数。结果是一个浮点数，除非操作数都是整数且可以整除。
- 取模运算符 (%) : 也称为模数运算符，用于求余数。它返回两个数相除后的余数。
- 自增运算符 (++) : 将变量的值增加1。有两种形式：前置（如 ++x）和后置（如 x++），它们在表达式中的行为有所不同。
- 自减运算符 (--) : 将变量的值减少1。同样，也有前置（如 --x）和后置（如 x--）两种形式。
- 注意
  - 自增（++）自减（--）运算符是一种特殊的算术运算符
  - 自增（++）自减（—）在变量左右有不同的意义
    - 在变量左边则先自增减操作，再进行表达式运算
    - 在变量右边则先进行表达式运算，在进行自增减操作
  - 自增和自减运算符只能用于操作变量，不能直接用于操作数值或常量
关系运算符（用于数值的比较，不能是字符串等其他非数值）
- 等于运算符 (==) : 判断两个值是否相等。
- 不等于运算符 (!=) : 判断两个值是否不相等。
- 大于运算符 (>) : 判断左边的值是否大于右边的值。
- 小于运算符 (<) : 判断左边的值是否小于右边的值。
- 大于等于运算符 (>=) : 判断左边的值是否大于或等于右边的值。
- 小于等于运算符 (<=) : 判断左边的值是否小于或等于右边的值。
- 注意
  - 在Java中，== 和 != 运算符不仅可以用于基本数据类型的比较，还可以用于引用数据类型的比较
  - 在这种情况下，它们比较的是引用是否指向同一个对象，即内存地址编号
  - 但是，对于引用数据类型的内容比较，通常需要使用特定的方法或equals()方法（如果类重写了该方法）。
逻辑运算符
- 逻辑与 &&
  - 仅当两个操作数都为真，条件才为真
  - 有短路作用，短路运算符的“短路”特性是指在满足一定条件时，会跳过后续表达式的执行，从而提高程序的执行效率
  - 如果第一个条件为false，则不会执行第二个条件的判断，因为无论第二个条件是什么，整个表达式的结果都将是false
- 逻辑或 ||
  - 任何两个操作数任何一个为真，条件为真
  - 有短路作用，如果第一个条件为true，则不会执行第二个条件的判断，无论第二个条件是什么，整个表达式结果都是true
- 逻辑非！
  - 反转操作数，如果条件为true，则逻辑非运算符将得到false
赋值运算符
- 赋值运算符用于给变量赋值。Java中的赋值运算符是 =。
- 复合赋值运算符, +=、-=、*=、/= 和 %= 这些运算符允许在给变量赋值的同时进行算术运算
三目运算符（条件运算符)
- 是Java中唯一一个三元运算符，它的格式是 条件表达式 ? 成功值1 :否则值2。
- 如果条件表达式的值为true，则整个表达式的值为值1；否则为值2。
运算符优先级
- 和数学运算一样，可以加括号控制优先级
  - 乘除取余 * / %
  - 加减 + -
  - 关系运算>, >=, <,<=
  - 相等 ==、!=
  - 逻辑与 &&
  - 逻辑或 ||
  - 三目运算 ? :
  - 赋值 =

public class Demo1 {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;

        int sum = a + b;
        System.out.println("sum: " + sum);

        int diff = b - a;
        System.out.println("diff: " + diff);

        int product = a * b;
        System.out.println("product: " + product);

        int quotient = b / a;
        System.out.println("quotient: " + quotient);

        int remainder = a % b;
        System.out.println("remainder: " + remainder);

        int c = a++;
        System.out.println("c: " + c);

        int d = ++a;
        System.out.println("d: " + d);

        int e = a--;
        System.out.println("e: " + e);

        int f = --a;
        System.out.println("f: " + f);

        boolean isEqual = a == b;
        System.out.println("isEqual: " + isEqual);

        boolean isNotEqual = a != b;
        System.out.println("isNotEqual: " + isNotEqual);

        boolean isGreater = a > b;
        System.out.println("isGreater: " + isGreater);

        boolean isLess = a < b;
        System.out.println("isLess: " + isLess);

        boolean isGreaterOrEqual = a >= b;
        System.out.println("isGreaterOrEqual: " + isGreaterOrEqual);

        boolean isLessOrEqual = a <= b;
        System.out.println("isLessOrEqual: " + isLessOrEqual);

        Student student1 = new Student();
        Student student2 = new Student();
        student1.setName("Steven Wong");
        student2.setName("Steven Wong");
        Student student3 = student1;
        System.out.println(student2 == student1);
        System.out.println(student3 == student1);

        boolean flag1 = true;
        boolean flag2 = false;

        System.out.println(!flag1);
        System.out.println(flag1 && flag2);
        System.out.println(flag1 || flag2);

        System.out.println(a += 1);
        System.out.println(a -= 1);
        System.out.println(a *= 1);
        System.out.println(a /= 1);
        System.out.println(a %= 1);

        int max = a > b ? a : b;
        System.out.println("max: " + max);
    }
}

Java核心基础之while循环

什么是循环
- 原先代码是顺序结构，只能被执行一次，如果同样操作被执行多次，就是循环
while循环
- 在编程中，经常需要重复执行某些操作，直到满足某个条件为止。
- Java 中的 while 循环语句就是用来处理这种情况的，允许代码块持续执行，直到指定的条件不再满足。
- 条件表达式：
  - 这是一个布尔表达式，如果它的值为 true，则执行循环体；
  - 如果为 false，则跳过循环体，继续执行 while 循环后面的代码。
- 循环体：
  - 这是要重复执行的代码块。每次循环开始时，都会重新评估条件表达式的值。
do…while 循环
- 循环体至少会执行一次，因为条件检查是在循环体执行之后才进行的
while和do while的区别
- while的话一定需要满足条件才会执行
- do while的话，会先执行一次循环内容，再判断是否继续执行
- 根据具体的需求选择使用 while 循环还是其他类型的循环（如 for 循环或 do-while 循环）

public class Demo2 {
    public static void main(String[] args) {
        int i = 0;

        while (i < 10) {
            System.out.println(i);
            i++;
        }
        System.out.println("while循环结束：" + i);

        do {
            System.out.println(i);
            i++;
        } while (i < 10);
        System.out.println("do while循环结束：" + i);
    }
}

Java核心基础之for和for-each循环

什么是for循环
- for 循环是 Java 中最常用的循环结构之一，它用于重复执行一段代码块，直到满足某个条件为止。
- for 循环在已知循环次数的情况下特别有用。

语法

初始化：在循环开始之前执行一次，通常用于设置循环变量的初始值。
条件表达式：在每次循环迭代之前检查。如果表达式的结果为 true，则执行循环体；如果为 false，则退出循环。
更新表达式：在每次循环迭代之后执行，通常用于修改循环变量的值。
循环体：需要重复执行的代码块。

public class ForLoopDemo {
    private static int i;

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }

        int sum = 0;
        for (i = 1; i <= 10; i++) {
            sum += i;
        }
        System.out.println("1到10的和是："+sum);

        int[] arr = {1, 2, 3, 4, 5};
        for (i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

for-each循环（增强的for循环）
- 在Java中，还有一种特殊的for循环称为for-each循环（也称为增强的for循环）
- 它用于遍历数组或集合中的元素，而无需使用索引。
- 循环简化了对数组或集合的遍历操作，使代码更加简洁易读, 但是它并不适用于需要修改集合元素或需要知道元素索引的场景
```
public class ForEachArrayDemo {
    private static int[] arr;

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        for (int i : arr) {
            System.out.println(i);
        }
    }
}
```

Java核心基础之String字符串

简介：Java核心基础之String字符串讲解

什么是字符串String
- String 类是 Java 中用于表示字符序列的类，属于引用数据类型，不是基本数据类型
- 它是 Java 中非常基础和重要的类之一，几乎在所有的 Java 程序中都会使用到。
String 类的创建
- 直接赋值
```
String str = "Hello World!"; 
```
- 使用 new 关键字创建：
```
String str = new String("Hello World!");
```
- 字符串拼接创建，任何数据类型和字符串拼接后都是字符串类型
```
String str = "abc" + 123;
```
注意：空对象null 和 " "
- null是空对象，不能调用任何方法
- “ ”是字符串，只不过内容为空
String 类的常用方法
- length()：返回字符串的长度（字符个数）
- charAt(int index)：返回指定索引处的字符。
- substring(int beginIndex, int endIndex)：返回一个新的字符串，它是此字符串的一个子字符串。
- concat(String str)：将指定字符串连接到此字符串的结尾。
- indexOf(int ch) 和 indexOf(String str)：返回指定字符或子字符串在此字符串中第一次出现处的索引。
- lastIndexOf(int ch) 和 lastIndexOf(String str)：返回指定字符或子字符串在此字符串中最后一次出现处的索引。
- startsWith(String prefix) 和 endsWith(String suffix)：测试此字符串是否以指定的前缀或后缀开始或结束。
- replace(CharSequence target, CharSequence replacement)：替换字符串中的字符或子字符串。
- trim()：返回字符串的副本，忽略前导空白和尾部空白。
- toUpperCase() 和 toLowerCase()：将字符串中的所有字符转换为大写或小写。
- split(String regex)：根据给定的正则表达式的匹配拆分此字符串。
字符串比较
- equals()方法用于比较两个字符串的内容是否相同
  - 注意：不要使用==来比较字符串的内容，因为它比较的是引用是否相同，而不是内容是否相同
- equals(Object anObject) 和 equalsIgnoreCase(String another)：比较两个字符串的内容是否相等，后者忽略大小写

import java.util.Arrays;

public class StringDemo {
    public static void main(String[] args) {
        String str1;
        String str2 = "";
        String str3 = null;
        String str4 = "Hello";
        String str5 = "World";
        String str6 = "  Hello  ";
        String str7 = new String("Hello");
        String str8 = new String("hello");

        System.out.println(str2);
        System.out.println(str3);
        System.out.println(str4);
        System.out.println(str4.length());
        System.out.println(str4.charAt(0));
        System.out.println(str4.substring(1, 3)); // el
        System.out.println(str4 + " ".concat(str5));
        System.out.println(str4.indexOf("l"));
        System.out.println(str4.indexOf("ll"));
        System.out.println(str4.lastIndexOf("l"));
        System.out.println(str4.startsWith("H"));
        System.out.println(str4.endsWith("d"));
        System.out.println(str4.replace("l", "a")); // Heaao
        System.out.println(str6.trim());
        System.out.println(str4.toUpperCase());
        System.out.println(str4.toLowerCase());
        System.out.println(Arrays.toString(str4.split("e")));
        System.out.println(str4 == str7);
        System.out.println(str4.equals(str7));
        System.out.println(str4.equalsIgnoreCase((str8)));
    }
}