当前页面 ： 首页 > 资讯 > 正文 >

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

来源：博客园 时间： 2023-05-18 22:44:22
目录

上：


(资料图片仅供参考)

基本语法与编译运行

数据类型和关键字

常用语法

数组与字符串

异常处理

中：

面向对象和类

下：

图形界面基本语法与编译运行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(); // 将字符串转换为大写
0开头表示8进制数、0x表示16进制数、077L表示长整型的8进制数Java类型转换主要包括自动类型转换（也叫隐式类型转换）和强制类型转换（也叫显式类型转换）：自动类型转换是指从较小的数据类型自动转换到较大的数据类型（如int转为double）；而强制类型转换则需要在表达式前显式地加上要转换的类型（如double转为int，可能会导致精度丢失）。
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语句：用于根据指定的条件执行代码。
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}

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

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循环或者for-each循环来遍历数组。例如：
for(int i=0; i < myArray.length; i++) {    System.out.println(myArray[i]);}for(int element : myArray) {    System.out.println(element);}
多维数组：Java也支持多维数组，最常见的是二维数组：
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块：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块中的代码都会被执行。

关键词：

为您推荐

快讯
行业
-
公司