Java高效学习行动手册
我的概括
我会围绕“Java高效学习行动手册”建立一条可执行的学习与决策路径。
Java高效学习行动手册:从入门到企业级开发
我的判断是:Java是全球使用最广泛的编程语言之一。
我会先把握这一点:企业级应用、Android开发、大数据,都离不开Java。
这里更重要的是:今天我分享Java的学习路径,帮你从入门到实战。
Java概述
为什么学Java?
- 落到执行上:应用广泛 :企业级应用、Android、大数据
- 我的判断是:生态成熟 :框架多、库丰富
- 我会先把握这一点:跨平台 :一次编写,到处运行(JVM)
- 这里更重要的是:就业好 :Java岗位需求大
Java能做什么?
| 领域 | 应用 | 框架/技术 |
|---|---|---|
| 企业级开发 | 电商、金融系统 | Spring、Spring Boot |
| Android开发 | 手机应用 | Android SDK |
| 大数据 | 数据处理 | Hadoop、Spark |
| 游戏开发 | Minecraft | LibGDX |
| 嵌入式 | 智能设备 | 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是通向企业级开发的桥梁,加油!
我的延伸
我会围绕输入、练习、反馈和复盘形成闭环,用可解释的例题与项目检验是否真正掌握。
- 我会先把这篇内容压缩成三个关键词,并写下一个可以在一周内验证的小实验。
- 我会在决策前补充一个反面案例,确认这条经验的适用边界。
- 我会在实践后记录结果、偏差和下一步修正,让知识从“读懂”走向“会用”。