Java程序设计复习提纲（上：入门语法）

目录

上：本文

• 基本语法与编译运行

• 数据类型和关键字

• 常用语法

• 数组与字符串

• 异常处理

---

中：Java程序设计复习提纲（中：面向对象） - 孤飞 - 博客园 (cnblogs.com)

• 面向对象和类

---

下：Java程序设计复习提纲（下：图形界面） - 孤飞 - 博客园 (cnblogs.com)

• 图形界面

基本语法与编译运行

1. java没有指针没有全局变量
2. Java源代码文件的后缀名是".java"。编译后会生成一个或多个字节码文件，后缀名为".class"。
3. Java的编译器是javac，解释器是java。使用javac编译源代码，然后用java运行编译后的字节码。
4. Java中的每一行代码都需要以分号（;）结束。
5. Java语言对大小写敏感，类名的首字母应该大写，而方法名应该以小写字母开头。
6. Java的主方法（程序的入口点）的声明应为：public static void main(String args[])。

数据类型和关键字

1. package语句可以没有，有的话必须放在文件开始的地方
2. public类每个文件中最多有一个
3. Java的注释：单行注释（//）、多行注释（/*...*/）和文档注释（/**...*/），其中文档注释必须出现在公有类定义或公有方法头前面，为将来的维护人员提供API
4. Java的true、false、null都是小写的
5. Java源码使用的是Unicode码，而不是ASCII码
6. 类名多为名词，含有大小写，首字母要求大写；接口名的命名约定与类名相同
7. Java不允许用数字0,1表示逻辑值
8. Java数据类型：

​ 另外字符数据还有string字符串。String类提供了许多用于操作字符串的方法，如连接字符串、比较字符串、查找子字符串等。

因此，char和String在Java中都有其用处。如果你只需要处理单个字符，可以使用char类型；如果你需要处理一个字符序列，或者需要使用到字符串操作的方法，应该使用String类。

以下是一些例子：

char c = 'a'; // char类型

String s = "Hello, world!"; // String类型

// 使用String类的方法
int length = s.length(); // 获取字符串的长度
String upper = s.toUpperCase(); // 将字符串转换为大写

9. 0开头表示8进制数、0x表示16进制数、077L表示长整型的8进制数
10. Java类型转换主要包括自动类型转换（也叫隐式类型转换）和强制类型转换（也叫显式类型转换）：自动类型转换是指从较小的数据类型自动转换到较大的数据类型（如int转为double）；而强制类型转换则需要在表达式前显式地加上要转换的类型（如double转为int，可能会导致精度丢失）。

double myDouble = 9.78;
int myInt = (int) myDouble;  // 强制类型转换

11. 在Java中，可以使用四种访问修饰符来修饰类和类的成员（如字段和方法）。这些访问修饰符决定了其他类可以访问的范围。以下是这四种访问修饰符（包括无修饰符，即默认）的访问权限：

    访问权限	同一类	同一包中的子类	同一包中的非子类	不同包中的子类	不同包中的非子类
    无修饰符（默认）	是	是	是	否	否
    private	是	否	否	否	否
    protected	是	是	是	是	否
    public	是	是	是	是	是

    (1). 无修饰符（默认）：只能被同一个包内的类访问。
    (2). private：只能在同一类中被访问。
    (3). protected：可以在同一包中的任何类以及其他包中的子类中被访问。
    (4). public：可以在任何地方被访问。

12. 类中定义的公有静态变量相当于全局变量。

13. 在Java中，"全局变量"这个术语通常不被使用，因为Java没有像C或C++那样的真正意义上的全局变量。然而，类中定义的公有静态变量（public static variables）在某种意义上可以视为"全局变量"，因为它们可以在类的任何实例或者甚至在类的外部被访问和修改。

    当我们在一个类中声明一个变量为public static时，这就意味着这个变量属于这个类，而不是类的任何一个实例。这个变量在内存中只有一个拷贝，所有的实例都共享这一个变量。

    public class MyClass {
        public static int count = 0;  // 公有静态变量
    }
    

    在这个例子中，count就是一个公有静态变量。我们可以在任何地方通过MyClass.count来访问和修改这个变量，无论我们创建了多少个MyClass的实例。这就是为什么公有静态变量在某种意义上可以视为"全局变量"。

    但是要注意的是，这并不意味着使用公有静态变量就是一种好的做法。在许多情况下，这样做可能会导致代码更难理解和维护，因为任何代码都可以修改公有静态变量的值，这可能会导致意想不到的副作用和错误。因此，除非有特别的理由，否则通常最好避免使用公有静态变量。

14. void是一个关键字，用于指定一个方法不返回任何值。

    public void printHello() {
        System.out.println("Hello, world!");
    }
    

15.在处理对象赋值这个问题上，Java和Python实际上有很多相似之处，因为它们都使用引用语义来处理对象。也就是说，当你在Java或Python中将一个对象赋值给另一个变量时，你实际上是在复制对象的引用，而不是整个对象。这意味着赋值后的两个变量指向的是同一个对象，对其中一个变量的任何修改都会影响到另一个变量。

然而，Java和Python在如何处理基本数据类型（如整数和浮点数）上有所不同：

• 在Java中，基本数据类型（如int，double等）不是对象，它们是直接存储的值。当你将一个基本类型的变量赋值给另一个变量时，Java会复制这个值，而不是引用。因此，修改一个变量不会影响到另一个变量。
• 而在Python中，所有的东西都是对象，包括整数和浮点数。这意味着当你在Python中复制一个整数或浮点数时，你实际上是在复制一个引用。但是，因为Python中的数值类型是不可变的（即你不能修改它们的值），所以在实际使用中，这种差异通常不会引起问题。

在处理数组和其他容器类型时，这种差异就变得更加明显了。例如，如果你在Java中复制一个数组，你会得到一个新的数组，它的元素是原数组的引用。如果你修改了新数组的元素，原数组也会被改变。但是，如果你在Python中复制一个列表，你会得到一个新的列表，它的元素是原列表的引用。如果你修改了新列表的元素，原列表不会被改变。这是因为在Python中，列表的赋值实际上是创建了一个新的列表对象，而这个新列表的元素是原列表的元素的引用。

在Java中：

public class Main {
    public static void main(String[] args) {
        int a = 5;
        int b = a;
        a = 3;
        System.out.println("a: " + a); // 输出 "a: 3"
        System.out.println("b: " + b); // 输出 "b: 5"
    }
}

在这个Java代码中，我们首先声明了变量a并赋值为5，然后声明了变量b并将a的值赋给它。然后我们改变a的值为3。由于Java中的int是基本数据类型，所以b的值是a在赋值时的值，改变a的值并不会影响到b。所以最后，a的值为3，b的值仍为5。

在Python中：

a = 5
b = a
a = 3
print('a:', a)  # 输出 "a: 3"
print('b:', b)  # 输出 "b: 5"

在这个Python代码中，我们首先创建了一个数值对象5并让a引用它，然后让b引用a引用的对象。然后我们创建了一个新的数值对象3并让a引用它。Python的数值对象是不可变的，所以我们实际上是创建了一个新的数值对象，而不是修改了原来的数值对象。因此，改变a的引用并不会影响到b。所以最后，a的值为3，b的值仍为5。

总的来说，不论是在Java还是Python中，修改原始变量并不会影响到被赋值的变量。这是因为在这两种语言中，数值赋值都是通过创建新的数值对象实现的，而不是直接修改原来的数值对象。

对于字符串结果也是一样的。

16. 在Java中，成员变量（也称为字段、属性或实例变量）和静态变量会有默认初始化，而局部变量则必须显式初始化才能使用。

• 成员变量和静态变量：如果你在类中声明一个字段但没有给它赋值，Java会为其提供一个默认值。具体默认值取决于字段的数据类型。例如，数字类型的默认值是0，布尔类型的默认值是false，引用类型（类、接口等）的默认值是null。
• 局部变量：这是在方法、构造函数或者代码块中定义的变量。局部变量在使用前必须显式初始化，否则编译器将报错。这是因为局部变量存储在栈上，而不是像成员变量和静态变量那样存储在堆上，Java不会为栈上的变量提供默认值。

例如，以下的Java代码将无法编译：

public class Main {
    public static void main(String[] args) {
        int a; // 这是一个局部变量
        System.out.println(a); // 编译错误：变量a可能尚未初始化
    }
}

你需要先给变量a赋值，才能使用它：

public class Main {
    public static void main(String[] args) {
        int a = 5; // 这是一个局部变量
        System.out.println(a); // 输出：5
    }
}

常用语法

1. 逻辑运算符

Java中的逻辑运算符主要有以下几种：

（1）. &&：逻辑与（AND）运算符。当且仅当两个操作数都为true时，结果才为true。例如：(5 > 3) && (2 > 3)的结果是false。
（2）. ||：逻辑或（OR）运算符。只要两个操作数中有一个为true，结果就为true。例如：(5 > 3) || (2 > 3)的结果是true。
（3）. !：逻辑非（NOT）运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将使其为false。例如：!(5 > 3)的结果是false。

值得注意的是，Java中的&&和||运算符都具有"短路"行为。这意味着，如果左边的操作数已经足够确定整个表达式的值，那么右边的操作数就不会被计算。例如，在true || (x > y)表达式中，不论(x > y)的值是什么，整个表达式的结果都是true，因此(x > y)不会被计算。同理，在false && (x > y)表达式中，(x > y)也不会被计算。这种特性可以用来防止程序中的某些计算产生副作用。

2. 控制流语句

在Java中，if、for、while、switch等都是控制流语句，用于控制程序的执行流程。以下是他们的基本语法：

• if语句：用于根据指定的条件执行代码。

if (condition) {
    // 代码块1
} else if (anotherCondition) {
    // 代码块2
} else {
    // 代码块3
}

• for循环：用于重复执行某段代码一定的次数。

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

• while循环：用于在满足特定条件时重复执行代码。

while (condition) {
    // 代码块
}

• do...while循环：类似于while循环，但至少会执行一次代码块。

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

• switch语句：用于根据变量或表达式的值来执行特定的代码块。

switch (expression) {
    case value1:
        // 代码块1
        break;
    case value2:
        // 代码块2
        break;
    default:
        // 代码块3
}

请注意，这些控制流语句可以根据需要进行嵌套使用。

3. break语句用于完全结束循环，无论循环条件是否仍然为真。它通常用于提前退出循环。一旦break语句被执行，控制流将立即跳出当前的循环体，并继续执行循环后面的语句。
   continue语句用于跳过当前循环的剩余部分，直接进入下一次循环。与break不同，continue并不会完全终止循环，它只是提前开始下一次循环。
   break和continue都是用来改变循环的正常执行流程的。break用于完全退出循环，而continue用于跳过当前循环的剩余部分并进入下一次循环。

4. 输入输出：Java的标准输入和输出主要依赖于java.util.Scanner类和System类。

输入

java.util.Scanner是一个简单的文本扫描器，可以解析原始类型和字符串的使用空格作为分隔符的文本。

以下是一个简单的使用Scanner从标准输入读取数据的例子：

import java.util.Scanner; // 导入Scanner类

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); // 创建一个新的Scanner对象，接收从标准输入读入的数据

        System.out.println("请输入一个数字：");
        int number = scanner.nextInt(); // 读取用户输入的整数

        System.out.println("你输入的数字是：" + number);
    }
}

输出

System.out是一个PrintStream类型的对象，它通常用于输出文本数据到标准输出（通常是控制台）。

以下是使用System.out.println输出数据的例子：

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, world!"); // 输出字符串到标准输出
    }
}

System.out.println可以接收各种类型的参数，包括字符串、整数、浮点数等，它会将这些参数转换为字符串并输出到标准输出。如果你只是想输出文本但不想在后面加上换行符，可以使用System.out.print方法。

数组与字符串

数组

在Java中，数组是同一类型数据的有序集合。

以下是Java数组的主要知识点：

1. 声明数组：在Java中，你可以使用以下语法声明数组：

dataType[] arrayName; // 声明

例如，声明一个整数数组：

int[] myArray;

2. 创建数组：一旦数组被声明，你需要使用new关键字创建数组：

arrayName = new dataType[arraySize]; // 创建

例如，创建一个可以存储5个整数的数组：

myArray = new int[5];

3. 初始化数组：你可以在声明时就初始化数组：

dataType[] arrayName = {element1, element2, element3, ...};

例如，声明并初始化一个整数数组：

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

或者，你也可以在创建数组后分别为每个元素赋值：

myArray[0] = 1;
myArray[1] = 2;

4. 访问数组元素：你可以通过索引来访问数组元素：

arrayName[index]

例如，访问数组的第一个元素：

int firstElement = myArray[0];

5. 数组长度：你可以使用length属性来获取数组的长度：

int length = arrayName.length;

例如，获取数组的长度：

int length = myArray.length;

6. 遍历数组：你可以使用for循环或者for-each循环来遍历数组。例如：

for(int i=0; i < myArray.length; i++) {
    System.out.println(myArray[i]);
}

for(int element : myArray) {
    System.out.println(element);
}

7. 多维数组：Java也支持多维数组，最常见的是二维数组：

int[][] my2DArray = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

这些是Java数组的基本知识点。数组是Java中非常重要的数据结构，用于存储和操作大量同类型的数据。

基本的数组操作，如初始化、访问、修改元素、获取数组长度等，都是通过索引操作或者使用length属性来完成的.

字符串

在 Java 中，字符串是一个非常常用的对象类型，用于存储和操作文本。以下是 Java 字符串的一些主要知识点：

1. 创建字符串：你可以使用双引号 ("") 来创建一个字符串字面量：

String str = "Hello, world!";

或者，你也可以使用 new 关键字来创建一个字符串对象：

String str = new String("Hello, world!");

2. 字符串长度：你可以使用 length() 方法来获取字符串的长度：

int len = str.length();

3. 连接字符串：你可以使用 + 运算符或者 concat() 方法来连接两个字符串：

String str1 = "Hello";
String str2 = "world";
String str3 = str1 + " " + str2; // 使用 + 运算符
String str4 = str1.concat(" ").concat(str2); // 使用 concat() 方法

4. 比较字符串：你可以使用 equals() 方法或者 equalsIgnoreCase() 方法来比较两个字符串是否相等：

boolean isEqual = str1.equals(str2); // 区分大小写
boolean isEqualIgnoreCase = str1.equalsIgnoreCase(str2); // 不区分大小写

5. 字符串子串：你可以使用 substring() 方法来获取字符串的子串：

String substr = str.substring(startIndex, endIndex); // 索引从 0 开始，包含开始索引，不包含结束索引

6. 查找字符或子串：你可以使用 indexOf() 方法或者 lastIndexOf() 方法来查找字符或子串在字符串中的位置：

int index = str.indexOf('o'); // 返回字符 'o' 第一次出现的位置
int lastIndex = str.lastIndexOf('o'); // 返回字符 'o' 最后一次出现的位置

7. 替换字符或子串：你可以使用 replace() 方法来替换字符串中的字符或子串：

String newStr = str.replace('o', 'a'); // 将所有的 'o' 替换为 'a'

8. 字符串分割：你可以使用 split() 方法来根据指定的分隔符分割字符串：

String[] parts = str.split(" "); // 使用空格作为分隔符

9. 字符串转换：你可以使用 toLowerCase()、toUpperCase() 方法来将字符串转换为小写或大写：

String lowerCaseStr = str.toLowerCase();
String upperCaseStr = str.toUpperCase();

异常处理

在Java中，异常是在程序执行期间发生的问题的对象表示。Java使用异常来表示错误，以便程序可以捕获并处理它们。以下是Java异常的主要知识点：

1. 异常类型：在Java中，所有的异常类型都是java.lang.Throwable类的子类。它有两个主要的子类：java.lang.Error和java.lang.Exception。Error类表示的是程序无法处理的严重问题，如系统崩溃、虚拟机错误等，程序通常不处理这类错误。Exception类表示的是程序可以处理的异常，它又分为两种：检查型异常（checked exceptions）和非检查型异常（unchecked exceptions）。

2. 抛出异常：你可以使用throw关键字来抛出一个异常。例如：

throw new Exception("This is an exception");

3. 捕获异常：你可以使用try-catch语句来捕获并处理异常。例如：

try {
    // some code that may throw an exception
} catch (Exception e) {
    // handle the exception
    System.out.println(e.getMessage());
}

4. finally块：finally块包含的代码无论是否发生异常都会被执行，常用于资源的清理工作。例如：

try {
    // some code that may throw an exception
} catch (Exception e) {
    // handle the exception
} finally {
    // cleanup code here
}

5. 自定义异常：你可以通过扩展Exception类（或其子类）来创建自定义的异常类。

6. 异常链：你可以使用initCause()方法或者在构造函数中提供一个cause参数来设置一个异常的原因，这样就可以形成一个异常链，它可以提供更详细的错误信息。

当Java中的代码抛出一个异常时，程序的正常执行流程会被中断，然后立即跳转到匹配该异常类型的catch块。

以下是具体的步骤：

1. 当一个异常在try块中被抛出时，程序的控制权将立即转移到第一个匹配该异常类型的catch块。这意味着在异常被抛出之后的try块中的任何代码都不会被执行。

2. 如果找到一个匹配的catch块，那么它的内部代码将被执行。这通常涉及到错误处理逻辑，例如记录错误、清理资源、通知用户等。

3. 如果try/catch块后面有finally块，那么不管是否捕获到异常，finally块中的代码都将被执行。这常用于资源的清理工作，例如关闭文件、释放内存等。

4. 在所有的catch和finally块执行完毕后，程序控制权将返回到try/catch/finally块之后的代码，然后程序将继续正常执行。

5. 如果在try块中抛出的异常没有被任何catch块捕获，那么该异常将会被传播到上一级方法中，如果上一级方法也没有捕获该异常，那么该异常将继续向上传播，直到被捕获或者达到程序的最顶层。如果一个异常到达了程序的最顶层还没有被捕获，那么程序将会终止，并打印出异常的堆栈跟踪信息。

下面是一个例子，演示了异常的捕获和处理：

try {
    int a = 5;
    int b = 0;
    int c = a / b; // This line will throw an ArithmeticException
    System.out.println(c);
} catch (ArithmeticException e) {
    System.out.println("An error occurred: " + e.getMessage());
} finally {
    System.out.println("This is the finally block.");
}

在这个例子中，当尝试除以0时，将会抛出一个ArithmeticException，这将中断程序的正常执行流程，然后立即跳转到catch块。在catch块中，程序打印出一个错误消息。然后，不管是否发生了异常，finally块中的代码都会被执行。