Java程序设计复习提纲（上：入门语法）
上：
(资料图片仅供参考)
基本语法与编译运行
数据类型和关键字
常用语法
数组与字符串
异常处理
中：
面向对象和类下：
图形界面基本语法与编译运行java没有指针没有全局变量Java源代码文件的后缀名是".java"。编译后会生成一个或多个字节码文件，后缀名为".class"。Java的编译器是javac，解释器是java。使用javac编译源代码，然后用java运行编译后的字节码。Java中的每一行代码都需要以分号（;）结束。Java语言对大小写敏感，类名的首字母应该大写，而方法名应该以小写字母开头。Java的主方法（程序的入口点）的声明应为：public static void main(String args[])。数据类型和关键字package语句可以没有，有的话必须放在文件开始的地方public类每个文件中最多有一个Java的注释：单行注释（//）、多行注释（/.../）和文档注释（/**...*/），其中文档注释必须出现在公有类定义或公有方法头前面，为将来的维护人员提供APIJava的true、false、null都是小写的Java源码使用的是Unicode码，而不是ASCII码类名多为名词，含有大小写，首字母要求大写；接口名的命名约定与类名相同Java不允许用数字0,1表示逻辑值Java数据类型： 另外字符数据还有string字符串。String类提供了许多用于操作字符串的方法，如连接字符串、比较字符串、查找子字符串等。
因此，char和String在Java中都有其用处。如果你只需要处理单个字符，可以使用char类型；如果你需要处理一个字符序列，或者需要使用到字符串操作的方法，应该使用String类。
以下是一些例子：
javaCopy codechar c = "a"; // char类型String s = "Hello, world!"; // String类型// 使用String类的方法int length = s.length(); // 获取字符串的长度String upper = s.toUpperCase(); // 将字符串转换为大写double myDouble = 9.78;int myInt = (int) myDouble; // 强制类型转换在Java中，可以使用四种访问修饰符来修饰类和类的成员（如字段和方法）。这些访问修饰符决定了其他类可以访问的范围。以下是这四种访问修饰符（包括无修饰符，即默认）的访问权限：
| 访问权限 | 同一类 | 同一包中的子类 | 同一包中的非子类 | 不同包中的子类 | 不同包中的非子类 |
|---|---|---|---|---|---|
| 无修饰符（默认） | 是 | 是 | 是 | 否 | 否 |
private | 是 | 否 | 否 | 否 | 否 |
protected | 是 | 是 | 是 | 是 | 否 |
public | 是 | 是 | 是 | 是 | 是 |
(1). 无修饰符（默认）：只能被同一个包内的类访问。(2). private：只能在同一类中被访问。(3). protected：可以在同一包中的任何类以及其他包中的子类中被访问。(4). public：可以在任何地方被访问。
类中定义的公有静态变量相当于全局变量。
在Java中，"全局变量"这个术语通常不被使用，因为Java没有像C或C++那样的真正意义上的全局变量。然而，类中定义的公有静态变量（public static variables）在某种意义上可以视为"全局变量"，因为它们可以在类的任何实例或者甚至在类的外部被访问和修改。
当我们在一个类中声明一个变量为public static时，这就意味着这个变量属于这个类，而不是类的任何一个实例。这个变量在内存中只有一个拷贝，所有的实例都共享这一个变量。
javaCopy codepublic class MyClass { public static int count = 0; // 公有静态变量}在这个例子中，count就是一个公有静态变量。我们可以在任何地方通过MyClass.count来访问和修改这个变量，无论我们创建了多少个MyClass的实例。这就是为什么公有静态变量在某种意义上可以视为"全局变量"。
但是要注意的是，这并不意味着使用公有静态变量就是一种好的做法。在许多情况下，这样做可能会导致代码更难理解和维护，因为任何代码都可以修改公有静态变量的值，这可能会导致意想不到的副作用和错误。因此，除非有特别的理由，否则通常最好避免使用公有静态变量。
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 = 5b = aa = 3print("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中，修改原始变量并不会影响到被赋值的变量。这是因为在这两种语言中，数值赋值都是通过创建新的数值对象实现的，而不是直接修改原来的数值对象。
对于字符串结果也是一样的。
在Java中，成员变量（也称为字段、属性或实例变量）和静态变量会有默认初始化，而局部变量则必须显式初始化才能使用。成员变量和静态变量：如果你在类中声明一个字段但没有给它赋值，Java会为其提供一个默认值。具体默认值取决于字段的数据类型。例如，数字类型的默认值是0，布尔类型的默认值是false，引用类型（类、接口等）的默认值是null。局部变量：这是在方法、构造函数或者代码块中定义的变量。局部变量在使用前必须显式初始化，否则编译器将报错。这是因为局部变量存储在栈上，而不是像成员变量和静态变量那样存储在堆上，Java不会为栈上的变量提供默认值。例如，以下的Java代码将无法编译：
javaCopy codepublic class Main { public static void main(String[] args) { int a; // 这是一个局部变量 System.out.println(a); // 编译错误：变量a可能尚未初始化 }}你需要先给变量a赋值，才能使用它：
javaCopy codepublic class Main { public static void main(String[] args) { int a = 5; // 这是一个局部变量 System.out.println(a); // 输出：5 }}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)也不会被计算。这种特性可以用来防止程序中的某些计算产生副作用。
在Java中，if、for、while、switch等都是控制流语句，用于控制程序的执行流程。以下是他们的基本语法：
if (condition) { // 代码块1} else if (anotherCondition) { // 代码块2} else { // 代码块3}for (initialization; condition; update) { // 代码块}while (condition) { // 代码块}do { // 代码块} while (condition);switch (expression) { case value1: // 代码块1 break; case value2: // 代码块2 break; default: // 代码块3}请注意，这些控制流语句可以根据需要进行嵌套使用。
break语句用于完全结束循环，无论循环条件是否仍然为真。它通常用于提前退出循环。一旦break语句被执行，控制流将立即跳出当前的循环体，并继续执行循环后面的语句。continue语句用于跳过当前循环的剩余部分，直接进入下一次循环。与break不同，continue并不会完全终止循环，它只是提前开始下一次循环。break和continue都是用来改变循环的正常执行流程的。break用于完全退出循环，而continue用于跳过当前循环的剩余部分并进入下一次循环。
输入输出：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数组的主要知识点：
声明数组：在Java中，你可以使用以下语法声明数组：dataType[] arrayName; // 声明例如，声明一个整数数组：
int[] myArray;new关键字创建数组：arrayName = new dataType[arraySize]; // 创建例如，创建一个可以存储5个整数的数组：
myArray = new int[5];dataType[] arrayName = {element1, element2, element3, ...};例如，声明并初始化一个整数数组：
int[] myArray = {1, 2, 3, 4, 5};或者，你也可以在创建数组后分别为每个元素赋值：
myArray[0] = 1;myArray[1] = 2;arrayName[index]例如，访问数组的第一个元素：
int firstElement = myArray[0];length属性来获取数组的长度：int length = arrayName.length;例如，获取数组的长度：
int length = myArray.length;for(int i=0; i < myArray.length; i++) { System.out.println(myArray[i]);}for(int element : myArray) { System.out.println(element);}int[][] my2DArray = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};这些是Java数组的基本知识点。数组是Java中非常重要的数据结构，用于存储和操作大量同类型的数据。
基本的数组操作，如初始化、访问、修改元素、获取数组长度等，都是通过索引操作或者使用length属性来完成的.
在 Java 中，字符串是一个非常常用的对象类型，用于存储和操作文本。以下是 Java 字符串的一些主要知识点：
创建字符串：你可以使用双引号 ("") 来创建一个字符串字面量：String str = "Hello, world!";或者，你也可以使用 new关键字来创建一个字符串对象：
String str = new String("Hello, world!");length()方法来获取字符串的长度：int len = str.length();+运算符或者 concat()方法来连接两个字符串：String str1 = "Hello";String str2 = "world";String str3 = str1 + " " + str2; // 使用 + 运算符String str4 = str1.concat(" ").concat(str2); // 使用 concat() 方法equals()方法或者 equalsIgnoreCase()方法来比较两个字符串是否相等：boolean isEqual = str1.equals(str2); // 区分大小写boolean isEqualIgnoreCase = str1.equalsIgnoreCase(str2); // 不区分大小写substring()方法来获取字符串的子串：String substr = str.substring(startIndex, endIndex); // 索引从 0 开始，包含开始索引，不包含结束索引indexOf()方法或者 lastIndexOf()方法来查找字符或子串在字符串中的位置：int index = str.indexOf("o"); // 返回字符 "o" 第一次出现的位置int lastIndex = str.lastIndexOf("o"); // 返回字符 "o" 最后一次出现的位置replace()方法来替换字符串中的字符或子串：String newStr = str.replace("o", "a"); // 将所有的 "o" 替换为 "a"split()方法来根据指定的分隔符分割字符串：String[] parts = str.split(" "); // 使用空格作为分隔符toLowerCase()、toUpperCase()方法来将字符串转换为小写或大写：String lowerCaseStr = str.toLowerCase();String upperCaseStr = str.toUpperCase();在Java中，异常是在程序执行期间发生的问题的对象表示。Java使用异常来表示错误，以便程序可以捕获并处理它们。以下是Java异常的主要知识点：
异常类型：在Java中，所有的异常类型都是java.lang.Throwable类的子类。它有两个主要的子类：java.lang.Error和java.lang.Exception。Error类表示的是程序无法处理的严重问题，如系统崩溃、虚拟机错误等，程序通常不处理这类错误。Exception类表示的是程序可以处理的异常，它又分为两种：检查型异常（checked exceptions）和非检查型异常（unchecked exceptions）。
抛出异常：你可以使用throw关键字来抛出一个异常。例如：
throw new Exception("This is an exception");try-catch语句来捕获并处理异常。例如：try { // some code that may throw an exception} catch (Exception e) { // handle the exception System.out.println(e.getMessage());}finally块包含的代码无论是否发生异常都会被执行，常用于资源的清理工作。例如：try { // some code that may throw an exception} catch (Exception e) { // handle the exception} finally { // cleanup code here}自定义异常：你可以通过扩展Exception类（或其子类）来创建自定义的异常类。
异常链：你可以使用initCause()方法或者在构造函数中提供一个cause参数来设置一个异常的原因，这样就可以形成一个异常链，它可以提供更详细的错误信息。
当Java中的代码抛出一个异常时，程序的正常执行流程会被中断，然后立即跳转到匹配该异常类型的catch块。
以下是具体的步骤：
当一个异常在try块中被抛出时，程序的控制权将立即转移到第一个匹配该异常类型的catch块。这意味着在异常被抛出之后的try块中的任何代码都不会被执行。
如果找到一个匹配的catch块，那么它的内部代码将被执行。这通常涉及到错误处理逻辑，例如记录错误、清理资源、通知用户等。
如果try/catch块后面有finally块，那么不管是否捕获到异常，finally块中的代码都将被执行。这常用于资源的清理工作，例如关闭文件、释放内存等。
在所有的catch和finally块执行完毕后，程序控制权将返回到try/catch/finally块之后的代码，然后程序将继续正常执行。
如果在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块中的代码都会被执行。
