Java基础知识总结

引言

Java作为一门广泛应用于后端开发的编程语言，在近年来备受关注。Java语言的简洁、高效、稳定、跨平台等特点，都使其成为众多开发者的不二选择。Java语言的基础知识是程序员必不可少的一部分，本篇文章将对Java基础知识做一个简要总结，从语法特性、面向对象、IO操作、多线程、异常处理等方面展开阐述。

Java语法特性

关键字

Java语言有许多关键字，这些关键字是Java语法的基础。Java的关键字不能作为标识符，它们是Java语言的保留字。关键字不区分大小写。

public class MyClass {
    public static void main(String[] args) {
        int if = 10;
        int while = 10;
        int else = 10;
        System.out.println(if + while + else);
    }
}

上面的代码是一个错误示例，因为if、while、else都是Java语言的关键字，不能作为标识符。

基本数据类型和运算符

Java语言有8种基本数据类型，分为4种整型、2种浮点型、1种字符型和1种布尔型。Java中所有的基本数据类型都具有默认值，遵循以下规则：

下面是基本运算符的示例代码：

public class MyClass {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = a + b;      // 加法运算符
        int d = b - a;      // 减法运算符
        int e = a * b;      // 乘法运算符
        int f = b / a;      // 除法运算符
        int g = b % a;      // 取模运算符
        int h = ++a;        // 自增运算符
        int i = --b;        // 自减运算符
        boolean j = true;   // 布尔类型
        boolean k = !j;     // 取反运算符
        boolean l = j && k; // 逻辑与运算符
        boolean m = j || k; // 逻辑或运算符
        boolean n = j ^ k;  // 逻辑异或运算符
    }
}

面向对象

类和对象

Java是一门面向对象的编程语言，类是Java语言的基础。Java中的类用于描述对象的属性和行为。对象是类的实例，它包含类属性的值以及可调用的方法。

public class MyClass {
    private String field;

    public void setField(String field) {
        this.field = field;
    }

    public String getField() {
        return field;
    }
}

MyClass obj = new MyClass();
obj.setField("Hello World");
System.out.println(obj.getField());

继承和多态

继承是Java语言中的一种机制，它允许程序员扩展已定义的类。一个类可以继承另一个类中的所有数据和方法。继承的好处是可以避免代码重复，增加代码的可维护性。Java中的多态是指同一个方法可以有多种实现方式，这个机制实现了程序的灵活性。

public class Animal {
    public void sound() {
        System.out.println("Animal makes sound");
    }
}

public class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Dog barks");
    }
}

public class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("Cat meows");
    }
}

public class MyClass {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();
        animal1.sound();    // output: Dog barks
        animal2.sound();    // output: Cat meows
    }
}

IO操作

文件输入输出

Java中的文件输入输出包含向文件写入信息和从文件读取信息的操作。Java提供了一系列处理输入输出流的类。

import java.io.File;
import java.io.FileWriter;
import java.io.FileReader;
import java.io.IOException;

public class MyClass {
    public static void main(String[] args) {
        File file = new File("myfile.txt");
        try {
            FileWriter fw = new FileWriter(file);
            fw.write("Hello World");
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            FileReader fr = new FileReader(file);
            int c;
            while ((c = fr.read()) != -1) {
                System.out.print((char) c);
            }
            fr.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

网络输入输出

Java中的网络输入输出是指客户端和服务器端之间的交互，通过网络输入输出实现数据交换。Java提供了Socket类和ServerSocket类，可以方便地实现网络输入输出。

import java.net.Socket;
import java.net.UnknownHostException;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;

public class Client {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("localhost", 8888);
            Scanner sc = new Scanner(System.in);
            PrintWriter pw = new PrintWriter(socket.getOutputStream());
            String text = sc.next();
            pw.println(text);
            pw.flush();
            pw.close();
            socket.close();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.net.ServerSocket;
import java.net.Socket;
import java.io.IOException;
import java.util.Scanner;

public class Server {
    public static void main(String[] args) {
        try {
            ServerSocket server = new ServerSocket(8888);
            Socket socket = server.accept();
            Scanner sc = new Scanner(socket.getInputStream());
            String text = sc.next();
            System.out.println(text);
            sc.close();
            socket.close();
            server.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

多线程

线程创建和启动

在Java语言中，线程可以通过继承Thread类或实现Runnable接口来创建。

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread is running");
    }
}

public class MyClass {
    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.start();
    }
}

线程同步和互斥

Java中的线程同步和互斥是针对多个线程同时访问共享资源的情况下，为了避免数据竞争、死锁和其他不一致的情况而采取的措施。

class Shared {
    private int count = 0;

    public void increment() {
        synchronized (this) {
            count++;
        }
    }

    public int getCount() {
        return count;
    }
}

class MyThread extends Thread {
    private Shared sharedObject;

    public MyThread(Shared sharedObject) {
        this.sharedObject = sharedObject;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100000; i++) {
            sharedObject.increment();
        }
    }
}

public class MyClass {
    public static void main(String[] args) {
        Shared sharedObject = new Shared();
        MyThread t1 = new MyThread(sharedObject);
        MyThread t2 = new MyThread(sharedObject);
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(sharedObject.getCount()); // output: 200000
    }
}

异常处理

Java的异常处理是指在程序执行时，当发现某些错误时，Java会抛出一个异常对象，然后程序员可以通过catch语句捕捉这个异常，进行相应的处理。

public class MyClass {
    public static void main(String[] args) {
        try {
            int[] array = new int[3];
            array[4] = 10;
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Array index out of bounds");
        }
    }
}

总结

本文简要总结了Java语言的基础知识，包括语法特性、面向对象、IO操作、多线程和异常处理。Java作为一门广泛应用于后端开发的编程语言，Java基础知识对程序员来说十分重要，希望本文能对读者有所帮助。