零基础小白-自学java全栈开发-学习路线-只要看这一篇就可以了（完整版）

小白自述

我是一位刚从大学毕业的学生，想以后从事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开发，通俗一点讲，就是开发类似于淘宝网站。

一个网站的组成部分由这三大块。

1. 页面显示
2. 逻辑处理
3. 数据存储

那与之对应的相关技术

1. html，css，javascript
2. java，servlert，jsp
3. mysql，jdbc

只要掌握以上几种技术，那么一个基本的网站功能就已经实现了。

那么，如果要想在企业中混，只会以上技术还不够滴，因为企业为了提高开发效率，降低系统的维护成本，在开发上往往是采用框架形式，那么就要学习框架设计，主要包括以下几点。

1. springmvc
2. spring
3. mybatis

这些框架就是对应着上面的每个层次，页面显示层使用springmvc框架，业务逻辑处理层使用spring框架，还有数据存储层使用mybatis框架。

好了，这就完了吗？

还没有，企业为了进一步提高开发效率，降低企业用人成本，采用分离式的开发模式。主要技术有如下：

1. vue框架
2. spingboot框架

vue对应着前端的开发，springboot整合了后台开发技术。使得前后台开发完全独立开来。

好了，学到这里，大家应该可以胜任企业的大部分开发要求了，至于其它的技术，大家可以进企业边工作边学习，比如：集群，分布式，消息队列，redis缓存技术，数据库性能优化等技术。

开发工具的使用

在我们的实际开发中，为了提高开发效率，我们一般会使用开发工具。

1. HBuilder
2. Eclipse for j2ee
3. maven
4. git

前端html，css，js开发工具使用HBuilder，后台的java代码一般使用Eclipse，项目架构一般使用maven，还有项目的版本管理工具使用git。

总结一下

要学好java软件开发，必须多看多学多练，多敲代码，当代码量达到一定程度了，那么也就自然会写代码了。

引用下面一句话送给大家：

书山有路勤为径，学海无涯苦作舟。

什么是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程序，那么首先需要安装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中常用的类型有以下几种：

1. int 整数类型
2. float 浮点类型
3. char 字符类型
4. String 字符串类型
5. boolean 布尔类型

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

		
	}

注释：给自己写过的代码添加说明，一边以后阅读。常用的注释有两种：

1. 单行注释
2. 多行注释

//定义了一个变量
	static int a;
	
	/**
	 * 定义了一个方法
	 * 输出变量a的值
	 */
	public static void method(){
   
		
		System.out.println("a的值："+a);
		
	}
	
	
	public static void main(String[] args)  {
   
		

		//调用方法
		method();
		
		
	}

运算符操作

计算机的主要工作就是做 运算 ，然后java中提供了以下几种常用运算操作。

1. 赋值运算
2. 算术运算
3. 关系运算
4. 逻辑运算

赋值运算：就是把一个值赋值给一个标识符，可以是变量或者常量。

算术运算：主要实现数学相关的操作，比如：+、-、*、/、%、++、--等操作。

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--);
		
	}

控制语句

控制语句就是控制程序的执行流程，比如：当条件满足的时候再执行，如果不满足执行其它代码。还有，可以循环控制代码的执行次数。

常用的控制语句如下：

1. if…else if…else
2. while条件循环
3. for条件循环

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工具，版本为：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 main(String[] args)  {
   
		
		com.User user1=new com.User();
		System.out.println(user1.name);
		
		cn.User user2=new cn.User();
		System