Java高效学习行动手册

我的概括

我会围绕“Java高效学习行动手册”建立一条可执行的学习与决策路径。

Java高效学习行动手册:从入门到企业级开发

我的判断是:Java是全球使用最广泛的编程语言之一。

我会先把握这一点:企业级应用、Android开发、大数据,都离不开Java。

这里更重要的是:今天我分享Java的学习路径,帮你从入门到实战。

Java概述

为什么学Java?

  • 落到执行上:应用广泛 :企业级应用、Android、大数据
  • 我的判断是:生态成熟 :框架多、库丰富
  • 我会先把握这一点:跨平台 :一次编写,到处运行(JVM)
  • 这里更重要的是:就业好 :Java岗位需求大

Java能做什么?

领域应用框架/技术
企业级开发电商、金融系统Spring、Spring Boot
Android开发手机应用Android SDK
大数据数据处理Hadoop、Spark
游戏开发MinecraftLibGDX
嵌入式智能设备Java ME

Java学习路线

阶段一:基础语法

落到执行上:学习重点:

  • 我的判断是:数据类型
  • 我会先把握这一点:运算符
  • 这里更重要的是:控制结构
  • 落到执行上:数组
  • 我的判断是:路径
    我会先把握这一点:学习时间: 3-4周

阶段二:面向对象

这里更重要的是:学习重点:

  • 落到执行上:类与对象
  • 我的判断是:继承
  • 我会先把握这一点:多态
  • 这里更重要的是:接口
  • 落到执行上:抽象类
  • 我的判断是:封装
    我会先把握这一点:这是Java的核心!

阶段三:高级特性

这里更重要的是:学习重点:

  • 落到执行上:异常处理
  • 我的判断是:集合框架
  • 我会先把握这一点:泛型
  • 这里更重要的是:注解
  • 落到执行上:反射
  • 我的判断是:枚举
    我会先把握这一点:学习时间: 3-4周

阶段四:企业级开发

这里更重要的是:学习重点:

  • 落到执行上:Spring Boot
  • 我的判断是:MyBatis/MySQL
  • 我会先把握这一点:RESTful API
  • 这里更重要的是:Git
  • 落到执行上:Maven/Gradle

基础语法

数据类型

// 基本数据类型
byte b = 127 ; // 1字节
short s = 32767 ; // 2字节
int i = 2147483647 ; // 4字节
long l = 922337203685477L ; // 8字节
float f = 3.14f ; // 4字节
double d = 3.1415926 ; // 8字节
char c = 'A' ; // 2字节
boolean bool = true ; // 1字节

// 引用类型
String str = "Hello" ;
int [] arr = { 1 , 2 , 3 };

控制结构

// if-else
if (score >= 90 ) {
grade = "A" ;
} else if (score >= 80 ) {
grade = "B" ;
} else {
grade = "C" ;
}

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

// 增强for循环
for ( int num : arr) {
System.out. println (num);
}

// while循环
int i = 0 ;
while (i < 10 ) {
System.out. println (i ++ );
}

// switch
switch (day) {
case 1 :
System.out. println ( "星期一" );
break ;
case 2 :
System.out. println ( "星期二" );
break ;
default:
System.out. println ( "其他" );
}

数组

// 一维数组
int [] arr = { 1 , 2 , 3 , 4 , 5 };
int [] arr2 = new int [ 5 ];

// 二维数组
int [][] matrix = {
{ 1 , 2 , 3 },
{ 4 , 5 , 6 },
{ 7 , 8 , 9 }
};

// 数组操作
int len = arr.length; // 长度
Arrays. sort (arr); // 排序
Arrays. toString (arr); // 转字符串

面向对象

类与对象

public class Student {
// 成员变量
private String name;
private int age;
private String major;

// 构造方法
public Student () {
}

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

// Getter和Setter
public String getName () {
return name;
}

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

// 方法
public void study (String subject ) {
System.out. println (name + "学习" + subject);
}

// toString方法
@ Override
public String toString () {
return "Student{name='" + name + "', age=" + age + ", major='" + major + "'}" ;
}
}

// 使用
Student s1 = new Student ( "张三" , 20 , "CS" );
s1. study ( "Java" );
System.out. println (s1);

继承

// 父类
public class Person {
protected String name;
protected int age;

public void eat () {
System.out. println ( "吃饭" );
}
}

// 子类
public class Student extends Person {
private String major;

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

public void study () {
System.out. println (name + "学习" + major);
}
}

// 使用
Student s = new Student ( "张三" , 20 , "CS" );
s. eat (); // 继承自父类
s. study (); // 子类自己的方法

接口

// 定义接口
public interface Flyable {
void fly ();
}

public interface Swimmable {
void swim ();
}

// 实现接口
public class Duck implements Flyable , Swimmable {
@ Override
public void fly () {
System.out. println ( "鸭子飞" );
}

@ Override
public void swim () {
System.out. println ( "鸭子游泳" );
}
}

多态

// 父类引用指向子类对象
Person p = new Student ( "张三" , 20 , "CS" );
p. eat (); // 调用的是Student的eat方法

// 抽象类
public abstract class Shape {
public abstract double getArea ();
public abstract double getPerimeter ();
}

public class Circle extends Shape {
private double radius;

public Circle ( double radius ) {
this .radius = radius;
}

@ Override
public double getArea () {
return Math.PI * radius * radius;
}

@ Override
public double getPerimeter () {
return 2 * Math.PI * radius;
}
}

我说
我的判断是:>

面向对象是Java的核心思想。 我的理解是,封装、继承、多态 是OOP的三大特性。 从执行角度看,理解了这三个,才能真正掌握Java。

异常处理

// 异常类型
try {
int result = 10 / 0 ;
} catch (ArithmeticException e ) {
System.out. println ( "除数不能为0" );
e. printStackTrace ();
} finally {
System.out. println ( "无论是否异常,都会执行" );
}

// 抛出异常
public void divide ( int a, int b) throws ArithmeticException {
if (b == 0 ) {
throw new ArithmeticException ( "除数不能为0" );
}
System.out. println (a / b);
}

// 自定义异常
public class MyException extends Exception {
public MyException (String message ) {
super (message);
}
}

集合框架

主要集合

集合特点底层实现
ArrayList有序、可重复数组
LinkedList有序、可重复链表
HashSet无序、不可重复哈希表
TreeSet有序、不可重复红黑树
HashMap键值对哈希表
TreeMap有序键值对红黑树

ArrayList

import java.util.ArrayList;

ArrayList< String > list = new ArrayList<>();
list. add ( "Java" );
list. add ( "Python" );
list. add ( "C++" );

// 遍历
for ( int i = 0 ; i < list. size (); i ++ ) {
System.out. println (list. get (i));
}

for (String item : list) {
System.out. println (item);
}

// Lambda遍历
list. forEach (item -> System.out. println (item));

// 操作
list. remove ( 0 ); // 按索引删除
list. remove ( "Java" ); // 按对象删除
list. contains ( "Java" ); // 是否包含
list. size (); // 大小

HashMap

import java.util.HashMap;

HashMap< String , Integer > map = new HashMap<>();
map. put ( "Java" , 98 );
map. put ( "Python" , 92 );
map. put ( "C++" , 88 );

// 遍历
for (String key : map. keySet ()) {
System.out. println (key + ": " + map. get (key));
}

for (Integer value : map. values ()) {
System.out. println (value);
}

for (String key : map. keySet ()) {
Integer value = map. get (key);
System.out. println (key + ": " + value);
}

// Lambda遍历
map. forEach ((key, value) -> System.out. println (key + ": " + value));

常用工具

String

String s = "Hello Java" ;

// 常用方法
s. length (); // 长度
s. charAt ( 0 ); // 字符
s. substring ( 0 , 5 ); // 子串
s. indexOf ( "Java" ); // 查找
s. contains ( "Java" ); // 是否包含
s. startsWith ( "Hello" ); // 是否以...开头
s. endsWith ( "Java" ); // 是否以...结尾
s. toLowerCase (); // 转小写
s. toUpperCase (); // 转大写
s. trim (); // 去空格
s. split ( "," ); // 分割
s. replace ( "Java" , "Python" ); // 替换
s. equals ( "hello" ); // 比较(不能用==)

时间处理

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

LocalDate date = LocalDate. now ();
LocalDateTime datetime = LocalDateTime. now ();

// 格式化
DateTimeFormatter formatter = DateTimeFormatter. ofPattern ( "yyyy-MM-dd HH:mm:ss" );
String formatted = datetime. format (formatter);

// 解析
LocalDate parsed = LocalDate. parse ( "2024-01-01" );

Spring Boot入门

项目结构

src/main/java
├── com.example.demo
│ ├── DemoApplication.java
│ ├── controller
│ │ └── UserController.java
│ ├── service
│ │ ├── UserService.java
│ │ └── impl
│ │ └── UserServiceImpl.java
│ ├── mapper
│ │ └── UserMapper.java
│ └── entity
│ └── User.java

RESTful API

@ RestController
@ RequestMapping ( "/api/users" )
public class UserController {

@ Autowired
private UserService userService;

@ GetMapping ( "/{id}" )
public Result< User > getUser (@ PathVariable Long id ) {
User user = userService. getById (id);
return Result. success (user);
}

@ PostMapping
public Result< Void > addUser (@ RequestBody User user ) {
userService. save (user);
return Result. success ();
}

@ PutMapping ( "/{id}" )
public Result< Void > updateUser (@ PathVariable Long id , @ RequestBody User user ) {
user. setId (id);
userService. update (user);
return Result. success ();
}

@ DeleteMapping ( "/{id}" )
public Result< Void > deleteUser (@ PathVariable Long id ) {
userService. delete (id);
return Result. success ();
}
}

学习资源

书籍

书籍特点
《Java核心技术》经典参考书
《Effective Java》进阶必读
《深入理解Java虚拟机》JVM深入理解
《Spring Boot实战》企业级开发

在线资源

资源说明
菜鸟教程Java入门基础
尚硅谷Java视频教程
敖丙Java技术博客
LeetCode算法练习

项目推荐

项目难度说明
通讯录管理系统入门Java SE
学生成绩管理系统入门JDBC + MySQL
博客系统中等Spring Boot
电商系统进阶微服务

学长私房话

我会先把握这一点:Java是就业最好的编程语言之一。

这里更重要的是:学好了Java,不愁找不到工作。

我的学习方法:
落到执行上:>

理解OOP:Java的核心是面向对象
我的判断是:>

多做练习:敲代码比看书重要
我会先把握这一点:>

做项目:一个项目顶10章书
这里更重要的是:>

学习框架:Spring Boot必学

我踩过的坑
落到执行上:>

我学Java时,光看语法觉得挺简单。 我会把这一点理解为,后来做项目才发现,OOP思想没理解透,很多设计不合理。 我的理解是,Java不是学出来的,是做出来的。

我的判断是:Java学习的核心:

  • 我会先把握这一点:理解OOP
  • 这里更重要的是:掌握集合
  • 落到执行上:理解异常
  • 我的判断是:学习框架
    我会先把握这一点:Java是通向企业级开发的桥梁,加油!

我的延伸

我会围绕输入、练习、反馈和复盘形成闭环,用可解释的例题与项目检验是否真正掌握。

  • 我会先把这篇内容压缩成三个关键词,并写下一个可以在一周内验证的小实验。
  • 我会在决策前补充一个反面案例,确认这条经验的适用边界。
  • 我会在实践后记录结果、偏差和下一步修正,让知识从“读懂”走向“会用”。