专门为Java初学者准备的Java小抄集合("Java初学者必备：实用Java速查手册合集")

原创

ithorizon 4周前 (10-19) 阅读数 21 #后端开发

Java初学者必备：实用Java速查手册合集

一、Java简介

Java是一种面向对象的编程语言，由Sun Microsystems公司于1995年推出。Java具有跨平台、平安性、稳定性等特点，广泛应用于Web开发、桌面应用、移动应用等领域。

二、Java基础语法

Java基础语法包括变量、数据类型、运算符、控制结构等。

2.1 变量

变量是存储数据的容器。Java中的变量分为基本数据类型和引用数据类型。


        // 基本数据类型
        int a = 10;
        double b = 3.14;
        char c = 'A';
        
        // 引用数据类型
        String str = "Hello, World!";

2.2 数据类型

Java中的数据类型分为基本数据类型和引用数据类型。

基本数据类型：int、double、char、boolean等

引用数据类型：String、Array、Class等

2.3 运算符

Java中的运算符包括算术运算符、关系运算符、逻辑运算符等。


        // 算术运算符
        int a = 10;
        int b = 5;
        int sum = a + b; // 加法
        int diff = a - b; // 减法
        int prod = a * b; // 乘法
        double div = a / b; // 除法
        // 关系运算符
        boolean isGreater = a > b; // 大于
        boolean isLess = a < b; // 小于
        boolean isEqual = a == b; // 等于
        // 逻辑运算符
        boolean result = (a > b) && (a < c); // 逻辑与运算
        result = (a > b) || (a < c); // 或运算
        result = !isEqual; // 非运算

2.4 控制结构

Java中的控制结构包括分支结构、循环结构等。


        // 分支结构
        if (a > b) {
            System.out.println("a 大于 b");
        } else if (a < b) {
            System.out.println("a 小于 b");
        } else {
            System.out.println("a 等于 b");
        }
        // 循环结构
        for (int i = 0; i < 10; i++) {
            System.out.println("i = " + i);
        }
        int i = 0;
        while (i < 10) {
            System.out.println("i = " + i);
            i++;
        }

三、Java面向对象编程

Java是一种面向对象的编程语言，其核心概念包括类、对象、封装、继承、多态等。

3.1 类与对象

类是对象的模板，对象是类的实例。


        // 定义类
        public class Student {
            private String name;
            private int age;
            // 构造方法
            public Student(String name, int age) {
                this.name = name;
                this.age = age;
            }
            // 成员方法
            public void study() {
                System.out.println(name + " 正在学习");
            }
        }
        // 创建对象
        Student student = new Student("张三", 20);
        student.study();

3.2 封装

封装是指将对象的属性和行为组合在一起，隐藏内部细节。


        public class Student {
            private String name;
            private int age;
            public Student(String name, int age) {
                this.name = name;
                this.age = age;
            }
            public String getName() {
                return name;
            }
            public void setName(String name) {
                this.name = name;
            }
            public int getAge() {
                return age;
            }
            public void setAge(int age) {
                this.age = age;
            }
        }

3.3 继承

继承是指子类继承父类的属性和方法。


        public class Person {
            private String name;
            private int age;
            public Person(String name, int age) {
                this.name = name;
                this.age = age;
            }
            public void eat() {
                System.out.println(name + " 正在吃饭");
            }
        }
        public class Student extends Person {
            public Student(String name, int age) {
                super(name, age);
            }
            public void study() {
                System.out.println(getName() + " 正在学习");
            }
        }

3.4 多态

多态是指允许不同类的对象对同一消息做出响应。


        public class Animal {
            public void sound() {
                System.out.println("动物发出叫声");
            }
        }
        public class Dog extends Animal {
            public void sound() {
                System.out.println("汪汪汪！");
            }
        }
        public class Cat extends Animal {
            public void sound() {
                System.out.println("喵喵喵！");
            }
        }
        public class Main {
            public static void main(String[] args) {
                Animal animal1 = new Dog();
                Animal animal2 = new Cat();
                animal1.sound(); // 输出：汪汪汪！
                animal2.sound(); // 输出：喵喵喵！
            }
        }

四、Java常用类库

Java提供了多彩的类库，用于简化编程。以下是一些常用的类库。

4.1 String类

String类用于处理字符串。


        String str1 = "Hello";
        String str2 = "World";
        String str3 = str1 + " " + str2; // 拼接字符串
        int length = str3.length(); // 获取字符串长度
        char firstChar = str3.charAt(0); // 获取第一个字符
        String upperCaseStr = str3.toUpperCase(); // 变成大写
        String lowerCaseStr = str3.toLowerCase(); // 变成小写

4.2 ArrayList类

ArrayList类用于实现动态数组。


        ArrayList list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        int firstElement = list.get(0); // 获取第一个元素
        int size = list.size(); // 获取数组长度
        list.remove(1); // 删除索引为1的元素

4.3 HashMap类

HashMap类用于实现键值对映射。


        HashMap map = new HashMap<>();
        map.put("apple", 1);
        map.put("banana", 2);
        map.put("orange", 3);
        Integer value = map.get("apple"); // 获取键为"apple"的值
        map.remove("banana"); // 删除键为"banana"的键值对

五、Java异常处理

Java异常处理机制用于处理程序运行过程中出现的异常。

5.1 try-catch语句

try-catch语句用于捕获并处理异常。


        try {
            // 或许出现异常的代码
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            // 处理异常
            System.out.println("出现算术异常：" + e.getMessage());
        }

5.2 throws关键字

throws关键字用于声明方法或许抛出的异常。


        public void divide(int a, int b) throws ArithmeticException {
            if (b == 0) {
                throw new ArithmeticException("除数不能为0");
            }
            return a / b;
        }

5.3 finally块

finally块用于执行无论是否出现异常都需要执行的代码。


        try {
            // 或许出现异常的代码
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            // 处理异常
            System.out.println("出现算术异常：" + e.getMessage());
        } finally {
            // 无论是否出现异常，都会执行的代码
            System.out.println("执行finally块");
        }

六、Java输入输出

Java输入输出用于处理数据的读取和写入。

6.1 System.out.println()方法

System.out.println()方法用于输出字符串。


        System.out.println("Hello, World!");

6.2 Scanner类

Scanner类用于读取用户输入的数据。


        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int number = scanner.nextInt();
        System.out.println("您输入的整数是：" + number);

6.3 File类

File类用于处理文件和目录。


        File file = new File("example.txt");
        if (file.exists()) {
            System.out.println("文件存在");
        } else {
            System.out.println("文件不存在");
        }

七、Java多线程编程

Java多线程编程用于实现程序的并发执行。

7.1 创建线程

创建线程有两种方法：通过继承Thread类或实现Runnable接口。


        // 通过继承Thread类创建线程
        public class MyThread extends Thread {
            @Override
            public void run() {
                System.out.println("线程正在运行");
            }
        }
        MyThread thread = new MyThread();
        thread.start();
        // 通过实现Runnable接口创建线程
        public class MyRunnable implements Runnable {
            @Override
            public void run() {
                System.out.println("线程正在运行");
            }
        }
        MyRunnable myRunnable = new MyRunnable();
        Thread thread2 = new Thread(myRunnable);
        thread2.start();

7.2 线程同步

线程同步用于解决多线程程序中的并发问题。


        public class Counter {
            private int count = 0;
            public synchronized void increment() {
                count++;
            }
            public synchronized int getCount() {
                return count;
            }
        }

7.3 线程通信

线程通信用于实现线程间的协作。


        public class ProducerConsumer {
            private int count = 0;
            public synchronized void produce() throws InterruptedException {
                while (count >= 10) {
                    wait();
                }
                count++;
                System.out.println("生产者生产了一个产品，当前库存：" + count);
                notifyAll();
            }
            public synchronized void consume() throws InterruptedException {
                while (count <= 0) {
                    wait();
                }
                count--;
                System.out.println("消费者消费了一个产品，当前库存：" + count);
                notifyAll();
            }
        }

八、Java网络编程

Java网络编程用于实现网络通信。

8.1 Socket编程

Socket编程用于实现客户端和服务器之间的通信。


        // 服务器端
        public class Server {
            public static void main(String[] args) throws IOException {
                ServerSocket serverSocket = new ServerSocket(8080);
                Socket socket = serverSocket.accept();
                BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                String line = reader.readLine();
                System.out.println("客户端发送的消息：" + line);
                serverSocket.close();
            }
        }
        // 客户端
        public class Client {
            public static void main(String[] args) throws IOException {
                Socket socket = new Socket("localhost", 8080);
                PrintWriter writer = new PrintWriter(socket.getOutputStream());
                writer.println("Hello, Server!");
                writer.flush();
                socket.close();
            }
        }

8.2 URL编程

URL编程用于处理HTTP请求和响应。


        URL url = new URL("http://www.example.com");
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("GET");
        int responseCode = connection.getResponseCode();
        System.out.println("响应码：" + responseCode);

九、Java数据库编程

Java数据库编程用于实现数据库的连接和操作。

9.1 JDBC

JDBC（Java Database Connectivity）是Java用于数据库连接的API。


        Class.forName("com.mysql.cj.jdbc.Driver");
        Connection connection = DriverManager.getConnection(
            "jdbc:mysql://localhost:3306/mydatabase", "username", "password");
        Statement statement = connection.createStatement();
        ResultSet resultSet = statement.executeQuery("SELECT * FROM users");
        while (resultSet.next()) {
            String name = resultSet.getString("name");
            int age = resultSet.getInt("age");
            System.out.println("Name: " + name + ", Age: " + age);
        }
        resultSet.close();
        statement.close();
        connection.close();

9.2 SQL注入

SQL注入是一种攻击手段，用于在数据库查询中插入恶意SQL代码。


        // 不平安的查询
        String username = "admin' -- ";
        String query = "SELECT * FROM users WHERE username = '" + username + "'";
        // 执行查询
        // 预编译查询
        String query = "SELECT * FROM users WHERE username = ?";
        PreparedStatement statement = connection.prepareStatement(query);
        statement.setString(1, username);
        // 执行查询

总结

本文介绍了Java初学者必备的实用Java速查手册合集，包括Java基础语法、面向对象编程、常用类库、异常处理、输入输出、多线程编程、网络编程和数据库编程等内容。期望这些内容能够帮助Java初学者飞速掌握Java编程的基础知识，为后续学习打下坚实的基础。

文章标签：后端开发

上一篇：孩子喜欢飞机，于是我给她做了一个雷达("孩子痴迷飞机，我亲手打造专属雷达玩具") 下一篇：数据处理利器：Pandas带你游刃有余操控结构化数据(Pandas：高效处理结构化数据的利器)