手记

Java主流技术实战：新手入门与初级提升指南

慕姐8265434
2024-10-29 17:24:34浏览 80
概述

Java主流技术实战涵盖了从基础入门到高级应用的全面指南，包括Java编程基础、面向对象编程、常用技术框架、Web开发实战以及多线程与并发编程等内容。本文旨在帮助新手快速掌握Java核心技术和提升实战能力，适合初学者和初级开发者参考。希望这些内容能够为你提供有用的信息和实践经验。

Java主流技术实战：新手入门与初级提升指南
Java基础入门

Java简介

Java是一种面向对象的编程语言，由Sun Microsystems（现为Oracle Corporation）开发。Java语言具备平台无关性，这意味着编写的Java程序可以在任何支持Java的平台上运行，无需重新编译。Java还具备内存管理自动化的特性，可以减少内存泄漏和内存溢出的风险。

安装Java开发环境

为了在本地开发Java程序，你需要安装Java开发工具包（JDK）。以下是安装步骤：

  1. 访问Oracle官方网站或相关下载平台下载JDK。
  2. 根据操作系统选择合适的安装包。
  3. 完成安装后，设置环境变量。编辑系统环境变量，在PATH中添加JDK的安装路径。
  4. 验证安装是否成功。打开命令行工具，输入java -version和javac -version，查看是否显示版本信息。

第一个Java程序

创建一个简单的Java程序，输出"Hello, World!"。

  1. 创建一个名为HelloWorld.java的文件。
  2. 在文件中编写以下代码：
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}
  1. 使用命令行工具编译程序。在命令行中输入： 
    javac HelloWorld.java
  2. 编译成功后，运行程序。在命令行中输入： 
    java HelloWorld

Java基本语法

Java的基本语法包括变量、类型、运算符、控制结构等。以下是一些基本概念及其示例代码。

变量与类型

Java支持多种数据类型，包括基本类型和引用类型。

  1. 基本类型：

    • 整型（如int、short、byte、long）
    • 浮点型（如float、double）
    • 布尔型（boolean）
    • 字符型（char）
  2. 示例代码： 
    int age = 25;
double height = 1.75;
boolean isAdult = true;
char gender = 'M';

运算符

Java支持多种运算符，包括算术运算符、逻辑运算符、关系运算符等。

  1. 算术运算符：

    • +、-、*、/、%

  2. 示例代码：

    int a = 10;
int b = 5;
int sum = a + b;          // 15
int diff = a - b;         // 5
int prod = a * b;         // 50
int quot = a / b;         // 2
int rem = a % b;          // 0

  3. 逻辑运算符：

    • &&、||、!

  4. 示例代码：

    boolean x = true;
boolean y = false;
boolean result1 = x && y; // false
boolean result2 = x || y; // true
boolean result3 = !x;     // false

  5. 关系运算符：

    • ==、!=、<、>、<=、>=
  6. 示例代码： 
    int num1 = 10;
int num2 = 20;
boolean isEqual = num1 == num2;  // false
boolean isNotEqual = num1 != num2; // true
boolean isLessThan = num1 < num2;  // true
boolean isGreaterThan = num1 > num2; // false
boolean isLessThanOrEqual = num1 <= num2; // true
boolean isGreaterThanOrEqual = num1 >= num2; // false

控制结构

Java支持多种控制结构，包括条件语句、循环语句等。

  1. 条件语句：if、else if、else

    int score = 85;
if (score >= 90) {
   System.out.println("优秀");
} else if (score >= 70) {
   System.out.println("良好");
} else {
   System.out.println("及格");
}

  2. 循环语句：for、while、do-while

    // for 循环
for (int i = 1; i <= 5; i++) {
   System.out.println(i);
}

// while 循环
int count = 1;
while (count <= 5) {
   System.out.println(count);
   count++;
}

// do-while 循环
int num = 1;
do {
   System.out.println(num);
   num++;
} while (num <= 5);
Java面向对象编程

类与对象

面向对象编程的核心概念是类和对象。类是对象的蓝图，对象是类的实例。

  1. 类的定义：

    class Person {
   // 成员变量
   String name;
   int age;

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

   // 成员方法
   public void introduce() {
       System.out.println("姓名：" + name + "，年龄：" + age);
   }
}

  2. 对象的创建：

    Person person1 = new Person("张三", 25);
Person person2 = new Person("李四", 30);
  3. 调用成员方法： 
    person1.introduce(); // 输出：姓名：张三，年龄：25
person2.introduce(); // 输出：姓名：李四，年龄：30

继承与多态

继承允许一个类继承另一个类的属性和方法，多态允许在一个接口中使用多种形式的实现。

  1. 继承示例：

    class Student extends Person {
   int grade;

   public Student(String name, int age, int grade) {
       super(name, age);
       this.grade = grade;
   }

   public void study() {
       System.out.println(name + "正在学习，年级：" + grade);
   }
}
  2. 多态示例： 
    Person person = new Person("张三", 25);
Student student = new Student("李四", 30, 2);
person.introduce(); // 输出：姓名：张三，年龄：25
student.introduce(); // 输出：姓名：李四，年龄：30
student.study();     // 输出：李四正在学习，年级：2

接口和抽象类

接口定义了类的行为规范，抽象类定义了类的部分行为。

  1. 接口的定义：

    interface Flyable {
   void fly();
}

  2. 实现接口的示例：

    class Bird implements Flyable {
   public void fly() {
       System.out.println("鸟在飞翔");
   }
}

  3. 抽象类的定义：

    abstract class Animal {
   abstract void makeSound();
}
  4. 继承抽象类的示例： 
    class Dog extends Animal {
   public void makeSound() {
       System.out.println("汪汪汪");
   }
}

封装与数据隐藏

封装是将数据和方法打包到一个类中，通过访问修饰符控制数据的访问。

  1. 使用访问修饰符示例：

    class Car {
   private String brand;
   private int year;

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

   // getter 方法
   public String getBrand() {
       return brand;
   }

   public int getYear() {
       return year;
   }

   // setter 方法
   public void setBrand(String brand) {
       this.brand = brand;
   }

   public void setYear(int year) {
       this.year = year;
   }
}
  2. 创建对象并调用方法： 
    Car car = new Car("宝马", 2020);
System.out.println(car.getBrand()); // 输出：宝马
car.setYear(2021);
System.out.println(car.getYear());  // 输出：2021
Java常用技术框架

Spring框架入门

Spring是一个轻量级的企业级开发框架，提供了依赖注入、事务管理、AOP等功能。

  1. 依赖注入示例：

    // 配置类
@Configuration
public class AppConfig {
   @Bean
   public MessageService messageService() {
       return new ConsoleMessageService();
   }
}

// 服务类
@Component
public class ConsoleMessageService implements MessageService {
   @Override
   public void sendMessage(String message) {
       System.out.println("消息：" + message);
   }
}

// 使用依赖注入
@ComponentScan
public class App {
   public static void main(String[] args) {
       ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
       MessageService service = context.getBean(MessageService.class);
       service.sendMessage("Hello Spring!");
   }
}

  2. 事务管理示例：

    // 配置类
@Configuration
@EnableTransactionManagement
public class AppConfig {
   @Bean
   public PlatformTransactionManager transactionManager() {
       return new DataSourceTransactionManager(dataSource());
   }

   @Bean
   public DataSource dataSource() {
       // 配置数据源
       return new DriverManagerDataSource("jdbc:mysql://localhost:3306/test", "root", "password");
   }
}

// 服务类
@Service
public class UserService {
   @Autowired
   private DataSource dataSource;

   @Transactional
   public void insertUser(User user) {
       // 使用事务管理执行数据库操作
   }
}

// 使用事务管理
@ComponentScan
public class App {
   public static void main(String[] args) {
       ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
       UserService service = context.getBean(UserService.class);
       User user = new User();
       service.insertUser(user);
   }
}

MyBatis框架入门

MyBatis是一个持久层框架，提供了SQL映射的解决方案。

  1. 配置文件示例：

    <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>

  2. SQL映射文件示例：

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

  3. 使用MyBatis：

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

public class App {
   public static void main(String[] args) {
       SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader("MyBatisConfig.xml"));
       SqlSession session = sqlSessionFactory.openSession();
       UserMapper mapper = session.getMapper(UserMapper.class);
       User user = mapper.getUserById(1);
       System.out.println(user.getName());
   }
}

Servlet与JSP基础

Servlet和JSP是Java Web开发的基础。

  1. 创建Servlet：

    @WebServlet("/HelloServlet")
public class HelloServlet extends HttpServlet {
   protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
       response.setContentType("text/html;charset=UTF-8");
       PrintWriter out = response.getWriter();
       out.println("<h1>Hello, Servlet!</h1>");
   }
}
  2. 创建JSP： 
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
   <title>My JSP</title>
</head>
<body>
<h1>Hello, JSP!</h1>
</body>
</html>
Java Web开发实战

前后端分离开发

前后端分离开发能够提高开发效率，简化部署和维护工作。

  1. 前端代码示例：

    <!DOCTYPE html>
<html>
<head>
   <title>前端页面</title>
</head>
<body>
   <h1>Hello, Frontend!</h1>
   <script>
       fetch('/api/hello')
           .then(response => response.text())
           .then(data => document.body.innerHTML += `<p>${data}</p>`);
   </script>
</body>
</html>
  2. 后端代码示例： 
    @RestController
@RequestMapping("/api")
public class HelloController {
   @GetMapping("/hello")
   public String hello() {
       return "Hello, Backend!";
   }
}

使用Spring Boot快速搭建Web应用

Spring Boot简化了Spring应用的开发，提供了自动配置和依赖管理。

  1. 创建Spring Boot项目，添加依赖：

    <dependencies>
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
   </dependency>
</dependencies>

  2. 配置文件示例：

    server:
 port: 8080

  3. 创建Controller类：

    @RestController
public class HelloController {
   @GetMapping("/hello")
   public String hello() {
       return "Hello, Spring Boot!";
   }
}
  4. 运行Spring Boot应用： 
    @SpringBootApplication
public class Application {
   public static void main(String[] args) {
       SpringApplication.run(Application.class, args);
   }
}

数据库连接与操作

Java Web应用通常需要与数据库进行交互。

  1. 配置数据库连接：

    spring:
 datasource:
   url: jdbc:mysql://localhost:3306/test
   username: root
   password: password

  2. 创建实体类：

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

   // Getter 和 Setter 方法
}

  3. 创建Repository接口：

    public interface UserRepository extends JpaRepository<User, Integer> {
   // 自定义查询方法
}

  4. 使用Repository进行数据库操作：

    @Service
public class UserService {
   @Autowired
   private UserRepository userRepository;

   public List<User> getAllUsers() {
       return userRepository.findAll();
   }

   public User getUserById(int id) {
       return userRepository.findById(id).orElse(null);
   }

   public void addUser(User user) {
       userRepository.save(user);
   }
}
Java多线程与并发编程

线程基础

Java提供了多线程支持，允许程序同时执行多个任务。

  1. 创建线程示例：

    public class MyThread extends Thread {
   public void run() {
       System.out.println("线程开始运行");
       for (int i = 0; i < 5; i++) {
           System.out.println(Thread.currentThread().getName() + "：" + i);
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
       System.out.println("线程结束");
   }
}

public class Main {
   public static void main(String[] args) {
       MyThread thread1 = new MyThread();
       MyThread thread2 = new MyThread();
       thread1.start();
       thread2.start();
   }
}

  2. 使用Runnable接口创建线程：

    public class MyRunnable implements Runnable {
   @Override
   public void run() {
       System.out.println("线程开始运行");
       for (int i = 0; i < 5; i++) {
           System.out.println(Thread.currentThread().getName() + "：" + i);
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
       System.out.println("线程结束");
   }
}

public class Main {
   public static void main(String[] args) {
       MyRunnable runnable = new MyRunnable();
       Thread thread1 = new Thread(runnable);
       Thread thread2 = new Thread(runnable);
       thread1.start();
       thread2.start();
   }
}

线程同步与锁机制

线程同步是为了防止多个线程同时访问共享资源导致数据不一致的问题。

  1. 使用synchronized关键字：

    public class Counter {
   private int count = 0;

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

   public synchronized int getCount() {
       return count;
   }
}

public class CounterThread extends Thread {
   private Counter counter;

   public CounterThread(Counter counter) {
       this.counter = counter;
   }

   public void run() {
       for (int i = 0; i < 1000; i++) {
           counter.increment();
       }
   }
}

public class Main {
   public static void main(String[] args) throws InterruptedException {
       Counter counter = new Counter();
       CounterThread thread1 = new CounterThread(counter);
       CounterThread thread2 = new CounterThread(counter);
       thread1.start();
       thread2.start();
       thread1.join();
       thread2.join();
       System.out.println("最终计数：" + counter.getCount());
   }
}

  2. 使用Lock接口：

    import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Counter {
   private int count = 0;
   private final Lock lock = new ReentrantLock();

   public void increment() {
       lock.lock();
       try {
           count++;
       } finally {
           lock.unlock();
       }
   }

   public int getCount() {
       lock.lock();
       try {
           return count;
       } finally {
           lock.unlock();
       }
   }
}

public class CounterThread extends Thread {
   private Counter counter;

   public CounterThread(Counter counter) {
       this.counter = counter;
   }

   public void run() {
       for (int i = 0; i < 1000; i++) {
           counter.increment();
       }
   }
}

public class Main {
   public static void main(String[] args) throws InterruptedException {
       Counter counter = new Counter();
       CounterThread thread1 = new CounterThread(counter);
       CounterThread thread2 = new CounterThread(counter);
       thread1.start();
       thread2.start();
       thread1.join();
       thread2.join();
       System.out.println("最终计数：" + counter.getCount());
   }
}

并发编程工具类

Java提供了多种并发工具类，如ExecutorService、CountDownLatch、CyclicBarrier等。

  1. 使用ExecutorService：

    import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Task implements Runnable {
   public void run() {
       System.out.println("任务开始执行");
       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("任务结束执行");
   }
}

public class Main {
   public static void main(String[] args) {
       ExecutorService executorService = Executors.newFixedThreadPool(2);
       executorService.execute(new Task());
       executorService.execute(new Task());
       executorService.shutdown();
   }
}

  2. 使用CountDownLatch：

    import java.util.concurrent.CountDownLatch;

public class Task implements Runnable {
   private CountDownLatch latch;

   public Task(CountDownLatch latch) {
       this.latch = latch;
   }

   public void run() {
       System.out.println("任务开始执行");
       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("任务结束执行");
       latch.countDown();
   }
}

public class Main {
   public static void main(String[] args) throws InterruptedException {
       CountDownLatch latch = new CountDownLatch(2);
       ExecutorService executorService = Executors.newFixedThreadPool(2);
       executorService.execute(new Task(latch));
       executorService.execute(new Task(latch));
       latch.await();
       System.out.println("所有任务执行完毕");
   }
}

  3. 使用CyclicBarrier：

    import java.util.concurrent.CyclicBarrier;

public class Task implements Runnable {
   private CyclicBarrier barrier;

   public Task(CyclicBarrier barrier) {
       this.barrier = barrier;
   }

   public void run() {
       System.out.println("任务开始执行");
       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("任务结束执行");
       barrier.await();
   }
}

public class Main {
   public static void main(String[] args) throws InterruptedException {
       CyclicBarrier barrier = new CyclicBarrier(2);
       ExecutorService executorService = Executors.newFixedThreadPool(2);
       executorService.execute(new Task(barrier));
       executorService.execute(new Task(barrier));
       executorService.shutdown();
   }
}
Java项目实战

实战项目选型

选择合适的框架和技术栈是项目成功的关键。根据项目需求和团队技术背景，可以选择Spring Boot、MyBatis、Spring MVC等技术栈。

  1. 典型的Web项目技术栈：
    • 前端：HTML、CSS、JavaScript、Vue.js、React.js
    • 后端：Spring Boot、MyBatis、Spring MVC
    • 数据库：MySQL、PostgreSQL、MongoDB
    • 服务器：Tomcat、Jetty、Undertow

项目开发流程

项目开发流程通常包括需求分析、设计、编码、测试、部署和维护。

  1. 需求分析：明确项目目标和功能需求。

    • 示例代码：

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

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

 // Getter 和 Setter 方法
}

  2. 设计：设计系统架构、数据库模型、API接口等。

    • 示例代码： 
      server:
port: 8080
spring:
datasource:
 url: jdbc:mysql://localhost:3306/test
 username: root
 password: password
  3. 编码：编写代码实现设计。
  4. 测试：进行单元测试、集成测试、系统测试等。
  5. 部署：将应用部署到服务器。
  6. 维护：监控系统运行状态，处理问题和需求变更。

项目部署与运维

项目部署和运维包括服务器配置、应用部署、监控和日志分析等。

  1. 服务器配置：

    • 操作系统：Linux、Windows
    • 数据库：配置数据库连接参数、备份策略
    • 服务器软件：Tomcat、Nginx等
    • 示例代码： 
      server:
port: 8080
spring:
datasource:
 url: jdbc:mysql://localhost:3306/test
 username: root
 password: password
  2. 应用部署：
    • 使用脚本自动化部署
    • 配置环境变量、数据源等
    • 启动服务器和应用
  3. 监控和日志分析：
    • 使用工具如Prometheus、Grafana监控系统状态
    • 使用ELK Stack（Elasticsearch、Logstash、Kibana）分析日志
  4. 故障排查：
    • 分析日志文件
    • 使用调试工具定位问题
    • 与团队成员协作解决问题

以上是Java主流技术实战的全面指南，帮助新手入门并提升到初级水平。希望这些内容能够为你提供有用的信息和实践经验。

相关标签
Java
0人推荐
随时随地看视频
慕课网APP