Java 入门第三篇，程序+输出+基础类型+循环+选择+判断语法等

2023-12-13 21:41:41

Java 入门第三篇，程序+输出+循环+数组+选择+判断语法等

一，什么是类

在Java中，类（Class）是一种面向对象编程的基本概念。类是用于创建对象的模板，它定义了对象的属性（成员变量）和行为（方法）。可以将类看作是一种自定义的数据类型，它封装了数据和操作数据的方法。

类的定义通常包括以下几个部分：

  1. 类名：类的名称用于标识该类，在Java中，类名的首字母通常大写。

  2. 成员变量：也称为属性或实例变量，用于存储对象的状态信息。成员变量定义了对象的特征和属性。

  3. 方法：也称为函数，用于定义对象的行为和操作。方法包含一系列的语句，用于执行特定的任务。

  4. 构造方法：构造方法是一种特殊的方法，用于创建对象并初始化对象的成员变量。

  5. 访问修饰符：可以使用访问修饰符（如public、private、protected）来控制类的成员的可访问性。
    以下是Java中的访问修饰符（access modifiers）及其对应的权限等级的表格：

修饰符当前类同一包内子类其他包
public????????
protected???????
默认（无修饰符）??????
private?????
  • ?? 表示具有访问权限
  • ? 表示没有访问权限

下面是对每个访问修饰符的解释：

  1. public：具有最高的访问权限，可以从任何地方访问。被public修饰的成员可以在当前类、同一包内的其他类、子类和其他包中的类中访问。

  2. protected：被protected修饰的成员可以在当前类、同一包内的其他类和子类中访问。但是，如果子类位于不同的包中，则只能访问其继承的父类的protected成员。

  3. 默认（无修饰符）：如果没有指定访问修饰符，则成员具有默认的访问权限。默认权限下，成员可以在当前类和同一包内的其他类中访问，但是对于不在同一包内的类来说是不可访问的。

  4. private：具有最低的访问权限，只能在当前类中访问。被private修饰的成员对于同一包内的其他类和子类来说都是不可访问的。

这些访问修饰符可以用于类的成员变量、方法、构造方法和内部类，用于控制这些成员的可见性和访问权限。通过合理使用访问修饰符，可以实现封装和信息隐藏，提高代码的安全性和可维护性。

下面是一个简单的Java类的示例：

public class Person {
    // 成员变量
    private String name;
    private int age;
    
    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 方法
    public void sayHello() {
        System.out.println("Hello, my name is " + name + " and I'm " + age + " years old.");
    }
}

在上面的示例中，Person类有两个成员变量（name和age），一个构造方法（用于初始化成员变量），以及一个sayHello方法（用于输出个人信息）。通过创建Person类的对象，我们可以使用该对象的方法和访问其成员变量。

Person person = new Person("John", 25);
person.sayHello();  // 输出：Hello, my name is John and I'm 25 years old.

类是Java中面向对象编程的核心概念之一，它提供了一种组织和封装代码的方式，使得代码更加可维护和可扩展。通过定义类和创建对象，我们可以利用面向对象的特性来构建复杂的程序。

二，输出

System.out.println() 是 Java 中用于在控制台输出信息的方法。它是 System.out 对象的一个方法，用于将指定的数据或文本打印到标准输出流（通常是控制台）。

System.out.println() 的主要特点包括：

  • 输出到控制台：System.out.println() 将输出信息显示在控制台上，可以用于调试程序、显示结果或与用户进行交互。

  • 自动换行：在输出信息后会自动换行，使得每个输出都位于独立的一行，方便阅读。

  • 支持多种数据类型：System.out.println() 可以接受各种数据类型的参数，包括整数、浮点数、字符、字符串等。

下面是一些示例：

int age = 25;
System.out.println("My age is " + age);  // 输出：My age is 25

double pi = 3.14159;
System.out.println("The value of pi is " + pi);  // 输出：The value of pi is 3.14159

char grade = 'A';
System.out.println("My grade is " + grade);  // 输出：My grade is A

String message = "Hello, World!";
System.out.println(message);  // 输出：Hello, World!

在上面的示例中，我们使用 System.out.println() 方法将不同类型的数据输出到控制台。可以通过字符串拼接（使用 + 操作符）将文本与变量的值组合起来输出。

需要注意的是，System.out.println() 是一个重载方法，它可以接受不同类型的参数。除了 println() 方法之外，System.out 对象还提供了其他输出方法，如 print()、printf() 等，它们的使用方式和功能有所不同。

总而言之，System.out.println() 是一个常用的方法，用于在 Java 中输出信息到控制台。它可以方便地显示程序的执行结果和调试信息，对于开发和调试 Java 程序非常有用。

三，Java 八大基础类型

以下是关于 Java 八大基本数据类型的代码教程示例：

  1. byte 类型示例：
byte num = 10;
byte result = num + 5;
System.out.println(result); // 输出：15
  1. short 类型示例：
short num = 1000;
short result = num - 500;
System.out.println(result); // 输出：500
  1. int 类型示例：
int num = 10000;
int result = num * 2;
System.out.println(result); // 输出：20000
  1. long 类型示例：
long num = 10000000000L;
long result = num / 2;
System.out.println(result); // 输出：5000000000
  1. float 类型示例：
float num = 3.14f;
float result = num + 1.5f;
System.out.println(result); // 输出：4.64
  1. double 类型示例：
double num = 3.14159;
double result = num * 2.0;
System.out.println(result); // 输出：6.28318
  1. char 类型示例：
char ch = 'A';
char result = (char)(ch + 1);
System.out.println(result); // 输出：B
  1. boolean 类型示例：
boolean flag = true;
if (flag) {
    System.out.println("条件成立");
} else {
    System.out.println("条件不成立");
}

输出：条件成立

以上示例代码展示了如何声明和使用 Java 八大基本数据类型。你可以根据需要调整变量的值和进行不同的运算操作。这些基本数据类型在实际编程中非常常用，可以用于存储和操作各种数据。

Java 语言中有八种基本数据类型，它们分别是：byte、short、int、long、float、double、char 和 boolean。下面对每种类型进行简要的介绍和讲解：

  1. byte：byte 数据类型是一个有符号的 8 位整数，取值范围为 -128 到 127。它通常用于表示小范围的整数值，比如文件的字节数据或图像的像素值。

  2. short：short 数据类型是一个有符号的 16 位整数，取值范围为 -32768 到 32767。它通常用于表示较小的整数值，比如计数器或数组的索引。

  3. int：int 数据类型是一个有符号的 32 位整数，取值范围为 -2147483648 到 2147483647。它是 Java 中最常用的整数类型，用于表示整数值。

  4. long：long 数据类型是一个有符号的 64 位整数，取值范围为 -9223372036854775808 到 9223372036854775807。当需要处理较大的整数值时，可以使用 long 类型。

  5. float：float 数据类型是一个单精度的 32 位浮点数，用于表示小数值。它可以表示大约 7 位有效数字，并且适用于需要节省内存的情况。

  6. double：double 数据类型是一个双精度的 64 位浮点数，用于表示更大范围和更高精度的小数值。它可以表示大约 15 位有效数字，是 Java 中常用的浮点数类型。

  7. char：char 数据类型是一个 16 位的 Unicode 字符，用于表示单个字符。可以用单引号括起来，比如 ‘A’ 或 ‘5’。它可以表示从 0 到 65535 之间的字符。

  8. boolean：boolean 数据类型只有两个取值：true 和 false。用于表示逻辑值，常用于条件判断和控制流程。

这些基本数据类型在 Java 中是直接支持的，它们具有固定的大小和范围。在使用这些类型时，需要注意类型的取值范围和精度，以确保数据的正确表示和计算。

除了基本数据类型，Java 还提供了包装类（Wrapper Classes），用于将基本数据类型转换为对象，以便在面向对象的环境中使用。例如，可以使用 Integer 类来表示 int 类型的整数，并调用其方法进行操作。

总而言之，了解和熟悉 Java 的八大基本数据类型是编写 Java 程序的基础。它们在变量声明、数值计算、方法参数传递等方面都起到重要作用，是进行数据处理和存储的基础。

四，Java 八大基础类型的封装类型

以下是 Java 八大基本数据类型的封装类型（包装类）的代码教程示例：

  1. Byte 类型示例：
Byte num = 10;
Byte result = (byte) (num + 5);
System.out.println(result); // 输出：15
  1. Short 类型示例：
Short num = 1000;
Short result = (short) (num - 500);
System.out.println(result); // 输出：500
  1. Integer 类型示例：
Integer num = 10000;
Integer result = num * 2;
System.out.println(result); // 输出：20000
  1. Long 类型示例：
Long num = 10000000000L;
Long result = num / 2;
System.out.println(result); // 输出：5000000000
  1. Float 类型示例：
Float num = 3.14f;
Float result = num + 1.5f;
System.out.println(result); // 输出：4.64
  1. Double 类型示例：
Double num = 3.14159;
Double result = num * 2.0;
System.out.println(result); // 输出：6.28318
  1. Character 类型示例：
Character ch = 'A';
Character result = (char) (ch + 1);
System.out.println(result); // 输出：B
  1. Boolean 类型示例：
Boolean flag = true;
if (flag) {
    System.out.println("条件成立");
} else {
    System.out.println("条件不成立");
}

输出：条件成立

以上示例代码展示了如何使用 Java 的包装类来处理基本数据类型的对象表示。封装类提供了许多方法和工具类来操作数据，例如类型转换、比较、运算等。你可以根据需要使用包装类来处理各种数据操作。

基础类型和封装类型的区别

基础类型（Primitive Types）和封装类型（Wrapper Types）在 Java 中有一些重要的区别：

  1. 数据类型：

    • 基础类型：基础类型是原始的数据类型，用于存储简单的数据值。Java 的基础类型包括 byte、short、int、long、float、double、char 和 boolean。
    • 封装类型：封装类型是基础类型的对象表示。Java 提供了对应于每个基础类型的封装类，例如 Byte、Short、Integer、Long、Float、Double、Character 和 Boolean。

  2. 可空性：

    • 基础类型：基础类型不能为 null。它们始终具有默认值，例如 0、0.0、false 等，不需要显式初始化。
    • 封装类型：封装类型是对象，可以为 null。如果未显式初始化封装类型的对象，则其默认值为 null。

  3. 内存占用：

    • 基础类型：基础类型在内存中占用固定大小的空间，不需要额外的内存开销。
    • 封装类型：封装类型是对象，占用的内存空间比基础类型大，并且需要额外的内存开销来存储对象的元数据。

  4. 自动装箱与拆箱：

    • 自动装箱：Java 提供了自动装箱机制，可以自动将基础类型转换为对应的封装类型。例如，将 int 赋值给 Integer 对象。
    • 自动拆箱：Java 也提供了自动拆箱机制，可以自动将封装类型转换为对应的基础类型。例如，将 Integer 对象赋值给 int。

  5. 方法调用：

    • 基础类型：基础类型作为方法参数传递时，会进行值传递。
    • 封装类型：封装类型作为方法参数传递时，会进行引用传递。

  6. 数组和集合：

    • 基础类型：基础类型可以直接用于数组和集合的存储和操作。
    • 封装类型：封装类型可以作为数组和集合的元素进行存储和操作。

封装类型的存在主要是为了提供更多的功能和灵活性，例如在集合框架中使用泛型、进行类型转换、处理 null 值等。在实际开发中，可以根据需求选择使用基础类型或封装类型。

五，Java 循环语法

在Java中，有几种常见的循环语法，包括for循环、while循环、do-while循环和增强for循环。下面是这些循环语法的教程示例：

  1. for循环语法：
for (初始化; 条件判断; 更新表达式) {
    // 循环体代码
}

示例：

for (int i = 0; i < 5; i++) {
    System.out.println(i);
}

输出：

0
1
2
3
4
  1. while循环语法：
while (条件判断) {
    // 循环体代码
    // 更新表达式
}

示例：

int i = 0;
while (i < 5) {
    System.out.println(i);
    i++;
}

输出：

0
1
2
3
4
  1. do-while循环语法：
do {
    // 循环体代码
    // 更新表达式
} while (条件判断);

示例：

int i = 0;
do {
    System.out.println(i);
    i++;
} while (i < 5);

输出：

0
1
2
3
4
  1. 增强for循环语法（用于遍历数组或集合）：
for (元素类型 变量名 : 数组或集合) {
    // 循环体代码
}

示例：

int[] numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
    System.out.println(num);
}

输出：

1
2
3
4
5

这些循环语法可以根据具体的需求选择使用。for循环适用于已知循环次数的情况；while循环适用于未知循环次数的情况；do-while循环适用于至少执行一次循环体的情况；增强for循环适用于遍历数组或集合的情况。根据具体的业务逻辑，选择合适的循环语法可以提高代码的可读性和效率。

循环是编程中一种重要的控制结构，它允许我们重复执行一段代码块，以达到特定的目的。循环的主要作用包括以下几个方面：

  1. 重复执行：循环允许我们多次执行相同或类似的操作，而不需要重复编写相同的代码。这在处理大量数据、遍历集合或数组、执行某种计算等情况下非常有用。

  2. 自动化处理：循环可以自动化处理重复的任务，减少手动操作的工作量。通过循环，我们可以在代码中定义一次性的操作，然后通过循环结构重复执行这些操作，从而实现自动化处理。

  3. 控制流程：循环可以控制程序的流程，使代码按照特定的逻辑顺序执行。通过循环中的条件判断和更新表达式，我们可以控制循环的终止条件和迭代过程，从而灵活地控制程序的执行路径。

  4. 数据处理：循环可以用于处理数据集合中的每个元素。通过循环遍历数组、集合或其他数据结构，我们可以对每个元素执行相同的操作，进行数据的筛选、转换、计算等操作。

  5. 代码简化：循环可以将重复的代码逻辑封装在一个循环体中，使代码更加简洁和可读。通过循环，我们可以避免重复编写相同的代码，提高代码的复用性和可维护性。

总之，循环是一种重要的编程工具，它可以帮助我们实现重复执行、自动化处理、控制流程和数据处理等功能。通过合理地使用循环，我们可以提高代码的效率、简化代码的结构，并实现各种复杂的业务逻辑和算法。

六，数组

在Java中，数组是一种用于存储多个相同类型元素的数据结构。下面是Java数组的基本语法和示例代码教程：

  1. 声明数组：
// 声明一个整型数组
int[] numbers;

// 声明一个字符串数组
String[] names;
  1. 创建数组：
// 创建一个包含5个整型元素的数组
int[] numbers = new int[5];

// 创建一个包含3个字符串元素的数组
String[] names = new String[3];
  1. 初始化数组：
// 初始化整型数组
int[] numbers = {1, 2, 3, 4, 5};

// 初始化字符串数组
String[] names = {"Alice", "Bob", "Charlie"};
  1. 访问数组元素：
// 访问数组中的第一个元素
int firstNumber = numbers[0];

// 修改数组中的第二个元素
numbers[1] = 10;

// 访问数组中的第三个元素
String thirdName = names[2];
  1. 数组长度：
// 获取整型数组的长度
int length = numbers.length;
  1. 遍历数组：
// 使用for循环遍历整型数组
for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}

// 使用增强for循环遍历字符串数组
for (String name : names) {
    System.out.println(name);
}
  1. 多维数组：
// 声明和创建一个二维整型数组
int[][] matrix = new int[3][3];

// 初始化二维整型数组
int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

// 访问二维数组中的元素
int value = matrix[1][2];

这些是Java数组的基本语法和示例代码。通过数组，我们可以方便地存储和操作一组相同类型的数据。使用合适的数组操作，我们可以实现各种数据处理和算法逻辑。记得在使用数组时，要注意数组下标的范围，避免越界访问。
数组在编程中有着广泛的应用，其主要作用包括以下几个方面：

  1. 存储多个相同类型的数据：数组可以用于存储一组相同类型的数据。通过数组，我们可以将多个相关的数据元素组织在一起，便于统一管理和操作。例如，可以使用数组存储学生的成绩、员工的工资、图书的价格等。

  2. 访问和操作数组元素：数组提供了通过索引访问和操作数组元素的方式。每个数组元素都有一个唯一的索引值，通过索引，我们可以快速定位到数组中的特定元素，并对其进行读取、修改、删除等操作。

  3. 集合数据的处理：数组可以用于处理集合型数据，如列表、矩阵、图像等。通过数组，我们可以方便地表示和操作这些集合数据，进行搜索、排序、过滤、计算等操作。

  4. 简化代码逻辑：使用数组可以简化代码逻辑，减少重复的代码。通过使用循环结构和数组，我们可以对数组中的元素进行批量处理，而不需要逐个编写相同的代码。

  5. 传递和返回多个值：数组可以作为方法的参数和返回值，用于传递和返回多个值。通过将多个相关的数据封装在数组中，我们可以方便地在方法之间传递这些值，并在方法中返回多个结果。

  6. 多维数据的表示：数组可以用于表示多维数据结构，如二维数组、三维数组等。通过多维数组，我们可以方便地表示和处理具有多个维度的数据，如矩阵、图像等。

为什么需要数组介绍？因为数组是一种常用的数据结构，掌握数组的基本概念和用法对于编程非常重要。了解数组的作用和用法可以帮助我们更好地理解和应用数组，从而提高代码的效率和可读性。数组是编程中的基础知识点，掌握好数组的使用可以为后续学习和开发打下坚实的基础。

七 选择器

当我们需要根据不同的条件执行不同的代码块时，可以使用选择器语法，如if语句和switch语句。下面我将为你提供一个Java选择器语法代码教程，并进行相应的讲解。

  1. if语句：
int num = 10;

if (num > 0) {
    System.out.println("Number is positive");
} else if (num < 0) {
    System.out.println("Number is negative");
} else {
    System.out.println("Number is zero");
}

在这个例子中，我们使用了if语句来根据num的值执行不同的代码块。首先，判断num > 0，如果条件为真，则执行第一个代码块中的语句，即打印"Number is positive"。如果条件为假，则继续判断num < 0，如果条件为真，则执行第二个代码块中的语句，即打印"Number is negative"。如果前两个条件都为假，则执行else代码块中的语句，即打印"Number is zero"。

  1. switch语句：
int dayOfWeek = 2;
String dayName;

switch (dayOfWeek) {
    case 1:
        dayName = "Monday";
        break;
    case 2:
        dayName = "Tuesday";
        break;
    case 3:
        dayName = "Wednesday";
        break;
    case 4:
        dayName = "Thursday";
        break;
    case 5:
        dayName = "Friday";
        break;
    default:
        dayName = "Invalid day";
        break;
}

System.out.println("Day of the week: " + dayName);

在这个例子中，我们使用了switch语句来根据dayOfWeek的值执行不同的代码块。dayOfWeek的值被依次与每个case中的值进行比较，如果匹配成功，则执行相应的代码块。在每个case的代码块末尾，使用break关键字来跳出switch语句。如果没有匹配的case，则执行default代码块中的语句。在这个例子中，dayOfWeek的值为2，所以与case 2匹配，执行相应的代码块，将dayName设置为"Tuesday"，最后打印"Day of the week: Tuesday"。

选择器语法在根据不同的条件执行不同的代码块时非常有用。if语句适用于需要进行复杂条件判断的情况，而switch语句适用于需要根据具体值进行选择的情况。记得根据实际需求选择合适的选择器语法，并注意选择器语法的语法规则和代码块的书写方式，以确保正确的逻辑和语法。

八，判断（运算符）

在Java中，我们可以使用判断语法来进行条件判断，根据条件的真假执行不同的代码块。常用的判断语法包括比较运算符、逻辑运算符和三元运算符。下面是一个Java判断语法代码教程，并进行相应的讲解。

  1. 比较运算符：
    比较运算符用于比较两个值的大小或者是否相等，返回一个布尔值（true或false）。
int num1 = 10;
int num2 = 5;

boolean result1 = num1 > num2;      // 大于运算符
boolean result2 = num1 < num2;      // 小于运算符
boolean result3 = num1 == num2;     // 等于运算符
boolean result4 = num1 >= num2;     // 大于等于运算符
boolean result5 = num1 <= num2;     // 小于等于运算符
boolean result6 = num1 != num2;     // 不等于运算符

System.out.println(result1);       // 输出：true
System.out.println(result2);       // 输出：false
System.out.println(result3);       // 输出：false
System.out.println(result4);       // 输出：true
System.out.println(result5);       // 输出：false
System.out.println(result6);       // 输出：true

在上述代码中，我们使用了比较运算符（大于、小于、等于、大于等于、小于等于、不等于）来比较num1和num2的值，并将结果存储在相应的布尔变量中。然后，使用System.out.println()语句打印结果。

  1. 逻辑运算符：
    逻辑运算符用于组合多个条件，返回一个布尔值（true或false）。
int age = 25;
boolean isStudent = true;

boolean result1 = age > 18 && isStudent;    // 与运算符
boolean result2 = age > 60 || isStudent;    // 或运算符
boolean result3 = !isStudent;               // 非运算符

System.out.println(result1);       // 输出：true
System.out.println(result2);       // 输出：true
System.out.println(result3);       // 输出：false

在上述代码中，我们使用了逻辑运算符（与、或、非）来组合条件。result1为true，因为年龄大于18并且是学生；result2为true，因为年龄大于60或者是学生；result3为false，因为isStudent为true，取非后为false。

  1. 三元运算符：
    三元运算符是一种简洁的条件语句，用于根据条件选择不同的值。
int num = 10;
String result = (num > 0) ? "Positive" : "Negative";

System.out.println(result);       // 输出：Positive

在上述代码中，我们使用了三元运算符来根据条件判断num的正负，并将结果赋值给result变量。如果num大于0，则返回"Positive"；否则返回"Negative"。

判断语法在编程中非常常用，可以根据条件的真假执行不同的代码块或者返回不同的值。记得根据实际需求选择合适的判断语法，并理解运算符的含义和使用方式，以确保正确的逻辑和语法。

文章来源:https://blog.csdn.net/qq_49841284/article/details/134981728
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。