首页手记 Java主流技术学习：新手入门全攻略

Java主流技术学习：新手入门全攻略

标签：

Java 架构

概述

Java主流技术学习涵盖从基础入门到高级应用的全面内容，包括Java开发环境的搭建、面向对象编程、常用框架如Spring和MyBatis的使用，以及Web开发和数据库集成等关键技术。本文旨在帮助新手快速掌握Java开发的核心技能和最佳实践。

Java主流技术学习：新手入门全攻略

Java基础入门

Java简介

Java是一种广泛使用的面向对象编程语言，具备平台无关性、安全性、高效性等特点，适用于开发桌面应用、Web应用、移动应用和企业级应用。Java语言支持自动内存管理，开发环境丰富，拥有大量的库和框架，使得开发过程更加高效。

Java开发环境主要包括Java编译器（javac）、Java虚拟机（JVM）、Java类库（JDK）和开发工具（IDE如Eclipse、IntelliJ IDEA）。

安装Java开发环境

安装Java开发环境需要以下步骤：

下载Java JDK
访问Oracle官方网站下载最新的Java JDK：
```
https://www.oracle.com/java/technologies/javase-downloads.html
```
或者选择OpenJDK，它是Java的一个开源实现，同样支持Java应用的开发：
```
https://openjdk.java.net/install/
```
安装Java JDK
下载后，根据操作系统进行安装。在安装过程中，确保选择安装Java Development Kit（JDK），这样可以包含编译Java程序所需的所有工具。
配置环境变量
安装完成后，需要配置环境变量。编辑PATH环境变量，添加Java安装目录的bin文件夹路径，例如：
```
export PATH=$PATH:/path/to/java/jdk/bin
```
验证安装是否成功，可以在命令行中输入以下命令：
```
java -version
javac -version
```

第一个Java程序

创建第一个Java程序可以按照以下步骤进行：

创建Java文件
使用文本编辑器创建一个名为HelloWorld.java的文件，并输入以下代码：

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

编译Java文件
打开命令行，切换到包含Java文件的目录，使用javac命令编译Java文件：
```
javac HelloWorld.java
```
运行Java程序
编译成功后，会在同一目录下生成一个名为HelloWorld.class的字节码文件。使用java命令运行程序：
```
java HelloWorld
```

简单的Java程序实例

除了Hello World程序，还可以尝试以下简单程序：

public class SumCalculator {
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 20;
        int sum = num1 + num2;
        System.out.println("Sum: " + sum);
    }
}

Java面向对象编程

类和对象

在Java中，类是对象的蓝图，定义了对象的属性和行为。对象是类的具体实例，具有类定义的属性和方法。以下是一个简单的类和对象的示例：

public class Person {
    // 属性
    private String name;
    private int age;

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

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

// 创建Person对象
public class Main {
    public static void main(String[] args) {
        Person person = new Person("Alice", 25);
        person.showDetails();
    }
}

实际应用示例

例如，可以创建一个表示汽车的类：

public class Car {
    private String make;
    private String model;
    private int year;

    public Car(String make, String model, int year) {
        this.make = make;
        this.model = model;
        this.year = year;
    }

    public void displayCarDetails() {
        System.out.println("Make: " + make + ", Model: " + model + ", Year: " + year);
    }
}

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

继承与多态

继承允许一个类继承另一个类的属性和方法。多态允许子类覆盖父类的方法，实现不同的行为。以下是一个继承和多态的示例：

// 父类
public class Animal {
    public void makeSound() {
        System.out.println("Animal makes 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 Main {
    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 class Bird extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Bird chirps");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal bird = new Bird();
        bird.makeSound();
    }
}

封装与抽象

封装允许将数据和方法绑定在一起，防止外部直接访问内部数据。抽象通过接口或抽象类定义行为，不关心具体实现。以下是一个封装和抽象的示例：

// 定义一个抽象接口
public interface Drawable {
    void draw();
}

// 定义一个具体实现
public class Circle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

// 定义一个具体实现
public class Square implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing a square");
    }
}

// 测试类
public class Main {
    public static void main(String[] args) {
        Drawable circle = new Circle();
        circle.draw();

        Drawable square = new Square();
        square.draw();
    }
}

Java常用框架入门

Spring框架简介

Spring框架是一个广泛应用的企业级Java开发框架，提供了IoC（控制反转）和AOP（面向切面编程）等核心功能。Spring框架主要分为几个模块，如核心容器、数据访问、Web开发等。

Spring Boot快速入门

Spring Boot简化了Spring应用程序的开发，提供了自动配置和快速启动的功能。以下是一个简单的Spring Boot应用示例：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@RestController
class HelloController {
    @GetMapping("/")
    public String hello() {
        return "Hello, World!";
    }
}

实际应用示例

例如，可以创建一个简单的REST API：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@RestController
class UserController {
    @GetMapping("/users")
    public String hello() {
        return "Hello, User!";
    }
}

MyBatis框架基础

MyBatis是一个持久层框架，用于处理数据库操作。以下是一个简单的MyBatis示例：

数据库准备
假设有一个用户表users，包含id和name两个字段。

创建Mapper接口

public interface UserMapper {
   User selectUserById(int id);
}

创建Mapper XML文件

<mapper namespace="com.example.UserMapper">
   <select id="selectUserById" resultType="com.example.User">
       SELECT id, name FROM users WHERE id = #{id}
   </select>
</mapper>

配置文件

<configuration>
   <environments default="development">
       <environment id="development">
           <transactionManager type="JDBC" />
           <dataSource type="POOLED">
               <property name="driver" value="com.mysql.jdbc.Driver" />
               <property name="url" value="jdbc:mysql://localhost:3306/test" />
               <property name="username" value="root" />
               <property name="password" value="password" />
           </dataSource>
       </environment>
   </environments>
   <mappers>
       <mapper resource="com/example/UserMapper.xml" />
   </mappers>
</configuration>

测试代码

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class Main {
   public static void main(String[] args) {
       String resource = "mybatis-config.xml";
       SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader(resource));
       SqlSession session = factory.openSession();
       UserMapper mapper = session.getMapper(UserMapper.class);
       User user = mapper.selectUserById(1);
       System.out.println(user.getName());
   }
}

Java Web开发基础

Servlet与JSP

Servlet是Java EE的一部分，用于处理HTTP请求和响应。JSP（JavaServer Pages）是一种动态网页技术，可以在网页中嵌入Java代码。

创建Servlet

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

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

创建JSP页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
   <title>Hello, World!</title>
</head>
<body>
   <h1>Hello, World!</h1>
</body>
</html>

MVC设计模式

MVC（Model-View-Controller）是一种常见的软件架构模式，用于分离应用程序的各个组件。Spring MVC是一个流行的实现方式。

创建Controller

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class HelloController {
   @GetMapping("/")
   @ResponseBody
   public String hello() {
       return "Hello, World!";
   }
}

配置Spring MVC

<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 class="org.springframework.web.servlet.view.InternalResourceViewResolver">
       <property name="prefix" value="/WEB-INF/views/" />
       <property name="suffix" value=".jsp" />
   </bean>
</beans>

创建View

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
   <title>Hello, World!</title>
</head>
<body>
   <h1>Hello, World!</h1>
</body>
</html>

实际应用示例
例如，可以创建一个简单的Web应用，展示一个动态页面：

@Controller
public class SimpleController {
   @GetMapping("/greeting")
   @ResponseBody
   public String greeting() {
       return "Hello, Spring MVC!";
   }
}

Tomcat服务器配置

Tomcat是Apache的开源Java Servlet容器，用于部署和运行Java Web应用。以下是Tomcat的基本配置步骤：

安装Tomcat
下载并解压Tomcat到指定目录。

配置server.xml
编辑conf/server.xml文件，配置端口和服务：

<Server port="8005" shutdown="SHUTDOWN">
   <Connector port="8080" protocol="HTTP/1.1"
              connectionTimeout="20000"
              redirectPort="8443" />
   <Engine name="Catalina" defaultHost="localhost">
       <Host name="localhost" appBase="webapps" unpackWARs="true" autoDeploy="true" />
   </Engine>
</Server>

部署应用
将应用放置在webapps目录下，Tomcat会自动检测并部署应用。
启动Tomcat
进入Tomcat目录，执行以下命令启动Tomcat：
```
bin/startup.sh
```
访问http://localhost:8080查看应用是否成功启动。

数据库与Java集成

JDBC连接数据库

JDBC（Java Database Connectivity）是Java访问数据库的标准接口。以下是一个简单的JDBC示例：

加载驱动

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

public class JdbcExample {
   public static void main(String[] args) {
       try {
           Class.forName("com.mysql.jdbc.Driver");
       } catch (ClassNotFoundException e) {
           e.printStackTrace();
       }
   }
}

连接数据库

Connection conn = null;
try {
   conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "password");
} catch (SQLException e) {
   e.printStackTrace();
}

执行SQL语句

Statement stmt = null;
ResultSet rs = null;
try {
   stmt = conn.createStatement();
   rs = stmt.executeQuery("SELECT * FROM users");
   while (rs.next()) {
       System.out.println(rs.getInt("id") + " " + rs.getString("name"));
   }
} catch (SQLException e) {
   e.printStackTrace();
} finally {
   try {
       if (rs != null) rs.close();
       if (stmt != null) stmt.close();
       if (conn != null) conn.close();
   } catch (SQLException e) {
       e.printStackTrace();
   }
}

实际应用示例

例如，可以创建一个简单的应用程序来查询数据库：

public class DatabaseQueryExample {
    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "password");
            stmt = conn.createStatement();
            rs = stmt.executeQuery("SELECT * FROM users");
            while (rs.next()) {
                System.out.println(rs.getString("name"));
            }
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (rs != null) rs.close();
                if (stmt != null) stmt.close();
                if (conn != null) conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

ORM技术简介

ORM（Object-Relational Mapping）技术用于将对象映射到关系数据库。常见的ORM框架有Hibernate、MyBatis等。

Hibernate框架基础

Hibernate是一个流行的ORM框架。以下是一个简单的Hibernate示例：

创建实体类

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private int id;
   private String name;

   // Getter and Setter methods
}

配置文件

<hibernate-configuration>
   <session-factory>
       <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
       <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/test</property>
       <property name="hibernate.connection.username">root</property>
       <property name="hibernate.connection.password">password</property>
       <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
       <property name="hibernate.hbm2ddl.auto">update</property>
       <property name="hibernate.show_sql">true</property>
       <mapping class="com.example.User" />
   </session-factory>
</hibernate-configuration>

测试代码

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

public class HibernateExample {
   public static void main(String[] args) {
       SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
       Session session = sessionFactory.openSession();
       session.beginTransaction();
       User user = new User();
       user.setName("Alice");
       session.save(user);
       session.getTransaction().commit();
       session.close();
   }
}

Java调试与异常处理

常见调试工具

Java提供了多种调试工具，如JDB（Java Debugger）和IDE内置调试器（如Eclipse、IntelliJ IDEA）。以下是一个使用IDE调试器的基本步骤：

设置断点
在代码中设置断点。
启动调试模式
使用IDE的调试模式启动应用。
单步执行
通过单步执行、步过和步出等方式调试代码。

实际调试示例

例如，可以在以下代码中设置断点并调试：

public class DebugExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        int result = a / b;
        System.out.println("Result: " + result);
    }
}

异常处理机制

Java通过异常处理机制处理程序中的错误。异常处理通常使用try-catch-finally结构。

基本用法

public class ExceptionExample {
   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.");
       }
   }
}

自定义异常

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

public class CustomExceptionExample {
   public static void main(String[] args) {
       try {
           throw new MyException("Custom exception occurred.");
       } catch (MyException e) {
           System.out.println("MyException caught: " + e.getMessage());
       }
   }
}

实际异常处理示例

例如，可以在以下代码中处理输入验证异常：

public class InputValidationExample {
    public static void main(String[] args) {
        try {
            String input = "";
            if (input.isEmpty()) {
                throw new IllegalArgumentException("Input is empty.");
            }
            System.out.println("Input is valid.");
        } catch (IllegalArgumentException e) {
            System.out.println("IllegalArgumentException caught: " + e.getMessage());
        }
    }
}

日志管理

日志管理是开发和维护应用的重要部分。Java提供了多种日志框架，如Log4j、SLF4J等。以下是一个使用SLF4J的基本示例：

引入依赖

<dependency>
   <groupId>org.slf4j</groupId>
   <artifactId>slf4j-api</artifactId>
   <version>1.7.30</version>
</dependency>
<dependency>
   <groupId>org.slf4j</groupId>
   <artifactId>slf4j-simple</artifactId>
   <version>1.7.30</version>
</dependency>

使用日志

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class LoggingExample {
   private static final Logger logger = LoggerFactory.getLogger(LoggingExample.class);

   public static void main(String[] args) {
       logger.debug("Debug message");
       logger.info("Info message");
       logger.warn("Warn message");
       logger.error("Error message");
   }
}

以上是Java主流技术学习的全攻略。从基础入门到高级应用，Java提供了强大的功能和技术支持，使得开发过程更加高效和灵活。希望这篇文章能帮助你掌握Java开发的核心技术和最佳实践。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

德玛西亚99

手记
篇

粉丝

92

获赞与收藏

559

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19278 315

Java 并发原理入门教程

26个小节 39003 568

Java 入门教程

50个小节 342046 3165

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

Java主流技术学习：新手入门全攻略

Java基础入门

Java简介

安装Java开发环境

第一个Java程序

简单的Java程序实例

Java面向对象编程

类和对象

实际应用示例

继承与多态

实际应用示例

封装与抽象

Java常用框架入门

Spring框架简介

Spring Boot快速入门

实际应用示例

MyBatis框架基础

Java Web开发基础

Servlet与JSP

MVC设计模式

Tomcat服务器配置

数据库与Java集成

JDBC连接数据库

实际应用示例

ORM技术简介

Hibernate框架基础

Java调试与异常处理

常见调试工具

实际调试示例

异常处理机制

实际异常处理示例

日志管理

阅读免费教程