/**
 * 被创建的类的例子，也可以是抽象类
 */
public class MyClass {
private String name;
public String getName() {
return name;
    }
public void setName(String name) {
this.name = name;
    }
}

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
/**
 * 使用CGLIB动态生成一个类的子类的例子
 */
public class MyClassProxy {
public static void main(String[] argvs) throws Exception{
MyClass mc = createDefaultImplementation(MyClass.class);
        mc.setName("waytt");
System.out.println(mc.getName());
    }
public static <A> A createDefaultImplementation(Class<A> abstractClass) {
Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(abstractClass);
        enhancer.setCallback(new MethodInterceptor() {
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
System.out.println("MethodInterceptor.intercept(proxy, " + method.getName() + ",...)");
if (!Modifier.isAbstract(method.getModifiers())) {
//not abstract method, 可调用类的方法并返回
return methodProxy.invokeSuper(proxy, args);
                } else {
// 抽象方法，不能执行父类的方法了，需要自己构建一个返回值
System.out.println("abstract method....");
Class type = method.getReturnType();
// 生成返回值
return null；
                }
            }
        });
return (A) enhancer.create();
    }
public static <A> A createDefaultImplementation(String className) throws ClassNotFoundException{
return (A) createDefaultImplementation(Class.forName(className));
    }
}

/**
 * 一个自定义接口，供下面的程序调用；
 */
public interface MyInterface {
    public String getName();
    public void setName(String name);
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 实现InvocationHandler的类，对创建出来的类的调用都会转给此类
 */
public class MyInvocationHandler implements InvocationHandler {

    public Object invoke(Object proxy, Method method, Object[] args)  {
        System.out.println("invoke(" + proxy.getClass().getName() + ", method:" + method.getName() + ", " + (args == null ? "NULL" : args) + ")");
        if(method.getName().equals("getName")) {
            return "waytt";
        } else if(method.getName().equals("setName")) {
            System.out.println("args " + (args != null && args.length > 0 ? args[0] : "NULL"));
            return null;
        }
        return null;
    }

    
    public static void main(String[] argvs) throws Exception{
        // 动态创建接口的程序在此
        InvocationHandler handler = new MyInvocationHandler();
        // 第二个参数是需要实现的接口，可以多个，一个类实现多个接口
        MyInterface e = (MyInterface) Proxy.newProxyInstance(MyInterface.class.getClassLoader(),
                new Class[] { MyInterface.class }, handler);
        e.setName("abc");
        System.out.println("getName() return " + e.getName());
    }
}

BufferedImage bufferedImage = ImageIO.read(new File("desk.tif"));
// 这里得到的bufferedImage == null

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
 
public class CompletableFutureTester {
 
    public static void main(String[] argvs) {
        CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("enter cf");
            try {
                //sleep 3秒
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("s1");
            return "done";
        });
 
        try {
            //试图在2秒内得到结果，否则算超时
            String result = cf1.get(2, TimeUnit.SECONDS);
            System.out.println("result is : " + result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            System.out.println("超时未得到结果");
            e.printStackTrace();
        }
    }
}

String content = "这是段.md文件的内容。其中[这是一个链接](./html/README.md)，还有其他内容，这里又有一个[another link](another.md)，这次链接到了another.md。";
 
//括号用于分组；需要匹配括号则用\c
//[^\]] 表示任意不是']'的字符，后面的*表示任意多个
Pattern p = Pattern.compile("\\[([^\\]]*)\\]\\(([^\\)]*)\\)", Pattern.CASE_INSENSITIVE);
 
Matcher matcher = p.matcher(content);
while(matcher != null && matcher.find()) {
    String link = matcher.group();
    for(int i=0; i<= matcher.groupCount(); i++){
        //得到的分组，第0个是整个字串，例如第一次发现时打印：[这是一个链接](./html/README.md)
        //第一个是正则表达式中第一个括号匹配到的内容，例如第一次发现时打印：这是一个链接
        System.out.println(matcher.group(i));
    }
    System.out.println();
}