现在培训机构零基础培训的时间一般3-4个月，从最基本的编程语法，到编程项目实际 。一般每天培训8个小时，整体花下来的实际1000个小时左右 。

当然，很多自控力和学习力比较牛逼的同学，可能看看博客和书本，一个月也可以基本入门，甚至拿到了实习的机会。

下面，我收集到了一份Java培训的学习大纲，分享给你参考：

第1周 ： Java基础

第1天：

1.1 软件开发基础

1.1.1 计算机基础 操作系统，文件，目录，可执行程序，常用快捷键

1.1.2 常用的Shell命令

1.1.3 常用开发语言 了解

1.2 JAVA开发环境 需要说明

1.2.1 安装JDK1.7 ，开发环境目录要求

1.2.2 设置环境变量

1.3 第一个JAVA程序HelloWord.java

1.3.1 在记事本编写程序

1.3.2 在Shell命令窗口编译、执行

1.3.3 讲解程序的编译执行过程

1.4 Java编码规范

1.4.1 源码存储规范

1.4.2 命名规则

1.4.3 书写格式

1.4.4 代码注释

第2天：

2.1 关键字、标识符

2.1.1 什么是标识符

2.1.2 标识符的命名规范

2.1.3 JAVA关键字

2.2 常量、进制转换

2.2.1 什么是常量

2.2.2 二进制转换十进制

2.3 变量、数据类型、类型转换

2.3.1 什么是变量

2.3.2 变量的声明和初始化

2.3.3 变量的分类

2.3.4 变量的作用域

2.4 数据类型简介

2.4.1 JAVA中的数据类型

2.4.2 基本数据类型

2.4.3 引用数据类型

2.5 基本数据类型有哪些

2.6 数据类型的取值范围

2.7 数据类型的转换

2.7.1 自动类型转换

2.7.2 强制类型转换

2.8 运算符

2.8.1 常用运算符

2.8.2 算术运算符

2.8.3 赋值运算符

2.8.4 关系运算符

2.8.5 逻辑运算符

2.8.6 三目运算符

2.8.7 字符串连接运算符

2.8.8 位运算符

2.8.9 移位运算符

2.9 表达式的值和类型

2.10 转义字符

2.11 运算符优先级

第3天：

3.1 什么是JAVA语句的执行结构

3.1.1 JAVA语句有哪些结构

3.1.2 顺序语句

3.1.3 分支语句

3.1.4 循环语句

3.2 If语句

3.2.1 简单if语句

3.2.2 复杂if语句

3.2.3 if-else语句

3.2.4 多重if语句

3.2.5 嵌套if语句

3.3 switch语句

3.3.1 switch语句用法

3.3.2 switch使用String分支

3.3.3 switch语句与if语句的区别

第4天

4.1 循环语句

4.1.1 什么是循环

4.1.2 Java中的循环语句

4.2 for循环语句

4.3 while循环

4.1.1 while循环语句

4.1.2 do-while循环语句

4.4 特殊流程控制语句

4.4.1 break语句的使用

4.4.2 continue语句的使用

4.4.3 label 的简述

4.5 比较while和do-while的区别

第5天：

5.1 什么是方法

5.1.1 方法（函数）

5.1.2 方法中的参数

5.1.2.1形参

5.1.2.2实参

5.1.3 方法的返回值

5.2 方法的声明和调用

5.2.1 声明方法的格式

5.2.2 调用方法的格式

第一周综合测试(15:30--17:00)

第6天：数组的应用

6.1 数组的说明

6.1.1 为什么用数组

6.1.2 一维数组的声明与创建

6.1.3 Java内存分析，堆和栈（局部变量存储）

6.2数组的初始化

6.2.1 静态初始化

6.2.2 动态初始化

6.3 数组的访问

6.3.1 通过下标访问指定元素

6.3.2 循环访问

6.4 数组的排序

6.4.1 冒泡排序

6.4.2 选择排序

6.5 数组的查找

6.5.1 顺序查找

6.5.2 二分法查找

6.6 Arrays工具类

6.6.1 工具类中排序和查找

6.7 可变参数

6.7.1 可变参数的写法

6.7.2 可变参数的使用

第7天：

上午

7.1 二维数组

7.1.1 二维数组的声明

7.1.2 二维数组的创建

7.2 二维数组的初始化

7.2.1 静态初始化

7.2.2 动态初始化

7.3 二维数组的访问

7.3.1通过下标访问指定元素

7.3.2通过循环访问数组

面向对象

7.4 面向对象的设计思想

7.4.1 什么是面向对象

7.5 面向对象和面向过程的区别

7.5.1 面向对象

7.5.2 面向过程

7.5.3 区别总结

7.6 类与对象的关系

7.6.1 类的定义

7.6.2 对象的定义

7.6.3 类中成员变量的定义

7.6.4 类中方法的定义

7.6.5 方法的重载

7.7 对象的创建以及内存分析

7.8 构造方法的定义

7.8.1 构造方法的定义

7.8.2 构造方法的使用

7.8.3 构造方法重载

7.8.4 构造方法与普通方法的区别

第8天：封装性（依赖于第5天方法）

8.1 面向对象特性之封装

8.1.1 private 的使用

8.1.2 get/set 方法的说明(讲this之前，参数与成员变量名称要不同)

8.2 this关键字

8.2.1 this.属性：访问本类的成员属性（成员变量与局部变量同名的情况，成员变量无效）

8.2.2 this.方法：访问本类的成员方法

8.2.3 this()：访问本类中的构造函数

8.3 static关键字

8.3.1 静态属性

8.3.2 静态方法

8.3.3 静态代码块

8.4 static的应用

8.4.1 工具类（操作数组常用方法为例，写一个工具类）

8.4.2 工具类的概念

8.5 设计模式

8.5.1单例设计模式

第9天

9.1 继承

9.1.1 继承的概念

9.1.2 类的继承的使用

9.2 super关键字

9.3 继承中的构造方法

9.4 访问权限

9.4.1 private

9.4.2 default（默认）

9.4.3 protected

9.4.4 public

9.5 方法重写

9.5.1 方法重写的规则

9.5.2 Object 类

9.5.2.1 equals()方法

9.5.2.2 hashCode()方法

9.5.2.3 getClass()方法

9.5.2.4 toString()方法

9.6 final关键字

9.6.1 final修饰的类

9.6.2 final修饰的方法

9.6.3 final修饰的属性

9.6.4 final与static的区别

9.7 抽象类和抽象方法

9.7.1 抽象类出现的原因

9.7.2 抽象类的特点

第10天

10.1接口

10.1.1 接口的概念

10.1.2 接口的使用

10.1.2.1 接口的声明语法

10.1.2.2 接口的实现类

10.1.2.3 接口的使用规则

10.1.2.4 接口的使用用途

10.1.2.5 接口与抽象类的区别

10.2多态

10.2.1 什么是多态

10.2.2 多态的体现

10.2.3 对象的多态性

10.2.4 多态的表现形式

10.3对象转型

10.3.1 对象的向上转型

10.3.2 instanceof 关键字

10.3.3 对象的向下转型

10.4 简单工厂设计模式

第11天

11.1内部类

11.1.1 成员内部类

11.1.2 静态内部类

11.1.3 匿名内部类

11.1.4 局部内部类

11.2 面向对象总结

11.3 Eclipse开发工具的介绍

11.3.1 工作空间的概念

11.3.2 工程的概念以及命名规范

11.3.3 包的概念以及命名规范

11.3.3.1 创建包

11.3.3.2 导入包

11.3.3.3 创建包的命名规范

11.3.4 常用快捷键的介绍

11.3.5 工程的导入导出

11.4 综合案例

第12天

12.1 字符串

12.1.1 String类

12.1.2 StringBuffer类

12.1.3 StringBuilder类

12.1.4 String.format() 格式化

12.2 常用类

12.2.1 基本数据类型的包装类

12.2.1.1 基本数据类型与其包装类

12.2.2.2 数据的装箱和拆箱

12.2.2.3 String 与 基本数据类型的互换

12.2.2 Date类

12.2.3 Calendar类

12.2.4 SimpleDateFormat类

12.2.5 Math类

12.2.6 Random类

12.2.7 Runtime类

12.2.8 System类

第13天：

13.1 枚举的简单使用

12.3.1 枚举的定义

12.3.2 枚举的使用（结合switch的使用）

13.2 异常

13.2.1 异常的概念

13.2.2 异常的分类

13.2.3 异常的处理方式

13.2.3.1 捕获异常：try..catch..finally语句

13.2.3.2 抛出异常：throws和throw

13.2.4 自定义异常

13.3 集合框架介绍

13.3.1 集合的概念

13.3.2 集合的框架结构介绍

13.3.3 集合与数组的对比

13.4 Collection接口

13.4.1 集合对象的创建

13.4.2 Collection中常用的方法

13.5 List接口

13.5.1 List接口的存储特点

13.5.2 List接口的实现类

13.5.2.1 ArrayList实现类的使用

13.5.2.2 LinkedList实现类的使用

13.5.2.3 ArrayList与LinkedList存储的比较

13.5.3 增强for循环

13.6 扩展知识-视频

第14天

14.1 泛型的使用

14.1.1 泛型应用在集合上

14.1.2 泛型类声明，方法返回泛型，方法参数泛型

14.1.3 泛型限定 视频

14.2 Iterator迭代器

14.2.1 迭代器的工作原理

14.2.2 迭代器的使用

14.3 集合工具

14.3.1 Collections 工具类

14.3.2 Comparable

14.3.3 Comparator

第15天：

15.1 Set接口

15.1.1 集合的存储特点

15.1.2 HashSet的实现原理

15.1.2.1 重写hashCode()

15.1.2.2 重写equals()

15.1.3 LinkedHashSet(添加)

15.2 Map接口概述

15.3 Map接口的常用方法：重点

15.4 Map接口的常用实现类

15.4.1 HashMap

15.4.2 Hashtable 和 HashMap的区别

15.4.3 LinkedHashMap

15.5 Map的遍历：各种遍历方式 Map.Entry

15.6 集合的总结

第16天：文件与IO流

16.1 File类

16.1.1 File类作用

16.1.2 File类的构造方法

16.1.3 File类常用方法

16.1.4 使用File类对文件进行操作

16.1.5 使用File类浏览目录中的文件和子目录

16.1.6 递归算法遍历目录下所有文件与子目录

16.2 IO概念和种类:

16.2.1 什么是IO流？

16.2.2 流的作用和原理？

16.3 IO流的种类:

16.3.1 按方向分：输入流、输出流

16.3.2 按数据单位分：字符流、字节流

16.3.3 按层次分：节点流、处理流

17.1 字节输入流:

17.1.1 InputStream类的常用方法

17.1.2 InputStream类的子类:文件输入流FileInputStream

17.1.3 FileInputStream构造方法和常用方法

17.2 字节输出流:

17.2.1 OutputStream类的常用方法

17.2.2 OutputStream类的子类:文件输出类FileOutputStream

17.2.3 FileOutputStream构造方法和常用方法

第17天：

17.1字节缓冲流

17.1.1字节缓冲流的构造方法

17.1.2使用字节缓冲流对文件进行读写

17.1.3 装饰设计模式

17.2 字符输入流:

17.2.1 Reader类的常用方法

17.2.2 Reader类的子类:FileReader

17.2.3 FileReader构造方法和常用方法

17.3 字符缓冲流

17.3.1 字符缓冲流构造方法

17.3.2 字符缓冲流的常用方法:readLine()， newLine()

17.3.3 字符缓冲流对文件进行读写

17.4 字符输出流

17.4.1 Writer类的常用方法

17.4.2 Writer类的子类:FileWriter

17.4.3 FileWriter构造方法和常用方法

17.5 转换流

17.5.1 InputStreamReader的构造方法

17.5.2 InputStreamReader的使用

17.5.3 OutputStreamWriter的构造方法

17.5.4 OutputStreamWriter的使用

以下为当天的扩展知识（可不讲）：

17.6打印流

17.6.1打印流构造方法

17.6.2打印流的常用操作:print()， println()

17.7 标准输入输出流

17.7.1 使用System.in获取键盘数据

17.7.2 使用System.out输出数据

第18天

18.1内存流（重点掌握）

18.1.1什么是内存流

18.1.2内存流的构造方法写入到内存和读取内存数据

18.1.3写入到内存和读取内存数据

18.1.4常用方法:toByteArray(), toString()

18.2 数据输入输出流

18.2.1 DataOutputStream 使用

18.2.2 DataInputStream 使用

18.3 对象流

18.3.1 对象序列化

18.3.2 序列化的常用属性:

static的属性不能序列化

transient的属性不能序列化

serialVersionUID=1L

18.3.3 对象输入流ObjectInputStream

18.3.4 对象输出流ObjectOutputStream

18.4 RandomAccessFile类 （看视频，可不讲）

18.4.1 RandomAccessFile类的构造方法

18.4.2 RandomAccessFile常用操作:skipBytes() seek()

18.4.3 常用方法: getFilePointer() writerUTF() readUTF()

18.4.4 向文件中随机写入键盘文字

18.5 IO流总结

第19天 多线程

19.1进程的介绍

19.1.1进程的概念

19.1.2线程的介绍

19.2 线程的概念

19.2.1进程和线程的关系以及区别

19.3 线程的实现

19.3.1 实现Runnable接口

19.3.2 两种实现方式的比较

19.4线程的启动

19.4.1调用start()方法启动线程

19.4.2调用start()与调用run()的区别

19.5 线程的生命周期

19.6 线程的常用方法

19.6.1线程的优先级

19.6.2线程的名称

19.6.3线程的睡眠

19.6.4线程的中断

19.6.5线程的停止

第20天

20.1 多线程访问临界资源时的数据安全问题

20.1.1 synchronized关键字

20.1.2 同步代码块

20.1.3 同步方法

20.1.4 同步静态方法

20.1.5 锁对象

20.1.6 死锁

20.2 生产者消费者 （看视频，可不讲）

20.3 线程池 （只看视频）

20.3.1单线程池

20.3.2固定线程池

20.3.3缓冲线程池

第21天：网络编程

21.1 网络通信协议介绍

21.1.1 TCP/IP协议

21.1.2 IP地址和端口号

21.1.3 基于TCP的网络编程

21.1.4 Socket和ServerSocket

21.1.5 UDP编程(视频)

第22天：HTTP访问

22.1 URL类的使用

22.1.1 什么是URL类

22.1.2 URL的构造方法

22.1.3 URL类的常用方法

22.2 HttpURLConnection类简介（重点）

22.2.1 简单介绍HttpURLConnection类

22.2.2 HttpURLConnection的常用方法

22.3 HttpURLConnection类的应用

22.3.1 HttpURLConnection请求服务器，获取响应的文本

22.3.2 HttpURLConnection下载文件

22.4 OkHttp 简单使用

24.4.1 同步GET、POST请求

22.5 接口回调 ＊＊＊

22.5.1 接口回调结合多线程的应用

22.5.2 OkHttp 异步请求，利用内部类，实现接口回调

第23天：XML 解析

23.1 XML简介

23.1.1 什么是XML

23.1.2 XML语法结构

23.1.3 XML元素定义

23.1.4 XML属性使用

23.1.5 自定义XML文件

23.1.6 XML解析的三种方式说明：SAX, PULL, DOM（只看视频）

23.2 PULL解析

23.2.1 PULL解析原理

23.2.2 PULL解析XML文件

23.2.3网络XML文件解析

23.3 SAX解析

23.3.1 SAX解析的原理

23.3.2 SAX解析常用类介绍

23.3.3 SAX解析XML文件步骤

23.3.4网络XML文件解析

23.4 PULL解析与SAX解析的区别

第24天：JSON解析（重点）

24.1 JSON解析简介

24.1.1 什么是JSON

24.1.2 JSON与XML之间的比较

24.1.3 JSON解析在网络中的应用

24.2 JSON的数据表示

24.2.1 键值对的对象表示

24.2.2 数组的表示

24.3 JSON解析

24.3.1一个对象的JSON解析

24.3.2多个对象的解析

24.3.3复杂对象的解析

24.3.4将集合转成JSON字符串

24.4 官方JSON解析

24.5 Gson解析

第25天

25.1 正则表达式

25.1.1 String 正则

25.1.2 Pattern Matcher

25.1.3 正则元字符

25.1.4 正则表达式

25.2 SQLite数据库

25.2.1 数据库创建

25.2.2 表的创建以及常用约束

25.2.3 增删改查

第26天：

26.1 反射

26.1.1 类的加载 Class.forName()

26.1.2 创建对象的两种方式（newInstance与带参数构造器）

26.1.3 成员变量的访问 Field类 和 getDeclaredField方法

26.1.4 方法的访问与调用 Method

26.1.5 构造方法

26.2 注解

第27天：HTML5的简单应用

27.1 HTML5网页语言：

27.1.1 HTML5介绍

27.1.2 HTML5常用标签

27.1.3 Form表单

27.1.4 HTTP协议分析

27.2 CSS样式-常用的属性

27.3 JavaScript解释脚本语言

第28天 Servlet

28.1 Web服务器搭建-Tomcat

28.2 Servlet简介：

28.2.1 什么是B/S和C/S结构

28.2.2 什么是Servlet？

28.2.3 doGet与doPost方法的区别

28.3 Servlet的应用

28.3.1 信息收集实例

28.3.2 文件上传实例

28.3.3 移动客户端的Http请求处理

第29天： 工具类设计

29.1 工具类设计原则

29.2 单例模式的工具类

29.3 静态方法的工具类

29.4 接口回调的设计过程

29.5 使用Java语言的注意事项

第30天： 核心知识点的综合应用

30.1 面向对象的设计原则

30.2 集合、IO流、异常的应用

30.3 网络请求json数据的应用

30.4 线程池的下载网络资源的应用

如果需要更全的学习资料，可以关注私聊我，免费。

谢邀

学好一个编程语言，这“好”看你要如何定义了？

会用

这个应该是作为学一门编程语言最基本的要求的，要学会用一门编程语言来解决实际项目，这个过程大概几个月左右即可。所以很多培训机构一般也将培训时间控制在几个月内，一般学到这个程度都能够自己多带带开发项目了。

不过作为开发人员来说，会用一门开发语言是远远不够的，一般开发一个项目也会涉及到多门开发语言，就比如说搭建一个网站，作为后端你可以选择java、Python、php等，但是还需要自己设计前端js、css、html这些是少不了的。

当你会用这门语言的时候，只能说你只是入门有了基础而已，后面要学的东西还有很多，这也是为什么说程序员要一直学习。

精通

要达到这个过程需要很久，可能直到你退休的时候也无法真正精通这门语言，因为对于一门编程语言来说，想精通它，还需要很多其他的知识，而这些知识又会需要其他的知识，你只能不停的学习，很难掌握所有的知识，这也是为什么说学无止境

对于开发者来说很难掌握的很全面，所以我觉得刚开始学习的时候可以多学点，把自己的眼界和知识面打开，然后再去选择某个领域一直学习下去。

感谢邀请，作为一个工作多年的程序员，我来分享一下我的个人观点

我的观点是：任何一门语言，要学好，这个时间是无限的。接下来我说下学习一门编程语言的顺序。

1、肯定是要初步了解一下这门语言的发展历史，以及它能做什么，优缺点。

2、学其语法。任何一门编程语言都有自己特定的语法。

3、基础知识、简单的应用。比如用JS写一个小游戏。

4、学习框架，比如Vue，react,angular这些都是不错的框架，先学会使用他们

5、阅读其源代码，学习框架作者优秀的编程思维。

....

当然后面还有更深层次的。以上这些都值得我们在有限的生命不断的学习，这是一个无止境的学习过程。

感谢题主邀请回答。

学好一个编程语言大概要多长时间？这个问题其实是一个最大的误区！可能和我们从小受到的教育体制的影响有关，始终会用学习，学生的态度对待一个新事物。但实际答案是：

学好一个编程语言可能只需要3天。是不是很吃惊？但作为一个有着20年编程经历的IT从业人员来说，这个体会可是工作里得来的。下面就结合Python大大本人的实践经历来详细展开阐述分析这个问题吧。

大大从小也是在传统教育体制下慢慢熬大的，特别是在上大学前，根本体会不到学习的快乐，都是想学好，但只能被动的被灌输，被动的应付考试。但这一切，在上大学后的计算编程的学习体验里被颠覆了，在阅读了国外的计算机教材后颠覆了。上大学时候，入门c++都是那本清华出的谭某的教程，虽然觉得枯燥，但还能上级实习，甚至能发现教材的漏洞，这种体验都是以前无法体会的，居然能捅教材的娄子，这还是感觉很爽的。再读了国外的教材，发现哇，外国人怪不得计算机好，他们的教程就是很不一样，计算机深入浅出的告诉你这个原理怎么来的，而且还能傻瓜化的实践下，让你自己去动手，自己领悟，完全把主动放给了读者，让读者去威武，而不是让教程变成读者心目中的神圣传说。

话说回来，学好一个编程语言大概要花费的时间，就是三天。三天里把语法了解了，大概上手练习下，基本上后面自己就开始实践，结合项目不断的实践，就能把语言搞得很好。这也有实例可以证明。

以前在一个公司，有个重要的服务器系统，用c++写的，有个研发人员维护了2年，结果离职时候，不爽，把代码删除了。当时都傻了！

大大临危受命，来重建这套系统。当时命很好，python也出现了，而且小范围流行。作者带着一个刚毕业的，给了他三天来学习基础语法，然后直接上手做系统，不到2周，整套服务器系统搞定上线，而且维护性还好。那刚毕业的同学刚开始都感觉不可完成这么艰难的任务，特别是用一种新语言，结果，大大就给了他一句话，“只要三天，你就可以学会”，最后，成功了！他现在也一直用Python来做项目，哈哈。现在这套经验，大大也用到教学上，刚开始就让同学直接上手编程，结果也是很喜人的！

希望对大家有用，谢谢！

作为一名刚毕业的软件大学生来说，我自己认为是学习成本还是比较低的吧。

在学校四年学到的一些计算机理论知识其实是远远没有办法应付真实的就业环境的。在大四后半学期我们出去进行了实习。我当初是走的大数据方向，但是去了公司却需要一个产品经理。最后我进行了一个月的自己学习，就可以简单的上手了。剩下的问题其实是在不断的遇到问题，不断的解决问题中成长起来的。

就按我上面所说的这样的话，其实学习的成本并不是很大。自学能力较强的半个月就差不多可以上手了。

除此之外市面上还有一些培训机构。他们从零基础开始学习，大概的周期是三到五个月吧。能让你从零到一定得入手。这个的学费差不多就两万左右吧。讲实话也其实时间和成本花费的并不是很多。

再者说，我们市场上面见到的那些软件。其实都是已经开发好了，有了完整的一套系统。真正的程序员不是去创造代码，而是去将不同的代码再次的组合起来，形成一个新的程序。比如购物商城大同小异都是这个样子的，手机app的小功能根据自己的公司定制成不同的。这其实都不需要太多的改动就可以完成。

所以说，在我看来学习的成本和时间还是很小的。当然前提是你有意向去学习这样一个东西。其中的乐趣其实有很多， 进去了你就知道了。如果有帮助到您的话，点赞收藏，感谢您的关注。

我是去年大学毕业，在培训学校培训了半年。我个人自制力不好，没有去自学。我觉得你既然决定自学的话，那就网上多找找资源，介意不要去学Java，目前市场太饱和，可以考虑前端，如果要是女生的话测试是最好的选择，不过测试不属于编程（自动化测试除外）。你可以关注w3school和letcode这些，csdn上面的一些博主也可以看看

谢谢邀请

这个要看你是自学还是去培训

首先，如果是培训机构进行学习，可以避免少走弯路，而且进行系统培训加实战，一般3-5个月就可学有所成;

其次，如果是自学，如果你认定了要学某种语言，就每天要有自己的规划：

1.每天至少花三个小时以上专心的学习，不要三天打鱼两天晒网，持之以恒对待它;

2.建议去网上实战和视频学习，自学网站推荐https://www.toutiao.com/i6697406763148247566/;

3.必须要有一个老师，如果没有人给你解答，会浪费很多时间，而且大多数问题对于新手来说，你可能琢磨一天，有人指导你，可能很快就能理解明白;

4.实践，任何技术学习都不能仅仅在于理论的掌握，而是要动手操作，动手操作的同时就是认识它的过程;另外要多做项目，代码量的多少决定你学习是否努力是否技能掌握;

总之，学习一定要动手实践，要多做项目，项目在理论基础上，但又在理论之中，只有不断的理论，实践，理论，实践....中不断的学习，技术才能越来越提高！至于要学多久，还是要靠自己努力和悟性！

如果有练习项目，思路通畅的话，1个月就够了.

去力扣中国（https://leetcode-

cn.com

从基础的题目开始刷，刷到100题语言基础就出师了，起码强于或不低于计算机专业的毕业生。继续用人生刷题。不过这里的题目都是语言基础的，不涉及第三方的组件，练习组件以及将组件使用到项目上，这需要工程方面的能力了！别相信大学里的软件工程课程，没什么用的！

软件的功能无外乎两个，解决算法问题，解决数据问题。当下用的最多的是解决数据问题，生产数据、统计数据，算法问题和框架问题基本都是老外在贡献，国内也就ucloud的框架可用！最后看一下学习路线。

1、打好语言基础，熟悉变量，条件控制语句，循环语句，各种数据结构（数组、集合等）；

2、熟练使用第三方组件和框架，这是通往工程之路第一步；

3、熟悉数据库，怎么都绕不开的东西

4、能够从需求出发设计系统，规划系统和开发方案、周期等管理相关工作！

大概两天时间

有思路就可以了