如题写下代码java
service层的curd操作 UserInterface先定义的是一个接口
UserInterfaceImpl 实现了这个接口
public interface UserInterface{
User saveUser(User user);
boolean delete(User user);
List query(User user);
User update(User user);
}
//保存为UserInterface.java，这是接口
public class UserInterfaceImpl implements UserInterface{
//add
public User save(User user){
return null;
}
//delete
public boolean delete(User user){
return false;
}
// query
public List query(User user){
return null;
}
// update
public User update(User user){
return null;
}
}
实体类（entity）
public class User{
}
1.实现接口
[code="java"]
public interface ExampleInterface{
public void do();
public String doThis(int number);
}
public class sub implements ExampleInterface{
public void do(){
//specify what must happen
}
public String doThis(int number){
//specfiy what must happen
}
}
[/code]
2.继续类
[code="java"]
public class SuperClass{
public int getNb(){
//specify what must happen
return 1;
}
public int getNb2(){
//specify what must happen
return 2;
}
}
public class SubClass extends SuperClass{
//you can override the implementation
@Override
public int getNb2(){
return 3;
}
}
[/code]
3.demo
[code="java"]
Subclass s = new SubClass();
s.getNb(); //returns 1
s.getNb2(); //returns 3
SuperClass sup = new SuperClass();
sup.getNb(); //returns 1
sup.getNb2(); //returns 2
[/code]
刷积分的吧！！！！！！
楼主这个提问很模糊，我的理解是不是下面的意思
1、声明一个接口
[code="java"]public interface SampleInterface {
public void doSomething();
}[/code]
2、接口的实现与调用
[code="java"]public class Test {
public void method1(SampleInterface sampleInterface) {
System.out.println("Do something in test..");
sampleInterface.doSomething();
}
public static void main(String[] args) {
Test test = new Test();
test.method1(new SampleInterface() {
@Override
public void doSomething() {
System.out.println("Do something in interface..");
}
});
}
}[/code]
教你如何实现简单的aop？。。。
[code="java"]
package spring.aop.jdkaop2;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class BusinessProcessorHandler implements InvocationHandler {
private Object target;
public Object bind(Object target) {
this.target = target;
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("You can do something here before process your business");
Object result = method.invoke(target, args);
System.out.println("You can do something here after process your business");
return result;
}
}
[/code]
[code="java"]
package spring.aop.jdkaop2;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import org.apache.commons.lang3.StringUtils;
import spring.aop.model.BusinessProcessor;
import spring.aop.model.BusinessProcessorImpl;
public class Main {
public static void main(String[] args) {
try {
Main test = new Main();
//test.test01();
test.test02();
} catch (Exception e) {
e.printStackTrace();
}
}
//通过结果我们就能够很简单的看出Proxy的作用了，它能够在你的核心业务方法前后做一些你所想做的辅助工作，如log日志，安全机制等等。
public void test01() {
//实现了 invocationHandler
BusinessProcessor businessProcessor = (BusinessProcessor) new BusinessProcessorHandler().bind(new BusinessProcessorImpl());
businessProcessor.processBusiness();
}
/**
* 实现了InvocationHandler接口的invoke方法。其实这个类就是最终Proxy调用的固定接口方法。
* Proxy不管客户端的业务方法是怎么实现的。当客户端调用Proxy时，它只
* 会调用InvocationHandler的invoke接口，所以我们的真正实现的方法就必须在invoke方法中去调用
*
* 1，客户端拿到的是$Proxy0的实例对象，由于$Proxy0继承了BusinessProcessor，因此转化为BusinessProcessor没任何问题。
* 2，实际上调用的是$Proxy0.processBusiness();那么$Proxy0.processBusiness()的实现就是通过InvocationHandler去调用invoke方法啦!
*
*/
public void test02() {
BusinessProcessor businessProcessor = (BusinessProcessor) new BusinessProcessorHandler().bind(new BusinessProcessorImpl());
System.out.println("----------------------基本输出------------------------------");
businessProcessor.processBusiness();
System.out.println("----------------------查看具体对象-----------------------------");
//bp原来是个$Proxy0这个类的对象。那么这个类到底是长什么样子呢？好的。我们再写二个方法去把这个类打印出来看个究竟，是什么三头六臂呢？
System.out.println("businessProcessor is: " + businessProcessor.getClass().getName());
System.out.println("----------------------查看具体对象内部的所有内容(字段，方法等)-----------------------------");
printClassDefinition(businessProcessor.getClass());
}
private String getModifier(int modifier) {
String result = "";
switch(modifier) {
case Modifier.ABSTRACT: result = "abstract";
case Modifier.FINAL: result = "final";
case Modifier.NATIVE: result = "native";
case Modifier.PRIVATE: result = "private";
case Modifier.PROTECTED: result = "protected";
case Modifier.PUBLIC: result = "public";
case Modifier.STATIC: result = "static";
case Modifier.SYNCHRONIZED: result = "synchronized";
/**
* transient是Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，
* transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。
*/
case Modifier.TRANSIENT: result = "transient";
/**
*
* volatile的作用： 作为指令关键字，确保本条指令不会因编译器的优化而省略，且要求每次直接读值.
* 简单地说就是防止编译器对代码进行优化.比如如下程序：
* XBYTE[2]=0x55;
* XBYTE[2]=0x56;
* XBYTE[2]=0x57;
* XBYTE[2]=0x58;
*
* 对外部硬件而言，上述四条语句分别表示不同的操作，会产生四种不同的动作，但是编译器却会对上述四条语句进行优化，
* 认为只有XBYTE[2]=0x58（即忽略前三条语句，只产生一条机器代码）。如果键入volatile，则编译器会逐一的进行编译
* 并产生相应的机器代码（产生四条代码）.
*/
case Modifier.VOLATILE: result = "volatile";
}
return result;
}
private void printClassDefinition(Class<?> clazz) {
//得到类的修饰符
String modifier = getModifier(clazz.getModifiers());
if(StringUtils.isNotEmpty(modifier)) {
modifier = modifier + " ";
}
//得到继承的类
String superClazzName = clazz.getSuperclass().getName();
if(StringUtils.isNotEmpty(superClazzName)) {
superClazzName = "extends " + superClazzName;
}
//得到所有的接口
Class<?>[] interfaces = clazz.getInterfaces();
String interfaceStr = "";
for(int i = 0; i < interfaces.length; i ++){
if(i == 0) {
interfaceStr = interfaceStr + "implements ";
}
interfaceStr += interfaces[i].getName();
}
System.out.println(modifier + clazz.getName() + " " + superClazzName + " " + interfaceStr);
System.out.println("{");
//获取字段信息
Field[] fields = clazz.getDeclaredFields();
for(int i = 0; i < fields.length; i ++) {
//获取字段修饰符
String modif = getModifier(fields[i].getModifiers());
if(StringUtils.isNotEmpty(modif)) {
modif = modif + " ";
}
//获取字段的类型和名称
String fieldType = fields[i].getType().getName();
String fieldName = fields[i].getName();
System.out.println("\t" + modif + fieldType + " " + fieldName + ";");
System.out.println();
}
System.out.println();
System.out.println();
//获取方法信息
Method[] methods = clazz.getMethods();
for(int i = 0; i < methods.length; i ++) {
Method method = methods[i];
//获取方法修饰符
String modif = getModifier(methods[i].getModifiers());
if(StringUtils.isNotEmpty(modif)) {
modif = modif + " ";
}
//获取方法的返回类型与名称
Class<?>[] params = methods[i].getParameterTypes();
String paramStr = "(";
for(int j = 0; j < params.length; j ++) {
paramStr = paramStr + params[j].getName();
if(i < params.length - 1) {
paramStr = paramStr + ",";
}
}
paramStr = paramStr + ")";
//得到所有的异常
Class<?>[] exceptions = method.getExceptionTypes();
String exceptionStr = "";
for(int j = 0; j < exceptions.length; j ++) {
if(j == 0) {
exceptionStr = exceptionStr + "throws ";
}
exceptionStr = exceptionStr + exceptions[j].getName();
if(i < exceptions.length - 1) {
exceptionStr = exceptionStr + ",";
}
}
exceptionStr = exceptionStr + ";";
String meothdName = methods[i].getName();
String returnType = methods[i].getReturnType().getName();
System.out.println("\t"+ modifier + returnType + " " + meothdName + " " + paramStr + " " + exceptionStr);
System.out.println();
}
System.out.println("}");
}
}
[/code]