Java基础知识
前言
一些Java的基础知识，包含：标识符、运算符、流程控制、循环结构、分支结构、数组、方法和类与对象。
一、标识符
标识符是用于命名变量、类、方法等元素的标签，它们在编程中起到了关键的作用。
1.标识符的命名规则
- 标识符必须以字母、下划线(_)或美元符号($)开头。
- 标识符的其他部分可以包含字母、数字、下划线(_)或美元符号($)。
- 标识符严格区分大小写。
- Java有一组关键字，这些关键字具有特殊含义，不能用作标识符。保留字是Java中未来可能使用的标识符，尽量避免使用。
代码如下（示例）：
int myVariable; // 合法的标识符，以字母开头
String _name; // 合法的标识符，以下划线开头
double $value; // 合法的标识符，以美元符号开头
int 2ndNumber; // 非法的标识符，不能以数字开头
String my-variable; // 非法的标识符，不能包含连字符
int if; // 非法的标识符，因为 "if" 是关键字
int class; // 非法的标识符，因为 "class" 是关键字
int goto; // 合法的标识符，但不推荐使用，因为 "goto" 是保留字
2.标识符的命名规范
遵循规范的命名方式可使代码更易读和维护。一般包括：
- 变量名全部小写。
- 常量名通常使用全大写字母和下划线分隔。
- 类名使用帕斯卡命名法（PascalCase），即每个单词首字母大写。
- 方法名使用使用驼峰命名法（camelCase），寄首字母小写，后面每个单词首字母大写。
代码如下（示例）：
String name; // 变量名全部小写
class PersonInfo { // 类名使用帕斯卡命名法
public static final int MAX_VALUE = 100; // 常量名使用全大写字母和下划线分隔
public void addNum(){ //方法名使用使用驼峰命名法
}
}
同时，命名应避免使用过于简单或含糊的标识符，使用有意义的名字将增加代码的可读性。
代码如下（示例）：
int x; // 含糊不清的变量名
int studentAge; // 见名知意
二、运算符
运算符一般包括：算术运算、逻辑运算和比较运算，用于执行各种运算操作。
1.算术运算符
| 算术运算符 | |
|---|---|
| 加法 | + |
| 减法 | - |
| 乘法 | * |
| 除法 | / |
| 取模（取余数） | % |
| 自加 | ++ |
| 自减 | – |
代码如下（示例）：
int a = 10;
int b = 5;
int sum = a + b; // 加法
int difference = a - b; // 减法
int product = a * b; // 乘法
int quotient = a / b; // 除法
int remainder = a % b; // 取模（取余数）
int self-increment = a++；
int self-decrement = a--；
System.out.println("Sum: " + sum); // 15
System.out.println("Difference: " + difference); // 5
System.out.println("Product: " + product); // 50
System.out.println("Quotient: " + quotient); // 2
System.out.println("Remainder: " + remainder); // 0
System.out.println("a after self-increment: " + a); // 11
System.out.println("b after self-decrement: " + b); // 4
其中，a++ 先返回当前值，然后再增加 a 的值，
++b 先增加 b 的值，然后再返回增加后的值。
代码如下（示例）：
int a = 5;
int b = 5;
int postIncrementResult = a++; // 后缀自增运算符
int preIncrementResult = ++b; // 前缀自增运算符
System.out.println("a: " + a); // 输出：a: 6
System.out.println("b: " + b); // 输出：b: 6
System.out.println("Post-increment result: " + postIncrementResult); // 输出：Post-increment result: 5
System.out.println("Pre-increment result: " + preIncrementResult); // 输出：Pre-increment result: 6
2.关系运算符
| 关系运算符 | |
|---|---|
| 相等 | == |
| 不相等 | != |
| 大于 | > |
| 小于 | < |
| 大于等于 | >= |
| 小于等于 | <= |
代码如下（示例）：
int x = 10;
int y = 20;
boolean isEqual = (x == y); // 相等
boolean isNotEqual = (x != y); // 不相等
boolean isGreaterThan = (x > y); // 大于
boolean isLessThan = (x < y); // 小于
boolean isGreaterOrEqual = (x >= y); // 大于等于
boolean isLessOrEqual = (x <= y); // 小于等于
System.out.println("Is Equal: " + isEqual); // false
System.out.println("Is Not Equal: " + isNotEqual); // true
System.out.println("Is Greater Than: " + isGreaterThan); // false
System.out.println("Is Less Than: " + isLessThan); // true
System.out.println("Is Greater Or Equal: " + isGreaterOrEqual); // false
System.out.println("Is Less Or Equal: " + isLessOrEqual); // true
3.逻辑运算符
| 逻辑运算符 | |
|---|---|
| 与 | && |
| 或 | ll |
| 非 | ! |
代码如下（示例）：
boolean a = true;
boolean b = false;
boolean andResult = a && b; // 与
boolean orResult = a || b; // 或
boolean notResultA = !a; // 非
boolean notResultB = !b; // 非
System.out.println("AND Result: " + andResult); // false
System.out.println("OR Result: " + orResult); // true
System.out.println("NOT Result (A): " + notResultA); // false
System.out.println("NOT Result (B): " + notResultB); // true
Java 中的逻辑运算符 ||（或）和 &&（与）存在短路现象，这意味着会根据第一个操作数的结果决定是否继续执行下一个比较条件。
3.1 || 运算符的短路现象
代码如下（示例）：
int x = 5;
int y = 10;
if (x > 2 || y < 5) {
System.out.println("条件为真");
} else {
System.out.println("条件为假");
} //"条件为真"
x > 2 条件为真，因此不需要再检查 y < 5，因为 || 运算符已经确定整个条件为真。因此，将打印 “条件为真”。
3.2 && 运算符的短路现象
代码如下（示例）：
int a = 3;
int b = 7;
if (b > 5 && a < 5) {
System.out.println("条件为假");
} else {
System.out.println("条件为真");
}
b > 5 条件为假，因此不需要再检查 a < 5，因为 && 运算符已经确定整个条件为假。因此，将打印 “条件为假”。
4.条件运算符（三目运算符）
代码如下（示例）：
int x = 10;
int y = 20;
int max = (x > y) ? x : y;
System.out.println("较大的数是：" + max); // 较大的数是：20
三、分支结构
1.if语句
if 语句根据条件执行不同的代码块。
代码如下（示例）：
int age = 20;
if (age >= 18) {
System.out.println("成年人");
} else {
System.out.println("未成年人");
}
2.if else 语句
代码如下（示例）：
int number = 10;
if (number > 5) {
System.out.println("数字大于5."); // 如果条件为真（true），执行这里的代码块
} else {
System.out.println("数字不大于5."); // 如果条件为假（false），执行这里的代码块
}
3.if else if语句
适用于处理多个条件并根据不同条件执行不同的操作。
代码如下（示例）：
int number = 10;
if (number < 5) {
System.out.println("数字小于5。"); // 如果number小于5，则执行以下代码块
}
else if (number < 10) {
System.out.println("数字小于10。"); // 如果number不小于5但小于10，则执行以下代码块
}
else {
System.out.println("数字为10或更大。"); // 如果number不小于10，则执行以下代码块
}
5.switch语句
switch语句是一种用于多条件分支的控制语句，它根据表达式的值选择执行不同的代码块。
代码如下（示例）：
int dayOfWeek = 2;
switch (dayOfWeek) {
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
default: // 如果值与所有 case 都不匹配，执行这里的代码块
System.out.println("其他天");
} // 星期二
四、循环结构
1.for循环语句
for 循环用于按照指定的条件执行循环体内的代码，先执行代码块，后判断循环条件。
代码如下（示例）：
for (int i = 1; i <= 5; i++) { //初始化; 条件; 更新
System.out.println("循环次数：" + i);// // 循环体：在条件为真时执行的代码块
}
2.while循环语句
while 循环先判断循环条件，后执行代码块。
代码如下（示例）：
int count = 0;
while (count < 3) {
System.out.println("循环次数：" + count);
count++;
}
3.do-while循环语句
do-while 循环与 while 循环类似，但它会先执行循环体，然后检查条件是否满足，因此至少会执行一次循环，与for循环类似。
代码如下（示例）：
int num = 1;
do {
System.out.println("循环次数：" + num);
num++;
} while (num <= 5);
4.continue语句
continue 语句用于跳过当前循环迭代的其余部分，继续下一次循环迭代。
代码如下（示例）：
int num = 1;
for (int i = 1; i <= 5; i++) {
if (i == 3) {
continue; // 当 i 等于 3 时跳过此次循环迭代
}
System.out.println("循环次数：" + i);
}
5.break语句
break 语句用于提前终止循环，跳出循环体。
代码如下（示例）：
for (int i = 1; i <= 10; i++) {
if (i == 5) {
break; // 当 i 等于 5 时提前退出循环
}
System.out.println("循环次数：" + i);
}
5.renturn语句
五、数组
1.声明和初始化数组
代码如下（示例）：
int[] numbers; // 声明一个整数数组
numbers = new int[5]; // 初始化数组并分配内存
}
2.访问数组元素
代码如下（示例）：
int[] numbers = {1, 2, 3, 4, 5};
int element = numbers[2]; // 获取索引为2的元素，值为3
3.遍历数组
一般使用循环的方式
代码如下（示例）：
int[] numbers = {1, 2, 3, 4, 5};
for (int i = 0; i < numbers.length; i++) {
System.out.println(numbers[i]);
}
4.多维数组
以二维数组为例：
代码如下（示例）：
int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; // 创建二维数组
int element = matrix[1][2]; // 获取第二行第三列的元素，值为6
5.常用数组操作
5.1 获取数组的长度
代码如下（示例）：
int[] numbers = {1, 2, 3, 4, 5};
int length = numbers.length; // 获取数组的长度，值为5
5.2 数组的复制和拷贝（循环）
代码如下（示例）：
int[] sourceArray = {1, 2, 3, 4, 5};
int[] targetArray = new int[sourceArray.length];
for (int i = 0; i < sourceArray.length; i++) {
targetArray[i] = sourceArray[i];
}
5.3 最大值、最小值及平均值
代码如下（示例）：
int[] numbers = {5, 2, 8, 1, 7};
int max = Arrays.stream(numbers).max().getAsInt(); // 获取最大值
int min = Arrays.stream(numbers).min().getAsInt(); // 获取最小值
double average = Arrays.stream(numbers).average().getAsDouble(); // 计算平均值
5.4 其他常用方法
六、方法
方法便于程序中多次调用，提高了代码的可维护性和可重用性。
1.方法的声明和调用
方法由名称、参数列表和返回类型组成。
方法的声明通常遵循以下结构：
returnType methodName(parameters) {
// 方法体
}
- returnType 是方法的返回类型。
- methodName 是方法的名称，用来唯一标识方法。
- parameters 是方法的参数列表。
方法调用的语法是通过方法名称和传递给方法的参数来实现的。
代码如下（示例）：
// 声明一个方法，用于计算两个整数的和
public int add(int a, int b) {
return a + b;
}
// 调用方法
int result = add(3, 5);
System.out.println("结果：" + result); // 输出：结果：8
}
返回值为空的方法，用void定义：
代码如下（示例）：
// 声明一个不返回值的方法，用于打印问候语
public void sayHello(String name) {
System.out.println("Hello, " + name + "!");
}
// 调用方法
sayHello("Bob"); // 输出：Hello, Bob!
方法可以有一个返回值，其类型与 returnType 相匹配：
代码如下（示例）：
// 声明一个方法，返回字符串
public String greet(String name) {
return "Hello, " + name + "!";
}
// 调用方法
String message = greet("Alice");
System.out.println(message); // 输出：Hello, Alice!
为方法添加多个入口参数：
代码如下（示例）：
// 声明一个方法，接受两个整数参数，返回它们的差
public int subtract(int a, int b) {
return a - b;
}
// 调用方法
int difference = subtract(10, 3);
System.out.println("差值：" + difference); // 输出：差值：7
2.方法的重载
可以在同一个类中定义多个方法，它们具有相同的名称但不同的参数列表。
调用方法时，编译器根据提供的参数数量和类型来确定要调用的具体方法。
代码如下（示例）：
// 声明方法的重载，可以接受不同数量的参数
public int add(int a, int b) {
return a + b;
}
public int add(int a, int b, int c) {
return a + b + c;
}
double addNumbers(double a, double b) {
return a + b;
}
3.静态方法和实例方法
静态方法属于类，使用 static 关键字，静态方法可以直接通过类名调用，无需创建类的实例。
实例方法属于对象，必须在类中声明。实例方法属于类的实例，可以访问该类的成员变量和其他实例方法，要调用实例方法，必须通过类的对象来调用，方法调用的语法是 对象.方法名()。。
代码如下（示例）：
// 静态方法
public static int staticMethod(int x, int y) {
return x + y;
}
// 实例方法
public class Person {
// 成员变量
private String name;
private int age;
// 构造方法
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 实例方法：获取姓名
public String getName() {
return name;
}
}
public class Main {
public static void main(String[] args) {
// 创建一个Person对象
Person person = new Person("Alice", 25);
// 调用实例方法来获取属性值
String personName = person.getName();
System.out.println("姓名: " + personName);
}
}
4.方法的可见性
在Java中，方法可以具有不同的可见性修饰符，如 public、private、protected 或默认可见性。
这些修饰符决定了其他类是否可以访问该方法。
| 修饰词 | 可见性 |
|---|---|
| public | 公共可见性，可以被任何类访问。最开放的可见性级别 |
| private | 私有可见性，只能在声明它们的类内部访问。最严格的可见性级别。 |
| protected | 受保护可见性，可以被同一包内的类访问，以及子类（不论是否在同一包中）。提供了一定的封装，但也允许继承类访问方法。 |
| 默认 | 默认可见性，没有任何访问修饰符，也称为包级别可见性。在同一包内的类可以访问默认可见性的方法，但在不同包中的类无法访问。 |
代码如下（示例）：
public class MyClass {
// 公共方法，可被任何类访问
public void publicMethod() {
}
// 私有方法，只能在当前类内部访问
private void privateMethod() {
}
// 受保护方法，同一包内的类和子类可以访问
protected void protectedMethod() {
}
// 默认可见性方法，同一包内的类可以访问
void defaultMethod() {
}
}
七、类与对象
1.类的声明和对象的创建
代码如下（示例）：
// 声明一个类
public class Person {
String name;
int age;
}
// 创建对象
Person person1 = new Person();
person1.name = "Alice";
person1.age = 25;
Person person2 = new Person();
person2.name = "Bob";
person2.age = 30;
System.out.println("结果：" + result); // 输出：结果：8
}
2.成员变量和局部变量的区别
成员变量定义在类的内部，但在方法外部，通常在类的顶部声明。它们是类的一部分，存在于整个类的生命周期中。
局部变量定义在方法内部、构造方法、或代码块内部。它们只在声明它们的方法、构造方法或代码块中可见，在对象创建时初始化，在对象被销毁时回收。
代码如下（示例）：
public class VariableExample {
// 成员变量（实例变量）
private int instanceVar = 30; // 成员变量，属于类的实例
public void exampleMethod() {
// 局部变量
int localVar = 10; // 局部变量，仅在该方法中有效
System.out.println("成员变量 instanceVar: " + instanceVar); // 访问成员变量，30
System.out.println("局部变量 localVar: " + localVar); // 访问局部变量，10
}
public void anotherMethod() {
// 局部变量
int localVar = 20; // 局部变量，与上面的方法中的局部变量同名，但互不干扰
System.out.println("成员变量 instanceVar: " + instanceVar); // 访问成员变量，30
System.out.println("局部变量 localVar: " + localVar); // 访问局部变量，20
}
public static void main(String[] args) {
int localVar = 50; // 局部变量被销毁，需要重新定义
}
}
4.成员变量和方法
代码如下（示例）：
public class Student {
String name; // 成员变量
int age;
// 方法
void study() {
System.out.println(name + " is studying.");
}
}
Student student = new Student();
student.name = "Charlie";
student.age = 20;
student.study(); // 输出：Charlie is studying.
5.类的封装
如果不进行封装，那么对属性的操作，就具有可读可写能力，并且可
写的值没有做任何规范性的约束，会造成数据的不安全。
私有访问修饰符来保护成员变量，使用公有方法访问它们，分别是
赋值方法和取值方法。
代码如下（示例）：
public class Book {
private String title; // 私有成员变量
public void setTitle(String title) {
this.title = title;
}
public String getTitle() {
return title;
}
}
Book book = new Book();
book.setTitle("Java Programming");
String bookTitle = book.getTitle();
6.构造方法
构建对象时用的方法，即就是对象创建时要执行的方法。
构造方法没有返回值类型。也不需要写返回值。因为它是为构建对象的，对象创建完，方法就执行结束。
构造方法名称必须和类名保持一致。
构造方法没有具体的返回值。
当一个类没有显式的写构造方法时，使用的时默认的无参构造方法
代码如下（示例）：
public class Car {
String make;
String model;
// 构造方法
public Car(String make, String model) {
this.make = make;
this.model = model;
}
}
Car myCar1 = new Car("Toyota", "Camry");
Car myCar2 = new Car(); // 无参构造
7.类的继承
如果想声明一个类继承另一个类，需要使用extends关键字，类只支持单继承。
代码如下（示例）：
// 基类（父类）
public class Animal {
void eat() {
System.out.println("Animal is eating.");
}
}
// 派生类（子类）
public class Dog extends Animal {
void bark() {
System.out.println("Dog is barking.");
}
}
Dog myDog = new Dog();
myDog.eat(); // 输出：Animal is eating.
myDog.bark(); // 输出：Dog is barking.
总结
以上就是一些Java的基础知识，包含：标识符、运算符、流程控制、循环结构、分支结构、数组、方法和类与对象。
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
