建造者模式（Builder Pattern）和模板模式（Template Pattern）在Java中都是行为设计模式，但它们的用途和目的有所不同。以下是两者的主要区别，并通过代码实例来说明。

建造者模式（Builder Pattern）
建造者模式主要用于构建复杂对象的表示，并将构建过程与它的表示分离，使得同样的构建过程可以创建不同的表示。该模式允许你通过简单的方法来创建具有复杂内部结构的对象。

代码实例
java
// 产品接口  
public interface Car {  
    void setEngine(String engine);  
    void setWheels(int wheels);  
    void setBody(String body);  
    // ... 其他设置方法  
  
    void display();  
}  
  
// 具体的产品实现  
public class ConcreteCar implements Car {  
    private String engine;  
    private int wheels;  
    private String body;  
    // ... 其他属性  
  
    // 省略getter和setter  
  
    @Override  
    public void display() {  
        System.out.println("Car Details:");  
        System.out.println("Engine: " + engine);  
        System.out.println("Wheels: " + wheels);  
        System.out.println("Body: " + body);  
        // ... 输出其他属性  
    }  
}  
  
// 建造者接口  
public interface CarBuilder {  
    CarBuilder setEngine(String engine);  
    CarBuilder setWheels(int wheels);  
    CarBuilder setBody(String body);  
    // ... 其他设置方法  
  
    Car build();  
}  
  
// 具体的建造者实现  
public class ConcreteCarBuilder implements CarBuilder {  
    private ConcreteCar car = new ConcreteCar();  
  
    @Override  
    public CarBuilder setEngine(String engine) {  
        car.setEngine(engine);  
        return this; // 链式调用  
    }  
  
    // ... 其他实现  
  
    @Override  
    public Car build() {  
        return car;  
    }  
}  
  
// 使用示例  
public class Client {  
    public static void main(String[] args) {  
        CarBuilder builder = new ConcreteCarBuilder();  
        Car car = builder.setEngine("V8")  
                         .setWheels(4)  
                         .setBody("Sedan")  
                         .build();  
        car.display();  
    }  
}
模板模式（Template Pattern）
模板模式定义了一个操作中的算法的框架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤。

代码实例
java
// 抽象类定义模板  
public abstract class AbstractClass {  
    public final void templateMethod() {  
        specificMethod1();  
        specificMethod2();  
        // ... 其他方法调用  
  
        hook(); // 钩子方法，可选实现  
    }  
  
    protected abstract void specificMethod1();  
    protected abstract void specificMethod2();  
  
    // 钩子方法，子类可以选择实现  
    protected void hook() {  
        // 默认实现为空  
    }  
}  
  
// 具体子类实现模板中的抽象方法  
public class ConcreteClass extends AbstractClass {  
    @Override  
    protected void specificMethod1() {  
        System.out.println("ConcreteClass implements specificMethod1");  
    }  
  
    @Override  
    protected void specificMethod2() {  
        System.out.println("ConcreteClass implements specificMethod2");  
    }  
  
    // 可以选择覆盖钩子方法  
    @Override  
    protected void hook() {  
        System.out.println("ConcreteClass overrides hook");  
    }  
}  
  
// 使用示例  
public class Client {  
    public static void main(String[] args) {  
        AbstractClass obj = new ConcreteClass();  
        obj.templateMethod(); // 调用模板方法，会按照定义的顺序调用各个方法  
    }  
}
通过上面的代码实例，我们可以看到两种模式的主要区别：

建造者模式关注的是复杂对象的构建过程，并提供了构建步骤的封装和复用；而模板模式关注的是算法框架的定义，允许子类在不改变算法结构的情况下重定义某些步骤。
建造者模式通常用于创建对象，而模板模式通常用于定义算法或操作过程。
建造者模式中的建造者接口和具体建造者类是可扩展的，可以根据需要添加新的构建步骤；而模板模式中的抽象类和具体子类通常更加稳定，不容易频繁变动。