我是一位刚从大学毕业的学生，想以后从事java软件开发，但是由于不是计算机相关的专业，也不知道从哪里开始学起？该学哪些内容？也不知道具体往哪个领域发展？需要学习多久才能适合企业开发要求？
于是从百度上搜索java自学以及企业开发要求相关的资料，但是网上东西实在是太多，太杂，比如：需要学习javase，struts，hibernate，springboot，jquery，vue，springmvc ，angularjs，redis，socket，gui，html5等，还有一个叫struts2的，后来进一步了解，才知道这个是框架，以前是叫struts1，现在叫struts2，也不知道它们之间到底有啥区别？现在用哪个比较合适？
还有一个叫mybatis,ibatis的框架，不知道它们是不是同一个东西，看着有点像，然后百度里跟mybatis相关的框架还有hibernate,jpa等，实在是一头雾水，感觉好像是大海捞针一样，还是一片迷茫。
所以，小编在这个为大家分析一下，我们应该怎样去自学java软件开发。
java软件开发领域很广，但是主要集中在javaweb开发，通俗一点讲，就是开发类似于淘宝网站。
一个网站的组成部分由这三大块。
那与之对应的相关技术
只要掌握以上几种技术，那么一个基本的网站功能就已经实现了。
那么，如果要想在企业中混，只会以上技术还不够滴，因为企业为了提高开发效率，降低系统的维护成本，在开发上往往是采用框架形式，那么就要学习框架设计，主要包括以下几点。
这些框架就是对应着上面的每个层次，页面显示层使用springmvc框架，业务逻辑处理层使用spring框架，还有数据存储层使用mybatis框架。
好了，这就完了吗？
还没有，企业为了进一步提高开发效率，降低企业用人成本，采用分离式的开发模式。主要技术有如下：
vue对应着前端的开发，springboot整合了后台开发技术。使得前后台开发完全独立开来。
好了，学到这里，大家应该可以胜任企业的大部分开发要求了，至于其它的技术，大家可以进企业边工作边学习，比如：集群，分布式，消息队列，redis缓存技术，数据库性能优化等技术。
在我们的实际开发中，为了提高开发效率，我们一般会使用开发工具。
前端html，css，js开发工具使用HBuilder，后台的java代码一般使用Eclipse，项目架构一般使用maven，还有项目的版本管理工具使用git。
要学好java软件开发，必须多看多学多练，多敲代码，当代码量达到一定程度了，那么也就自然会写代码了。
引用下面一句话送给大家：
书山有路勤为径，学海无涯苦作舟。
java是一门计算机编程语言，所谓的编程语言就是通过书写一段代码片段，让计算机按照你的要求去执行。
比如：让计算机输出一段简单的信息。
public static void main(String[] args) {
System.out.println("您好，java微课程");
}
可以让计算机自动循环输出10次数据。
public static void main(String[] args) throws InterruptedException {
System.out.println("程序开始执行......");
for (int i = 1; i <= 10; i++) {
System.out.println("输出结果:"+i);
Thread.sleep(1000);
}
System.out.println("程序执行结束......");
}
还可以人机互动数据操作。
public static void main(String[] args) throws InterruptedException {
while(true){
System.out.println("请输入信息");
Scanner sc=new Scanner(System.in);
String info=sc.nextLine();
if(info.equals("bye")){
System.out.println("再见！");
return ;
}
System.out.println("您输入的信息是:"+info);
}
}
软件安装环境 ：要想让计算机运行java程序，那么首先需要安装java的开发环境，这个环境叫JDK（Java Development Kit ），从官网上下载安装包并且安装。
设置环境变量：安装好JDK，设置环境变量，这样就能在计算机的任意位置都能够使用JDK了。
测试JDK能否使用。
java -version
编写java代码：创建一个文件，文件的后缀为 .java，它是由class定义的，而 class 是类的意思，也就是类型，在java的世间里，一切皆为类。
在这个类中，我们可以存放属性以及方法，其中有一个比较特殊的方法，那就是程序入口方法 main，只要程序运行，首先执行的就是这个 main 方法。
public class Test {
public static String name="属性值";
public static void show1(){
System.out.println("方法1");
}
public static void main(String[] args) {
System.out.println(name);
show1();
}
}
以上文件就叫源码，但是java不能执行源码的，执行是后缀为.class 的文件，我们通过javac编译命令 把 .java 源码文件编译成.class 字节码文件。
javac Test.java
然后通过 java执行命令 运行 .class 字节码文件，让计算机执行代码。
java Test
ps:注意，操作系统文件的后缀名默认是隐藏的，需要显示后缀方能修改。
标识符：要使用数据，那么就要先定义名字，这个名字就是标识符的意思，但是要遵守定义规则，名字只能是是字母，_，$开头，不能是关键字，所谓的关键字，就是java已经被定义过了，就不能用来再次定义了。
public static void main(String[] args) {
String name="zhangsan";
String $name="lisi";
String _name="wangwu";
System.out.println("测试输出内容");
}
变量：就是定义的值会发生变化，也就是给名字重新赋值。
public static void main(String[] args) {
String name="zhangsan";
System.out.println("最初名字："+name);
name="lisi";
System.out.println("修改后的名字："+name);
}
常量：相对于变量而言，名字一旦被赋值了，那么就不能再被修改了。
public static void main(String[] args) {
final String name="zhangsa";
final String name2;
name2="lisi";
}
类型：标识符是用来存储数据的，但是这个数据也是可以有类型的。java中常用的类型有以下几种：
public static void main(String[] args) {
int a=100;
float b=3.14f;
char c='a';
String d="abc";
boolean e=true;
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
System.out.println(e);
}
类型之间可以相互装换，但是只局限于同种类型之间的转换。转换的规则是低精度自动转换为高精度，高精度强制转换为低精度。
public static void main(String[] args) {
int a=100;
float b=3.14f;
char c='a';
String d="abc";
boolean e=true;
b=a;
System.out.println(b);
a=(int) b;
System.out.println(a);
}
注释：给自己写过的代码添加说明，一边以后阅读。常用的注释有两种：
//定义了一个变量
static int a;
/**
* 定义了一个方法
* 输出变量a的值
*/
public static void method(){
System.out.println("a的值："+a);
}
public static void main(String[] args) {
//调用方法
method();
}
计算机的主要工作就是做 运算 ，然后java中提供了以下几种常用运算操作。
赋值运算：就是把一个值赋值给一个标识符，可以是变量或者常量。
算术运算：主要实现数学相关的操作，比如：+、-、*、/、%、++、--等操作。
public static void main(String[] args) {
int a = 1;
int b = 2;
int c = 3;
int d = 4;
System.out.println("a+b=" +(a + b) );
System.out.println("a-b=" +(a - b) );
System.out.println("a*b=" +(a * b) );
System.out.println("b/a=" +(b / a) );
System.out.println("b%a=" +(b % a) );
System.out.println("a++=" +(a++) );
System.out.println("a--=" +(++a) );
System.out.println("d++= " +(d--) );
System.out.println("++d= " +(--d) );
}
加号(+)比较特殊，如果符号左右都是数字，那么就按照算术来运算，如果符号有一边只要是字符串，那么就按照字符串拼接运算。
public static void main(String[] args) {
int a = 1;
int b = 2;
System.out.println(a+b);
String c="javawkc";
System.out.println(a+c);
}
在处理算术算术赋值的时候，可以通过以下方式书写。
public static void main(String[] args) {
int a = 1;
a=a+1;
System.out.println(a);
a+=1;
System.out.println(a);
}
关系运算：如果两个数字进行比较，可以使用关系运算符，两数比较的结果是布尔类型 boolean 。
public static void main(String[] args) {
int a = 1;
int b=2;
System.out.println(a==b);
System.out.println(a>b);
System.out.println(a<b);
System.out.println(a!=b);
System.out.println(a>=b);
System.out.println(a<=b);
}
逻辑运算：对布尔结果进行多条件的运算叫逻辑运算，比如：两个布尔的并且运算，或者运算，取反运算。判断的结果还是布尔类型。
public static void main(String[] args) {
boolean a=true;
boolean b=false;
System.out.println(a&&b);
System.out.println(a||b);
System.out.println(!a);
}
运算优先级：
一般是按照先乘除后加减，如果遇到括号先运算括号，自增自减优先运行。
public static void main(String[] args) {
int a=1;
int b=2;
int c=3;
int d=4;
int e=5;
int f=6;
int g=7;
int h=8;
System.out.println(a+b-c*d/(e+f)*++g*h--);
}
控制语句就是控制程序的执行流程，比如：当条件满足的时候再执行，如果不满足执行其它代码。还有，可以循环控制代码的执行次数。
常用的控制语句如下：
public static void main(String[] args) {
boolean flag=true;
if(flag){
System.out.println("执行正确");
}
flag=false;
if(flag){
System.out.println("执行正确");
}else{
System.out.println("执行错误");
}
int i=2;
if(i==0){
System.out.println("输出零");
}else if(i==1){
System.out.println("输出壹");
}else if(i==2){
System.out.println("输出贰");
}else{
System.out.println("输出都不是");
}
int k=0;
while(k<5){
System.out.println("循环输出："+k);
k++;
}
for(int j=0;j<5;j++){
System.out.println("循环输出："+j);
}
}
有时候在一个变量中我们需要保存多个数据，而不止一个数据的时候，那么我们就需要使用数组类型，数组类型就是对java中每种类型的扩展，使得能保存多个数据。
public static void main(String[] args) {
int[] a={
1,2,3,4,5};
String[] b={
"zhangsan","lisi","wangwu"};
boolean[] c={
true,false,true};
System.out.println(a[0]);
System.out.println(b[1]);
System.out.println(c[2]);
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
for (int value : a) {
System.out.println(value);
}
}
在数组中可以存放java中的基本类型以外，还可以存放数组。
public static void main(String[] args) {
int[][] d={
{
1,2},{
3},{
4,5,6}};
int[] e=d[0];
System.out.println(e);
System.out.println(e[0]);
for (int i = 0; i < d.length; i++) {
for (int j = 0; j < d[i].length; j++) {
System.out.print(d[i][j]);
}
System.out.println("");
}
}
如果一些代码被多个地方调用，那么可以把这些代码写在一个功能函数中，也叫方法，再去调用这个方法。
public static void method1(){
System.out.println("输出1");
System.out.println("输出2");
System.out.println("输出3");
System.out.println("输出4");
System.out.println("输出5");
}
public static void main(String[] args) {
System.out.println("使用方法");
method1();
System.out.println("我想在使用");
method1();
}
参数：在定义方法的时候，可以通过定义参数来接受调用者传递的数据。
public static void method2(String name){
System.out.println("调用者是:"+name);
}
public static void main(String[] args) {
System.out.println("使用方法");
method1("张三");
System.out.println("再次使用方法");
method1("李四");
}
返回值：在调用方法的时候，也可以获取方法返回的数据。
public static String method3(String name){
System.out.println("调用者是:"+name);
return name+"-java微课程";
}
public static void main(String[] args) {
System.out.println("使用方法");
System.out.println(method1("张三"));
System.out.println("再次使用方法");
System.out.println(method1("李四"));
}
重载：如果一些方法的含义是一样的，只是功能不一样，那么可以不用另外取新的方法名字，使用同一个名字，通过参数的不同，达到功能的不同。
public static void method(){
System.out.println("普通方法的功能");
}
public static void method(String name){
System.out.println("带一个参数的功能："+name);
}
public static void method(String name,int id){
System.out.println("带两个参数的功能："+name+id);
}
public static void method(int id,String name){
System.out.println("带两个相反顺序参数的功能："+name+id);
}
public static void main(String[] args) {
method();
method("zhangsan");
method("lisi", 1);
method(2,"wangwu");
}
为了提高代码开发效率，我们使用Eclipse工具，版本为：Eclipse IDE for Java EE Developers Photon ，此版本既可以开发J2SE项目，也可以开发后期的J2EE项目，首先从官方网站下载软件。
Eclipse的主界面
点击File新建一个java project
给项目取一个名字，并且选择java环境。
最终的工程界面如下：
类是一种类型，是具体事物的模板描述，而对象就是对类的一个具体的事物描述，比如：定义了一个类型为User的用户类，在使用的时候实例化这个类型成为对象，而这个类型可以实例化多个对象，对象之间彼此独立，互不影响。
构造对象使用 new 关键字实例化。
public class User {
public String name;
}
public static void main(String[] args) {
User user1=new User();
user1.name="张三";
User user2=new User();
user2.name="李四";
User user3=new User();
user3.name="王五";
System.out.println(user1);
System.out.println(user2);
System.out.println(user3);
}
构造函数：在使用 new 关键字构造对象的时候，其实就是在调用类中一个特殊的函数，构造函数 它的主要特点是函数名字和类的名字要一样，没有返回标识。
public class User {
public String name;
public User(){
System.out.println("构造函数");
}
}
构造函数和普通函数也一样，也可以定义参数，在 new 构造的时候传递参数。
public class User {
public String name;
public User(){
System.out.println("构造函数");
}
public User(String name){
System.out.println("带参数的构造函数："+name);
}
}
public static void main(String[] args) {
User user1=new User();
User user2=new User("李四");
}
全局和局部变量：定义在类中的变量称之为全局变量，在类中的每个方法都可以调用这个全局变量。定义在方法体内的变量称之为局部变量。
public class User {
public String name="zhangsan";
public void method1(){
String sex="man";
System.out.println(name+"-"+sex);
}
public void method2(){
String sex="woman";
System.out.println(name+"-"+sex);
}
public void method3(){
String name="lisi";
String sex="woman";
System.out.println(name+"-"+sex);
}
}
public static void main(String[] args) {
User user1=new User();
user1.method1();
user1.method2();
user1.method3();
}
地址引用：当对象作为一个方法的参数传递时，是按照这个对象的内存地址引用的，如果改变方法中对象参数的数据，那么会影响外部定义的那个对象中的数据。
public class User {
public String name="来自于cn包";
public void method1(User user){
System.out.println("接受的名字:"+user.name);
user.name="lisi";
System.out.println("改变后的名字:"+user.name);
}
public void method2(String name){
System.out.println("接受普通的名字:"+name);
name="lisi";
System.out.println("改变普通后的名字:"+name);
}
}
public static void main(String[] args) {
User user=new User();
user.name="zhangsan";
System.out.println("传递之前的名字:"+user.name);
user.method1(user);
System.out.println("调用之后的名字:"+user.name);
String name="zhangsan";
System.out.println("传递普通之前的名字:"+name);
user.method2(name);
System.out.println("调用普通之后的名字:"+name);
}
static关键字：
static是修饰类中的属性和方法的调用方式，普通的属性和方法是属于对象的，是相互独立的。而static修饰的属性和方法是属于类的，是每个对象公用的。
public class User {
public String name;
public static String name2;
}
public static void main(String[] args) {
//第一个对象
User user1=new User();
user1.name="zhangsan";
user1.name2="lisi";
System.out.println(user1.name);
System.out.println(user1.name2);
//第二个对象
User user2=new User();
user2.name="wangwu";
user2.name2="zhaoliu";
System.out.println(user2.name);
System.out.println(user2.name2);
System.out.println(user1.name);
System.out.println(user1.name2);
System.out.println(user2.name);
System.out.println(user2.name2);
}
修饰方法，那么在方法中使用的属性只能是静态的。
public class User {
public String name;
public static String name2;
public void method1(){
System.out.println("方法1"+name+name2);
}
public static void method2(){
System.out.println("方法2"+name2);
}
}
属性和方法使用static修饰，还可以直接通过类调用，不需要实例化对象。
public static void main(String[] args) {
User.name2="张三";
System.out.println(User.name2);
User.method2();
}
包的使用：
java中的包类似于文件夹的功能，可以给定义的类归类，通过关键字pakage修饰，然后通过关键字import导入
package cn;
public class User {
public String name="来自于cn包";
}
import cn.User;
public class Test {
public static void main(String[] args) {
User user2=new User();
System.out.println(user2.name);
}
}
包还可以解决同名类的问题。但是在调用具体包中的类的时候，则需要通过全名引用。
package com;
public class User {
public String name="来自于com包";
}
public static void <