第一阶段：Java专业基础课程
阶段目标：
1. 熟练掌握Java的开发环境与编程核心知识
2. 熟练运用Java面向对象知识进行程序开发
3. 对Java的核心对象和组件有深入理解
4. 熟练应用JavaAPI相关知识
5. 熟练应用JAVA多线程技术
6. 能综合运用所学知识完成一个项目
知识点：
1、基本数据类型，运算符，数组，掌握基本数据类型转换，运算符，流程控制。
2、数组，排序算法，Java常用API，类和对象，了解类与对象，熟悉常用API。
3、面向对象特性，集合框架，熟悉面向对象三大特性，熟练使用集合框架。
4、IO流，多线程。
5、网络协议，线程运用。
第二阶段：JavaWEB核心课程
阶段目标:
1. 熟练掌握数据库和MySQL核心技术
2. 深入理解JDBC与DAO数据库操作
3. 熟练运用JSP及Servlet技术完成网站后台开发
4. 深入理解缓存，连接池，注解，反射，泛型等知识
5. 能够运用所学知识完成自定义框架
知识点：
1、数据库知识，范式，MySQL配置，命令，建库建表，数据的增删改查，约束，视图，存储过程，函数，触发器，事务，游标，建模工具。
2、深入理解数据库管理系统通用知识及MySQL数据库的使用与管理。为Java后台开发打下坚实基础。Web页面元素，布局，CSS样式，盒模型，JavaScript，jQuery。
3、掌握前端开发技术，掌握jQuery。
4、Servlet，EL表达式，会话跟踪技术，过滤器，FreeMarker。
5、掌握Servlet相关技术，利用Servlet，JSP相关应用技术和DAO完成B/S架构下的应用开发。
6、泛型，反射，注解。
7、掌握JAVA高级应用，利用泛型，注解，枚举完成自己的CRUD框架开发为后续框架学习做铺垫。
8、单点登录，支付功能，项目整合，分页封装熟练运用JSP及Servlet核心知识完成项目实战。
第三阶段：JavaEE框架课程
阶段目标：
1. 熟练运用Linux操作系统常见命令及完成环境部署和Nginx服务器的配置
2. 熟练运用JavaEE三大核心框架：Spring,SpringMVC,MyBatis
3. 熟练运用Maven,并使用SpringBoot进行快速框架搭建
4. 深入理解框架的实现原理，Java底层技术，企业级应用等
5. 使用Shiro,Ztree和Spring,SpringMVC,Mybaits完成企业项目
知识点：
1、Linux安装配置，文件目录操作，VI命令，管理，用户与权限，环境部署，Struts2概述，hiberante概述。
2、Linux作为一个主流的服务器操作系统，是每一个开发工程师必须掌握的重点技术，并且能够熟练运用。
3、SSH的整合,MyBatis,SpringMVC,Maven的使用。
4、了解AOP原理，了解中央控制器原理，掌握MyBatis框架，掌握SSM框架的整合。
5、Shiro,Ztree，项目文档，项目规范，需求分析，原型图设计，数据库设计，工程构建，需求评审，配置管理，BUG修复，项目管理等。
6、独立自主完成一个中小型的企业级综合项目的设计和整体架构的原型和建模。独立自主完成一个大型的企业级综合项目，并具备商业价值
一、程序运行界面：1、总控制台
3、控制台输出结果。
二、程序开发环境：
使用Java(JDK 1.4)开发，图形界面使用Eclipse （2.1.3版）的SWT方式开发。运行主机：P4 2.6+1G内存 windowsXP操作系统
三、预备。
开发此类程序，最好不要直接使用JAVA的线程来编程，这样会增加不必要的复杂度和难度，吃力不讨好。在JAVA中有一个包 java.util.Timer 这个包封装了对线程的操作，我们可以把它称做定时器类。我们先来看一个简单例子：
import java.util.Timer
import java.util.TimerTask
public class Reminder {
Timer timer
public Reminder(int seconds) {
timer = new Timer()
timer.schedule(new RemindTask(),seconds*1000)//参数要求转化成毫秒
}
public static void main(String args[]) {
new Reminder(5)//5秒后运行
}
/**一个内部类，封装了所要运行的任务*/
class RemindTask extends TimerTask {
public void run() {
System.out.println("任务运行。。。。")
timer.cancel()//结束timer中的所有任务
}
}
}
这里涉及于两个JAVA类Timer和TimerTask。我们继承TimerTask类后，将所要运行的任务封装其run方法中；Timer可以管理几千个任务（TimerTask），注意，同一个任务对象不能两次加入到Timer中执行。
对（虽然执行的任务都一样，但是两个任务对象）：
timer.schedule(new RemindTask(), seconds * 1000)
timer.schedule(new RemindTask(), seconds * 1000)
错
RemindTask task= new RemindTask()
timer.schedule(task, seconds * 1000)
timer.schedule(task, seconds * 2000)
四、设计方案。
主要的类图
说明：
任务类的设计。我们先创建一个抽象类AbstractTimerTask，这个类直接继承至TimerTask类，提供对TimerTask封装。然后所有具体的任务类（如：TimerTask_1）继承自AbstractTimerTask。
import java.util.TimerTask
public abstract class AbstractTimerTask extends TimerTask {
TaskEntry taskEntry//任务记录
public AbstractTimerTask(TaskEntry taskEntry) {
this.taskEntry = taskEntry
}
/*
* 生成一个新的实例相当于克隆自身原因在于：同一任务对象不能两次加入到Timer
* 在TaskEntry类将看到它的使用方法
*/
abstract AbstractTimerTask getCloneObject()
}
下面是它的一个实现类的源代码我们可以将要运行任务的代码写在这个类中。
import java.util.Calendar
public class TimerTask_1 extends AbstractTimerTask {
public TimerTask_1(TaskEntry taskEntry) { //构造方法
super(taskEntry)
}
public AbstractTimerTask getCloneObject() {
return new TimerTask_1(taskEntry)
}
public void run() {
/*在这里写你要执行的程序。。。。。*/
System.out.println("??时："+taskEntry.getName()+"运行了一次")
this.taskEntry.taskStart()//运行下一个时间点任务
}
}
在AbstractTimerTask类有一个TaskEntry字段，这是本设计的一个核心类,它代表一条封装完整的任务记录,每个任务类和它的运行计划都封装在这条类中,源代码如下。Timer和AbstractTimerTask前面都已说过,那么TimePlan是做什么用的呢？
import java.util.Calendar
import java.util.Date
import java.util.Timer
import mytimer.util.Util
/**任务记录类*/
public class TaskEntry {
public static final int TASK_START = 0//定义两个表示任务记录状态常量
public static final int TASK_STOP = 1
private Long oid//任务ID号，唯一
private String name//任务名称
private int state = TASK_STOP//任务状态（启动/停止）
private Timer timer//JAVA计时器
private TimePlan timePlan//时间计划的类型
private AbstractTimerTask timerTask//任务类的种子对象,由这个对象来不断克隆
private AbstractTimerTask runTimerTask//运行计划的当前任务
/**
* ITaskEntry.taskStart()-->TimerTask.run()-->ITaskEntry.taskStart()
* 形成一个循环回路。本方法负责起动本类代表的任务
*/
public void taskStart() {
if (timePlan.haveNext()) {
Date date = timePlan.nextDate()//得到任务计划时间
runTimerTask = timerTask.getCloneObject()//得到任务(复制)
timer.schedule(runTimerTask, date)//加入计划队列
//打印将要运行的计划任务的信息
Calendar c = Calendar.getInstance()
c.setTimeInMillis(runTimerTask.scheduledExecutionTime())
System.out.println(Util.dateToLongStr(c.getTime())+"将运行"+name)
} else {
state = TASK_STOP
System.out.println(name + "结束")
}
}
/**停止任务*/
public void taskStop() {
if (runTimerTask != null) {
//打印信息
Calendar c = Calendar.getInstance()
c.setTimeInMillis(runTimerTask.scheduledExecutionTime())
System.out.println("计划于:"+Util.dateToLongStr(c.getTime())+"运行的" + name + "被终止")
//终止本任务, 调用Timer.cancel()是终止Timer的所有任务。
runTimerTask.cancel()
} else {
System.out.println(name + "未进入执行计划")
}
}
……… 一些属性的get/set方法（省略）
/** 监听类（内部类） */
public static class DateBeforeTodayException extends NullPointerException {
private Date date
public DateBeforeTodayException(Date date) {this.date = date}
public String toString() {
return "计划时间(" + Util.dateToLongStr(date) + ")早于当前时间"
}
}
}
1、TimePlan是一个接口(interface)，它是表示“运行计划的方案”，这个程序中提供了三种运行计划方案（见前图：计划任务的设置界面）：
一次性运行。
每隔一个时间段运行。
一周中选择那几天运行。
将它设计成一个接口是为了方便今后扩展，如果要新增新的时间方案只需要继承这个接口写一个新的实现即可。三种时间方案的类图如下：
说明：
a) TimePlan封装了五个方法，其它haveNext()和nextDate()最重要，这个两个方法模仿了Java中集合类（Collection）的迭代器(Iterator)的设计形式，代码如下：
import java.util.Date
//时间计划方案的接口
public interface TimePlan {
boolean haveNext()//判断还有没有下一个计划时间
Date nextDate()//得到下一个计划时间
Date getCurrentDate()//得到开始时间
void setCurrentDate(Date date)//设计开始时间
String getTimePlanString()//显示运行计划方案的文字说明
}
b) AbstractTimePlan是这个抽象类，主要目的是将一些各子类的公共方法写在这里。代码如下：
import java.util.Date
public abstract class AbstractTimePlan implements TimePlan {
//记录计划的第一时间点，除设置新的起始时间，否则不再改变
protected Date currentDate
/*
当前计划的时间点，每次计划替换时被更新，
似乎这个才应叫cureentDate，sorry不想再改了
*/
protected Date planDate
public boolean haveNext() {
return (planDate != null)
}
public Date getCurrentDate() {
return currentDate
}
public void setCurrentDate(Date date) {
currentDate = date
planDate = date//在赋给currentDate值时，同时也赋给planDate
}
}
c) 然后我们看看三种计划方案的实现类的源代码：
//“一次性运行”的计划方案类
import java.util.Date
public class TimePlanOnce extends AbstractTimePlan {
public Date nextDate() {
//把要当前的计划时间保存在中间变量中
Date returnDate = this.planDate
//算出下一个计划时间。没有下一个就设为null
this.planDate = null
//判断一下计划时间合不合条件
if (returnDate == null)
throw new NullPointerException("没有下一个计划日期")
return returnDate
}
public String getTimePlanString() {
return "一次性运行,运行时间: （打印this.currentDate） "
}
}
//“周期性间隔”的时间计划方案类
import java.util.Date
public class TimePlanPeriod extends AbstractTimePlan {
public static final int HOUR = 0
public static final int DAY = 1
private int spaceTime//间隔时间,单位毫秒
private int timeType
public Date nextDate() {
//把要当前的计划时间保存在中间变量中
Date returnDate = this.planDate
//算出下一个计划时间。没有下一个就设为null
int milliSecond = 0
if (timeType ==HOUR) milliSecond = spaceTime * 1000//小时*60*60*1000
if (timeType ==DAY) milliSecond = spaceTime * 24 * 60 * 60 * 1000//天
planDate = Util.DateAddSpaceMilliSecond(planDate, milliSecond)
//判断一下计划时间合不合条件
if (returnDate == null)
throw new NullPointerException("没有下一个计划日期")
return returnDate
}
public String getTimePlanString() {
if (timeType == HOUR)
return "第一次运行于:currentDate.并每隔spaceTime小时运行一次"
if (timeType == DAY)
return "第一次运行于:currentDate.并每隔spaceTime天运行一次"
return ""
}
public int getSpaceTime() { return spaceTime}
public int getTimeType() { return timeType }
public void setSpaceTime(int i) { spaceTime = i}
public void setTimeType(int i) { timeType = i}
}
/**选择一周的某几天,让这几天在同一时间点运行任务, 一周内必须选择一天*/
import java.util.Calendar
import java.util.Date
public class TimePlanSelectWeek extends AbstractTimePlan {
private static Calendar c = Calendar.getInstance()//取得一个日历实例
private static int spaceMilliSecond = 0//间隔时间,单位毫秒
private boolean[] selectWeek = new boolean[7]//0为星期日 ,1为星期一
public Date nextDate() {
Date returnDate = null
if (!isSelectWeek(planDate)) //如果这一天不是所选周中的一天
planDate = getNextDate(planDate)
returnDate = planDate
planDate = getNextDate(planDate)
//判断一下计划时间合不合条件
if (returnDate == null)
throw new NullPointerException("没有下一个计划日期")
return returnDate
}
//算出下一个计划时间。没有下一个就设为null
private Date getNextDate(Date date) {
Date tempDate = date
Date returnDate = null
for (int i = 0i <7i++) {
tempDate = Util.DateAddSpaceMilliSecond(tempDate, spaceMilliSecond)
if (isSelectWeek(tempDate)) {
returnDate = tempDate
break
}
}
return returnDate
}
/**设置某星期是否被选, 0为星期日 ,1为星期一....6为星期六*/
public void setSelectWeek(int i, boolean b) {selectWeek[i] = b}
/** 判断某星期是否被选*/
public boolean isSelectWeek(int i) {return selectWeek[i]}
/**判断某天所属星期几是否被选*/
public boolean isSelectWeek(Date date) {
if (date == null) return false
c.setTime(date)
//Calendar.DAY_OF_WEEK:星期日=1,星期六=7 c.get(Calendar.DAY_OF_WEEK)
return isSelectWeek(c.get(Calendar.DAY_OF_WEEK) - 1)
}
public String getTimePlanString() {
StringBuffer sb = new StringBuffer("")
if (selectWeek[1]) sb.append("周一,")
if (selectWeek[2]) sb.append("周二,")
if (selectWeek[3]) sb.append("周三,")
if (selectWeek[4]) sb.append("周四,")
if (selectWeek[5]) sb.append("周五,")
if (selectWeek[6]) sb.append("周六,")
if (selectWeek[0]) sb.append("周日,")
return "每周的"+sb.toString()+"运行"
}
}
TimerTask的工厂类。将生成TimerTask的代码另起一个类的好处是代码的层次比较清楚，也比较好管理。由于TimerTask包含有几个字段，因此产生一个TimerTask对象还是有一定的复杂度，建立一个专门生成TimerTask的工厂类，这样我们在生成一个TimerTask对象时就可以少掉很多麻烦的代码了。当然由于我的工作任务，只需要一个TimerTask对象就够了，所以最初之前我是将它直接写在图形界面的代码里的。
这里建立一个TimerTask对象池tasks，它是一个静态变量，这样在getInstance时不必总是要新生成一个TimerTask。还有Timer也是一个静态变量，它是一个全局单例（是最简单的单例模式了），因为前面说了Timer可以管理几千个任务，所以Timer对象一个就够了。
import java.util.HashMap
import java.util.Timer
public class TaskEntryFactory {
private static final HashMap tasks = new HashMap()
private static final Timer timer = new Timer()
public static TaskEntry getInstance(Long oid, String name) {
if (tasks.containsKey(oid)) {
return (TaskEntry) tasks.get(oid)
} else {
TaskEntry entry = new TaskEntry()
entry.setOid(oid)
entry.setName(name)
entry.setTimer(timer)
entry.setTimerTask(new TimerTask_1(entry))
tasks.put(oid, entry)
return entry
}
}
}
起动和停止任务,当“任务设置界面（TaskListDialog.java）”点击OK后处理。界面的编写就不在本文讨论的范围内了。
//任务设置界面中点击”确认(OK)”按钮后的处理
if (dialog.open() == Window.OK) {
if (taskEntry.getState() == TaskEntry.TASK_START) {
taskEntry.taskStop()//将旧的停掉
taskEntry.taskStart()//开始新设置的
}
if (taskEntry.getState() == TaskEntry.TASK_STOP)
taskEntry.taskStop()
tv.refresh(taskEntry)
}
java开发前台通常指的是开发界面，用到的技术：html5，jsp，js ，css，jquery，easyui等。java后台开发就是普通意义上的java代码开发。学java开发推荐千锋教育。千锋智能AI技术实时监课和回顾，对授课行为数据进行挖掘与分析，生成数据分析报表，为授课评价与管理决策提供大数据分析依据。java的学习方法：
1、面向对象的知识：java是一种面向对象的开发语言，因此熟悉面向对象对学习java很有必要，你需要了解：什么是对象，什么是类，什么是封装，什么是多态，什么是继承，什么是抽象类，什么是接口。理解以上概念后，还需要知道这些概念是如何体现的，如类和对象有什么区别；类是如何封装的。
2、java语法：如果已经有了开发经验，那么学习java语法将比较容易。如果有C++等面向对象语言的开发经验，那就只需简单的翻看一下介绍java的相关书籍就可以了。如果是新手，没有关系，多下些工夫，好好研究一本java初级教程之类的书就可以。
想要了解更多java开发的相关信息，推荐咨询千锋教育。千锋励精图治，不改教育初心。十一年来，千锋以政策为引导，不断完善国内特色现代职业教育体系建设，充分发挥教研师资队伍使命，构建品质教育，加大创新型人才培养力度，为经济发展提供智力人才和智力支撑，成为新时期职业教育发展的新方向，在同行业中有很高的美誉度。
![[R语言] Heatmap绘图经验总结](/aiimages/%5BR%E8%AF%AD%E8%A8%80%5D+Heatmap%E7%BB%98%E5%9B%BE%E7%BB%8F%E9%AA%8C%E6%80%BB%E7%BB%93.png)
