JAVA主流技术入门详解

本文详细介绍了JAVA主流技术入门的相关内容，涵盖了基础语法、面向对象编程、常用类库、异常处理、数据库交互及Web开发等多个方面。通过丰富的示例代码，帮助读者深入理解并掌握Java编程的核心知识。

Java基础语法入门

变量与数据类型

Java是一种静态类型语言，这意味着当你声明一个变量时，必须指定其数据类型。以下是Java中常见的数据类型：

• 基本数据类型：

  • byte：8位有符号整数（-128到127）
  • short：16位有符号整数（-32768到32767）
  • int：32位有符号整数（-2147483648到2147483647）
  • long：64位有符号整数
  • float：32位单精度浮点数
  • double：64位双精度浮点数
  • char：16位无符号字符
  • boolean：布尔值（true或false）
• 引用数据类型：
  • String：字符串类型
  • Object：所有类的超类
  • Class：类类型
  • 数组：可以包含任何基本类型或对象类型的数组

下面是一些示例代码：

public class DataTypesExample {
    public static void main(String[] args) {
        byte myByte = 127;
        short myShort = 32767;
        int myInt = 2147483647;
        long myLong = 9223372036854775807L;
        float myFloat = 3.14f;
        double myDouble = 3.14159;
        char myChar = 'A';
        boolean myBoolean = true;

        String myString = "Hello, World!";
        System.out.println("byte: " + myByte);
        System.out.println("short: " + myShort);
        System.out.println("int: " + myInt);
        System.out.println("long: " + myLong);
        System.out.println("float: " + myFloat);
        System.out.println("double: " + myDouble);
        System.out.println("char: " + myChar);
        System.out.println("boolean: " + myBoolean);
        System.out.println("String: " + myString);
    }
}

控制结构（条件语句、循环语句、开关语句）

条件语句

Java中的条件语句包括if、else、else if。下面是一个示例代码，展示了如何使用这些条件语句：

public class ConditionalExample {
    public static void main(String[] args) {
        int num = 5;

        if (num > 0) {
            System.out.println("Number is positive");
        } else if (num < 0) {
            System.out.println("Number is negative");
        } else {
            System.out.println("Number is zero");
        }
    }
}

循环语句

Java中的循环语句包括for、while和do-while。下面是一个示例代码，展示了如何使用这些循环语句：

public class LoopExample {
    public static void main(String[] args) {
        // for loop
        for (int i = 1; i <= 5; i++) {
            System.out.println("for loop iteration: " + i);
        }

        // while loop
        int j = 1;
        while (j <= 5) {
            System.out.println("while loop iteration: " + j);
            j++;
        }

        // do-while loop
        int k = 1;
        do {
            System.out.println("do-while loop iteration: " + k);
            k++;
        } while (k <= 5);
    }
}

开关语句

Java中的switch语句可以根据变量的不同取值执行不同的语句块。下面是一个示例代码，展示了如何使用switch语句：

public class SwitchExample {
    public static void main(String[] args) {
        String day = "Monday";
        switch (day) {
            case "Monday":
                System.out.println("Today is Monday");
                break;
            case "Tuesday":
                System.out.println("Today is Tuesday");
                break;
            case "Wednesday":
                System.out.println("Today is Wednesday");
                break;
            default:
                System.out.println("Today is not Monday, Tuesday, or Wednesday");
                break;
        }
    }
}

数组与字符串

数组

数组是一种可以存储一组相同类型元素的数据结构。在Java中可以通过new关键字创建数组。下面是一个示例代码，展示了如何创建和使用数组：

public class ArrayExample {
    public static void main(String[] args) {
        // 创建一个整型数组
        int[] numbers = new int[5];
        numbers[0] = 1;
        numbers[1] = 2;
        numbers[2] = 3;
        numbers[3] = 4;
        numbers[4] = 5;

        // 遍历数组
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("Array element: " + numbers[i]);
        }

        // 创建一个字符串数组
        String[] names = {"Alice", "Bob", "Charlie"};
        for (String name : names) {
            System.out.println("String array element: " + name);
        }
    }
}

字符串

在Java中，字符串是String类的一个实例。字符串是不可变的，即一旦创建，其内容就不能改变。下面是一个示例代码，展示了如何创建和操作字符串：

public class StringExample {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "World";

        // 字符串连接
        String str3 = str1 + " " + str2;
        System.out.println("Concatenated string: " + str3);

        // 字符串长度
        int length = str3.length();
        System.out.println("Length of str3: " + length);

        // 字符串查找
        int index = str3.indexOf("World");
        System.out.println("Index of 'World': " + index);

        // 字符串替换
        String str4 = str3.replace("World", "Java");
        System.out.println("Replaced string: " + str4);

        // 字符串分割
        String[] split = str4.split(" ");
        for (String s : split) {
            System.out.println("Split element: " + s);
        }
    }
}

Java面向对象编程

类与对象

在Java中，类是对象的蓝图，对象是类的实例。下面是一个示例代码，展示了如何定义类和创建对象：

public class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void displayInfo() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}

public class ClassExample {
    public static void main(String[] args) {
        Person person1 = new Person("Alice", 30);
        person1.displayInfo();

        Person person2 = new Person("Bob", 25);
        person2.displayInfo();
    }
}

继承与多态

继承允许一个类继承另一个类的属性和方法。多态允许子类重写父类的方法，实现不同的行为。下面是一个示例代码，展示了如何实现继承和多态：

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

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

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

public class InheritanceExample {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.makeSound();

        Animal dog = new Dog();
        dog.makeSound();

        Animal cat = new Cat();
        cat.makeSound();
    }
}

接口与抽象类

接口是一种完全抽象的类，只包含抽象方法。抽象类可以包含抽象方法和具体方法。下面是一个示例代码，展示了如何定义和使用接口和抽象类：

public interface Movable {
    void move();
}

public abstract class Vehicle implements Movable {
    public void start() {
        System.out.println("Vehicle starts");
    }

    public abstract void move();
}

public class Car extends Vehicle {
    @Override
    public void move() {
        System.out.println("Car moves");
    }
}

public class InterfaceExample {
    public static void main(String[] args) {
        Car car = new Car();
        car.start();
        car.move();
    }
}

Java常用类库介绍

常用工具类（如StringBuffer、Date等）

StringBuffer

StringBuffer是线程安全的可变字符串类，提供了多种方法来操作字符串。下面是一个示例代码，展示了如何使用StringBuffer：

public class StringBufferExample {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("Hello");
        sb.append(" World");
        System.out.println("StringBuffer: " + sb.toString());

        sb.insert(5, " Java");
        System.out.println("After insert: " + sb.toString());

        sb.delete(5, 9);
        System.out.println("After delete: " + sb.toString());

        sb.reverse();
        System.out.println("Reversed: " + sb.toString());
    }
}

Date

Date类用于表示特定的瞬间，精确到毫秒。SimpleDateFormat类可以用来格式化和解析日期。下面是一个示例代码，展示了如何使用Date和SimpleDateFormat：

import java.text.SimpleDateFormat;
import java.util.Date;

public class DateExample {
    public static void main(String[] args) {
        Date currentDate = new Date();
        System.out.println("Current date: " + currentDate);

        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String formattedDate = formatter.format(currentDate);
        System.out.println("Formatted date: " + formattedDate);
    }
}

StringBuilder

StringBuilder是另一种可变字符串类，但其不是线程安全的。下面是一个示例代码，展示了如何使用StringBuilder：

public class StringBuilderExample {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello");
        sb.append(" World");
        System.out.println("StringBuilder: " + sb.toString());

        sb.insert(5, " Java");
        System.out.println("After insert: " + sb.toString());

        sb.delete(5, 9);
        System.out.println("After delete: " + sb.toString());

        sb.reverse();
        System.out.println("Reversed: " + sb.toString());
    }
}

Calendar

Calendar类提供了对日期的高级处理功能。下面是一个示例代码，展示了如何使用Calendar：

import java.util.Calendar;

public class CalendarExample {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH);
        int day = calendar.get(Calendar.DAY_OF_MONTH);

        System.out.println("Current year: " + year);
        System.out.println("Current month: " + month);
        System.out.println("Current day: " + day);
    }
}

集合框架（List、Set、Map等）

List

List接口表示一个有序的集合，允许元素重复。ArrayList是List接口的一个实现。下面是一个示例代码，展示了如何使用ArrayList：

import java.util.ArrayList;
import java.util.List;

public class ListExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");
        list.add(1, "Grape");

        System.out.println("List elements: " + list);

        boolean contains = list.contains("Banana");
        System.out.println("Contains Banana: " + contains);

        String firstElement = list.get(0);
        System.out.println("First element: " + firstElement);

        list.remove("Grape");
        System.out.println("After removing Grape: " + list);
    }
}

Set

Set接口表示一个不包含重复元素的集合。HashSet是Set接口的一个实现。下面是一个示例代码，展示了如何使用HashSet：

import java.util.HashSet;
import java.util.Set;

public class SetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Orange");
        set.add("Apple");

        System.out.println("Set elements: " + set);
    }
}

Map

Map接口表示一个键值对的集合，其中键是唯一的。HashMap是Map接口的一个实现。下面是一个示例代码，展示了如何使用HashMap：

import java.util.HashMap;
import java.util.Map;

public class MapExample {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("key1", "value1");
        map.put("key2", "value2");
        map.put("key3", "value3");

        System.out.println("Map elements: " + map);

        String value = map.get("key2");
        System.out.println("Value of key2: " + value);

        map.remove("key1");
        System.out.println("After removing key1: " + map);
    }
}

LinkedList

LinkedList是List接口的一个实现，它通过双向链表来存储元素。下面是一个示例代码，展示了如何使用LinkedList：

import java.util.LinkedList;
import java.util.List;

public class LinkedListExample {
    public static void main(String[] args) {
        List<String> list = new LinkedList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");
        list.add(1, "Grape");

        System.out.println("List elements: " + list);

        boolean contains = list.contains("Banana");
        System.out.println("Contains Banana: " + contains);

        String firstElement = list.get(0);
        System.out.println("First element: " + firstElement);

        list.remove("Grape");
        System.out.println("After removing Grape: " + list);
    }
}

TreeSet

TreeSet是Set接口的一个实现，它通过红黑树来存储元素。下面是一个示例代码，展示了如何使用TreeSet：

import java.util.TreeSet;
import java.util.Set;

public class TreeSetExample {
    public static void main(String[] args) {
        Set<String> set = new TreeSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Orange");
        set.add("Apple");

        System.out.println("Set elements: " + set);
    }
}

Java异常处理与调试

异常处理机制

Java中的异常处理机制允许程序捕获和处理运行时错误。异常处理的基本结构是try-catch-finally。下面是一个示例代码，展示了如何使用异常处理：

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            int number = 10 / 0;
            System.out.println("This will not be printed");
        } catch (ArithmeticException e) {
            System.out.println("Caught ArithmeticException: " + e.getMessage());
        } finally {
            System.out.println("Finally block executed");
        }
    }
}

自定义异常

可以创建自定义异常来处理特定的错误情况。下面是一个示例代码，展示了如何创建和使用自定义异常：

public class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}

public class CustomExceptionExample {
    public static void main(String[] args) {
        try {
            throw new CustomException("This is a custom exception");
        } catch (CustomException e) {
            System.out.println("Caught CustomException: " + e.getMessage());
        }
    }
}

常用调试方法与工具

调试是查找和修复程序错误的过程。Java提供了一些调试工具和方法，如System.out.println、JDB（Java Debugger）等。下面是一个示例代码，展示了如何使用System.out.println进行调试：

public class DebugExample {
    public static void main(String[] args) {
        int a = 5;
        int b = 0;
        int result;

        try {
            result = a / b;
        } catch (ArithmeticException e) {
            System.out.println("Caught ArithmeticException: " + e.getMessage());
            result = 0;
        }

        System.out.println("Result: " + result);
    }
}

Java与数据库交互

JDBC基础

Java数据库连接（JDBC）是Java访问数据库的标准API。下面是一个示例代码，展示了如何使用JDBC连接到数据库：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class JDBCDemo {
    public static void main(String[] args) {
        try {
            // 注册驱动
            Class.forName("com.mysql.cj.jdbc.Driver");

            // 建立连接
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/testdb", "root", "password");

            // 创建Statement对象
            Statement stmt = conn.createStatement();

            // 执行查询
            ResultSet rs = stmt.executeQuery("SELECT * FROM users");

            // 处理结果集
            while (rs.next()) {
                System.out.println("ID: " + rs.getInt("id"));
                System.out.println("Name: " + rs.getString("name"));
                System.out.println("Age: " + rs.getInt("age"));
            }

            // 关闭连接
            rs.close();
            stmt.close();
            conn.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

数据库连接与操作

使用JDBC可以执行各种数据库操作，如查询、插入、更新和删除。下面是一个示例代码，展示了如何插入数据到数据库：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class JDBCDemoInsert {
    public static void main(String[] args) {
        try {
            // 注册驱动
            Class.forName("com.mysql.cj.jdbc.Driver");

            // 建立连接
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/testdb", "root", "password");

            // 准备SQL语句
            String sql = "INSERT INTO users (name, age) VALUES (?, ?)";
            PreparedStatement pstmt = conn.prepareStatement(sql);

            // 设置参数
            pstmt.setString(1, "Alice");
            pstmt.setInt(2, 30);

            // 执行插入
            int rowsInserted = pstmt.executeUpdate();
            System.out.println(rowsInserted + " rows inserted");

            // 关闭连接
            pstmt.close();
            conn.close();
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }
    }
}
``

### 更新与删除操作

下面是一个示例代码，展示了如何更新和删除数据库中的数据：

```java
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

public class JDBCDemoUpdateDelete {
    public static void main(String[] args) {
        try {
            // 注册驱动
            Class.forName("com.mysql.cj.jdbc.Driver");

            // 建立连接
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/testdb", "root", "password");

            // 更新操作
            String updateQuery = "UPDATE users SET age = 25 WHERE name = 'Alice'";
            Statement stmt = conn.createStatement();
            int updatedRows = stmt.executeUpdate(updateQuery);
            System.out.println(updatedRows + " rows updated");

            // 删除操作
            String deleteQuery = "DELETE FROM users WHERE name = 'Bob'";
            int deletedRows = stmt.executeUpdate(deleteQuery);
            System.out.println(deletedRows + " rows deleted");

            // 关闭连接
            stmt.close();
            conn.close();
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }
    }
}

Java Web开发入门

Servlet与JSP基础

Servlet

Servlet是一种Java技术，可以在Web服务器上运行，处理客户端请求并生成动态内容。下面是一个示例代码，展示了如何创建和使用Servlet：

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        response.getWriter().println("<h1>Hello, World!</h1>");
    }
}

JSP

Java Server Pages (JSP) 是一种动态网页技术，允许在网页中嵌入Java代码。下面是一个示例代码，展示了如何创建和使用JSP：

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
    <title>JSP Example</title>
</head>
<body>
    <h1>Hello, <%= new java.util.Date() %></h1>
</body>
</html>

MVC设计模式简介

Model-View-Controller (MVC) 是一种软件架构模式，用于分离应用程序的不同关注点。下面是一个简单的MVC示例，展示了如何使用该模式：

Model

public class User {
    private int id;
    private String name;
    private int age;

    // Getters and Setters
}

View

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
    <title>User Details</title>
</head>
<body>
    <h1>User Details</h1>
    <p>ID: <%= user.getId() %></p>
    <p>Name: <%= user.getName() %></p>
    <p>Age: <%= user.getAge() %></p>
</body>
</html>

Controller

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class UserController extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        User user = new User();
        user.setId(1);
        user.setName("Alice");
        user.setAge(30);

        request.setAttribute("user", user);
        request.getRequestDispatcher("user.jsp").forward(request, response);
    }
}

通过这种方式，可以清晰地分离应用程序的各个层，提高代码的可维护性和可扩展性。

总结以上内容，我们对Java的基础语法、面向对象编程、常用类库、异常处理、数据库交互以及Web开发进行了详细介绍，并通过示例代码展示了每个部分的用法。希望这些内容能帮助你更好地理解和掌握Java编程。如果你想进一步学习，可以参考慕课网提供的相关课程。