JAVAEE基础总结

最新推荐文章于 2024-05-02 10:18:53 发布

程序员沙蛙

最新推荐文章于 2024-05-02 10:18:53 发布

阅读量1.4k

点赞数 28

分类专栏： JAVAEE全套教学文章标签： java-ee java 开发语言

本文链接：https://blog.csdn.net/qq_46189388/article/details/134664851

版权

JAVAEE全套教学专栏收录该内容

6 篇文章 0 订阅

订阅专栏

一、基础介绍

1.1基础语法介绍

Java基础语法包括以下几个方面：

Java标识符：Java标识符是用来命名类、变量、方法等程序元素的名称，它们必须以字母、美元符或下划线开头，后面可以跟任意数量的字母、数字、美元符或下划线。Java标识符是大小写敏感的，不能使用关键字或保留字作为标识符。例如，HelloWorld、$salary、_value都是合法的标识符，而123abc、-salary、if都是非法的标识符。
Java数据类型：Java数据类型分为两种，基本数据类型和引用数据类型。基本数据类型包括八种，分别是：byte（字节型）、short（短整型）、int（整型）、long（长整型）、float（单精度浮点型）、double（双精度浮点型）、char（字符型）和boolean（布尔型）。引用数据类型包括类、接口、数组和枚举等，它们都是指向对象的引用，而不是对象本身。例如，int a = 10;表示定义了一个名为a的整型变量，并赋值为10；String s = “Hello”;表示定义了一个名为s的字符串变量，并赋值为"Hello"。
Java变量：Java变量是用来存储数据的内存空间，它有三种类型：局部变量、成员变量和类变量。局部变量是定义在方法或代码块中的变量，它们只在方法或代码块中有效，出了作用域就会被销毁。成员变量是定义在类中但在方法外的变量，它们属于类的实例对象，每个对象都有自己的一份成员变量。类变量是用static修饰的变量，它们属于类本身，不依赖于对象，所有对象共享一份类变量。例如，下面的代码中，x和y是局部变量，name和age是成员变量，count是类变量。

public class Person {
    // 类变量
    public static int count = 0;
    // 成员变量
    public String name;
    public int age;

public Person(String name, int age) {
    // 局部变量
    int x = 10;
    int y = 20;
    this.name = name;
    this.age = age;
    count++;
}

}

Java运算符：Java运算符是用来对一个或多个操作数进行操作的符号，它们可以分为以下几类：算术运算符（+ - * / % ++ --）、赋值运算符（= += -= *= /= %=）、比较运算符（== != > < >= <=）、逻辑运算符（&& || !）、位运算符（& | ^ ~ << >> >>>）、三元运算符（? :）等。例如，下面的代码中使用了算术运算符、赋值运算符和比较运算符。

int a = 10; // 赋值运算
int b = 20; // 赋值运算
int c = a + b; // 算术运算
a++; // 算术运算
b--; // 算术运算
boolean d = a > b; // 比较运算

Java控制语句：Java控制语句是用来控制程序流程的语句，它们可以分为以下几类：选择语句（if else switch case）、循环语句（for while do while）、跳转语句（break continue return）。例如，下面的代码中使用了选择语句和循环语句。

int score = 80; // 定义一个分数变量
// 选择语句
if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 80) {
    System.out.println("良好");
} else if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}
// 循环语句
for (int i = 1; i <= 10; i++) {
    System.out.println(i);
}

Java方法：Java方法是用来实现特定功能的一段代码，它有四个部分：修饰符、返回值类型、方法名和参数列表。修饰符是用来限定方法的访问范围和特性的，如public、private、static等。返回值类型是指方法执行后返回的数据类型，如果没有返回值，则用void表示。方法名是用来调用方法的标识符，它应该遵循标识符的命名规则和规范。参数列表是用来传递给方法的数据，它包括参数类型和参数名，多个参数之间用逗号隔开。例如，下面的代码中定义了一个求两个数最大值的方法。

// 定义一个方法
public static int max(int a, int b) {
    // 判断a和b的大小，返回较大的值
    if (a > b) {
        return a;
    } else {
        return b;
    }
}
// 调用方法
int x = 10;
int y = 20;
int z = max(x, y); // z的值为20

2.2 对象和类介绍

Java对象和类是Java语言的核心概念，它们实现了面向对象编程的思想。面向对象编程是一种编程范式，它把程序看作是由一系列相互作用的对象组成的，每个对象都有自己的属性和行为，可以封装数据和操作，提高程序的可读性和可维护性。

对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。在Java中，我们可以使用new关键字来创建一个对象，并通过点号(.)来访问对象的属性和方法。例如：

// 创建一个Dog类
class Dog {
    // 定义属性
    String color;
    String name;
    String breed;
    // 定义方法
    void wagTail() {
        System.out.println(name + " is wagging its tail.");
    }
    void bark() {
        System.out.println(name + " is barking.");
    }
    void eat() {
        System.out.println(name + " is eating.");
    }
}

// 创建一个Dog对象
Dog myDog = new Dog();
// 给对象赋值
myDog.color = "black";
myDog.name = "Tommy";
myDog.breed = "Labrador";
// 调用对象的方法
myDog.wagTail();
myDog.bark();
myDog.eat();

类：类是一个模板，它描述一类对象的行为和状态。在Java中，我们可以使用class关键字来定义一个类，并在类中定义属性和方法。例如：

// 定义一个Person类
class Person {
    // 定义属性
    String name;
    int age;
    // 定义方法
    void introduce() {
        System.out.println("Hello, my name is " + name + ", and I am " + age + " years old.");
    }
}

类和对象的关系：类和对象是一对多的关系，即一个类可以创建多个对象，但一个对象只属于一个类。类是对象的抽象，对象是类的具体化。类定义了对象的共同特征和行为，而对象则体现了类的个性化和多样化。例如：

// 创建一个Person类
class Person {
    // 定义属性
    String name;
    int age;
    // 定义方法
    void introduce() {
        System.out.println("Hello, my name is " + name + ", and I am " + age + " years old.");
    }
}

// 创建两个Person对象
Person p1 = new Person();
Person p2 = new Person();
// 给对象赋值
p1.name = "Alice";
p1.age = 20;
p2.name = "Bob";
p2.age = 25;
// 调用对象的方法
p1.introduce();
p2.introduce();

二、数据类型

2.1基本数据类型

Java基本数据类型是Java语言中最基本的数据类型，它们直接存储在内存中，不需要通过对象来访问。Java基本数据类型有八种，分为四类：

整型：整型数据类型用来表示整数，有四种不同的长度和范围，分别是byte（字节型）、short（短整型）、int（整型）和long（长整型）。它们的取值范围和默认值如下表所示：

类型	位数	最小值	最大值	默认值
byte	8	-128	127	0
short	16	-32768	32767	0
int	32	-2^31	2^31-1	0
long	64	-2^63	2^63-1	0L

例如，我们可以用以下代码来定义和使用整型变量：

// 定义一个byte类型的变量
byte b = 10;
// 定义一个short类型的变量
short s = -100;
// 定义一个int类型的变量
int i = 100000;
// 定义一个long类型的变量
long l = 1000000000L;
// 打印变量的值
System.out.println("b = " + b);
System.out.println("s = " + s);
System.out.println("i = " + i);
System.out.println("l = " + l);

浮点型：浮点型数据类型用来表示带小数点的数值，有两种不同的精度和范围，分别是float（单精度浮点型）和double（双精度浮点型）。它们的取值范围和默认值如下表所示：

类型	位数	最小值	最大值	默认值
float	32	-3.4E38	+3.4E38	0.0f
double	64	-1.7E308	+1.7E308	0.0d

例如，我们可以用以下代码来定义和使用浮点型变量：

// 定义一个float类型的变量
float f = 3.14f;
// 定义一个double类型的变量
double d = -6.28;
// 打印变量的值
System.out.println("f = " + f);
System.out.println("d = " + d);

字符型：字符型数据类型用来表示单个字符，只有一种长度和范围，即char（字符型）。它占用16位，采用Unicode编码，可以表示任何字符。它的取值范围和默认值如下表所示：

类型	位数	最小值	最大值	默认值
char	16	\u0000	\uffff	\u0000

例如，我们可以用以下代码来定义和使用字符型变量：

// 定义一个char类型的变量
char c = 'A';
// 打印变量的值
System.out.println("c = " + c);

布尔型：布尔型数据类型用来表示真或假的逻辑值，只有两个取值，即true（真）和false（假）。它没有固定的位数，根据不同的虚拟机实现可能占用1位或4位或8位。它的默认值是false。
例如，我们可以用以下代码来定义和使用布尔型变量：

// 定义一个boolean类型的变量
boolean b = true;
// 打印变量的值
System.out.println("b = " + b);

2.2变量类型

Java变量类型是指Java语言中定义和使用变量的规则和方式，它们决定了变量的名称、数据类型、作用域和生命周期等特征。Java变量类型可以分为以下几种：

基本数据类型：基本数据类型是Java语言中最基本的数据类型，它们直接存储在内存中，不需要通过对象来访问。Java基本数据类型有八种，分为四类：整型、浮点型、字符型和布尔型。它们的取值范围和默认值如下表所示：

类型	位数	最小值	最大值	默认值
byte	8	-128	127	0
short	16	-32768	32767	0
int	32	-2,147,483,648	2,147,483,647	0
long	64	-9,223,372,036,854,775,808	9,223,372,036,854,775,807	0L
float	32	-3.4E38	+3.4E38	0.0f
double	64	-1.7E308	+1.7E308	0.0d
char	16	\u0000	\uffff	\u0000
boolean	-	false	true	false

例如，我们可以用以下代码来定义和使用基本数据类型的变量：

// 定义一个byte类型的变量
byte b = 10;
// 定义一个short类型的变量
short s = -100;
// 定义一个int类型的变量
int i = 100000;
// 定义一个long类型的变量
long l = 1000000000L;
// 定义一个float类型的变量
float f = 3.14f;
// 定义一个double类型的变量
double d = -6.28;
// 定义一个char类型的变量
char c = 'A';
// 定义一个boolean类型的变量
boolean b = true;
// 打印变量的值
System.out.println("b = " + b);
System.out.println("s = " + s);
System.out.println("i = " + i);
System.out.println("l = " + l);
System.out.println("f = " + f);
System.out.println("d = " + d);
System.out.println("c = " + c);
System.out.println("b = " + b);

引用数据类型：引用数据类型是指那些通过引用（即内存地址）来存储和访问数据的数据类型，它们包括类、接口、数组和枚举等。引用数据类型的变量实际上是指向对象的引用，而不是对象本身。引用数据类型的默认值都是null，表示没有指向任何对象。
例如，我们可以用以下代码来定义和使用引用数据类型的变量：

// 定义一个String类的变量
String s = "Hello";
// 定义一个数组类型的变量
int[] arr = {1,2,3};
// 定义一个枚举类型的变量
enum Color {RED, GREEN, BLUE};
Color c = Color.RED;
// 打印变量的值
System.out.println("s = " + s);
System.out.println("arr[0] = " + arr[0]);
System.out.println("c = " + c);

局部变量：局部变量是定义在方法、构造方法或语句块中的变量，它们只在方法、构造方法或语句块中有效，出了作用域就会被销毁。局部变量必须在使用前声明，并且不能被访问修饰符修饰。局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。
例如，我们可以用以下代码来定义和使用局部变量：

public class Test {
    public static void main(String[] args) {
        // 定义一个局部变量
        int x = 10;
        // 打印变量的值
        System.out.println("x = " + x);
    }
}

成员变量：成员变量是定义在类中但在方法外的变量，它们属于类的实例对象，每个对象都有自己的一份成员变量。成员变量可以被访问修饰符修饰，如public、private、protected等。成员变量有默认值，根据数据类型的不同而不同，如int类型的默认值为0，boolean类型的默认值为false，引用类型的默认值为null等。
例如，我们可以用以下代码来定义和使用成员变量：

public class Person {
    // 定义一个成员变量
    public String name;
    public Person(String name) {
    // 给成员变量赋值
    this.name = name;
}

public void introduce() {
    // 使用成员变量
    System.out.println("Hello, my name is " + name);
}

public static void main(String[] args) {
    // 创建一个Person对象
    Person p = new Person("Alice");
    // 调用对象的方法
    p.introduce();
}

}

类变量：类变量是定义在类中但在方法外的变量，并且使用static关键字修饰，它们属于类本身，不依赖于对象，所有对象共享一份类变量。类变量可以被访问修饰符修饰，如public、private、protected等。类变量有默认值，根据数据类型的不同而不同，如int类型的默认值为0，boolean类型的默认值为false，引用类型的默认值为null等。
例如，我们可以用以下代码来定义和使用类变量：

public class Counter {
    // 定义一个类变量
    public static int count = 0;
    public Counter() {
    // 每创建一个对象，类变量加一
    count++;
}

public static void main(String[] args) {
    // 创建三个Counter对象
    Counter c1 = new Counter();
    Counter c2 = new Counter();
    Counter c3 = new Counter();
    // 打印类变量的值
    System.out.println("count = " + count);
}

}

2.3类型转换

Java类型转换是指将一种数据类型的值转换为另一种数据类型的值的过程，它是Java语言中常见的操作之一。Java类型转换可以分为两种：

隐式类型转换（自动）：这种类型转换是由Java编译器自动完成的，不需要程序员手动指定。它通常发生在从小类型到大类型的转换中，即较低的数据类型（占用内存空间较小）可以自动转换为较高的数据类型（占用内存空间较大）。这样做不会导致数据丢失或精度降低。例如，byte可以自动转换为short，short可以自动转换为int，int可以自动转换为long，long可以自动转换为float，float可以自动转换为double等。下面是一个隐式类型转换的例子：

// 定义一个byte类型的变量
byte b = 10;
// 定义一个double类型的变量
double d = b; // byte自动转换为double
// 打印变量的值
System.out.println("b = " + b); // 输出 b = 10
System.out.println("d = " + d); // 输出 d = 10.0

强制类型转换（手动）：这种类型转换是由程序员手动指定的，需要使用强制转换符（括号）来实现。它通常发生在从大类型到小类型的转换中，即较高的数据类型（占用内存空间较大）需要强制转换为较低的数据类型（占用内存空间较小）。这样做可能会导致数据丢失或精度降低。例如，double需要强制转换为float，float需要强制转换为long，long需要强制转换为int，int需要强制转换为short，short需要强制转换为byte等。下面是一个强制类型转换的例子：

// 定义一个double类型的变量
double d = 10.99;
// 定义一个int类型的变量
int i = (int) d; // double强制转换为int
// 打印变量的值
System.out.println("d = " + d); // 输出 d = 10.99
System.out.println("i = " + i); // 输出 i = 10

除了基本数据类型之间的类型转换外，还有一些其他的类型转换，例如字符串和数字之间的互相转换，数组和集合之间的互相转换等。这些类型转换通常需要使用一些特定的类或方法来实现，例如Integer.parseInt()、String.valueOf()、Arrays.asList()等。下面是一些其他类型转换的例子：

// 将字符串转换为整数
String s = "100";
int i = Integer.parseInt(s); // 使用Integer类的parseInt()方法

// 将整数转换为字符串
int i = 100;
String s = String.valueOf(i); // 使用String类的valueOf()方法

// 将数组转换为列表
int[] arr = {1,2,3};
List<Integer> list = Arrays.asList(arr); // 使用Arrays类的asList()方法

// 将列表转换为数组
List<Integer> list = Arrays.asList(1,2,3);
Integer[] arr = list.toArray(new Integer[list.size()]); // 使用List接口的toArray()方法

2.4运算符

Java运算符是用来对一个或多个操作数进行操作的符号，它们可以实现数学、逻辑、位、赋值、条件等功能。Java运算符可以分为以下几类：

算术运算符：算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。有加法（+）、减法（-）、乘法（*）、除法（/）、取余（%）、自增（++）和自减（–）等。例如：
*

int a = 10; // 定义一个整型变量a，并赋值为10
int b = 20; // 定义一个整型变量b，并赋值为20
int c = a + b; // 定义一个整型变量c，并赋值为a和b的和，即30
int d = a - b; // 定义一个整型变量d，并赋值为a和b的差，即-10
int e = a * b; // 定义一个整型变量e，并赋值为a和b的积，即200
int f = b / a; // 定义一个整型变量f，并赋值为b和a的商，即2
int g = b % a; // 定义一个整型变量g，并赋值为b和a的余数，即0
a++; // 将a自增1，即a变为11
b--; // 将b自减1，即b变为19

关系运算符：关系运算符用来比较两个操作数的大小或相等性，它们的结果是布尔类型，即true或false。有等于（==）、不等于（!=）、大于（>）、小于（<）、大于等于（>=）和小于等于（<=）等。例如：

int a = 10; // 定义一个整型变量a，并赋值为10
int b = 20; // 定义一个整型变量b，并赋值为20
boolean c = a == b; // 定义一个布尔变量c，并赋值为a和b是否相等，即false
boolean d = a != b; // 定义一个布尔变量d，并赋值为a和b是否不等，即true
boolean e = a > b; // 定义一个布尔变量e，并赋值为a是否大于b，即false
boolean f = a < b; // 定义一个布尔变量f，并赋值为a是否小于b，即true
boolean g = a >= b; // 定义一个布尔变量g，并赋值为a是否大于等于b，即false
boolean h = a <= b; // 定义一个布尔变量h，并赋值为a是否小于等于b，即true

逻辑运算符：逻辑运算符用来对两个或一个布尔类型的操作数进行逻辑运算，它们的结果也是布尔类型。有逻辑与（&&）、逻辑或（||）、逻辑非（!）等。例如：

boolean a = true; // 定义一个布尔变量a，并赋值为true
boolean b = false; // 定义一个布尔变量b，并赋值为false
boolean c = a && b; // 定义一个布尔变量c，并赋值为a和b的逻辑与，即false
boolean d = a || b; // 定义一个布尔变量d，并赋值为a和b的逻辑或，即true
boolean e = !a; // 定义一个布尔变量e，并赋值为a的逻辑非，即false

位运算符：位运算符用来对两个或一个整数类型的操作数按位进行运算，它们的结果也是整数类型。有按位与（&）、按位或（|）、按位异或（^）、按位取反（~）、左移（<<）、右移（>>）和无符号右移（>>>）等。例如：

int a = 10; // 定义一个整型变量a，并赋值为10，其二进制表示为00001010
int b = 20; // 定义一个整型变量b，并赋值为20，其二进制表示为00010100
int c = a & b; // 定义一个整型变量c，并赋值为a和b的按位与，即00000000，即0
int d = a | b; // 定义一个整型变量d，并赋值为a和b的按位或，即00011110，即30
int e = a ^ b; // 定义一个整型变量e，并赋值为a和b的按位异或，即00011110，即30
int f = ~a; // 定义一个整型变量f，并赋值为a的按位取反，即11110101，即-11
int g = a << 2; // 定义一个整型变量g，并赋值为a左移2位，即00101000，即40
int h = a >> 2; // 定义一个整型变量h，并赋值为a右移2位，即00000010，即2
int i = a >>> 2; // 定义一个整型变量i，并赋值为a无符号右移2位，即00000010，即2

赋值运算符：赋值运算符用来将右操作数的值赋给左操作数。有简单赋值（=）、加法赋值（+=）、减法赋值（-=）、乘法赋值（*=）、除法赋值（/=）、取余赋值（%=）、左移赋值（<<=）、右移赋值（>>=）、无符号右移赋值（>>>=）、按位与赋值（&=）、按位或赋值（|=）和按位异或赋值（^=）等。例如：

int a = 10; // 定义一个整型变量a，并使用简单赋值将10赋给a
a += 5; // 使用加法赋值将a加5并重新赋给a，相当于a = a + 5，即15
a -= 3; // 使用减法赋值将a减3并重新赋给a，相当于a = a - 3，即12
a *= 2; // 使用乘法赋值将a乘2并重新赋给a，相当于a = a * 2，即24
a /= 4; // 使用除法赋值将a除4并重新赋给a，相当于a = a / 4，即6
a %= 5; // 使用取余赋值将a对5取余并重新赋给a，相当于a = a % 5，即1

条件运算符：条件运算符也叫三元运算符，它是Java中唯一需要三个操作数的运算符。它的形式是：条件表达式 ? 表达式1 : 表达式2。如果条件表达式为true，则返回表达式1的值；如果条件表达式为false，则返回表达式2的值。例如：

int a = 10; // 定义一个整型变量a，并赋值为10
int b = 20; // 定义一个整型变量b，并赋值为20
int c = a > b ? a : b; // 定义一个整型变量c，并使用条件运算符判断a和b的最大值并返回给c，即20

三、函数

3.1函数的概念

Java函数是一种将一组语句封装起来的代码块，它可以实现某个特定的功能或任务，并且可以被多次调用。Java函数也称为方法，它们是Java面向对象编程的重要组成部分，通常定义在类中，并且可以被类的对象或类本身调用。

Java函数的概念包括以下几个方面：

函数的声明：函数的声明是指定义函数的名称、参数、返回值和修饰符等信息，它告诉编译器和调用者这个函数的基本特征。函数的声明的一般格式如下：

修饰符 返回值类型 函数名(参数列表) {
    // 函数体
}

其中，修饰符是指限定函数的访问范围和特性的关键字，如public、private、static等；返回值类型是指函数执行后返回的数据类型，如果没有返回值，则用void表示；函数名是指用来调用函数的标识符，它应该遵循标识符的命名规则和规范；参数列表是指传递给函数的数据，它包括参数类型和参数名，多个参数之间用逗号隔开；函数体是指实现函数功能的代码块，它可以包含变量声明、语句、控制结构、调用其他函数等。

例如，下面是一个声明一个求两个数最大值的函数的例子：

// 声明一个求两个数最大值的函数
public static int max(int a, int b) {
    // 函数体
    if (a > b) {
        return a;
    } else {
        return b;
    }
}

函数的调用：函数的调用是指在程序中使用函数名和实际参数来执行函数功能的过程，它可以在主函数、其他函数或语句块中进行。函数的调用的一般格式如下：

// 调用一个求两个数最大值的函数
int x = 10;
int y = 20;
int z = max(x, y); // 调用max函数，并将x和y作为实际参数传递给a和b，将返回值赋给z

其中，实际参数是指在调用时传递给函数形式参数的具体值，它们必须与形式参数类型和个数相匹配；返回值是指在调用后从函数中返回给调用者的数据，它必须与返回值类型相符。

3.2函数的作用

函数的作用：函数的作用是指使用函数可以带来哪些好处，它主要有以下几点：

减少重复代码：通过将重复出现的代码封装成一个函数，可以避免在不同地方写相同或相似的代码，提高代码的复用性。
提高程序可读性：通过将一些复杂或繁琐的代码封装成一个有意义的函数名，可以使程序更容易理解和维护。
提高程序灵活性：通过将一些可能会变化或需要扩展的代码封装成一个可配置或可重载的函数，可以使程序更容易适应不同的需求或场景。
实现模块化编程：通过将程序分解成多个相互协作或独立运行的函数模块，可以使程序更容易设计、开发、测试和调试。

四、返回值与返回值类型

4.1 返回值与返回值类型

返回值和返回值类型是Java函数中的重要概念，它们决定了函数执行后返回给调用者的数据的类型和值。

返回值：返回值是指函数执行后从函数中返回给调用者的数据，它可以是一个基本数据类型的值，如int、float、double等，也可以是一个引用数据类型的对象，如String、数组、类等。返回值可以用于赋值给变量，或作为参数传递给其他函数，或作为表达式的一部分计算，或直接输出等。例如：

// 定义一个求两个数最大值的函数
public static int max(int a, int b) {
    // 判断a和b的大小，返回较大的值
    if (a > b) {
        return a;
    } else {
        return b;
    }
}

// 调用函数，并使用返回值
int x = 10;
int y = 20;
int z = max(x, y); // 调用max函数，并将x和y作为实际参数传递给a和b，将返回值赋给z
System.out.println("The greater number among x and y is: " + z); // 输出 z = 20

返回值类型：返回值类型是指函数声明时指定的函数执行后返回的数据的类型，它必须与实际返回的数据类型相匹配，否则会导致编译错误或运行时异常。如果函数没有返回任何数据，则使用void作为返回值类型。例如：

// 定义一个求两个数最大值的函数
public static int max(int a, int b) { // 返回值类型为int
    // 判断a和b的大小，返回较大的值
    if (a > b) {
        return a; // 返回一个int类型的值
    } else {
        return b; // 返回一个int类型的值
    }
}

// 定义一个打印Hello World的函数
public static void printHello() { // 返回值类型为void
    // 打印Hello World
    System.out.println("Hello World");
    // 没有return语句
}

4.2 return关键字

return关键字是Java语言中的一个保留字，它用来表示函数执行结束，并返回一个值给调用者。return关键字的概念包括以下几个方面：

return关键字的作用：return关键字的作用是结束函数的执行，并将函数的返回值传递给调用者。当函数遇到return关键字时，它会立即退出，不再执行后面的语句。如果函数没有返回值，则使用void作为返回值类型，并且不需要写return语句，或者只写return;表示结束函数。
return关键字的语法：return关键字的语法格式如下：

return 表达式;

其中，表达式是指要返回的值，它可以是一个常量、变量、运算符或方法调用等，它必须与函数声明时指定的返回值类型相匹配，否则会导致编译错误或运行时异常。例如：

// 定义一个求两个数最大值的函数
public static int max(int a, int b) {
    // 判断a和b的大小，返回较大的值
    if (a > b) {
        return a; // 返回a
    } else {
        return b; // 返回b
    }
}

// 定义一个打印Hello World的函数
public static void printHello() {
    // 打印Hello World
    System.out.println("Hello World");
    // 没有return语句，或者只写return;
}

return关键字的注意事项：使用return关键字时，需要注意以下几点：

return关键字只能用在函数中，不能用在其他地方。
return关键字后面不能有其他语句，否则会导致编译错误或永远不会被执行。
return关键字可以有多个，但是只能有一个被执行，一旦执行了一个return语句，其他的就不会被执行。
return关键字可以和if-else、switch-case等控制语句结合使用，以实现不同条件下返回不同的值。
return关键字可以在循环中使用，以实现提前结束循环并返回值。

五、循环结构

5.1 选择结构语句

选择结构语句是Java语言中的一种程序控制结构，它用来根据条件的真假来选择执行不同的代码分支。选择结构语句可以实现程序的分支和跳转，提高程序的灵活性和逻辑性。

Java语言中有三种选择结构语句，分别是：

if语句：if语句是一种单选择结构语句，它用来判断一个条件是否为真，如果为真，则执行一个代码块，如果为假，则跳过该代码块。if语句的一般格式如下：

if (条件) {
    // 代码块
}

例如，下面是一个判断一个数是否为正数的if语句：

int num = 10; // 定义一个整型变量num，并赋值为10
if (num > 0) { // 判断num是否大于0
    System.out.println("num is a positive number."); // 如果为真，则输出num是正数
}

if…else语句：if…else语句是一种双选择结构语句，它用来判断一个条件是否为真，如果为真，则执行一个代码块，如果为假，则执行另一个代码块。if…else语句的一般格式如下：

if (条件) {
    // 代码块1
} else {
    // 代码块2
}

例如，下面是一个判断一个数是否为偶数的if…else语句：

int num = 10; // 定义一个整型变量num，并赋值为10
if (num % 2 == 0) { // 判断num是否能被2整除
    System.out.println("num is an even number."); // 如果为真，则输出num是偶数
} else {
    System.out.println("num is an odd number."); // 如果为假，则输出num是奇数
}

switch语句：switch语句是一种多选择结构语句，它用来根据一个表达式的值来匹配不同的case分支，并执行相应的代码块。switch语句的一般格式如下：

switch (表达式) {
    case 值1:
        // 代码块1
        break;
    case 值2:
        // 代码块2
        break;
    ...
    default:
        // 默认代码块
        break;
}

其中，表达式可以是byte、short、char、int、String或枚举类型的值；case分支用来匹配表达式的值，并执行相应的代码块；break语句用来结束switch语句；default分支用来处理没有匹配到任何case分支的情况。

例如，下面是一个根据月份输出季节的switch语句：

int month = 3; // 定义一个整型变量month，并赋值为3
switch (month) { // 根据month的值匹配case分支
    case 12: 
    case 1: 
    case 2: 
        System.out.println("Winter"); // 如果month是12、1或2，则输出冬季
        break;
    case 3: 
    case 4: 
    case 5: 
        System.out.println("Spring"); // 如果month是3、4或5，则输出春季
        break;
    case 6: 
    case 7: 
    case 8: 
        System.out.println("Summer"); // 如果month是6、7或8，则输出夏季
        break;
    case 9: 
    case 10: 
    case 11: 
        System.out.println("Autumn"); // 如果month是9、10或11，则输出秋季
        break;
    default: 
        System.out.println("Invalid month"); // 如果month不在1到12之间，则输出无效月份
        break;
}

5.2 循环结构语句

循环结构语句是Java语言中的一种程序控制结构，它用来重复执行一段代码，直到满足某个条件或达到某个目标。循环结构语句可以实现程序的循环和迭代，提高程序的效率和灵活性。

Java语言中有三种循环结构语句，分别是：

for循环：for循环是一种计数循环，它用来在已知循环次数的情况下重复执行一段代码。for循环由四个部分组成：初始化、条件、增量和语句。初始化部分用来定义和赋值循环变量；条件部分用来判断循环是否继续；增量部分用来更新循环变量的值；语句部分用来执行循环体中的代码。for循环的一般格式如下：

for (初始化; 条件; 增量) {
    // 语句
}

例如，下面是一个使用for循环打印1到10的例子：

// 使用for循环打印1到10
for (int i = 1; i <= 10; i++) { // 定义一个整型变量i，并从1开始递增到10
    System.out.println(i); // 打印i的值
}

while循环：while循环是一种条件循环，它用来在不确定循环次数的情况下重复执行一段代码。while循环由两个部分组成：条件和语句。条件部分用来判断循环是否继续；语句部分用来执行循环体中的代码。while循环先判断条件，再执行语句，因此可能出现一次都不执行的情况。while循环的一般格式如下：

while (条件) {
    // 语句
}

例如，下面是一个使用while循环计算阶乘的例子：

// 使用while循环计算阶乘
int n = 5; // 定义一个整型变量n，并赋值为5
int fact = 1; // 定义一个整型变量fact，并赋值为1
int i = 1; // 定义一个整型变量i，并赋值为1
while (i <= n) { // 当i小于等于n时，继续循环
    fact = fact * i; // 更新fact的值为fact乘以i
    i++; // 将i加1
}
System.out.println("The factorial of " + n + " is " + fact); // 打印n的阶乘

do…while循环：do…while循环是一种后测试循环，它用来在不确定循环次数的情况下重复执行一段代码。do…while循环由两个部分组成：语句和条件。语句部分用来执行循环体中的代码；条件部分用来判断循环是否继续。do…while循环先执行语句，再判断条件，因此至少会执行一次。do…while循环的一般格式如下：

do {
    // 语句
} while (条件);

例如，下面是一个使用do…while循环实现猜数字游戏的例子：

// 使用do...while循环实现猜数字游戏
int secret = 8; // 定义一个整型变量secret，并赋值为8，表示要猜的数字
int guess; // 定义一个整型变量guess，表示用户输入的猜测
Scanner sc = new Scanner(System.in); // 创建一个Scanner对象，用来接收用户输入
do {
    System.out.println("Please enter a number between 1 and 10: "); // 提示用户输入一个数字
    guess = sc.nextInt(); // 接收用户输入的数字，并赋值给guess
    if (guess < secret) { // 如果guess小于secret，提示猜小了
        System.out.println("Too low!");
    } else if (guess > secret) { // 如果guess大于secret，提示猜大了
        System.out.println("Too high!");
    } else { // 如果guess等于secret，提示猜对了
        System.out.println("You got it!");
    }
} while (guess != secret); // 当guess不等于secret时，继续循环

六、数组

6.1一维数组

一维数组是一种数据结构，它可以存储多个相同类型的数据，例如整数、浮点数、字符等。一维数组的特点是：

一维数组的每个元素都有一个唯一的下标，用来表示元素在数组中的位置。下标从0开始，到数组长度减1结束。例如，一个长度为5的整型数组，它的下标范围是0到4。
一维数组的元素可以通过数组名和下标来访问或修改。例如，如果有一个整型数组a，那么a[0]表示数组的第一个元素，a[4]表示数组的第五个元素。
一维数组在内存中是连续存储的，也就是说，相邻的元素在内存中也是相邻的。这样可以提高访问数组元素的效率。
要使用一维数组，首先需要定义它。一维数组的定义格式如下：

类型说明符 数组名 [常量表达式];

其中，类型说明符表示数组元素的数据类型，如int、float、char等；数组名是一个标识符，用来表示数组；常量表达式表示数组元素的个数，也就是数组的长度。

例如，下面是一个定义一个长度为10的整型数组a的语句：

int a[10];

定义了一维数组后，可以对它进行初始化、赋值和访问等操作。初始化是指在定义时就给数组元素赋予初始值；赋值是指在运行时给数组元素赋予新值；访问是指读取或输出数组元素的值。

初始化一维数组的格式如下：

类型说明符 数组名 [常量表达式] = {初始值1, 初始值2, ..., 初始值n};

其中，初始值1, 初始值2, …, 初始值n是用逗号分隔的常量或变量，它们必须与类型说明符相匹配，并且个数不能超过常量表达式。

例如，下面是一个初始化一个长度为5的整型数组b，并给它赋予1, 2, 3, 4, 5这五个值的语句：

int b[5] = {1, 2, 3, 4, 5};

如果没有给出初始值，则默认为0（对于数值类型）或空字符（对于字符类型）。

赋值一维数组的格式如下：

数组名 [下标] = 表达式;

其中，下标是一个整型常量或变量，用来指定要赋值的元素位置；表达式是一个与类型说明符相匹配的常量、变量或运算结果。

例如，下面是一个给a[0]赋值为10，给a[9]赋值为20的语句：

a[0] = 10;
a[9] = 20;

注意：下标不能超过常量表达式减1，否则会发生越界错误。

访问一维数组的格式如下：

表达式 = 数组名 [下标];

或者

输出函数 (数组名 [下标]);

其中，表达式是一个与类型说明符相匹配的变量或运算结果；输出函数是一个用来输出数据的函数，如printf、cout等。

例如，下面是一个将a[0]和a[9]相加，并输出结果的语句：

printf("%d\n", a[0] + a[9]);

通常情况下，要对一维数组进行批量操作时，需要使用循环语句。例如，要输入或输出一个长度为n的一维数组，可以使用如下的循环语句：

// 输入一个长度为n的一维数组
for (int i = 0; i < n; i++) {
    scanf("%d", &a[i]); // 输入第i个元素的值
}

// 输出一个长度为n的一维数组
for (int i = 0; i < n; i++) {
    printf("%d ", a[i]); // 输出第i个元素的值
}

6.2二维数组

二维数组是一种数据结构，它可以存储多个相同类型的数据，例如整数、浮点数、字符等。二维数组的特点是：

二维数组的每个元素都有两个下标，用来表示元素在数组中的行和列位置。下标从0开始，到数组长度减1结束。例如，一个3行4列的整型数组，它的下标范围是0到2和0到3。
二维数组的元素可以通过数组名和下标来访问或修改。例如，如果有一个整型数组a，那么a[0][0]表示数组的第一行第一列的元素，a[2][3]表示数组的第三行第四列的元素。
二维数组在内存中是按行存储的，也就是说，相邻的元素在内存中也是相邻的。这样可以提高访问数组元素的效率。
要使用二维数组，首先需要定义它。二维数组的定义格式如下：

类型说明符 数组名 [常量表达式1] [常量表达式2];

其中，类型说明符表示数组元素的数据类型，如int、float、char等；数组名是一个有效的C标识符；常量表达式1和常量表达式2分别表示数组的行数和列数。

例如，下面是一个定义一个3行4列的整型数组a的语句：

int a[3][4];

定义了二维数组后，可以对它进行初始化、赋值和访问等操作。初始化是指在定义时就给数组元素赋予初始值；赋值是指在运行时给数组元素赋予新值；访问是指读取或输出数组元素的值。

初始化二维数组有以下几种方法：

可以按行给二维数组赋初值，每一行用一个花括号括起来，每个元素用逗号分隔。例如：

int a[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};

这种赋初值的方法比较直观，将第一个花括号内的数据赋给第一行的元素、第二个花括号内的数据赋给第二行的元素……即每行看作一个元素，按行赋初值。

也可以将所有数据写在一个花括号内，按照从左到右、从上到下的顺序对各元素赋初值。例如：

int a[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};

效果与第一种方法是一样的。但第一种方法更好，一行对一行，界限清楚。第二种方法如果数据多，写成一大片，容易遗漏，也不易检查。

也可以只对部分元素赋初值。例如：

int a[3][4] = {{1, 2}, {5}, {9}};

它的作用是对第一行的前两个元素赋值、第二行和第三行的第一个元素赋值。其余元素自动为0。

如果在定义数组时就对全部元素赋初值，则可以省略第一维或两个维度都省略。例如：

int a[][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};

或者

int a[][] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};

系统会根据数据总数和第二维的长度算出第一维的长度。但这种省略的写法几乎不用，因为可读性差。

赋值二维数组的格式如下：

数组名[下标1][下标2] = 表达式;

其中，下标1和下标2是整型常量或变量，用来指定要赋值的元素位置；表达式是一个与类型说明符相匹配的常量、变量或运算结果。

例如，下面是一个给a[0][0]赋值为10，给a[2][3]赋值为20的语句：

a[0][0] = 10;
a[2][3] = 20;

注意：下标不能超过常量表达式减1，否则会发生越界错误。

访问二维数组的格式如下：

表达式 = 数组名[下标1][下标2];

或者

输出函数(数组名[下标1][下标2]);

其中，表达式是一个与类型说明符相匹配的变量或运算结果；输出函数是一个用来输出数据的函数，如printf、cout等。

例如，下面是一个将a[0][0]和a[2][3]相加，并输出结果的语句：

printf("%d\n", a[0][0] + a[2][3]);

通常情况下，要对二维数组进行批量操作时，需要使用嵌套循环。例如，要输入或输出一个m行n列的二维数组，可以使用如下的循环语句：

// 输入一个m行n列的二维数组
for (int i = 0; i < m; i++) {
    for (int j = 0; j < n; j++) {
        scanf("%d", &a[i][j]); // 输入第i行第j列的元素值
    }
}

// 输出一个m行n列的二维数组
for (int i = 0; i < m; i++) {
    for (int j = 0; j < n; j++) {
        printf("%d ", a[i][j]); // 输出第i行第j列的元素值
    }
    printf("\n"); // 换行
}

6.2一些关于数组的例题

一维数组的例题：

请编写一个函数，实现将一个一维数组中的所有元素逆序存放。例如，原数组为{1, 2, 3, 4, 5}，逆序后为{5, 4, 3, 2, 1}。
答案：

// 定义一个函数，接受一个一维数组作为参数
void reverse(int arr[], int n) {
    // 定义一个临时变量，用来交换元素
    int temp;
    // 定义一个循环变量，用来遍历数组
    int i;
    // 使用for循环，从两端向中间交换元素
    for (i = 0; i < n / 2; i++) {
        // 将第i个元素和第n-i-1个元素交换
        temp = arr[i];
        arr[i] = arr[n - i - 1];
        arr[n - i - 1] = temp;
    }
}

请编写一个函数，实现将一个一维数组中的最大值和最小值互换位置。例如，原数组为{1, 2, 3, 4, 5}，互换后为{5, 2, 3, 4, 1}。
答案：

// 定义一个函数，接受一个一维数组作为参数
void swap(int arr[], int n) {
    // 定义两个变量，分别存储最大值和最小值的下标
    int max_index = 0;
    int min_index = 0;
    // 定义一个临时变量，用来交换元素
    int temp;
    // 定义一个循环变量，用来遍历数组
    int i;
    // 使用for循环，找出最大值和最小值的下标
    for (i = 1; i < n; i++) {
        // 如果当前元素大于最大值，则更新最大值的下标
        if (arr[i] > arr[max_index]) {
            max_index = i;
        }
        // 如果当前元素小于最小值，则更新最小值的下标
        if (arr[i] < arr[min_index]) {
            min_index = i;
        }
    }
    // 将最大值和最小值互换位置
    temp = arr[max_index];
    arr[max_index] = arr[min_index];
    arr[min_index] = temp;
}

二维数组的例题：

请编写一个函数，实现将一个二维数组中的每一行按照从小到大的顺序排序。例如，原数组为{{3, 2, 1}, {6, 5, 4}, {9, 8, 7}}，排序后为{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}。
答案：

// 定义一个函数，接受一个二维数组作为参数
void sort(int arr[][3], int m) {
    // 定义三个循环变量，分别用来遍历行、列和比较次数
    int i, j, k;
    // 定义一个临时变量，用来交换元素
    int temp;
    // 使用外层for循环，遍历每一行
    for (i = 0; i < m; i++) {
        // 使用内层for循环，遍历每一列，并进行冒泡排序
        for (j = 0; j < 3 - 1; j++) {
            for (k = j + 1; k < 3; k++) {
                // 如果前一个元素大于后一个元素，则交换它们的位置
                if (arr[i][j] > arr[i][k]) {
                    temp = arr[i][j];
                    arr[i][j] = arr[i][k];
                    arr[i][k] = temp;
                }
            }
        }
    }
}

请编写一个函数，实现将一个二维数组中的所有元素顺时针旋转90度。例如，原数组为{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}，旋转后为{{7, 4, 1}, {8, 5, 2}, {9, 6, 3}}。
答案：

// 定义一个函数，接受一个二维数组作为参数
void rotate(int arr[][3], int n) {
    // 定义一个临时变量，用来交换元素
    int temp;
    // 定义两个循环变量，分别用来遍历行和列
    int i, j;
    // 使用外层for循环，遍历每一行
    for (i = 0; i < n / 2; i++) {
        // 使用内层for循环，遍历每一列，并进行对角线交换
        for (j = i; j < n - i - 1; j++) {
            // 将左上角的元素和右上角的元素交换
            temp = arr[i][j];
            arr[i][j] = arr[j][n - i - 1];
            arr[j][n - i - 1] = temp;
            // 将左上角的元素和右下角的元素交换
            temp = arr[i][j];
            arr[i][j] = arr[n - i - 1][n - j - 1];
            arr[n - i - 1][n - j - 1] = temp;
            // 将左上角的元素和左下角的元素交换
            temp = arr[i][j];
            arr[i][j] = arr[n - j - 1][i];
            arr[n - j - 1][i] = temp;
        }
    }
}

程序员沙蛙

关注

28
点赞
踩
22

收藏

觉得还不错? 一键收藏
0
评论
JAVAEE基础总结

Java标识符：Java标识符是用来命名类、变量、方法等程序元素的名称，它们必须以字母、美元符或下划线开头，后面可以跟任意数量的字母、数字、美元符或下划线。Java标识符是大小写敏感的，不能使用关键字或保留字作为标识符。例如，HelloWorld、$salary、_value都是合法的标识符，而123abc、-salary、if都是非法的标识符。Java数据类型：Java数据类型分为两种，基本数据类型和引用数据类型。
复制链接

扫一扫