单例模式
懒汉式，线程不安全
//懒汉式--线程不安全
class Singleton{
private static Singleton uniqueInstance;
private Singleton(){
System.out.println("懒汉式--线程不安全");
}
public static Singleton getUniqueInstance(){
if(uniqueInstance==null){
uniqueInstance=new Singleton();
}
return uniqueInstance;
}
}
public class Shejimoshi {
public static void main(String[] args) {
// TODO Auto-generated method stub
Singleton.getUniqueInstance();
}
}懒汉式，线程安全，在得到实例的方法上添加synchronized关键字
//懒汉式--线程安全
class Singleton{
private static Singleton uniqueInstance;
private Singleton(){
System.out.println("懒汉式--线程安全");
}
public static synchronized Singleton getUniqueInstance(){
if(uniqueInstance==null){
uniqueInstance=new Singleton();
}
return uniqueInstance;
}
}
public class Shejimoshi {
public static void main(String[] args) {
// TODO Auto-generated method stub
Singleton.getUniqueInstance();
}
}饿汉式，线程安全
//饿汉式--线程安全
class Singleton{
private static Singleton uniqueInstance=new Singleton();
private Singleton(){
System.out.println("饿汉式--线程安全");
}
public static Singleton getUniqueInstance(){
return uniqueInstance;
}
}
public class Shejimoshi {
public static void main(String[] args) {
// TODO Auto-generated method stub
Singleton.getUniqueInstance();
}
}双重校验，线程安全
有两个if检验，因为如果两个线程同时执行if，会同时进入if内，虽然if内加锁，但是两个线程都会执行new实例操作（只是先后不同），因此要两个if校验。
用volatile修饰，使多线程情况下指令不会重排。
//双重校验--线程安全
class Singleton{
private volatile static Singleton uniqueInstance;
private Singleton(){
System.out.println("双重校验--线程安全");
}
public static Singleton getUniqueInstance(){
if(uniqueInstance==null){
synchronized (Singleton.class) {
if(uniqueInstance==null){
uniqueInstance=new Singleton();
}
}
}
return uniqueInstance;
}
}
public class Shejimoshi {
public static void main(String[] args) {
// TODO Auto-generated method stub
Singleton.getUniqueInstance();
}
}枚举实现，最佳实现，在面对复杂序列化或者反射攻击的时候，能够防止实例化多次
public class Shejimoshi {
// 枚举
public enum Singleton {
uniqueInstance;
protected void read(){
System.out.println("枚举单例模式");
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Singleton.uniqueInstance.read();
}
}工厂模式
简单工厂，客户类和具体子类解耦
interface Product{
}
class ConcreteProduct implements Product{
public ConcreteProduct(){
System.out.println("生产");
}
}
class ConcreteProduct1 implements Product{
public ConcreteProduct1(){
System.out.println("生产1");
}
}
class ConcreteProduct2 implements Product{
public ConcreteProduct2(){
System.out.println("生产2");
}
}
class SimpleFactory{
public Product createProduct(int type){
if(type==1){
return new ConcreteProduct1();
}else if(type==2){
return new ConcreteProduct2();
}
return new ConcreteProduct();
}
}
public class Shejimoshi {
public static void main(String[] args) {
// TODO Auto-generated method stub
SimpleFactory simpleFactory=new SimpleFactory();
Product product=simpleFactory.createProduct(1);
}
}
工厂方法，Factory是抽象类
interface Product{
}
abstract class Factory{
abstract public Product factoryMethod();
public void doSomething(){
Product product=factoryMethod();
}
}
class ConcreteProduct extends Factory implements Product{
public ConcreteProduct(){
System.out.println("生产");
}
@Override
public Product factoryMethod() {
// TODO Auto-generated method stub
return new ConcreteProduct();
}
}
class ConcreteProduct1 extends Factory implements Product{
public ConcreteProduct1(){
System.out.println("生产1");
}
@Override
public Product factoryMethod() {
// TODO Auto-generated method stub
return new ConcreteProduct1();
}
}
class ConcreteProduct2 extends Factory implements Product{
public ConcreteProduct2(){
System.out.println("生产2");
}
@Override
public Product factoryMethod() {
// TODO Auto-generated method stub
return new ConcreteProduct2();
}
}
public class Shejimoshi {
public static void main(String[] args) {
// TODO Auto-generated method stub
Factory factory=new ConcreteProduct1();
}
}抽象工厂
class AbstactProductA{}
class AbstactProductB{}
class ProductA1 extends AbstactProductA{
public ProductA1() {
System.out.println("生产A1");
}
}
class ProductA2 extends AbstactProductA{
public ProductA2() {
System.out.println("生产A2");
}
}
class ProductB1 extends AbstactProductB{
public ProductB1() {
System.out.println("生产B1");
}
}
class ProductB2 extends AbstactProductB{
public ProductB2() {
System.out.println("生产B2");
}
}
abstract class AbstractFactory{
abstract AbstactProductA createProductA();
abstract AbstactProductB createProductB();
}
class ConcreteFactory1 extends AbstractFactory{
@Override
AbstactProductA createProductA() {
// TODO Auto-generated method stub
return new ProductA1();
}
@Override
AbstactProductB createProductB() {
// TODO Auto-generated method stub
return new ProductB1();
}
}
class ConcreteFactory2 extends AbstractFactory{
@Override
AbstactProductA createProductA() {
// TODO Auto-generated method stub
return new ProductA2();
}
@Override
AbstactProductB createProductB() {
// TODO Auto-generated method stub
return new ProductB2();
}
}
public class Shejimoshi {
public static void main(String[] args) {
// TODO Auto-generated method stub
AbstractFactory abstractFactory=new ConcreteFactory1();
AbstactProductA productA=abstractFactory.createProductA();
}
}
Builder模式
内部静态类
class Student {
private int id;
private String name;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
static class Builder {
private Student student = new Student();
public Builder setId(int id) {
student.id = id;
return this;
}
public Builder setName(String name) {
student.name = name;
return this;
}
public Student builder() {
return student;
}
}
}
public class Shejimoshi {
public static void main(String[] args) {
// TODO Auto-generated method stub
Student.Builder builder = new Student.Builder();
Student student = builder.setId(110).setName("zhangsan").builder();
}
}原型模式
使用原型实例指定要创建的对象类型，通过复制这个原型来创建新对象。
abstract class Prototype{
abstract Prototype myClone();
}
class ConcretePrototype extends Prototype{
private String filed;
public ConcretePrototype(String filed){
this.filed=filed;
}
@Override
Prototype myClone() {
// TODO Auto-generated method stub
return new ConcretePrototype(filed);
}
public String toString(){
return filed;
}
}
public class Shejimoshi {
public static void main(String[] args) {
// TODO Auto-generated method stub
Prototype prototype=new ConcretePrototype("abd");
Prototype clone=prototype.myClone();
System.out.println(clone.toString());
}
}