学习JAVA副业入门需要从基础知识入手，安装配置开发环境，掌握核心编程概念，最后通过实战项目提高技能。

JAVA简介

Java 是一种广泛使用的编程语言，最初由 Sun Microsystems（后来被 Oracle 收购）在 1995 年开发。它的设计目标是提供一种“一次编写，到处运行”的跨平台开发方案。Java 代码可以在任何安装了 Java 运行时环境（JRE）的操作系统上运行，这主要得益于 Java 的“编写一次，到处运行”的特性。

Java 的设计哲学强调简单性、健壮性和安全性。它被广泛应用于桌面应用、Web 应用、移动应用以及企业级系统集成等各个方面。Java 还拥有庞大的开发者社区，拥有大量的开源库和框架，使得开发更加容易。

安装和配置开发环境

在开始使用 Java 编程前，首先需要安装 Java 开发环境。以下是安装步骤：

1. 安装 JDK (Java Development Kit)：JDK 是 Java 开发环境的一部分，包含了编译、运行 Java 程序所需的工具和库。下载最新版本的 JDK，并按照安装向导进行安装。安装完成后，需要设置环境变量。在 Windows 系统中，可以在系统环境变量中添加 JAVA_HOME 和 PATH；在 macOS 和 Linux 中，可以在终端中设置环境变量。

2. 配置环境变量：

   • 在 Windows 中，右键点击“此电脑”，选择“属性”，然后点击“高级系统设置”。
   • 在“系统属性”窗口中，点击“环境变量”按钮。
   • 在“系统变量”区域，添加一个新的变量 JAVA_HOME，值为 JDK 的安装目录（例如 C:\Program Files\Java\jdk-17.0.1）。
   • 在 PATH 变量中，添加 %JAVA_HOME%\bin。
3. 验证安装：打开命令行或终端，输入以下命令来验证环境变量是否设置正确：

java -version

如果安装成功，会显示 Java 的版本信息。

第一个JAVA程序

编写第一个 Java 程序通常是从“Hello World”程序开始的。以下是创建和运行 Java 程序的基本步骤：

1. 创建一个新的文本文件，并将其命名为 HelloWorld.java。
2. 在文件中输入以下代码：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

1. 使用命令行编译 Java 文件。在保存代码的目录打开命令行，输入以下命令：

javac HelloWorld.java

如果编译成功，将生成一个 HelloWorld.class 文件。

1. 运行 Java 程序。在同一目录中输入以下命令：

java HelloWorld

如果一切正常，将会看到输出：

Hello, World!

变量与数据类型

在 Java 中，变量是一种存储数据的容器。每个变量都有一个类型，该类型决定了变量可以存储的数据类型。Java 中的基本数据类型如下：

• byte：8 位有符号整数。
• short：16 位有符号整数。
• int：32 位有符号整数。
• long：64 位有符号整数。
• float：单精度浮点数。
• double：双精度浮点数。
• char：16 位 Unicode 字符。
• boolean：布尔值，真或假。

以下是定义变量的示例：

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

        System.out.println("myByte: " + myByte);
        System.out.println("myShort: " + myShort);
        System.out.println("myInt: " + myInt);
        System.out.println("myLong: " + myLong);
        System.out.println("myFloat: " + myFloat);
        System.out.println("myDouble: " + myDouble);
        System.out.println("myChar: " + myChar);
        System.out.println("myBoolean: " + myBoolean);
    }
}

创建和初始化数组

数组是存储一组相同类型元素的数据结构。Java 提供了多种类型的数组，包括一维数组和多维数组。以下是如何创建和初始化数组的示例：

public class ArraysExample {
    public static void main(String[] args) {
        int[] numbers = new int[5]; // 创建一个长度为5的整数数组
        for (int i = 0; i < numbers.length; i++) {
            numbers[i] = i * 2;
        }

        // 直接初始化数组
        String[] names = {"Alice", "Bob", "Charlie"};

        // 输出数组元素
        for (int number : numbers) {
            System.out.println(number);
        }
        for (String name : names) {
            System.out.println(name);
        }
    }
}

异常处理

Java 异常处理机制允许开发者编写更加健壮的程序。异常通常通过 try-catch 块处理，也可以使用 finally 块进行清理操作。以下是一个简单的异常处理示例：

public class ExceptionHandlingExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("ArithmeticException caught: " + e.getMessage());
        } finally {
            System.out.println("Finally block executed");
        }
    }
}

控制结构和循环

Java 支持多种控制结构，包括条件语句和循环语句，用于控制程序的流程。以下是 Java 中常用的控制结构示例：

条件语句

条件语句用于根据条件执行不同的代码块。Java 中的条件语句包括 if 和 switch。

public class ConditionalStatements {
    public static void main(String[] args) {
        int number = 10;
        if (number > 0) {
            System.out.println("Number is positive");
        } else if (number < 0) {
            System.out.println("Number is negative");
        } else {
            System.out.println("Number is zero");
        }

        switch (number) {
            case 1:
                System.out.println("Number is 1");
                break;
            case 2:
                System.out.println("Number is 2");
                break;
            default:
                System.out.println("Number is not 1 or 2");
        }
    }
}

循环语句

循环语句用于重复执行一段代码。Java 支持三种类型的循环：for、while 和 do-while。

public class LoopStatements {
    public static void main(String[] args) {
        // for 循环
        for (int i = 0; i < 5; i++) {
            System.out.println("Iteration: " + i);
        }

        // while 循环
        int i = 0;
        while (i < 5) {
            System.out.println("While Iteration: " + i);
            i++;
        }

        // do-while 循环
        int j = 0;
        do {
            System.out.println("Do-while Iteration: " + j);
            j++;
        } while (j < 5);
    }
}

函数和方法

在 Java 中，方法是可执行代码的封装单元。方法可以接受参数，执行一系列操作，并可以返回值。以下是定义和调用方法的示例：

public class Methods {
    public static void main(String[] args) {
        // 调用无参无返回值的方法
        printMessage();

        // 调用有返回值的方法
        int result = addNumbers(10, 15);
        System.out.println("Sum: " + result);

        // 调用有参有返回值的方法
        String fullName = getName("John", "Doe");
        System.out.println("Full Name: " + fullName);
    }

    public static void printMessage() {
        System.out.println("Hello from printMessage method!");
    }

    public static int addNumbers(int a, int b) {
        return a + b;
    }

    public static String getName(String firstName, String lastName) {
        return firstName + " " + lastName;
    }
}

类和对象

类是对象的蓝图，定义了对象的数据结构及其行为。对象是类的实例，包含了类所定义的数据和方法。

public class Car {
    // 数据成员
    private String brand;
    private int year;

    // 构造函数
    public Car(String brand, int year) {
        this.brand = brand;
        this.year = year;
    }

    // 方法
    public void startEngine() {
        System.out.println("Engine started!");
    }

    public void drive() {
        System.out.println("Car is driving!");
    }

    public String getBrand() {
        return brand;
    }

    public int getYear() {
        return year;
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建对象
        Car myCar = new Car("Toyota", 2020);

        // 访问对象的方法
        myCar.startEngine();
        myCar.drive();

        // 访问对象的数据成员
        System.out.println("Brand: " + myCar.getBrand());
        System.out.println("Year: " + myCar.getYear());
    }
}

构造函数与继承

构造函数是类的一种特殊方法，用于初始化新创建的对象。继承是 Java 中的一个重要特性，允许一个类继承另一个类的属性和方法。

public class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

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

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

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

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog("Buddy");

        myDog.makeSound();  // 输出 "Dog barks!"
    }
}

接口和包

接口定义了一组方法签名，但没有具体实现。类可以实现一个或多个接口，并提供接口中定义方法的具体实现。包用于组织相关的类和接口。

// 接口定义
public interface Moveable {
    void move();
}

// 实现接口的类
public class Car implements Moveable {
    public void move() {
        System.out.println("Car is moving!");
    }
}

// 包的使用
package com.example;

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.move();  // 输出 "Car is moving!"
    }
}

创建个人简历网站

创建一个简单的个人简历网站，展示个人信息、教育背景、工作经验和技能。

项目结构

resume/
└── src/
    ├── controllers/
    │   └── HomeController.java
    ├── models/
    │   └── Person.java
    ├── views/
    │   └── index.jsp
    └── App.java

主应用程序文件 App.java

public class App {
    public static void main(String[] args) {
        // 初始化 Servlet 容器
        ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
        context.setContextPath("/");

        // 注册控制器
        ServletHolder servletHolder = new ServletHolder(new HttpServletDispatcher());
        servletHolder.setInitParameter("dispatchOptionsRequest", "true");
        context.addServlet(servletHolder, "/*");

        // 启动服务器
        Server server = new Server(8080);
        server.setHandler(context);

        try {
            server.start();
            server.join();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            server.destroy();
        }
    }
}

控制器 HomeController.java

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

public class HomeController extends HttpServletDispatcher {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
        request.setAttribute("person", new Person("John Doe", "Developer", "john.doe@example.com"));

        RequestDispatcher dispatcher = request.getRequestDispatcher("/views/index.jsp");
        dispatcher.forward(request, response);
    }
}

模型 Person.java

public class Person {
    private String name;
    private String role;
    private String email;

    public Person(String name, String role, String email) {
        this.name = name;
        this.role = role;
        this.email = email;
    }

    public String getName() {
        return name;
    }

    public String getRole() {
        return role;
    }

    public String getEmail() {
        return email;
    }
}

视图 index.jsp

<%@ page import="com.example.models.Person" %>
<!DOCTYPE html>
<html>
<head>
    <title>Resume</title>
</head>
<body>
    <h1><%= ((Person) request.getAttribute("person")).getName() %></h1>
    <p>Role: <%= ((Person) request.getAttribute("person")).getRole() %></p>
    <p>Email: <%= ((Person) request.getAttribute("person")).getEmail() %></p>
</body>
</html>

实现简单的在线计算器

创建一个简单的在线计算器，支持加法、减法、乘法和除法操作。

主应用程序文件 CalculatorApp.java

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

public class CalculatorApp extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        String op = request.getParameter("operation");
        double num1 = Double.parseDouble(request.getParameter("num1"));
        double num2 = Double.parseDouble(request.getParameter("num2"));

        double result = 0;
        switch (op) {
            case "add":
                result = num1 + num2;
                break;
            case "subtract":
                result = num1 - num2;
                break;
            case "multiply":
                result = num1 * num2;
                break;
            case "divide":
                if (num2 != 0) {
                    result = num1 / num2;
                } else {
                    result = Double.NaN;
                }
                break;
            default:
                result = Double.NaN;
        }

        response.setContentType("text/html;charset=UTF-8");
        response.getWriter().println("<h1>Result: " + result + "</h1>");
    }
}

HTML 界面 calculator.html

<!DOCTYPE html>
<html>
<head>
    <title>Calculator</title>
</head>
<body>
    <form action="/calculator" method="post">
        <label for="num1">Number 1:</label>
        <input type="number" id="num1" name="num1" required>

        <label for="num2">Number 2:</label>
        <input type="number" id="num2" name="num2" required>

        <label for="operation">Operation:</label>
        <select id="operation" name="operation">
            <option value="add">Add</option>
            <option value="subtract">Subtract</option>
            <option value="multiply">Multiply</option>
            <option value="divide">Divide</option>
        </select>

        <input type="submit" value="Calculate">
    </form>
</body>
</html>

开发简易待办事项应用

创建一个简单的待办事项列表应用，支持添加、编辑和删除待办事项。

主应用程序文件 TodoApp.java

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

public class TodoApp extends HttpServlet {
    private List<String> todos = new ArrayList<>();

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        request.setAttribute("todos", todos);
        RequestDispatcher dispatcher = request.getRequestDispatcher("/views/todo.jsp");
        dispatcher.forward(request, response);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        String action = request.getParameter("action");
        String todo = request.getParameter("todo");

        if ("add".equals(action)) {
            todos.add(todo);
        } else if ("delete".equals(action)) {
            int index = Integer.parseInt(request.getParameter("index"));
            todos.remove(index);
        }

        doGet(request, response);
    }
}

视图 todo.jsp

<%@ page import="java.util.List" %>
<!DOCTYPE html>
<html>
<head>
    <title>Todo App</title>
</head>
<body>
    <h1>Todo List</h1>
    <form action="/todo" method="post">
        <input type="text" name="todo">
        <input type="hidden" name="action" value="add">
        <input type="submit" value="Add">
    </form>

    <ul>
        <%
            List<String> todos = (List<String>) request.getAttribute("todos");
            for (int i = 0; i < todos.size(); i++) {
                out.println("<li>" + todos.get(i) + " <a href=\"/todo?action=delete&index=" + i + "\">Delete</a></li>");
            }
        %>
    </ul>
</body>
</html>

常见的IDE工具

Java 开发中最常用的 IDE 工具有 Eclipse、IntelliJ IDEA 和 NetBeans。

Eclipse

Eclipse 是一个免费且开源的 IDE，支持多种编程语言，包括 Java。它提供了丰富的插件和扩展，可以集成各种工具和框架。

安装 Eclipse：

1. 访问 Eclipse 官方网站，下载适合的操作系统版本。
2. 安装下载的安装包，并按照向导步骤完成安装。

IntelliJ IDEA

IntelliJ IDEA 是一款功能强大的 Java IDE，支持多种编程语言和框架。它提供了智能代码完成、代码重构和调试功能。

安装 IntelliJ IDEA：

1. 访问 IntelliJ IDEA 官方网站，下载适合的操作系统版本。
2. 安装下载的安装包，并按照向导步骤完成安装。

NetBeans

NetBeans 是一个跨平台的 IDE，支持 Java 和其他语言。它提供了丰富的开发工具和插件，适合初学者使用。

安装 NetBeans：

1. 访问 NetBeans 官方网站，下载适合的操作系统版本。
2. 安装下载的安装包，并按照向导步骤完成安装。

简单框架的入门使用

Java 开发中常用的框架有 Spring、Hibernate 和 Struts。这里以 Spring 框架为例，介绍如何入门使用 Spring。

Spring 框架入门

Spring 是一个开源的 Java 平台框架，提供了全面的基础设施支持。它简化了 Java 应用的开发，支持依赖注入、面向切面编程等功能。

安装 Spring 框架：

1. 创建一个新的 Maven 项目，添加 Spring 依赖。
2. 在项目中创建一个简单的 Spring 应用。

示例代码：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringDemo {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        MessageRenderer renderer = context.getBean("messageRenderer", MessageRenderer.class);
        renderer.render();
    }
}

public interface MessageRenderer {
    void render();
}

public class MessageRendererImpl implements MessageRenderer {
    private MessageService messageService;

    public void setMessageService(MessageService messageService) {
        this.messageService = messageService;
    }

    @Override
    public void render() {
        System.out.println(messageService.getMessage());
    }
}

public interface MessageService {
    String getMessage();
}

public class MessageServiceImpl implements MessageService {
    @Override
    public String getMessage() {
        return "Hello, World!";
    }
}

在 applicationContext.xml 中配置 Bean：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="messageService" class="com.example.MessageServiceImpl"/>

    <bean id="messageRenderer" class="com.example.MessageRendererImpl">
        <property name="messageService" ref="messageService"/>
    </bean>
</beans>

Hibernate 框架入门

Hibernate 是一个对象关系映射（ORM）框架，用于简化 Java 程序中的数据库访问。以下是一个简单的 Hibernate 示例：

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateDemo {
    public static void main(String[] args) {
        SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
        Session session = sessionFactory.openSession();

        // 添加对象到数据库
        User user = new User("John Doe", "john.doe@example.com");
        session.beginTransaction();
        session.save(user);
        session.getTransaction().commit();

        // 查询数据库
        session = sessionFactory.openSession();
        session.beginTransaction();
        User dbUser = session.get(User.class, user.getId());
        System.out.println(dbUser.getEmail());
        session.getTransaction().commit();
    }
}

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

    public User(String name, String email) {
        this.name = name;
        this.email = email;
    }

    // 省略其他 getter 和 setter 方法
}

Struts 框架入门

Struts 是一个基于 MVC 架构的 Web 应用框架。以下是一个简单的 Struts 示例：

import com.opensymphony.xwork2.ActionSupport;

public class HelloWorldAction extends ActionSupport {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String execute() {
        System.out.println("Hello, " + name);
        return SUCCESS;
    }
}

在 struts.xml 中配置 Action：

<struts>
    <package name="default" extends="struts-default">
        <action name="hello" class="com.example.HelloWorldAction">
            <result name="success">/index.jsp</result>
        </action>
    </package>
</struts>

在线平台和资源

寻找 Java 副业机会的在线平台有很多，包括 Upwork、Freelancer 和 Toptal。这些平台提供了各种 Java 开发项目，适合不同技能水平的开发者。

Upwork 和 Freelancer

这两个平台上的项目通常由个人或企业发布，开发者可以自由申请工作。在申请项目时，需要提交个人简介、作品集和报价，以吸引雇主。

Toptal

Toptal 是一个较高要求的平台，需要通过严格审查才能成为会员。加入后，可以通过 Toptal 平台找到高质量的 Java 开发项目。

创建个人作品集

创建一个个人作品集网站或使用 GitHub 作为在线作品展示平台，有助于吸引潜在雇主的关注。

个人作品集网站

使用静态网站生成器如 Jekyll 或 Hugo 创建一个简单的个人作品集网站。在网站上展示你的技能、项目经验和联系方式。

示例作品集网站结构：

portfolio/
└── src/
    ├── _includes/
    │   └── header.html
    └── _layouts/
        └── default.html
    ├── _posts/
    │   └── 2023-01-01-first-project.md
    └── index.md

示例首页文件 index.md：

---
layout: default
title: Portfolio
---

<h1>Welcome to My Portfolio</h1>

<h2>Projects</h2>
<ul>
  {% for post in site.posts %}
    <li>
        <a href="{{ post.url }}">{{ post.title }}</a>
        <p>{{ post.excerpt }}</p>
    </li>
  {% endfor %}
</ul>

GitHub 仓库

在 GitHub 上创建一个个人仓库，将项目代码推送到仓库中。使用 README 文件描述项目的功能和使用方法。

示例 README 文件：

# MyProjects

This repository contains my personal projects. Feel free to check them out!

## Projects

### Project 1: Online Calculator
An online calculator built with Java Servlets.

- [View Project](https://github.com/yourusername/online-calculator)

### Project 2: Resume Website
A personal resume website built with Java Servlets.

- [View Project](https://github.com/yourusername/resume-website)

项目面试技巧

在面试 Java 开发岗位时，需要准备一些常见面试题的回答和相关项目经验的展示。

常见面试题

1. 解释 Java 中的类和对象？
2. 什么是 Java 集合框架？
3. Java 中的异常处理机制是什么？
4. 解释 Java 中的多态性？
5. Java 中的垃圾回收机制？

展示项目经验

在面试中，除了回答技术问题，还需要展示自己的项目经验。可以通过以下方式展示：

1. 编写简历
   • 在简历中列出相关的项目经验和技术栈。
   • 描述项目的背景、功能和你承担的角色。
2. 准备代码示例
   • 准备一些代码示例，展示你在项目中的具体实现。
   • 准备一些技术细节，如类的设计、算法实现等。
3. 展示作品集
   • 准备你的个人作品集网站或 GitHub 仓库链接，以便面试官查看你的作品。
   • 准备一些截图或视频，展示项目的功能和界面。
4. 回答问题
   • 准备回答关于项目的问题，如项目的设计思路、遇到的问题及解决方案等。

通过以上准备，可以在面试中展示自己的技术和项目经验，提高面试成功率。