Java-2

Java编程认识

1. Java Application初步

Java源文件以.java为扩展名,文件名与类名一致
一个源文件只能有一个public公共类
java应用程序的执行入口->main()方法,书写格式->public static void main(String[] args){}
java严格区分大小写
java方法由一条条语句构成,每个语句以分号结束

Java的注释方式-

单行注释
1
// 单行注释

多行注释

/* 多行注释1 */

/**
  * 多行注释2
  */

2. 命名

类名的首字母大写
变量名和方法名的首字母小写

运用驼峰标识

1. 单词之间没有空格或下划线，第一个单词的首字母通常大写，而后续单词的首字母大写
MinervaController // 类名
2. 第一个单词的首字母通常小写
startDate // 变量名
getDate // 方法名

3. 标识符

Java对各种变量\方法和类等要素命名时使用的字符序列称位标识符, 凡是自己可以起名字的地方都叫标识符

Java标识符的命名规则

1
2
3

1. 由字母\下划线_\美元符$\数字组成
2. 应以字母\下划线\美元符开头
3. 大小写敏感,长度无限制

4. 关键字

一些以特定的含义,用作专门的用途的字符称为关键字, 所有关键字均为小写

goto\const # 被保留
abstract\default\if\private\this
boolean\do\implements\protected\throw
break\double\import\public\throws
byte\else\instanceof\return\transient
case\extends\int\short\try
catch\final\interface\static\void
char\finally\long\strictfp\volatile
class\float\native\super\while
const\for\new\switch\null
continue\goto\package\synchronized

关键字 在下一篇详细介绍

5. java常量

使用final关键字定义常量

final 关键字可以用于基本数据类型和对象引用，确保它们的值不会被改变。一旦一个变量被声明为 final，它的值就不能再被修改。这适用于所有数据类型，包括基本类型和对象。

示例:

public class ConstantsExample {
    // 定义基本类型的常量
    public static final int MAX_SIZE = 100;
    public static final double PI = 3.14159;

    // 定义对象类型的常量
    public static final String APP_NAME = "My Application";
    public static final LocalDate START_DATE = LocalDate.of(2023, 1, 1);

    public static void main(String[] args) {
        System.out.println("Max Size: " + MAX_SIZE);
        System.out.println("PI: " + PI);
        System.out.println("App Name: " + APP_NAME);
        System.out.println("Start Date: " + START_DATE);
    }
}

使用枚举（enum）定义常量

枚举是一种特殊的类，用来表示一组固定的常量。枚举在 Java 5 中引入，提供了一种更安全、更清晰的方式来定义常量集合。

示例:

public enum Color {
    RED, GREEN, BLUE
}

public class EnumExample {
    public static void main(String[] args) {
        Color myColor = Color.RED;
        System.out.println("My color is: " + myColor);
    }
}

常量的作用
1. 代码可读性：使用常量可以使代码更具可读性和可维护性，因为常量名通常比硬编码的数字或字符串更容易理解。
2. 避免错误：常量可以防止在程序中多次使用相同的值时出现的拼写错误或数值错误。
3. 单一职责原则：如果需要更改某个值，只需在一个地方更改，而不必在整个代码库中查找和替换。
4. 类型安全：枚举提供了类型安全，确保只能使用预定义的值。
注意事项
- 常量通常使用大写字母命名，以提高可读性。
- 对于 final 变量，如果是在声明时初始化的，那么它必须被初始化；如果是在声明时不初始化，则必须在构造器中初始化。
- 枚举常量是隐式 public, static, 和 final 的，因此不能被改变

6. java变量

程序中最基本的存储单元,要素包括变量名,变量类型和作用域, 每一个变量都属于特定的数据类型,在使用前必须对其声明,声明格式为type varName = value
在 Java 中，数据类型分为两大类：基本数据类型（Primitive Data Types）和引用数据类型（Reference Data Types）。每种数据类型都有其特定的用途和特点。下面是对这两种数据类型的详细介绍：

基本数据类型（Primitive Data Types）

基本数据类型是 Java 中最简单的数据类型，它们直接存储值。Java 有 8 种基本数据类型：

byte
- 大小：8 位（1 字节）
- 范围：-128 到 127
- 用途：存储较小的整数，节省内存
short
- 大小：16 位（2 字节）
- 范围：-32,768 到 32,767
- 用途：存储中等大小的整数
int
- 大小：32 位（4 字节）
- 范围：-2,147,483,648 到 2,147,483,647
- 用途：最常用的整数类型
long
- 大小：64 位（8 字节）
- 范围：-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
- 用途：存储非常大的整数
float
- 大小：32 位（4 字节）
- 范围：约 ±1.4e-45 到 ±3.4e38
- 用途：存储单精度浮点数
double
- 大小：64 位（8 字节）
- 范围：约 ±4.9e-324 到 ±1.8e308
- 用途：存储双精度浮点数，精度更高
char
- 大小：16 位（2 字节）
- 范围：’\u0000’ 到 ‘\uffff’（0 到 65,535）
- 用途：存储单个 Unicode 字符
boolean
- 大小：1 位（实际占用内存取决于 JVM 实现）
- 范围：true 或 false
- 用途：存储布尔值

引用数据类型（Reference Data Types）

引用数据类型存储的是对象的引用（即地址），而不是对象本身。Java 中的主要引用数据类型包括：

类（Class）
- 例如：String, Integer, ArrayList 等
- 用途：表示复杂的对象结构，可以包含属性和方法
接口（Interface）
- 例如：List, Runnable 等
- 用途：定义行为规范，多个类可以实现同一个接口
数组（Array）
- 例如：int[], String[] 等
- 用途：存储相同类型的多个元素
枚举（Enum）
- 例如：Color（RED, GREEN, BLUE）
- 用途：表示一组固定的常量

示例:

基本数据类型示例

public class PrimitiveTypesExample {
    public static void main(String[] args) {
        byte b = 10;
        short s = 1000;
        int i = 100000;
        long l = 10000000000L;
        float f = 3.14f;
        double d = 3.141592653589793;
        char c = 'A';
        boolean bool = true;

        System.out.println("byte: " + b);
        System.out.println("short: " + s);
        System.out.println("int: " + i);
        System.out.println("long: " + l);
        System.out.println("float: " + f);
        System.out.println("double: " + d);
        System.out.println("char: " + c);
        System.out.println("boolean: " + bool);
    }
}

引用数据类型示例

public class ReferenceTypesExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        int[] numbers = {1, 2, 3, 4, 5};
        ArrayList<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");

        System.out.println("String: " + str);
        System.out.println("Array: " + Arrays.toString(numbers));
        System.out.println("List: " + list);
    }
}

总结
- 基本数据类型：直接存储值，效率高，但功能有限。
- 引用数据类型：存储对象的引用，功能强大，可以表示复杂的数据结构。

7. 程序格式

格式应该注意的问题:

大括号对齐, 到{时缩进,键盘快捷方式: tab/shift+tab
程序块之间加空行, 排语句之间加空格
运算符两侧加空格, { 前面有空格
成对编程

8. 运算符

算数运算符

算术运算符用于执行基本的数学运算。

加法 (+)：将两个操作数相加。
减法 (-)：从第一个操作数中减去第二个操作数。
乘法 (\*)：将两个操作数相乘。
除法 (/)：将第一个操作数除以第二个操作数。
取模 (%)：返回两个操作数相除后的余数。
自增 (++)：将操作数的值增加 1。
自减 (--)：将操作数的值减少 1。

示例:

int a = 10;
int b = 3;

int sum = a + b;       // 13
int difference = a - b; // 7
int product = a * b;   // 30
int quotient = a / b;  // 3
int remainder = a % b; // 1

a++; // a 现在是 11
b--; // b 现在是 2

关系运算符

关系运算符用于比较两个操作数，结果是一个布尔值（true 或 false）。

等于 (==)：检查两个操作数是否相等。
不等于 (!=)：检查两个操作数是否不相等。
大于 (>)：检查第一个操作数是否大于第二个操作数。
小于 (<)：检查第一个操作数是否小于第二个操作数。
大于等于 (>=)：检查第一个操作数是否大于或等于第二个操作数。
小于等于 (<=)：检查第一个操作数是否小于或等于第二个操作数。

示例:

int x = 10;
int y = 20;

boolean isEqual = (x == y);      // false
boolean isNotEqual = (x != y);   // true
boolean isGreaterThan = (x > y); // false
boolean isLessThan = (x < y);    // true
boolean isGreaterThanOrEqual = (x >= y); // false
boolean isLessThanOrEqual = (x <= y);    // true

逻辑运算符

逻辑运算符用于组合多个布尔表达式，结果也是一个布尔值。
- 逻辑与 (&&)：如果两个操作数都为 true，则结果为 true。
- 逻辑或 (||)：如果两个操作数中至少有一个为 true，则结果为 true。
- 逻辑非 (!)：反转操作数的布尔值。
- 示例:
  1
  2
  3
  4
  5
  6
  boolean p = true;
  boolean q = false;
  
  boolean andResult = (p && q); // false
  boolean orResult = (p || q); // true
  boolean notResult = !p; // false

位运算符

位运算符用于对二进制位进行操作。

按位与 (&)：对两个操作数的每一位进行与操作。
按位或 (|)：对两个操作数的每一位进行或操作。
按位异或 (^)：对两个操作数的每一位进行异或操作。
按位非 (~)：对操作数的每一位进行取反操作。
左移 (<<)：将操作数的二进制位向左移动指定的位数。
右移 (>>)：将操作数的二进制位向右移动指定的位数，高位补符号位。
无符号右移 (>>>)：将操作数的二进制位向右移动指定的位数，高位补零

示例:

int m = 5;  // 二进制: 0101
int n = 3;  // 二进制: 0011

int andResult = (m & n); // 0001 -> 1
int orResult = (m | n);  // 0111 -> 7
int xorResult = (m ^ n); // 0110 -> 6
int notResult = ~m;      // 11111111111111111111111111111010 -> -6
int leftShift = (m << 1); // 1010 -> 10
int rightShift = (m >> 1); // 0010 -> 2
int unsignedRightShift = (m >>> 1); // 0010 -> 2

赋值运算符

赋值运算符用于将一个值赋给一个变量。

简单赋值 (=)：将右边的值赋给左边的变量。

复合赋值运算符

：结合了赋值和算术运算。

+=：加法赋值
-=：减法赋值
*=：乘法赋值
/=：除法赋值
%=：取模赋值
&=：按位与赋值
|=：按位或赋值
^=：按位异或赋值
<<=：左移赋值
>>=：右移赋值
>>>=：无符号右移赋值

示例:

int x = 10;
x += 5; // 相当于 x = x + 5; x 现在是 15
x -= 3; // 相当于 x = x - 3; x 现在是 12
x *= 2; // 相当于 x = x * 2; x 现在是 24
x /= 4; // 相当于 x = x / 4; x 现在是 6
x %= 5; // 相当于 x = x % 5; x 现在是 1

条件运算符（三元运算符）

条件运算符（也称为三元运算符）根据条件的真假返回不同的值。
- 条件运算符 (? :)：如果条件为 true，则返回第一个值；否则返回第二个值。
- 示例:
  1
  2
  3
  int age = 20;
  String result = (age >= 18) ? "成年" : "未成年";
  System.out.println(result); // 输出 "成年"
类型转换运算符

类型转换运算符用于在不同数据类型之间进行转换。
- 显式类型转换：将一个数据类型强制转换为另一个数据类型。
- 隐式类型转换：编译器自动进行的类型转换。
- 示例:
  1
  2
  3
  4
  5
  int intValue = 100;
  double doubleValue = intValue; // 隐式类型转换
  
  double d = 10.5;
  int i = (int) d; // 显式类型转换

9. 表达式

9.1 表达式

符合一定语法规则的运算符和操作数的序列

表达式的类型和值
表达式的运算顺序
三目条件运算符
语法格式->x ? y : z

10. 变量的作用域

局部变量（Local Variable）：
- 局部变量是在方法或代码块（如for循环或if语句）内部声明的变量。
- 局部变量只能在声明它的代码块中使用，当代码块结束后，局部变量的生命周期也结束。
- 局部变量必须在使用前初始化，否则编译器会报错。
- 示例：
  1
  2
  3
  4
  5
  public void myMethod() {
  int x = 10; // 局部变量x
  System.out.println(x); // 有效
  }
  System.out.println(x); // 无效，编译错误
成员变量（Field/Instance Variable）：
- 成员变量是定义在类内部但在方法外部的变量，通常每个对象都有自己的成员变量。
- 成员变量的作用域是整个类，在类的所有方法中都可以访问。
- 成员变量在类的实例创建时被初始化，其生命周期与对象的生命周期一致。
- 示例：
  1
  2
  3
  4
  5
  6
  class MyClass {
  int num = 5; // 成员变量
  public void displayNum() {
  System.out.println(num); // 可以访问
  }
  }
类变量（Static Variable）：
- 类变量是使用static关键字声明的变量，属于类本身，而不是类的实例（对象）。
- 类变量的生命周期是整个程序的运行期，所有对象共享同一个类变量。
- 示例：
  1
  2
  3
  4
  5
  6
  class MyClass {
  static int staticNum = 10; // 类变量
  public static void displayStaticNum() {
  System.out.println(staticNum); // 通过类访问
  }
  }
方法参数（Parameter Variable）：
- 方法参数是在方法声明中定义的，用于接收方法调用时传入的实际参数。
- 方法参数的作用域仅限于方法内部。
- 示例：
  1
  2
  3
  public void myMethod(int param) {
  System.out.println(param); // 参数param的作用域在方法内
  }

11. 递归调用

递归是一种直接或间接调用自身的方法。递归通常用于解决可以分解为相似的子问题的问题。在递归调用时，必须要有一个终止条件，否则会导致无限递归，从而引发栈溢出错误。

递归的基本结构：
1. 终止条件：定义递归何时结束的条件。
2. 递归调用：方法在某些情况下调用自身。

示例：求阶乘的递归实现

public class Factorial {
    // 阶乘方法
    public static int factorial(int n) {
        if (n == 1) {
            return 1; // 终止条件：n等于1时返回1
        } else {
            return n * factorial(n - 1); // 递归调用
        }
    }

    public static void main(String[] args) {
        int result = factorial(5); // 调用递归方法
        System.out.println(result); // 输出120
    }
}

递归的优缺点：
- 优点：递归简化了某些问题的解决方案，使代码更加简洁。
- 缺点：递归可能消耗较多的内存和时间，特别是当递归深度过大时，容易导致栈溢出。

在 Java 中，分支语句和循环语句是控制程序流程的重要工具。它们允许你根据条件执行不同的代码块，或者重复执行某段代码。下面是对 Java 中主要的分支语句和循环语句的详细介绍。

12. 分支语句

1. `if` 语句

if 语句是最基本的条件分支语句，用于根据条件的真假来决定是否执行某段代码。

语法

1
2
3

if (condition) {
    // 执行代码块
}

示例

int x = 10;
if (x > 5) {
    System.out.println("x 大于 5");
}

2. `if-else` 语句

if-else 语句用于在条件为 true 时执行一个代码块，条件为 false 时执行另一个代码块。

语法

if (condition) {
    // 条件为 true 时执行的代码块
} else {
    // 条件为 false 时执行的代码块
}

示例

int x = 10;
if (x > 5) {
    System.out.println("x 大于 5");
} else {
    System.out.println("x 不大于 5");
}

3. `if-else if-else` 语句

if-else if-else 语句用于处理多个条件分支。

语法

if (condition1) {
    // 条件1为 true 时执行的代码块
} else if (condition2) {
    // 条件2为 true 时执行的代码块
} else {
    // 其他情况下执行的代码块
}

示例

int x = 10;
if (x > 15) {
    System.out.println("x 大于 15");
} else if (x > 5) {
    System.out.println("x 大于 5 但不大于 15");
} else {
    System.out.println("x 不大于 5");
}

4. `switch` 语句

switch 语句用于根据变量的值执行不同的代码块。它通常用于处理多个离散的值。

语法

switch (expression) {
    case value1:
        // 代码块1
        break;
    case value2:
        // 代码块2
        break;
    // 可以有多个 case
    default:
        // 默认代码块
}

示例

int day = 3;
switch (day) {
    case 1:
        System.out.println("星期一");
        break;
    case 2:
        System.out.println("星期二");
        break;
    case 3:
        System.out.println("星期三");
        break;
    case 4:
        System.out.println("星期四");
        break;
    case 5:
        System.out.println("星期五");
        break;
    case 6:
        System.out.println("星期六");
        break;
    case 7:
        System.out.println("星期日");
        break;
    default:
        System.out.println("无效的天数");
}

13. 循环语句

1. `for` 循环

for 循环用于在已知次数的情况下重复执行某段代码。

语法

1
2
3

for (initialization; condition; increment/decrement) {
    // 代码块
}

示例

1
2
3

for (int i = 0; i < 5; i++) {
    System.out.println("i 的值是: " + i);
}

2. `while` 循环

while 循环用于在条件为 true 时重复执行某段代码。

语法

1
2
3

while (condition) {
    // 代码块
}

示例

int i = 0;
while (i < 5) {
    System.out.println("i 的值是: " + i);
    i++;
}

3. `do-while` 循环

do-while 循环类似于 while 循环，但它是先执行一次代码块，然后再检查条件。

语法

1
2
3

do {
    // 代码块
} while (condition);

示例

int i = 0;
do {
    System.out.println("i 的值是: " + i);
    i++;
} while (i < 5);

4. `for-each` 循环

for-each 循环（也称为增强型 for 循环）用于遍历数组或集合中的每个元素。

语法

1
2
3

for (element : array/collection) {
    // 代码块
}

示例

int[] numbers = {1, 2, 3, 4, 5};
for (int number : numbers) {
    System.out.println("数字是: " + number);
}

控制循环的语句

1. `break` 语句

break 语句用于立即退出循环或 switch 语句。

示例

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break;
    }
    System.out.println("i 的值是: " + i);
}

2. `continue` 语句

continue 语句用于跳过当前循环的剩余部分，直接进入下一次循环。

示例

for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) {
        continue;
    }
    System.out.println("i 的值是: " + i);
}

总结

分支语句：if, if-else, if-else if-else, switch 用于根据条件执行不同的代码块。
循环语句：for, while, do-while, for-each 用于重复执行某段代码。
控制循环的语句：break 用于退出循环，continue 用于跳过当前循环的剩余部分。

掌握这些分支和循环语句，可以帮助你编写出更加灵活和强大的 Java 程序。希望这些信息对你有所帮助！