一、向上转型
下面一句话出自Thinking in Java。
使用接口的核心原因:为了能够向上转型为多个基类型。即利用接口的多实现,可向上转型为多个接口基类型。
j ava接口或抽象类都可以使用向上转型,它们用的都是java运行时多态技术,或者叫运行期绑定技术。
下面是一个java接口的普遍用法,
interface People{
void peopleList();
}
class Student implements People{
public void peopleList(){
System.out.println("I’m a student.");
}
}
class Teacher implements People{
public void peopleList(){
System.out.println("I’m a teacher.");
}
}
public class Example{
public static void main(String args[]){
People a; //声明接口变量
a=new Student(); //实例化,接口变量中存放对象的引用
a.peopleList(); //接口回调
a=new Teacher(); //实例化,接口变量中存放对象的引用
a.peopleList(); //接口回调
}
}
结果:
I’m a student.
I’m a teacher.
二、回调函数
java回调函数指:使用接口来实现回调对象方法使用权的功能。
当通常大家说的回调函数一般就是按照别人的定好的接口规范写的,等待别人调用的函数,在C语言中,回调函数通常通过函数指针来传递;Java 的面向对象模型目前并不支持方
法指针,Java 的接口支持提供了一种获得回调的等价功能的机制。其技巧就是:定义一个简单接口,并在该接口中声明我们要调用的方法。在实际应用中通常就是编写另外一个类
或类库的人规定一个接口,然后你来实现这个接口,然后把这个实现类的一个对象作为参数传给别人的程序,别人的程序必要时就会通过那个接口来调用你编写的函数。
下面是一个例子:
如果我们要测试一个类的方法的执行时间,通常我们会这样做:
public class TestObject {
public static void testMethod(){
for(int i=0; i<100000000; i++){
}
}
public void testTime(){
long begin = System.currentTimeMillis();//测试起始时间
testMethod();//测试方法
long end = System.currentTimeMillis();//测试结束时间
System.out.println("[use time]:" + (end - begin));//打印使用时间
}
public static void main(String[] args) {
TestObject test=new TestObject();
test.testTime();
}
}
大家看到了testTime()方法,就只有"//测试方法"是需要改变的,下面我们来做一个函数实现相同功能但更灵活:
首先定一个回调接口:
public interface CallBack {
//执行回调操作的方法
void execute();
}
然后再写一个工具类:
public class Tools {
public void testTime(CallBack callBack) {
long begin = System.currentTimeMillis();//测试起始时间
callBack.execute();/// 进行回调操作
long end = System.currentTimeMillis();//测试结束时间
System.out.println("[use time]:" + (end - begin));//打印使用时间
}
public static void main(String[] args) {
Tools tool = new Tools();
tool.testTime(new CallBack(){
//定义execute方法
public void execute(){
//这里可以加放一个或多个要测试运行时间的方法
TestObject.testMethod();
}
});
}
}
大家看到,testTime()传入定义callback接口的execute()方法就可以实现回调功能。
下面是Hibernate使用java回调函数的例子。
相信使用过Spring + Hibernate开发过的人,在写DAO的时候都使用过Spring的HibernateDaoSupport类,然后在实现的时候就可以很轻松的使用 getHibernateTemplate()方法之
后就可以调用save()、delete()、update()等Hibernate的 Session的操作,很简单。比如:
getHibernateTemplate().save(user);
这样一句话在我们没有Spring的时候就必须使用如下的代码才能完成:
Session session = HibernateUtil.getSession();
Transaction tx = session.beginTransaction();
session.save(user);
tx.commit();
HibernateUtil.colseSession();
这里还省去了异常处理,同时使用了HibernateUtil类来简化从 SessionFactory获取Session,以及关闭Session等处理。
但是我们在使用Hibernate的时候不一定会使用Spring,所以我们可以模仿Spring的处理方式,做一个Hibernate的模板,使用模板模式来简化我们的开发,其主要的目的就是
为了简化开发,使代码达到最大话的重用。
1.我们现来实现一个Hibernate模板:
package kick.hibernate;
import net.sf.hibernate.HibernateException;
import net.sf.hibernate.Session;
import net.sf.hibernate.Transaction;
public class HibernateTemplate{
public static Object run(HibernateCallback callback) throws HibernateException{
Session session = null;
Transaction tx = null;
try {
session = HibernateSessionutil.currentSession();
tx = session.beginTransaction();
Object result = callback.execute(session);
tx.commit();
session.flush();
return result;
} catch (HibernateException e) {
tx.rollback();
return null;
} finally {
HibernateSessionutil.closeSession();
}
}
这里类很简单,就是使用一个实现HibernateCallBack接口的一个回掉类,在调用的时候根据具体的需求实现 HibernateCallBack类。
2.回掉接口HibernateCallBack:
package kick.hibernate;
import net.sf.hibernate.HibernateException;
import net.sf.hibernate.Session;
public interface HibernateCallBack {
Object execute(Session session)throws HibernateException;
}
好了,到此为止我们就可以使用这个模板了,可以用如下的方式使用:
HibernateTemplate.run(new HibernateCallback() {
public Object execute(Session session) throws HibernateException {
session.save(user);
return null;
}
});
下面一句话出自Thinking in Java。
使用接口的核心原因:为了能够向上转型为多个基类型。即利用接口的多实现,可向上转型为多个接口基类型。
j ava接口或抽象类都可以使用向上转型,它们用的都是java运行时多态技术,或者叫运行期绑定技术。
下面是一个java接口的普遍用法,
interface People{
void peopleList();
}
class Student implements People{
public void peopleList(){
System.out.println("I’m a student.");
}
}
class Teacher implements People{
public void peopleList(){
System.out.println("I’m a teacher.");
}
}
public class Example{
public static void main(String args[]){
People a; //声明接口变量
a=new Student(); //实例化,接口变量中存放对象的引用
a.peopleList(); //接口回调
a=new Teacher(); //实例化,接口变量中存放对象的引用
a.peopleList(); //接口回调
}
}
结果:
I’m a student.
I’m a teacher.
二、回调函数
java回调函数指:使用接口来实现回调对象方法使用权的功能。
当通常大家说的回调函数一般就是按照别人的定好的接口规范写的,等待别人调用的函数,在C语言中,回调函数通常通过函数指针来传递;Java 的面向对象模型目前并不支持方
法指针,Java 的接口支持提供了一种获得回调的等价功能的机制。其技巧就是:定义一个简单接口,并在该接口中声明我们要调用的方法。在实际应用中通常就是编写另外一个类
或类库的人规定一个接口,然后你来实现这个接口,然后把这个实现类的一个对象作为参数传给别人的程序,别人的程序必要时就会通过那个接口来调用你编写的函数。
下面是一个例子:
如果我们要测试一个类的方法的执行时间,通常我们会这样做:
public class TestObject {
public static void testMethod(){
for(int i=0; i<100000000; i++){
}
}
public void testTime(){
long begin = System.currentTimeMillis();//测试起始时间
testMethod();//测试方法
long end = System.currentTimeMillis();//测试结束时间
System.out.println("[use time]:" + (end - begin));//打印使用时间
}
public static void main(String[] args) {
TestObject test=new TestObject();
test.testTime();
}
}
大家看到了testTime()方法,就只有"//测试方法"是需要改变的,下面我们来做一个函数实现相同功能但更灵活:
首先定一个回调接口:
public interface CallBack {
//执行回调操作的方法
void execute();
}
然后再写一个工具类:
public class Tools {
public void testTime(CallBack callBack) {
long begin = System.currentTimeMillis();//测试起始时间
callBack.execute();/// 进行回调操作
long end = System.currentTimeMillis();//测试结束时间
System.out.println("[use time]:" + (end - begin));//打印使用时间
}
public static void main(String[] args) {
Tools tool = new Tools();
tool.testTime(new CallBack(){
//定义execute方法
public void execute(){
//这里可以加放一个或多个要测试运行时间的方法
TestObject.testMethod();
}
});
}
}
大家看到,testTime()传入定义callback接口的execute()方法就可以实现回调功能。
下面是Hibernate使用java回调函数的例子。
相信使用过Spring + Hibernate开发过的人,在写DAO的时候都使用过Spring的HibernateDaoSupport类,然后在实现的时候就可以很轻松的使用 getHibernateTemplate()方法之
后就可以调用save()、delete()、update()等Hibernate的 Session的操作,很简单。比如:
getHibernateTemplate().save(user);
这样一句话在我们没有Spring的时候就必须使用如下的代码才能完成:
Session session = HibernateUtil.getSession();
Transaction tx = session.beginTransaction();
session.save(user);
tx.commit();
HibernateUtil.colseSession();
这里还省去了异常处理,同时使用了HibernateUtil类来简化从 SessionFactory获取Session,以及关闭Session等处理。
但是我们在使用Hibernate的时候不一定会使用Spring,所以我们可以模仿Spring的处理方式,做一个Hibernate的模板,使用模板模式来简化我们的开发,其主要的目的就是
为了简化开发,使代码达到最大话的重用。
1.我们现来实现一个Hibernate模板:
package kick.hibernate;
import net.sf.hibernate.HibernateException;
import net.sf.hibernate.Session;
import net.sf.hibernate.Transaction;
public class HibernateTemplate{
public static Object run(HibernateCallback callback) throws HibernateException{
Session session = null;
Transaction tx = null;
try {
session = HibernateSessionutil.currentSession();
tx = session.beginTransaction();
Object result = callback.execute(session);
tx.commit();
session.flush();
return result;
} catch (HibernateException e) {
tx.rollback();
return null;
} finally {
HibernateSessionutil.closeSession();
}
}
这里类很简单,就是使用一个实现HibernateCallBack接口的一个回掉类,在调用的时候根据具体的需求实现 HibernateCallBack类。
2.回掉接口HibernateCallBack:
package kick.hibernate;
import net.sf.hibernate.HibernateException;
import net.sf.hibernate.Session;
public interface HibernateCallBack {
Object execute(Session session)throws HibernateException;
}
好了,到此为止我们就可以使用这个模板了,可以用如下的方式使用:
HibernateTemplate.run(new HibernateCallback() {
public Object execute(Session session) throws HibernateException {
session.save(user);
return null;
}
});