目录
上:
-
基本语法与编译运行
-
数据类型和关键字
-
常用语法
-
数组与字符串
-
异常处理
中:
- 面向对象和类
下:
- 图形界面
基本语法与编译运行
- java没有指针没有全局变量
- Java源代码文件的后缀名是”.java”。编译后会生成一个或多个字节码文件,后缀名为”.class”。
- Java的编译器是
javac
,解释器是java
。使用javac
编译源代码,然后用java
运行编译后的字节码。 - Java中的每一行代码都需要以分号(;)结束。
- Java语言对大小写敏感,类名的首字母应该大写,而方法名应该以小写字母开头。
- Java的主方法(程序的入口点)的声明应为:
public static void main(String args[])
。
数据类型和关键字
- package语句可以没有,有的话必须放在文件开始的地方
- public类每个文件中最多有一个
- Java的注释:单行注释(//)、多行注释(/…/)和文档注释(/**…*/),其中文档注释必须出现在公有类定义或公有方法头前面,为将来的维护人员提供API
- Java的
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 = 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中,修改原始变量并不会影响到被赋值的变量。这是因为在这两种语言中,数值赋值都是通过创建新的数值对象实现的,而不是直接修改原来的数值对象。
对于字符串结果也是一样的。
- 在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
- 多维数组: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
块中的代码都会被执行。
服务器托管,北京服务器托管,服务器租用 http://www.fwqtg.net
机房租用,北京机房租用,IDC机房托管, http://www.fwqtg.net
相关推荐: args = vars(parser.parse_args())使用
args = vars(parser.parse_args()) 是将命令行参数解析器(ArgumentParser)解析的结果存储在一个字典中。 在使用 argparse 库解析命令行参数时,通常会定义一个 ArgumentParser 对象 parser,…