单例模式（饿汉式）：
/**
* 饿汉式的单例模式
* 优点：不能延迟加载，只要此类一被调用，对象立即创建
* 缺点：线程安全---天然的线程安全
*
*/
public class HungrySinglton {
//因为此实例只有一个，所以使用final修饰;因为此实例对象需要被getInstance()方法使用，所以使用static修饰
//此实例对象对于外部是不可见的，所以使用private修饰。
private static final HungrySinglton hungry=new HungrySinglton();
//需要实现单例，构造器需要私有化
private HungrySinglton(){
}
//构造器进行了私有化，那么需要提供一个public方法让外界获取的实例
//在类没有实例化的情况下，需要调用类的方法，那么方法加上static修饰
public static HungrySinglton getInstance(){
return hungry;
}
}
单例模式（懒汉式）：
/**
* 懒汉式单例模式
* 优点：能够延迟加载
* 缺点：线程不安全
*/
public class Lazy {
//声明一个对象,但是不进行实例化，需要时才进行实例化
private static Lazy lazy=null;
//一个private修饰的构造器，外界无法进行new操作
private Lazy(){
}
/**
* 让外界获取到实例对象
* @return
*/
public static Lazy getInstance(){
//此处存在线程不安全的问题
if(lazy==null){
return new Lazy();
}
return lazy;
}
}
注意：为什么我们会需要单例模式，因为需要创建的对象非常的庞大，需要消耗非常大的资源，而创建一个实例可以供大家一起使用，没有必要创建很多的实例，从而节约系统资源。所以使用单例模式。
工厂模式（简单工厂&静态工厂）：
/*
* 开闭原则：对于拓展开放，对于修改关闭
* 简单工厂：
* 优点：屏蔽了对象创建的复杂度，降低了调用者调用难度，增加了对象的安全系数
* 缺点：如果需要增加车子类，需要修改工厂类if...else分支语句，违背了开闭原则
* 静态工厂：静态工厂就是在简单工厂的基础之上，为每一个车类型增加一个工厂即可
* 符合开闭原则，但是如果车的类型很多就相应的要加入对应的工厂，
* 复杂度增加，后期不利于维护
*/
public class Test03 {
public static void main(String[] args) {
//简单工厂模式创建对象
//需要车实例，直接通过工厂获取即可，降低了调用者与车类之间的耦合度
Car car=CarFactory.getCar("audi");
car.run();
//静态工厂模式创建对象
Car car1=AudiFactory.getCar();
car1.run();
Car car2=AutoFactory.getCar();
car2.run();
}
}
//汽车工厂
class CarFactory{
public static Car getCar(String carType){
if("audi".equals(carType)){
return new Audi();
}else{
return new Auto();
}
}
}
//车的超类：抽象类
abstract class Car{
public abstract void run();
}
//子类Audi
class Audi extends Car{
@Override
public void run() {
System.out.println("audi is run.............");
}
}
//Audi车对应的工厂
class AudiFactory{
public static Car getCar(){
return new Audi();
}
}
//子类Auto
class Auto extends Car{
@Override
public void run() {
System.out.println("auto is run.............");
}
}
//Auto车对应的工厂
class AutoFactory{
public static Car getCar(){
return new Auto();
}
}注：设计模式只是前人对开发的总结，没有固定的写法，学习设计模式主要是继承相应设计模式的思想。在实际运用中，可能会同时使用到多种设计模式，只要实际开发需要，我们就可以综合使用。