1. 编程号首页

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

编程小号 • • 未分类

零基础小白-自学java全栈开发-学习路线-只要看这一篇就可以了（完整版）零基础小白-自学java全栈开发-学习路线-只要看这一篇就可以了（完整版）更多资料请关注微信公众号《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.out.println(user2.name);
		
	}

封装性：在一个类中，有些属性或者方法只能在当前类中被调用，不允许其它类访问，所以通过访问修饰符控制属性或方法的访问权限，这个就是对属性或方法的封装，起到保护作用。

public class Test { 
   

	
	public String name="zhangsan";
	private String sex="man";

	public static void main(String[] args)  { 
   
		
		Test t=new Test();
		System.out.println(t.name);
		System.out.println(t.sex);
		
		t.name="lisi";
		t.sex="woman";
		
		System.out.println(t.name);
		System.out.println(t.sex);
		
		
	}
	

}

public class Test2 { 
   
	
	public static void main(String[] args) { 
   

		Test t=new Test();
		System.out.println(t.name);
		
		t.name="lisi";
		System.out.println(t.name);


	}
	
}

不过有些属性允许外部获取，但是不允许修改，那么可以通过一个方法对其属性访问控制，一般是通过这个属性的set/get方法。

public class Test { 
   

	
	private int age=20;
	
	public int getAge() { 
   
		return age;
	}


	public static void main(String[] args)  { 
   

		
	}
	

}

public class Test2 { 
   
	
	
	public static void main(String[] args) { 
   
		
		
		Test t=new Test();
		System.out.println(t.getAge());
		
		
	}
	

}

还可以只允许修改，不允许查看的属性。

public class Test { 
   

	
	private int money=100;
	

	public void setMoney(int money2) { 
   
		money += money2;
		System.out.println("修改之后总额："+money);
	}




	public static void main(String[] args)  { 
   

		
	}
	

}


public class Test2 { 
   
	
	
	public static void main(String[] args) { 
   
		
		
		Test t=new Test();
		t.setMoney(1);
		t.setMoney(10);
		t.setMoney(100);
		
		
	}
	

}

当在定义set方法的时候，有时候定义的参数名字和成员属性名字一样，那么可以使用this关键字修饰成员属性，以便和方法中的参数名字区分开来。

public class Test { 
   

	
	private int money=100;
	

	public void setMoney(int money) { 
   
		this.money += money;
		System.out.println("修改之后总额："+this.money);
	}


	public static void main(String[] args)  { 
   

		
	}
	

}

继承性：如果每个类中定义的属性和方法有重复的，那么可以使用继承的方式，把其它类中定义的属性和方法继承下来。那么它们之间就成为父子关系，被继承的类叫父类，继承后的类叫子类。通过关键字extends实现继承，但是子类不能继承父类的私有数据。

public class Parent { 
   

	
	private String a="A";
	public String b="B";
	
	public void method1(){ 
   
		
		System.out.println("父类方法");
	}
	
}

public class Child extends Parent { 
   

	
	
	public String c="C";
	
	public void method2(){ 
   
		
		System.out.println("子类中的方法");

	}
	
}

public static void main(String[] args) { 
   

	
		Child child=new Child();
		
		System.out.println(child.b);
		System.out.println(child.c);
		
		child.method1();
		child.method2();
		
	}

多态性：调用同一个对象中的同一个方法的时候，有多种表现形态就叫多态，多态实现的条年有如下：

  1. 有继承关系
  2. 重写父类中的方法
  3. 父类引用子类
public class Animal { 
   

	
	
	public void jiaosheng(){ 
   
		
		
		System.out.println("动物的叫声");
	}
}

public class Dog extends Animal{ 
   

	@Override
	public void jiaosheng() { 
   


		System.out.println("旺旺");
	}

}

public class Cat extends Animal{ 
   

	@Override
	public void jiaosheng() { 
   
		System.out.println("喵喵");
	}


}


public void jiaoshen(Animal animal){ 
   
		

		animal.jiaosheng();
		
	}

	public static void main(String[] args)  { 
   

		

		Dog dog=new Dog();
		Cat cat=new Cat();
		
		Test test=new Test();
		
		test.jiaoshen(dog);
		test.jiaoshen(cat);

		
	}

抽象类：一般类中的方法都有功能实现，但是有些方法不需要实现，只是定义标准，让子类去实现，那么这个类可以定义为抽象类。通过关键字abstract修饰类，不过抽象类不能被实例化，需要子类去实现以及实例化对象。

public abstract class Base { 
   

	
	public void method1(){ 
   
		
		System.out.println("已经实现了方法");
		
	}
	
	public abstract void method2();
	
}

public class Child1 extends Base { 
   

	@Override
	public void method2() { 
   


		System.out.println("子类child1实现了");
		

	}

}

public class Child2 extends Base { 
   

	@Override
	public void method2() { 
   


		System.out.println("子类child2实现了");
		

	}

}

public static void main(String[] args)  { 
   

		
		Base base=new Child1();
		base.method1();
		base.method2();
		
		
		base=new Child2();
		base.method1();
		base.method2();
		
	}

接口：接口和抽象类类似，但是接口中的所有方法都是抽象的，只是定义标准，没有实现，让实现类去实现，使用关键字interface定义接口，使用关键字implements去实现接口。

public interface IBase { 
   

	
	public void method1();
	public void method2();
	
}


public class Imp1 implements IBase { 
   

	@Override
	public void method1() { 
   

		System.out.println("imp1实现方法1");

	}

	@Override
	public void method2() { 
   

		System.out.println("imp1实现方法2");

	}

}

public class Imp2 implements IBase { 
   

	@Override
	public void method1() { 
   

		System.out.println("imp2实现方法1");

	}

	@Override
	public void method2() { 
   

		System.out.println("imp2实现方法2");

	}

}

public static void main(String[] args)  { 
   

		
		IBase base=new Imp1();
		base.method1();
		base.method2();

		base=new Imp2();
		base.method1();
		base.method2();
		
	}

常用类

String:主要是处理字符串的类，通过以下两种方式创建。

public static void main(String[] args)  { 
   


		String a="hello";
		String b=new String("hello");
		
	}

判断字符串是否相等使用==或者equals方法。==好判断的是两个对象的内存地址，而equals方法判断的是两个对象的内容是否相等。

	public static void main(String[] args)  { 
   


		String a="hello";
		String b=new String("hello");
		
		System.out.println(a==b);
		System.out.println(a.equals(b));
		
	}

字符串的拼接可以使用+号或者concat方法。

public static void main(String[] args)  { 
   

		

		String a="he";
		String b="llo";
		
		String c=a+b;
		System.out.println(c);
		
		String d=a.concat(b);
		System.out.println(d);
		
		
	}

通过字符串拼接，再使用==号判断是否相等。

public static void main(String[] args)  { 
   


		String a="hello";
		String b="he";
		String c="llo";
		String d=b+c;
		
		System.out.println(a==d);
		
		String e="he"+"llo";
		System.out.println(a==e);
		
	}

StringBuffer:这个类主要是用字符串拼接，因为使用+号拼接字符，变量是不可变的，拼接的时候重新分配内存，浪费内存使用率，所以使用StringBuufer类处理字符串拼接，提高字符串内存使用率。

public static void main(String[] args)  { 
   

		String a="hello";
		String b="java";
		String c="wkc";
		
		String d=a+b+c;
		System.out.println(d);

		StringBuffer sb=new StringBuffer();
		sb.append(a);
		sb.append(b);
		sb.append(c);
	
		
		System.out.println(sb);
		
	}

Date:主要是关于日期的操作类，可以获取当前日期，也可以分别获取年月日时分秒。

public static void main(String[] args)  { 
   

		Date date=new Date();
		
		System.out.println(date);
		
		System.out.println("年:"+(date.getYear()+1900));
		System.out.println("月:"+(date.getMonth()+1));
		System.out.println("日:"+date.getDate());
		System.out.println("时:"+date.getHours());
		System.out.println("分:"+date.getMinutes());
		System.out.println("秒:"+date.getSeconds());
	}

也可以通过指定的值设置日期。

public static void main(String[] args)  { 
   

		Date date=new Date(2020,1,1,8,30,20);
		
		System.out.println(date);
		
		System.out.println("年:"+date.getYear());
		System.out.println("月:"+date.getMonth());
		System.out.println("日:"+date.getDate());
		System.out.println("时:"+date.getHours());
		System.out.println("分:"+date.getMinutes());
		System.out.println("秒:"+date.getSeconds());
	}

SimpleDateFormat 默认输出的日期格式不大符合国情，在中国，日期显示的格式一般是：xxxx年xx月xx日 xx.xx.xx。

public static void main(String[] args)  { 
   

		Date date=new Date();
		
		System.out.println(date);
		
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
		
		String date2=sdf.format(date);
		
		System.out.println(date2);
		
	}

DecimalFormat:用来格式化数字的一个类，比如：把一个小数，格式化成小数点后面2位的数字。

public static void main(String[] args)  { 
   

		DecimalFormat df=new DecimalFormat("#.##");
		
		float f=3.1415926F;
		
		System.out.println(df.format(f));
		
		f=123.456F;
		
		System.out.println(df.format(f));
		
		df.applyPattern("#####.######");
		System.out.println(df.format(f));
		
		df.applyPattern("00000.00000");
		System.out.println(df.format(f));
		
	}

Math:处理数学相关的帮助类，比如：绝对值，取最大最小值，获取随机数字，四舍五入等操作。

public static void main(String[] args)  { 
   

		int a=-100;
		int b=200;
		
		System.out.println(Math.abs(a));
		System.out.println(Math.max(a,b));
		System.out.println(Math.random());
		System.out.println(Math.round(2.5));
		System.out.println(Math.ceil(2.00001));
		System.out.println(Math.floor(3.999999));
	}

包装类：把基本类型包装成对象类型就称之为包装类，这样基本类型就拥有对象类型的方法，方便对数据的处理。

public static void main(String[] args)  { 
   

		int a=10;
		
		System.out.println(a);
		
		Integer b=10;
		
		System.out.println(b);
		
		System.out.println(b.floatValue());
		System.out.println(b.compareTo(20));
		System.out.println(b.toString());
		
		
	}

包装类还提供了一些常用的静态方法。比如：获取最大值，字节数，转化为字符串，二进制位等。

public static void main(String[] args)  { 
   

		int a=10;
		
		System.out.println(Integer.MAX_VALUE);
		System.out.println(Integer.SIZE);
		String a1=Integer.toString(a);
		System.out.println(a1+"1");
		
		String a2=Integer.toBinaryString(a);
		System.out.println(a2);
		
		
	}

在这里，需要注意对值的比较，这个需要看定义的方式。主要定义有如下3种：

  1. int a=10
  2. Integer a=10;
  3. Integer a=new Integer(10);

不同的定义方式，它们比较的值也有所不一样，还要看值。

public static void main(String[] args)  { 
   

		int a=10;
		Integer b=10;
		Integer c=new Integer(10);
		Integer d=new Integer(10);
		
		System.out.println(a==b);
		System.out.println(a==c);
		System.out.println(b==c);
		System.out.println(c==d);
		
		Integer e=10;
		
		System.out.println(b==e);
		b=128;
		e=128;
		System.out.println(b==e);
		
		
	}

Scanner类：

我们可以通过System.out.print往控制台输出信息，那么我们也可以通过System.in向控制台输入数据，最后通过Scanner类来接受控制台的数据在程序中使用。

public static void main(String[] args) { 
   

			
		Scanner sc=new Scanner(System.in);
		System.out.println("请输入一个字符串");
		String a=sc.next();
		
		System.out.println("请输入一个整数");
		int b=sc.nextInt();
		
		System.out.println("请输入一个小数");
		float c=sc.nextFloat();
		
		System.out.println("a的值:"+a);
		System.out.println("b的值:"+b);
		System.out.println("c的值:"+c);
		
		 

	}

集合类

集合是数组的另外一种表达方式，因为在使用数组的时候还是比较麻烦的，比如：存的数据超过数组本身定义的大小，会出现数组越界问题，还有，定义什么类型的数组，那么只能存放什么类型的数据，而集合则方便很多，功能也很多，除了存放很多数据之外，还有另外一种格式：键值对的形式存放，便于我们通过键获取值。
集合的主要接口有以下几种：

  1. collection
  2. list
  3. set
  4. map

list存放有序可以重复的数据。它的实现类是ArrayList。

public static void main(String[] args)  { 
   

		
		List list=new ArrayList();
		
		list.add("zhangsan");
		list.add("lisi");
		list.add("wangwu");
		list.add("zhaoliu");
		list.add("lisi");
		
		System.out.println(list);
		
		list.add(100);
		list.add(true);
		System.out.println(list);
		
		for (int i = 0; i < 100; i++) { 
   
			list.add(i);
		}
		System.out.println(list);
		
		System.out.println(list.get(3));
		
		list.remove(0);
		System.out.println(list);
		
		list.add(1, "javawkc");
		
		System.out.println(list);

		for (int i = 0; i < list.size(); i++) { 
   
			System.out.println(list.get(i));
		}
		
		Iterator it=list.iterator();
		while(it.hasNext()){ 
   
			
			System.out.println(it.next());
			
		}
	}

set存放不可重复的数据，它的实现类是HashSet。

public static void main(String[] args)  { 
   

		
		Set set=new HashSet();
		set.add("a");
		set.add("b");
		set.add("a");
		System.out.println(set);
		
		Iterator it=set.iterator();
		while(it.hasNext()){ 
   
			
			System.out.println(it.next());
			
		}
		
	}

map是以键值对的形式存放数据的，它的实现类是HashMap。

public static void main(String[] args)  { 
   

		

		Map map=new HashMap();
		map.put("a", "A");
		map.put("b", "B");
		map.put("c", "C");
		
		System.out.println(map);
		
		System.out.println(map.get("a"));
		
		Set key=map.keySet();
		System.out.println(key);
		
		Collection value=  map.values();
		System.out.println(value);
		
		map.remove("a");
		System.out.println(map);
		
	}

内部类

什么是内部类：内部类是定义在一个类中的类，比如说我们可以在类中定义一个成员属性，那么这个成员属性可以是字符串类型，可以是数字类型，还可以是类，那么这个类就叫内部类。

	private String name="zhangsan";
	
	private class InnerClass{ 
   
		
		private String name="lisi";
		
	}

public static void main(String[] args) throws Exception { 
   
		
		Test2 t=new Test2();
		System.out.println(t.name);
		
		Test2.InnerClass inner=t.new InnerClass();
		System.out.println(inner.name);
	
		
	}

还有一种内部类叫匿名内部类，就是说它是一个内部类，但是没有名字。

 interface IA{ 
   
	
	 public String name="wangwu";
	
}


	public static void main(String[] args) throws Exception { 
   
		
		Test2 t=new Test2();
		
		t.show(new IA(){ 
   });
		
	}
	
	public void show(IA ia){ 
   
		
		System.out.println(ia.name);
	}

异常处理

什么是异常：异常就是程序在遇到某些错误的时候，可以通过某种手段捕获错误，而不至于程序终止的一种机制。像这种错误叫异常。它相当于其它错误来说，是可控的，而普通错误就不能被捕获，程序遇到普通错误就只能终止。

public static void main(String[] args) { 
   

		Scanner sc=new Scanner(System.in);
		
		while(true){ 
   

		System.out.println("请输入第一个数字");
		
		int a=sc.nextInt();
		
		System.out.println("请输入第二个数字");
		
		int b=sc.nextInt();		

		try{ 
   
		System.out.println("结果为:"+a/b);
		}catch(Exception ex){ 
   
			
			System.out.println("第二个数字不能是0");
		}
		 
		} 

	}

MySQL数据库

什么是数据库：数据库（DB）就是存放数据的一个仓库，而数据库管理系统（DBMS）就是通过一定的方式来存储数据，然后通过命令去操作这个数据。而MySQL是数据库管理系统中的一种，所以更准确的来说，MySQL是数据库管理系统，它包含了数据库的功能。

数据库安装：到mysql数据官网上下载数据库服务器安装软件。

在这里插入图片描述
选择Complet完整版安装。

在这里插入图片描述
到这里，我们数据库已经安装完成，接下来点击Finish配置数据库。

在这里插入图片描述
数据库的默认端口最好就用3306，如果此端口被占用，可以用别的端口号，在端口号后面的有个选择框，最好√一下，添加到防火墙例外中。否则会被防火墙屏蔽了。

在这里插入图片描述
选择最后一个自定义编码，切记，先选择，然后再修改Character Set选择utf8编码集，否则在数据库中的中文会有乱码问题的。

在这里插入图片描述
在这里设置数据库默认账号root的密码，要记住密码。

在这里插入图片描述
最后点击Execute只有但4个都是绿色√才能成功安装数据库。
如果第三个是红色×，则需要删除注册表中的信息，重新安装
如果第四个是红色×，则说明能成功安装数据库，但是密码策略有问题，需要激活成功教程密码，不需要重装数据库。

数据库的基本使用：

  1. 连接数据库
  2. 显示现有的数据库
  3. 创建数据库
  4. 使用数据库
mysql -hlocalhost -uroot -p

show databases;

create database testdb;

use testdb;

DDL数据库定义:就是用来定义数据库表结构，创建字段的一种命令。

创建表结构

CREATE TABLE `tb1`(  
  `id` INT,
  `name` VARCHAR(10),
  `birthday` DATE
);

修改表结构

ALTER TABLE `tb1`   
  CHANGE `name` `name2` VARCHAR(10);

增加列

ALTER TABLE  `tb1`   
  ADD COLUMN `sex` CHAR(1) AFTER `birthday`;

删除列

ALTER TABLE `tb1`   
  DROP COLUMN `sex`;

删除表结构

DROP TABLE tb1;

DML数据库操作:对表中的数据进行增删改查所用的命令就是数据库操纵语言。

增加数据

insert into tb1(id,name) values(1,'zhangsan');

修改数据

update tb1 set name='lisi';

删除数据

delete from tb1;

带条件的修改和删除数据

update tb1 set name='wangwu' where id=1;
delate from tb1 where id=1;

查询数据

select * from tb1;
select name from tb1;
select name as n from tb1;

select * from tb1 where name='zhangsan';
select * from tb1 where name like '%zhan%';

多表操作：就是多个表关联操作，首先在定义多个表的时候要建立它们的关系，一般一个表为主表，另外一个表为从表，它们是主从关系。在主表上建立一个列为主键，从表上建立一个列为外键，通过主外键关联两表之间的关系。

比如：有一个用户表，和一个电话信息表，它们之间有一种关系，就是一个用户有多个电话号码。

CREATE TABLE `user`(  
  `id` INT NOT NULL,
  `name` VARCHAR(10),
  PRIMARY KEY (`id`)
);

CREATE TABLE `tel`(  
  `id` INT NOT NULL,
  `num` VARCHAR(18),
  `uid` INT,
  PRIMARY KEY (`id`),
  FOREIGN KEY (`uid`) REFERENCES `test2`.`user`(`id`)
);

存放两个个用户信息以及三个号码信息

INSERT INTO USER(id,NAME) VALUES(1,'zhangsan');
INSERT INTO USER(id,NAME) VALUES(2,'lisi');

INSERT INTO tel(id,num,uid) VALUES(1,'13888888881',1);
INSERT INTO tel(id,num,uid) VALUES(2,'13888888882',1);
INSERT INTO tel(id,num,uid) VALUES(3,'13888888882',1);

通过关联查询两个表，可以查询出zhangsan对应的电话号码信息

SELECT b.id,b.name,a.num
FROM tel a
LEFT JOIN USER b
ON a.uid=b.id
WHERE b.id=1

数据库备份还原：

mysqldump  -hlocalhost -P3306 -uroot -p123456  --database test2 > c:/file/test2.sql

source c:/file/test2.sql

JDBC操作

JDBC(Java DataBase Connectivity)就是使用java去连接数据库，并且操作数据库的一种技术，在使用的时候需要JDBC驱动包，因为java没有自带的数据库操作程序。

首先从官网上去下载Connector/J驱动包。

其次把驱动包复制到工程中，再把驱动包添加到builder path中。

在这里插入图片描述
在这里插入图片描述

通过java去连接mysql数据库

public static void main(String[] args) { 
   
		
		try { 
   
			Class.forName("com.mysql.jdbc.Driver");
		} catch (ClassNotFoundException e) { 
   
			e.printStackTrace();
		}
		
		String url="jdbc:mysql://localhost:3306/testdb";
		String user="root";
		String password="123456";
		
		try { 
   
			Connection conn=DriverManager.getConnection(url, user, password);
			System.out.println(conn);
		
		} catch (SQLException e) { 
   
			e.printStackTrace();
		}
		
		

	}

插入数据

			String sql=" insert into user(id,name) values(?,?) ";
			
			PreparedStatement pcmd=conn.prepareStatement(sql);
			pcmd.setInt(1, 2);
			pcmd.setString(2, "李四");
			
			pcmd.execute();

删除数据

			String sql=" delete from user where id=? ";
			
			PreparedStatement pcmd=conn.prepareStatement(sql);
			pcmd.setInt(1, 2);
			
			pcmd.execute();

更新数据

			String sql=" update user set name=? where id=? ";
			
			PreparedStatement pcmd=conn.prepareStatement(sql);
			
			pcmd.setString(1, "张三");
			pcmd.setInt(2, 1);
			
			pcmd.execute();

查询数据

			String sql=" select * from user where id=? ";
			
			PreparedStatement pcmd=conn.prepareStatement(sql);
	
			pcmd.setInt(1, 1);
			
			ResultSet rs= pcmd.executeQuery();
			
			rs.next();
			
			int id=rs.getInt("id");
			String name=rs.getString("name");
			
			System.out.println("编号:"+id);
			System.out.println("姓名:"+name);

查询多条数据

			String sql=" select * from user where 1=1 ";
			
			PreparedStatement pcmd=conn.prepareStatement(sql);
	
			ResultSet rs= pcmd.executeQuery();
			
			while(rs.next()){ 
   
				
				int id=rs.getInt("id");
				String name=rs.getString("name");
				
				System.out.println("编号:"+id);
				System.out.println("姓名:"+name);
			}

			List userList=new ArrayList();
			String sql=" select * from user where 1=1 ";
			
			PreparedStatement pcmd=conn.prepareStatement(sql);
	
			ResultSet rs= pcmd.executeQuery();
			
			while(rs.next()){ 
   
				User user=new User();
			
				user.setId(rs.getInt("id"));
				user.setName(rs.getString("name"));
				
				userList.add(user);
				
			}

		System.out.println("所有用户集合:"+userList);

I/O输入输出流

java支持对硬盘文件的输入以及输出，我们可以使用Writer抽象类实现文件的写操作，使用Reader抽象类实现文件的读操作。
所谓的读/写，就是把数据从硬盘->程序，这个过程就是读取，从程序->硬盘，这个过程就是写入。

因为Write和Reader都是抽象类，那么需要一个实现类去读写文件，文件的读写实现类是FileWrite和FileReader

public static void main(String[] args) throws  Exception { 
   

			
		Writer w=new FileWriter("c:/file/test.txt");
		
		w.write("hello zhangsan");
		w.write("\r\n");
		w.write("i am student");
		
		w.flush();
		w.close();
		 

	}

public static void main(String[] args) throws  Exception { 
   

		Reader r=new FileReader("c:/file/test.txt");
		char[] cbuf=new char[5];
		int count=0;
		while((count=r.read(cbuf))!=-1){ 
   
			System.out.print(new String(cbuf,0,count));
		}
		
		r.close();


	}

public static void main(String[] args) throws  Exception { 
   

			
		Reader r=new FileReader("c:/file/test.txt");
		BufferedReader bReader=new BufferedReader(r);
		String info="";
		
		while((info=bReader.readLine())!=null){ 
   
			System.out.println(info);
		}
		
		r.close();
		bReader.close();


	}

多线程

如果执行一件任务需要10分钟，那么把这个任务放在多线程中执行，只要5分钟，如果多开几个线程，可能只要1分钟就能完成任务，这个就是多线程操作。

要实现多线程，我们定义的类需要实现Runnable接口。

	int count=50;

	public static void main(String[] args) throws  Exception { 
   

			
		Test2 t=new Test2();
		
		long start=System.currentTimeMillis();
		
		while(t.count>0){ 
   
			
			System.out.println("当前数字："+t.count);
			
			try { 
   
				Thread.sleep(100);
			} catch (InterruptedException e) { 
   
				e.printStackTrace();
			}
			t.count--;
			
		}
		
		long end=System.currentTimeMillis();
		
		System.out.println("总共消耗:"+(end-start));
		System.out.println("count值："+t.count);
		

	}

	int count=50;
	

	public static void main(String[] args) throws  Exception { 
   

			
		Test2 t=new Test2();
		
		Thread t1=new Thread(t);
		Thread t2=new Thread(t);
		
		
		long start=System.currentTimeMillis();
		
		t1.start();
		t2.start();
		
		t1.join();
		t2.join();

		long end=System.currentTimeMillis();
		
		System.out.println("总共消耗:"+(end-start));
		System.out.println("count值："+t.count);
		


	}

	@Override
	public void run() { 
   


		while(this.count>0){ 
   
			
			try { 
   
				Thread.sleep(100);
			} catch (InterruptedException e) { 
   
				e.printStackTrace();
			}
			System.out.println("当前数字："+this.count);
			this.count--;
			
			
		}
		
	}

如果遇到线程安全，则需要同步处理，使用该关键字synchronized。

	int count = 50;

	public static void main(String[] args) throws Exception { 
   

		Test2 t = new Test2();

		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);

		long start = System.currentTimeMillis();

		t1.start();
		t2.start();

		t1.join();
		t2.join();

		long end = System.currentTimeMillis();

		System.out.println("总共消耗:" + (end - start));
		System.out.println("count值：" + t.count);

	}

	@Override
	public void run() { 
   

		while (this.count > 0) { 
   

			try { 
   
				Thread.sleep(100);
			} catch (InterruptedException e) { 
   
				e.printStackTrace();
			}

			synchronized (this) { 
   
			
			if (!(this.count <= 0)) { 
   
				
				System.out.println("当前数字：" + this.count);
				this.count--;

			}
			
			}

		}

	}

网络编程

输入输出流操作的是单个计算机中的硬盘数据，那么如果是两台或者多台计算机之间进行通讯，就可以使用java的网络接口来实现，一个是客户端接口Socket，还一个是服务器端接口ServerSocket，服务器端监听客户端的网络请求，一旦有客户端请求过来，就可以接受客户端的数据，然后可以往客户端响应信息，进而实现两台计算机之间的通讯了。

服务端程序：

public static void main(String[] args) throws  Exception { 
   

		ServerSocket ss=new ServerSocket(8080);
		
		System.out.println("正在等待客户端请求......");
		Socket s= ss.accept();
		
		InputStream in=s.getInputStream();
		DataInputStream dis= new DataInputStream(in);
		String info="";
		while((info=dis.readUTF())!=null){ 
   
			
			System.out.println("来自客户端信息："+info);
			
			OutputStream out= s.getOutputStream();
			DataOutputStream dout=new DataOutputStream(out);
			dout.writeUTF("您好，我已经收到你的消息了");
			dout.flush();
		}
	}

客户端程序：

		Socket s=new Socket("localhost", 8080);
		
		OutputStream out= s.getOutputStream();
		
		DataOutputStream dout=new DataOutputStream(out);
		Scanner sc=new Scanner(System.in);
		while(true){ 
   
			System.out.println("请输入要发送的数据");
			dout.writeUTF(sc.nextLine());
			dout.flush();
			
			InputStream in=s.getInputStream();
			DataInputStream dis= new DataInputStream(in);
			System.out.println("来自服务器的回应:"+dis.readUTF());
		}

GUI图形界面

每一个项目都有界面，界面的设计主要有以下几种：

  1. 控制台界面
  2. 图形化用户界面
  3. web标签界面

控制台界面比较单一，不便于操作，在早期的超时收银系统中是常用的一种界面，屏幕的漆黑一片，都是通过各种命令操作的，不小心操作失误就有可能重新操作。

然而图像化界面就比较人性化了，类似于QQ软件，可以打开窗口和别人聊天，还可以发送图片等功能。但是这种界面必须安装在电脑上才能使用，不利于后期的维护和升级。

最后一种是web界面，是基于浏览器的一种标记界面，通过书写标记在浏览器中渲染界面，它是目前比较流行的界面设计。不过在我们java初学阶段，可以尝试使用图形化界面设计，在后期的项目中使用web界面开发。

注意点：图形化用户界面（GUI）只是为了学习java而使用的界面设计，不要花太多时间去研究它，重点放在后面的web界面上。

插件安装：Eclipse默认是没有GUI图形化界面设计功能的，需要安装插件WB_v1.7.0_UpdateSite_for_Eclipse4.2插件。把插件解压缩，放在eclipse安装目录下的dropins目录下即可。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

创建一个GUI工程：创建界面的时候选择Swing设计中的Application Window。

在这里插入图片描述
在这里插入图片描述
用户登录界面：主要有账号标签控件，账号输入控件，密码标签控件，密码输入控件以及确定按钮组成。

在这里插入图片描述
在这里插入图片描述
实现功能：通过点击登录按钮，实现用户登录功能，简单模拟账号输入框和密码输入框中的数据只要是zhangsan和123即可登录成功。

button.addActionListener(new ActionListener() { 
   
			public void actionPerformed(ActionEvent e) { 
   
				
				String account=textField.getText();
				String pwd=passwordField.getText();
				
				if(account.equals("zhangsan")&&pwd.equals("123")){ 
   
					
					JOptionPane.showMessageDialog(frame, "登录成功");
					
				}else{ 
   
					JOptionPane.showMessageDialog(frame, "账号和密码不一致");
				}
				
			}
		});

其它组件的使用：比如下拉框，单选按钮，复选按钮。

在这里插入图片描述
在这里插入图片描述
功能实现代码：

button.addActionListener(new ActionListener() { 
   
			public void actionPerformed(ActionEvent e) { 
   
				
				String value=(String) comboBox.getSelectedItem();
				label.setText(value);
				

				if(radioButton.isSelected()){ 
   
					value=radioButton.getText();
				}else{ 
   
					value=rdbtnNewRadioButton.getText();
				}
				label_1.setText(value);
				

				value="";
				
				Component[] cs = frame.getContentPane().getComponents();
				for(Component c:cs){ 
   
					if(c instanceof JCheckBox){ 
   
						
						if(((JCheckBox) c).isSelected()){ 
   
							value+=((JCheckBox)c).getText();
						}
					}
				}
				
				label_2.setText(value);
				
			}
		});

表格组件的使用：数据按照表格的形式显示在界面上，是项目开发中常用的一个组件。表格组件主要是由行和列两个部分组成，列表示的是表格数据说明项，而行是表格中的数据部分。

在这里插入图片描述
功能实现部分：

button.addActionListener(new ActionListener() { 
   
			public void actionPerformed(ActionEvent e) { 
   

				String[] cols = { 
    "编号", "姓名" };
				String[][] data = { 
    { 
    "1", "张三" },{ 
   "2","李四"},{ 
   "3","王五"} };
				TableModel model = new DefaultTableModel(data, cols);

				table.setModel(model);

			}
		});

QA问答系统项目实战-swing版本

java的第一阶段 javase swing版 项目实战请访问以下链接。

QA问答系统项目实战（javase swing版）

HTML静态网页

什么是html：是指超文本标记语言（HyperText Markup Language），通过编写标记代码，在浏览器中按照既定格式渲染的页面编程语言。它是以一对<>开始，中间是标签内容，以</>结束。标签中还可以定义一些属性和值。

<font color='red' size='7'>java微课程</font>`

一个完整的页面组成：一个基本的页面有且只有一个根标签<html>，里面有<head>标签，表示页面的头部信息，包括页面的标题。还有一个是<body>标签，表示的是页面的主体部分，所有数据的显示都放在这个标签中。

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title>第一个页面</title>
	</head>
	<body>
		
		页面中的数据
		
	</body>
</html>

常用标签：

<body>
		
		<font color="red" size="7">字体标签</font>
		<br/>
		
		<hr size="2" color="blue"/>
		
		<p>段落1</p>
		<p>段落2</p>
		<p>段落3</p>
		
		<span>容器标签1</span>
		<span>容器标签2</span>
		
		<div>容器标签3</div>
		<div>容器标签4</div>
		
		<b>加粗标签</b>
		
		<a href="https://www.baidu.com" target="_blank">超链接</a>
		<a href="https://www.baidu.com/s?wd=java" target="_blank">搜索关键字</a>
		
		<br/>
		
	</body>

表格标签：表格是数据显示的一种格式，是以行和列表示。

<body>

		<table bgcolor="#eee" border="1" bordercolor="#999" width="300px" rules="all" cellpadding="5px">

			<caption>用户统计表</caption>
			<thead>

				<tr>

					<th>编号</th>
					<th>姓名</th>
					<th>年龄</th>

				</tr>

			</thead>

			<tbody>

				<tr>
					<td>BH001</td>
					<td>张三</td>
					<td>16</td>
				</tr>
				
				<tr>
					<td>BH002</td>
					<td>李四</td>
					<td>29</td>
				</tr>
				
				<tr>
					<td>BH003</td>
					<td>王五</td>
					<td>56</td>
				</tr>
				
				<tr>
					<td>BH004</td>
					<td>赵六</td>
					<td>36</td>
				</tr>


			</tbody>
			
			<tfoot>
				
				<tr>
					
					<th colspan="3">版权所有©</th>
					
				</tr>
				
			</tfoot>

		</table>

	</body>

表单标签：表单是接受用户的输入，并且把数据提交到服务器上的一种标签，类似于a超链接，只不过a超链接是通过?号传递参数，而表单是通过输入框传递数据。

<body>

		<form action="http://www.baidu.com/s">
			
			输入要搜索的内容:<input name="wd" />
			<br/>
			<input type="submit" value="搜索" />
			
			
		</form>

	</body>

表单中其它输入控件

<body>

		<form action="http://www.baidu.com/s">

			文本:<input /><br />
			只读:<input readonly="readonly" /><br />
			密码:<input type="password" /><br />
			单选:<input name='sex' checked="checked" type="radio" />男
			<input name='sex' type="radio" />女
			<br />
			多选:<input type="checkbox" />篮球
			<input type="checkbox" />排球
			<input type="checkbox" />足球
			<br />
			下拉:<select>

				<option>==请选择==</option>
				<option>选项一</option>
				<option>选项二</option>
				<option>选项三</option>
			</select>
			<br />
			隐藏:<input type="hidden" /><br />
			文件:<input type="file" /><br />
			<input type="submit" value="提交按钮" />
			<input type="button" value="普通按钮" />

		</form>

	</body>

CSS样式级联

什么是css：是指层叠样式表（Cascading Style Sheets），通俗来说就是html网页的美化技术，代替html属性控制。

<body>

		<font color="red" size="7">字体颜色和大小</font>
		<br/>
		<span style="color: red;font-size: 36px;">字体颜色和大小</span>
		
	</body>

css还有一个特点，就是一次定义到处生效，而标签中的属性则没法实现这个功能。

定义一个css文件my.css

span{
	
	color: red;
	font-size: 36px;
	
	}

在html中引用这个my.css文件，这样所有文件所有span元素使用的是同一个样式。

<link href="my.css" rel="stylesheet" />

<body>

		<font color="red" size="7">字体颜色和大小</font>
		<br/>
		<span>字体颜色和大小</span>
		<br/>
		<span>字体颜色和大小</span>
		<br/>
		<span>字体颜色和大小</span>
	</body>

也可以在当前页面使用style标签定义样式。

<style> span{ 
      color: red; } </style>
<body>
<span>页面定义样式</span>
</body>

选择器的使用：常用的选择器有以下几种：

  1. 元素选择器
  2. id选择器
  3. 类选择器
  4. 层次选择器
<style> span{ 
      color: red; } #div1{ 
      color: blue; } .c1{ 
      color: green; } ul li ol li{ 
      color: aqua; } </style>


<body>


		<span>元素选择器</span><br/>
		
		<div id="div1">id选择器</div>
		
		<b class="c1">类选择器</b>
		
		<ul>
			
			<li>
				项目1
				<ol>
					<li>层次选择器1</li>	
					<li>层次选择器2</li>
				</ol>
			</li>
			
			<li>
				项目2
				<ol>
					<li>层次选择器3</li>	
					<li>层次选择器4</li>
				</ol>
			</li>
			
			
		</ul>
		
		
	</body>

常用样式：在页面设计过程中，常用的样式有如下几个：

  1. 边框样式
  2. 边距样式
  3. 元素定位
  4. flex布局

每个元素都有边框，而且是由4条边组成。

<style> div{ 
      width: 100px; height: 50px; border-top-width: 1px; border-top-color: red; border-top-style: solid; border-left-width: 2px; border-left-color: green; border-left-style: dashed; border-right-width: 3px; border-right-color: blue; border-right-style: dotted; border-bottom-width: 4px; border-bottom-color: yellowgreen; border-bottom-style: double; border: 1px red solid; } </style>

	<body>

		<div>边框设置</div>
		
		
	</body>

边框之间有间距，主要分为外边距和内边距。

<style> body{ 
      border: 1px yellowgreen solid; } .c1{ 
      width: 100px; height: 50px; border: 1px red solid; } .c2{ 
      width: 100px; height: 50px; border: 1px blue solid; margin-top: 10px; margin-left: 20px; margin-bottom: 5px; } .c3{ 
      width: 100px; height: 50px; border: 1px green solid; padding-left: 5px; padding-top: 10px; padding-bottom: 15px; } </style>
		
	<body>

		<div class="c1">参考元素</div>
		<div class="c2">外边距</div>
		<div class="c3">内边距</div>
		
		
	</body>

元素定位使用position属性控制，主要有以下4中方式：

  1. 默认定位
  2. 相对定位
  3. 相对于浏览器的绝对定位
  4. 相对于父元素的绝对定位
<style> body{ 
      border: 1px yellowgreen solid; } .c1{ 
      width: 100px; height: 50px; border: 1px red solid; position: static; } .c2{ 
      width: 100px; height: 50px; border: 1px blue solid; position: relative; left: 10px; top: 20px; } .c3{ 
      width: 100px; height: 50px; border: 1px green solid; position: fixed; right: 0px; bottom: 0px; } body{ 
      position: relative; } .c4{ 
      width: 100px; height: 50px; border: 1px firebrick solid; position: absolute; left: 0px; top: 0px; } </style>

	<body>

		<div class="c1">默认定位</div>
		<div class="c1">默认定位</div>
		
		<div class="c2">相对定位</div>
		
		<div class="c3">相对浏览器绝对定位</div>
		
		<div class="c4">相对父容器绝对定位</div>
		
	</body>

页面布局采用flex方式，可以实现上下左右对齐。
在这里插入图片描述

<style> .container{ 
      width: 800px; margin: auto; display: flex; flex-wrap: wrap; } .c1{ 
      background-color: antiquewhite; height: 50px; width: 800px; } .c2{ 
      background-color: aquamarine; width: 100px; height: 350px; } .c3{ 
      background-color: bisque; width: 700px; height: 350px; display: flex; flex-wrap: wrap; justify-content: space-around; align-items: center; } .c3 div{ 
      border: 1px red solid; width: 150px; height: 150px; } .c4{ 
      background-color: gainsboro; height: 30px; width: 800px; } </style>


	<body>
		<div class="container">
			
			<div class="c1">头部</div>
			
			<div class="c2">左边</div>
			
			<div class="c3">
				
				<div>项目1</div>
				<div>项目2</div>
				<div>项目3</div>
				<div>项目4</div>
				<div>项目5</div>
				<div>项目6</div>
				<div>项目7</div>
				<div>项目8</div>
				
			</div>
			
			<div class="c4">底部</div>
			
		</div>
		
	</body>

JavaScript脚本编程

什么是javascript：它是一种脚本语言，是嵌入在html页面中运行的一种语言，主要作用就是动态的处理页面上的标签和样式的，可以接受用户的输入，从而实现用户和页面之间有一个交互。简称js。

调用方式：主要有如下几种：

  1. 页面切入方式
  2. 外部引用方式
  3. 通过事件调用
<script lang="javascript" type="text/javascript"> alert("欢迎使用js") </script>

定义一个外部的my.js文件

alert("欢迎使用js")

通过标签调用外部js文件

<script lang="javascript" type="text/javascript" src="my.js"></script>

通过事件调用，主要有页面加载事件，鼠标单击事件

<body onload="alert('页面加载之后调用')">
		
		<button onclick="alert('单击调用')">按钮</button>
		
	</body>

基本操作：基本上和java类似，包括变量，定义，控制语句等，但是也有区别，尤其是类型，java中的类型是强类型，类型在定义的时候确定，后面不能修改。而js中是弱类型，类型是由值确定，可以任意变换。

	var a=1;
			
			a="a";
			
			if(a==1){ 
   
				
				alert("数字一")
				
			}else if(a=='a'){ 
   
				
				alert("字母a")
			}else{ 
   
				alert("其它")
			}
			
			
			
			a=['张三','李四','王五','赵六'];
			for(var i=0;i<a.length;i++){ 
   
				
				alert("循环输出姓名："+a[i]);
			}

函数的使用：函数主要分为函数定义以及函数调用，在定义的时候可以通过参数传递，函数也可以有返回值。通过关键字function来定义函数。

<script> function show1(){ 
      alert("基本函数") } function show2(arg){ 
      alert("带参数的函数："+arg) } function show3(arg){ 
      alert("带参数并且有返回值的函数："+arg) return arg.toUpperCase(); } show1(); show2("java"); var rt=show3("java"); alert(rt); </script>

对象的使用：在js中，通常把文档和标签作为对象来理解，比如：把html文档作为document对象，把<input>标签作为input对象。

<script> document.write("hello"); document.write("<b>加粗</b>"); function show(){ 
      var info=""; var a=document.getElementById("a"); info+=a.value; var bs=document.getElementsByName("b"); for(var b of bs){ 
      if(b.checked){ 
      info+=b.value; break; } } var cs=document.getElementsByName("c"); for(var c of cs){ 
      if(c.checked){ 
      info+=c.value; } } var d=document.getElementById("d"); d.innerHTML=info; } </script>


<body>
		
		标签中的内容;
		<br/>
		<button onclick="show()">按钮</button>
		<br/>
		
		<input id="a"/>
		
		<br/>
		<input name="b" type="radio" value="男" checked="checked" />男
		<input name="b" type="radio" value="女" />女
		
		<br/>
		<input name="c" type="checkbox" value="篮球" />篮球
		<input name="c" type="checkbox" value="足球" />足球
		<input name="c" type="checkbox" value="排球" />排球
		
		<div id="d">默认内容</div>
		
	</body>

本地存储对象：把数据保存到浏览器中，可以使用本地存储，主要有两个对象，localStorage和sessionStorage。

<script> function saveLocal(){ 
      var name=document.getElementById("name").value; localStorage.setItem("name",name); } function saveSession(){ 
      var name=document.getElementById("name").value; sessionStorage.setItem("name",name); } function getName(){ 
      alert("本地:"+localStorage.getItem("name")); alert("会话:"+sessionStorage.getItem("name")); } function saveObj(){ 
      var name=document.getElementById("name").value; var age=document.getElementById("age").value; var user={ 
     "name":name,"age":age}; localStorage.setItem("user",JSON.stringify(user)); } function getObj(){ 
      var user=localStorage.getItem("user"); user=JSON.parse(user); alert(user.name+"-"+user.age) } </script>


<body>
		
		姓名:<input id="name" />
		<br/>
		<button onclick="saveLocal()">存储到本地</button>
		
		<br/>
		<button onclick="saveSession()">存储到会话</button>
		
		<br/>
		<button onclick="getName()">获取用户名</button>
	
		
		<br/>
		年龄:<input id="age" />
		<br/>
		<button onclick="saveObj()">存储对象</button>
		
		<br/>
		<button onclick="getObj()">获取对象</button>
	
	</body>

Servlet网络技术

什么是servlet：它是java中接受和响应网络传输数据的一个中间件，可以接受用户的请求数据，把请求的数据进一步处理，最后生成数据响应给用户。

tomcat：在使用servlet之前需要安装部署tomcat，它是一个web应用的服务器，也就是说，servlet中间件是运行在tomcat web 服务器上的，主要的作用就是接受用户请求数据，并且响应数据给用户这两大功能。

tomcat部署：首先从官网上下载tomcat，我们这边下载绿色版，下载之后解压缩就可以使用了。

在使用之前先设置JAVA_HOME环境变量，因为tomcat需要jdk的支持，设置方式和jdk环境变量类似，可以参考java中的环境变量设置。

解压之后进入tomcat的bin目录，找到一个文件为startup.bat，双击打开就可以启动tomcat服务器了，等到控制台看到Server startup in 15722 ms 说明已经启动了。

打开浏览器，在浏览器中输入地址为：httl://localhost:8080，如果能看到tomcat页面，说明已经成功启动tomcat服务器了。

我们还可以在webapps目录下新建目录，在webapps下的所有目录就是一个个项目，比如：新建一个test目录，在test目录下面再新建一个index.html文件，然后通过浏览器地址为:httl://localhost:8080/test就能访问到test项目下的index.html页面了。

为了能在eclipse中开发的servlet项目运行在tomcat上面，我们需要再eclipse中设置绑定tomcat。在首选项中找到Server节点。

在这里插入图片描述

接下来创建一个简单的servlet例子程序。
在eclipse中新建一个动态的web工程

在这里插入图片描述
在这里插入图片描述

创建一个servlet类以及配置文件

public class Servlet1 extends HttpServlet { 
   

	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
   

		resp.setCharacterEncoding("utf-8");
		resp.setContentType("text/html;charset=utf-8");

		System.out.println("用户请求了");
		
		String name=req.getParameter("name");
		
		System.out.println("接受请求参数:"+name);
		
		PrintWriter out=resp.getWriter();
		out.print("<html>");
		out.print("<head>");
		out.print("<link href='my.css' rel='stylesheet'/>");
		out.print("<script src='my.js'></script>");
		out.print("<title>");
		out.print("给用户响应数据");
		out.print("</title>");
		out.print("</head>");
		out.print("<body>");
		
		out.print("<b οnclick='show()'>"+name.toLowerCase()+"</b>");
		
		out.print("</body>");
		out.print("</html>");
		out.flush();
		out.close();
		
	}

	
	
}

my.css样式文件

@charset "UTF-8";
b{ 
   
	
	color: red;
}

my.js脚本文件

function show(){ 
   
	
	alert("单击了我");
	
}

<servlet>


		<servlet-name>servlet1</servlet-name>
		<servlet-class>com.servlet.Servlet1</servlet-class>

	</servlet>

	<servlet-mapping>
		<servlet-name>servlet1</servlet-name>
		<url-pattern>/servlet1</url-pattern>
	</servlet-mapping>

请求地址为:http://localhost:8080/testservlet/servlet1?name=zhangsan

JSP动态网页

什么是jsp：它是java服务页（java server page）的简称，言外之意就是在服务器端输出页面。之前我们使用servlet作为服务器，用来接收请求，响应数据，响应的数据可以的页面，那么在输出页面的时候比较繁琐，所以使用jsp技术专门在服务器端输出页面，来代替servlet页面输出。

在webContent目录下新建一个后缀为.jsp的文件。

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>给用户响应数据</title>
<link href='my.css' rel='stylesheet'/>
<script src='my.js'></script>
</head>
<body>

<b onclick='show()'><%=request.getParameter("name").toUpperCase() %></b>

</body>
</html>

通过地址访问：http://localhost:8080/testservlet/index.jsp?name=zhangsan

MVC开发模式

在实际的项目开发中，我们采取servlet+jsp的组合，servlet作为业务处理层，而jsp作为页面渲染层。像这种把业务和视图分开的开发模式成为Model-View-Controller(模型-视图-控制器)。

public class Action1 extends HttpServlet { 
   

	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
   

		
		System.out.println("用户请求了");
		
		String name=req.getParameter("name");
		
		System.out.println("接受请求参数:"+name);
		
		req.setAttribute("name", name.toUpperCase());
		
		req.getRequestDispatcher("success.jsp").forward(req, resp);
		
		

		
	}

	
	
	
}

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>mvc模式显示数据</title>
<link href='my.css' rel='stylesheet'/>
<script src='my.js'></script>
</head>
<body>
<b onclick='show()'><%=request.getAttribute("name") %></b>
</body>
</html>

<servlet>


		<servlet-name>action1</servlet-name>
		<servlet-class>com.action.Action1</servlet-class>

	</servlet>

	<servlet-mapping>
		<servlet-name>action1</servlet-name>
		<url-pattern>/action1</url-pattern>
	</servlet-mapping>

通过地址访问：http://localhost:8080/testservlet/action1?name=zhangsan

el表达式和jstl标签库：jsp可以使用脚本，也可以使用el表达式语言配合jstl标签库来实现页面的数据渲染。

首先从官网上下载jstl.jar，然后倒入到项目中即可。

public class Action1 extends HttpServlet { 
   

	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
   

		
		System.out.println("用户请求了");
		
		String name=req.getParameter("name");
		
		System.out.println("接受请求参数:"+name);
		
		req.setAttribute("name", name.toUpperCase());
		
		List list=new ArrayList();
		list.add("zhangsan");
		list.add("lisi");
		list.add("wangwu");
		
		req.setAttribute("list",list);
		
		
		req.getRequestDispatcher("success.jsp").forward(req, resp);
		

	}

	
}

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
    
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>   

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>mvc模式显示数据</title>
<link href='my.css' rel='stylesheet'/>
<script src='my.js'></script>
</head>
<body>
<b onclick='show()'><%=request.getAttribute("name") %></b>
<b onclick='show()'>${name}</b>
<c:if test="${name=='zhangsan' }">

	张三
	
</c:if>


<ul>
<c:forEach items="${list}" var="str" varStatus="s" >
	
	<c:if test="${s.index%2==0 }">
		<li style="color: red">
	</c:if>
	
	<c:if test="${s.index%2!=0 }">
		<li>
	</c:if>
	
	${str }</li>
		
</c:forEach>
</ul>	


</body>
</html>

通过地址访问：http://localhost:8080/testservlet/action1?name=zhangsan

Ajax异步技术

什么ajax：异步javascript和xml技术，简单来说，就是可以通过js直接访问后台服务，而无需刷新整个页面就能得到服务器端的数据，简称局部刷新技术。

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>ajax例子</title>
<script type="text/javascript"> function getData(){ 
      document.write(new Date()); document.write("<br/>"); var name=document.getElementById("name").value; var xhr=new XMLHttpRequest(); xhr.onreadystatechange=function(){ 
      if(xhr.readyState==4&&xhr.status==200){ 
      var data=xhr.responseText; document.getElementById("div1").innerHTML=data; } } xhr.open("get",'action1?name='+name,true); xhr.send(null); } </script>
</head>
<body>
<input id="name"><br/>
<button onclick="getData()">从服务器直接加载数据到页面</button>
<div id="div1" style="border: 1px red solid;width: 200px;height: 100px">
点击按钮就能加载服务器端数据到div中
</div>
</body>
</html>

public class Action1 extends HttpServlet { 
   

	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp)
			throws ServletException, IOException { 
   
	
		
		String name=req.getParameter("name");
		
		PrintWriter out=resp.getWriter();
		out.print(name.toUpperCase());
		out.flush();
		out.close();
		
		
		
		
		
	}

}

<servlet>
  <servlet-name>action1</servlet-name>
  <servlet-class>com.action.Action1</servlet-class>
  </servlet>
  
  <servlet-mapping>
  	<servlet-name>action1</servlet-name>
  	<url-pattern>/action1</url-pattern>
  </servlet-mapping>

QA问答系统项目实战-javaweb版本

java的第二阶段 javase web版 项目实战请访问以下链接。

QA问答系统项目实战（javaweb版）

MyBatis框架

什么是mybatis：它是一个数据库层的框架，方便jdbc的操作，通过简单的配置文件就能实现对数据库的操作，减少代码量，提高开发效率。是一个ORM（Object Relational Mapping）框架之一。

首先从官网上下载jar包，并且导入项目中。

编写总的配置文件config.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>

	<environments default="e1">

		<environment id="e1">

			<transactionManager type="JDBC"></transactionManager>
			<dataSource type="POOLED">
				<property name="driver" value="com.mysql.jdbc.Driver"></property>
				<property name="url" value="jdbc:mysql://127.0.0.1:3306/test2"></property>
				<property name="username" value="root"></property>
				<property name="password" value="123456"></property>
			</dataSource>

		</environment>

	</environments>
	
	<mappers>
	<mapper resource="com/entity/User.xml"/>
	</mappers>

</configuration>

编写实体类

package com.entity;

public class User { 
   

	
	private int id;
	private String name;
	public int getId() { 
   
		return id;
	}
	public void setId(int id) { 
   
		this.id = id;
	}
	public String getName() { 
   
		return name;
	}
	public void setName(String name) { 
   
		this.name = name;
	}
	
	
}

编写实体类对应的映射文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.entity.User">

	<insert id="save">
		insert into user(id,name) values (#{id},#{name})
    </insert>
    
    <update id="update">
    	update user set name=#{name} where id=#{id}
    </update>
    
    <select id="find" resultType="com.entity.User">
    
    	select * 
    	from user
    	where id=#{id}
    
    </select>
    
     <select id="findAll" resultType="com.entity.User">
    
    	select * 
    	from user
    	where 1=1
    
    </select>
    
    <delete id="del">
    
    	delete from user
    	where id=#{id}
    
    </delete>

</mapper>

编写测试类

public static void main(String[] args) throws IOException { 
   


		
        InputStream is = Resources.getResourceAsStream("config.xml");
        
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
       
        SqlSession session = sqlSessionFactory.openSession();
        User user = new User();
        user.setId(2);
        user.setName("李四2");
        
        session.insert("save",user);
        
        session.update("update", user);
        
        User user2= session.selectOne("find", 2);
        System.out.println(user2.getName());
        
        
        List<User> users= session.selectList("findAll");
        for (User u : users) { 
   
			System.out.println(u.getName());
			
				}
        
        session.delete("del",2);
        
        session.commit();
        
        session.close();
		
	}

Spring框架

什么是spring：它是一个业务层的框架，主要有两大核心，一个是控制反转/依赖注入(IOC/DI)，还一个是面向切面(AOP)。

IOC/DI：是控制管理对象的，是一个对象工厂容器，所用的对象从这个容器中获取，也方便以后对象的切换，只要通过修改配置文件以及增加新的实现类即可，不需要修改原有代码。

AOP：就是在调用方法之前和之后执行的代码，跟原有项目分离出来，以后修改只要改配置文件和切面类即可，无需修改原有代码。

首先从官网上下载spring包，然后导入基本jar到项目中。

控制反转IOC

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
	
	<bean id="user" class="com.entity.User"></bean>
	
</beans>

public class User { 
   

	
	private int id;
	private String name;

	public int getId() { 
   
		return id;
	}
	public void setId(int id) { 
   
		this.id = id;
	}
	public String getName() { 
   
		return name;
	}
	public void setName(String name) { 
   
		this.name = name;
	}
	
	
}

 		ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");
	  User user = ctx.getBean("user",User.class);
	  System.out.println(user);

依赖注入DI

<bean id="dog" class="com.entity.Dog">
		<constructor-arg name="name" value="旺财"></constructor-arg>
</bean>

<bean id="user" class="com.entity.User">
		<property name="name" value="张三"></property>
		<property name="dog" ref="dog"></property>
	</bean>

public class Dog { 
   

	
	private String name;
	
	public String getName() { 
   
		return name;
	}

	public Dog(String name){ 
   
		
		this.name=name;
	}
	
	
	
}

public class User { 
   

	
	private int id;
	private String name;
	
	private Dog dog;
	
	
	public Dog getDog() { 
   
		return dog;
	}
	public void setDog(Dog dog) { 
   
		this.dog = dog;
	}
	public int getId() { 
   
		return id;
	}
	public void setId(int id) { 
   
		this.id = id;
	}
	public String getName() { 
   
		return name;
	}
	public void setName(String name) { 
   
		this.name = name;
	}
	
	
}

 			System.out.println(user.getName());
	     
	     System.out.println(user.getDog());
	     System.out.println(user.getDog().getName());

面向切面AOP

public class UserAop { 
   

	
	public void before(){ 
   
		
		System.out.println("之前做什么");
	}
	
	public void after(){ 
   
		
		System.out.println("之后做什么");
	}
	
}

public class User { 
   

	
	private int id;
	private String name;
	
	private Dog dog;
	
	public void show(){ 
   
		
		System.out.println("显示数据");
		
	}
	
	public Dog getDog() { 
   
		return dog;
	}
	public void setDog(Dog dog) { 
   
		this.dog = dog;
	}
	public int getId() { 
   
		return id;
	}
	public void setId(int id) { 
   
		this.id = id;
	}
	public String getName() { 
   
		return name;
	}
	public void setName(String name) { 
   
		this.name = name;
	}
	
	
}

<aop:config>
	
	<aop:pointcut expression="execution(* com.entity.User.*(..))" id="pc"/>
	
	<aop:aspect ref="userAop">
		<aop:before method="before" pointcut-ref="pc"/>
		<aop:after method="after" pointcut-ref="pc"/>
	</aop:aspect>
	
	</aop:config>

 user.show();

SpringMVC框架

什么是springmvc：它是一个MVC开发模式的框架，处理客户端请求，转发以及响应数据的一个框架，它可以帮助我们处理很多重复性的代码，比如接受客户端请求参数以及封装成对象，减少配置文件的书写，封装响应数据，转发路径的统一管理等。

中央控制器配置文件

<servlet>
		<servlet-name>springMVC</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>
	
	<servlet-mapping>
		<servlet-name>springMVC</servlet-name>
		<url-pattern>*.do</url-pattern>
	</servlet-mapping>

控制器类

@Controller
public class UserController { 
   

	
	@RequestMapping("/show1")
	public String show1(){ 
   
		
		return "index";
		
	}
	
}

在WEB-INF文件夹中创建一个jsp文件夹，用来存放页面文件

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
</head>
<body>
jsp中的index页面
</body>
</html>

springMVC配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd ">


	<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/WEB-INF/jsp/" />
		<property name="suffix" value=".jsp" />
	</bean>

	<context:component-scan base-package="com.controller"></context:component-scan>

</beans>

发布项目，打开浏览器测试
http://localhost:8080/web/show1.do

接受参数以及封装数据

@RequestMapping("/show2")
	public ModelAndView show2(User user){ 
   
		
		
		System.out.println("接受到客户端的参数");
		System.out.println(user.getId());
		System.out.println(user.getName());
		
		user.setName("张三");
		ModelAndView mv=new ModelAndView();
		mv.setViewName("success");
		mv.addObject("user", user);
		
		return mv;
		
		
	}

修改index.jsp文件

<body>
jsp中的index页面

<br/>
<form action="show2.do">

编号:<input name="id"/><br/>
名字:<input name="name"/><br/>

<input type="submit" value="提交数据到后台"/>

</form>

</body>

在WEB-INF中再创建一个success.jsp文件

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
</head>
<body>

编号:${user.id }<br/>
姓名:${user.name }<br/>

</body>
</html>

请求测试，输入编号以及名字，查看后台输出以及页面输出数据
http://localhost:8080/web/show1.do

Maven项目架构工具

什么是maven：可以简单理解为创建项目的一个工具，主要功能是管理jar包以及自动发现jar包之间的依赖关系，而不需要程序员手动导入jar包。

首先从官网上下载maven，下载之后解压缩，打开conf目录下的settings.xml配置文件，设置如下

<localRepository>d:/repo</localRepository>

 <mirror>
      <id>aliyun</id>
      <mirrorOf>*</mirrorOf>
      <name>aliyun</name>
      <url>http://maven.aliyun.com/nexus/content/repositories/central</url>
 </mirror>

继承eclipse工具，这样就可以在eclipse中直接使用maven了。

在这里插入图片描述

接下来就可以在eclupse中新建一个maven工程了。

在这里插入图片描述

在这里插入图片描述

比如现在我们项目中需要jdbc驱动，那么只要修改pom.xml工程配置文件，添加依赖信息即可自动导入jar包。

<dependencies>


		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.26</version>
		</dependency>

	</dependencies>

如果需要junit.jar，那么它会把一个依赖jar包自动导入


		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.10</version>
			<scope>test</scope>
		</dependency>

常用的命令：

  1. clean
  2. compile
  3. package
  4. install

创建一个工程，分别为proa,prob,proc

proa工程配置文件

<dependencies>
  
  
  <dependency>
  
  <groupId>com.javawkc</groupId>
  <artifactId>prob</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  
  </dependency>
  
  
  </dependencies>

prob工程配置文件

<dependencies>
  
  
  <dependency>
  
  <groupId>com.javawkc</groupId>
  <artifactId>proc</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  
  </dependency>
  
  
  </dependencies>

SpringBoot框架整合

QA问答系统项目实战-vue版本

java的第三阶段 vue版 项目实战请访问以下链接。

QA问答系统项目实战（vue版）

Git与GitHub

完整课程内容：

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

开发学习中常见问题：

实战项目演练：

更多资料请关注微信公众号 《java微课程》

今天的文章零基础小白-自学java全栈开发-学习路线-只要看这一篇就可以了（完整版）分享到此就结束了，感谢您的阅读，如果确实帮到您，您可以动动手指转发给其他人。

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。
如需转载请保留出处：https://bianchenghao.cn/25247.html

赞 (0)
编程小号编程小号
0

相关推荐

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注