【Java菜鸟学习进阶路线】Java基础知识篇

Java语法是Java编程语言的基础，是每个Java初学者必须要掌握的内容。下面将详细介绍Java语法的基础知识

一、变量

在Java中，变量是用来存储数据的容器。变量可以存储整数、浮点数、字符、布尔值等不同类型的数据。在定义变量时，需要指定变量的类型和名称，例如：

int age;  // 定义一个整型变量
float weight;  // 定义一个浮点型变量
String name;  // 定义一个字符串变量
boolean isStudent;  // 定义一个布尔型变量
1
2
3
4

二、数据类型

Java是一种强类型语言，每个变量都必须指定其数据类型。Java中的数据类型可以分为两类：
基本类型

byte（位）: 该类型可以存储的最大数据量为255。
short（短整数）: 该类型可以存储的最大数据量为65536。
int（整数）: 该类型可以存储的最大数据量为2的32次方减1。
long（长整数）: 该类型可以存储的最大数据量为2的64次方减1。
float（单精度浮动数）: 需要在数字后加上f或F进行直接赋值。
double（双精度）。
boolean（布尔类型）: 该类型只有两个值，true和false。
char（字符）
1
2
3
4
5
6
7
8

引用类型

• 引用数据类型在Java中占据了重要的地位，它包括了类、接口和数组等类型。这些类型的取值范围和存储空间大小可以根据需求动态改变，它们可以进行对象的创建。与基本数据类型不同，引用数据类型在内存中占用的空间大于基本数据类型，因为需要存储更多的信息。具体来说，每个引用数据类型的变量都存储了一个地址值，这个地址指向了该对象在堆内存中的存储位置。
• 引用数据类型还具有以下特点：

1. 通过new关键字来创建新的对象；
2. 通过null关键字来表示一个空引用；
3. 通过 instanceof 运算符来判断一个对象是否属于某个类或接口；
4. 调用对象的方法或者访问其成员变量。
1
2
3
4

三、运算符

Java中的运算符包括算术运算符、比较运算符、逻辑运算符、位运算符和三元运算符。

1. 算术运算符：+、-、*、/、%等。
2. 比较运算符：==、!=、>、<、>=、<=等。
3. 逻辑运算符：&&、||、!等。
4. 位运算符：&、|、^、~、<<、>>等。
5. 三元运算符：?:。
1
2
3
4
5

四、控制流程

控制流程语句用于控制程序的执行流程，包括条件语句、循环语句和开关语句。

以下是一些Java控制流程语句的示例：

1. if语句：

int x = 10;
if (x > 5) {
  // 输出此语句
  System.out.println("x is greater than 5");
}
1
2
3
4
5

2. if-else语句：

int x = 10;
if (x > 10) {
  System.out.println("x is greater than 10");
} else {
  // 输出此语句
  System.out.println("x is less than or equal to 10");
}
1
2
3
4
5
6
7

3. switch语句：

int day = 3;
switch (day) {
  case 1:
    System.out.println("Monday");
    break;
  case 2:
    System.out.println("Tuesday");
    break;
  case 3:
    // 输出此语句
    System.out.println("Wednesday");
    break;
  default:
    System.out.println("Invalid day");
    break;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4. for循环语句：

for (int i = 0; i < 5; i++) {
  System.out.println("i is: " + i);
}
1
2
3

5. while循环语句：

int i = 0;
while (i < 5) {
  System.out.println("i is: " + i);
  i++;
}
1
2
3
4
5

6. do-while循环语句：

int i = 0;
do {
  System.out.println("i is: " + i);
  i++;
} while (i < 5);
1
2
3
4
5

五、常用API

Java标准库中提供了很多常用的API，可以帮助我们更方便地进行编程。常用比如Java String, ArrayList, HashMap是Java语言中常用的三种数据结构。

一、Java String

String是一个类，它代表了一个字符串对象。String类中有很多方法可以操作字符串，例如：

• length()方法：返回字符串的长度。
• charAt(int index)方法：返回指定索引位置的字符。
• substring(int beginIndex, int endIndex)方法：返回子字符串，它的内容是此字符串的一个子序列。
• concat(String str)方法：将指定的字符串连接到此字符串的末尾。
• indexOf(String str)方法：返回指定子字符串在此字符串中第一次出现的索引。
• replace(char oldChar, char newChar)方法：用指定的字符替换此字符串中的所有指定字符。

示例：

String str = "Hello World!";
 // 获取字符串长度
int len = str.length();
// 获取指定索引位置的字符
char c = str.charAt(0); 
// 获取子字符串
String subStr = str.substring(0, 5); 
 // 连接字符串
String newStr = str.concat("Java");
// 查找子字符串的索引位置
int index = str.indexOf("World"); 
// 替换字符串中的字符
String newStr2 = str.replace('o', 'a'); 
1
2
3
4
5
6
7
8
9
10
11
12
13

二、ArrayList

ArrayList是一个类，它实现了List接口，可以动态地存储任意类型的数据。ArrayList中有很多方法可以操作数据，例如：

• add(E e)方法：将指定的元素添加到此列表的尾部。
• remove(Object o)方法：从列表中删除第一个（最前面的）匹配的元素。
• get(int index)方法：返回在此列表中指定位置上的元素。
• set(int index, E element)方法：用指定的元素替换此列表中指定位置上的元素。
• iterator()方法：返回一个迭代器，该迭代器可以依次访问列表中的每个元素。

示例：

import java.util.ArrayList;
import java.util.Iterator;

// 创建一个ArrayList对象
ArrayList<String> list = new ArrayList<String>(); 
// 添加元素到列表尾部
list.add("Java"); 
// 从列表中删除元素
list.remove("Java"); 
// 获取列表中的元素
String str = list.get(0); 
// 替换列表中的元素
list.set(0, "Python"); 
// 获取迭代器对象，遍历列表中的元素
Iterator<String> it = list.iterator(); 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

六、异常处理

异常处理是Java中非常重要的机制，可以用来处理程序中可能出现的错误。在Java中，每个方法都可以抛出异常，如果在方法中没有处理异常，则需要使用try-catch语句块来捕获和处理异常。

import java.util.InputMismatchException;  
import java.util.Scanner;  
  
public class ExceptionExample {  
    public static void main(String[] args) {  
        Scanner scanner = new Scanner(System.in);  
        System.out.println("请输入一个整数：");  
        try {  
            int num = scanner.nextInt();  
            System.out.println("你输入的整数是：" + num);  
        } catch (InputMismatchException e) {  
            System.out.println("输入的不是一个整数！");  
            e.printStackTrace();  
        } finally {  
            scanner.close();  
        }  
    }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

七、文件操作

Java中提供了很多文件操作相关的API，可以用来读取和写入文件。比如，
FileInputStream和FileOutputStream类可以用来读写文件

import java.io.*;  
  
public class FileIOExample {  
    public static void main(String[] args) {  
        File inputFile = new File("input.bin");  
        File outputFile = new File("output.bin");  
  
        try (FileInputStream inputStream = new FileInputStream(inputFile);  
             FileOutputStream outputStream = new FileOutputStream(outputFile)) {  
            byte[] buffer = new byte[1024];  
            int bytesRead;  
            while ((bytesRead = inputStream.read(buffer)) != -1) {  
                outputStream.write(buffer, 0, bytesRead);  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

BufferedReader和BufferedWriter类可以用来读写文本文件

import java.io.*;  
  
public class TextFileIOExample {  
    public static void main(String[] args) {  
        File inputFile = new File("input.txt");  
        File outputFile = new File("output.txt");  
  
        try (BufferedReader reader = new BufferedReader(new FileReader(inputFile));  
             BufferedWriter writer = new BufferedWriter(new FileWriter(outputFile))) {  
            String line;  
            while ((line = reader.readLine()) != null) {  
                writer.write(line);  
                writer.newLine();  // 写入新的一行  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

八、网络编程

Java中提供了很多网络编程相关的API，可以用来实现网络通信。比如，Socket类可以用来实现TCP/IP连接，ServerSocket类可以用来实现服务器端程序等。
示例

Server

import java.io.*;  
import java.net.*;  
  
public class Server {  
    public static void main(String[] args) throws IOException {  
        int port = 6789;  
        try (  
            ServerSocket serverSocket = new ServerSocket(port);  
            Socket clientSocket = serverSocket.accept();  
            PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);  
            BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));  
        ) {  
            String inputLine;  
            while ((inputLine = in.readLine()) != null) {  
                out.println(inputLine);  
            }  
        } catch (IOException e) {  
            System.out.println("Exception caught when trying to listen on port " + port);  
            System.out.println(e.getMessage());  
        }  
    }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Client

import java.io.*;  
import java.net.*;  
  
public class Client {  
    public static void main(String[] args) throws IOException {  
        String hostName = "localhost";  
        int port = 6789;  
        try (  
            Socket echoSocket = new Socket(hostName, port);  
            PrintWriter out = new PrintWriter(echoSocket.getOutputStream(), true);  
            BufferedReader in = new BufferedReader(new InputStreamReader(echoSocket.getInputStream()));  
            BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));  
        ) {  
            String userInput;  
            while ((userInput = stdIn.readLine()) != null) {  
                out.println(userInput);  
                System.out.println("Echo from server: " + in.readLine());  
            }  
        } catch (UnknownHostException e) {  
            System.err.println("Don't know about host " + hostName);  
            System.exit(1);  
        } catch (IOException e) {  
            System.err.println("Couldn't get I/O for the connection to " + hostName);  
            System.exit(1);  
        }  
    }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

以上就是Java语法的基础知识，是每个Java初学者必须要掌握的内容。只有掌握了这些基础知识，才能够更好地学习和使用Java编程语言。