工厂方法模式：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
个人总结： 通过对象工厂灵活地生产多种对象
public class Factory_Method {
public static void main(String[] args){
AnimalsFactory animalsFactory = new AnimalsFactory();
//通过工厂创建一个cat对象
Animals cat = animalsFactory.getAnimals("cat");
//通过工厂创建一个dog对象
Animals dog = animalsFactory.getAnimals("dog");
cat.name(); dog.name();
}
}
interface Animals { //动物
void name();
}
class Cat implements Animals{ //猫
@Override
public void name(){
System.out.println("this is a cat");
}
}
class Dog implements Animals{ //狗
@Override
public void name(){
System.out.println("this is a dog");
}
}
class AnimalsFactory { //动物工厂
public Animals getAnimals(String name){
if(name.equalsIgnoreCase("cat"))
return new Cat();
else if(name.equalsIgnoreCase("dog"))
return new Dog();
else
return null;
}
}
抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
个人总结：工厂模式 >> 一种工厂，多种对象 ； 抽象工厂模式 >> 一种抽象工厂，多种工厂，每个工厂又可以生产多种对象
public class Abstract_Factory {
//工厂生成器：生产具体的工厂
public static AbstractFactory getFactory(String factoryName){
if(factoryName.equalsIgnoreCase("animals"))
return new AnimalsFactory();
else if(factoryName.equalsIgnoreCase("others"))
return new OthersFactory();
else
return null;
}
public static void main(String[] args){
//生产动物工厂
AbstractFactory animalsFactory = getFactory("animals");
//通过动物工厂创建一个cat对象
Animals cat = animalsFactory.getAnimals("cat");
cat.name();
}
}
interface Animals { //动物
void name();
}
class Cat implements Animals{ //猫
@Override
public void name(){
System.out.println("this is a cat");
}
}
class AnimalsFactory extends AbstractFactory{ //动物工厂
public Animals getAnimals(String name){
if(name.equalsIgnoreCase("cat"))
return new Cat();
else
return null;
}
@Override
public Object getObject() {
return null;
}
}
class OthersFactory extends AbstractFactory{ //其他工厂
public Object getObject() {
return null;
}
@Override
public Animals getAnimals(String name) {
return null;
}
}
abstract class AbstractFactory { //抽象工厂
abstract public Animals getAnimals(String name);
abstract public Object getObject();
}
单例模式：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
个人总结：在类内部创造单一对象，通过设置构造方法权限，使类外部无法再创造对象
复制代码
public class Singleton {
public static void main(String[] agrs){
Earth earth = Earth.getEarth();
System.out.println(earth.getAge());
}
}
//创建单例对象的方式有多种，下面是比较常用的一种方式；按需求选择合适方式。
class Earth { //只允许创建一个对象的类
//创建唯一对象
private static Earth earth = new Earth();
//构造函数访问权限必须private
private Earth(){}
//获取唯一对象
public static Earth getEarth(){
return earth;
}
private int age = 1000;
public int getAge() {
return age;
}
}
建造者模式：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。
个人总结：将一些不会变的基本组件，通过builder，组合，构建复杂对象，实现分离
public class BuilderDemo {
public static void main(String[] args) {
PriceBuilder priceBuilder = new PriceBuilder();
System.out.println("Car1和Car2:"+priceBuilder.Car1AndCar2());
System.out.println("Car1和Bus:"+priceBuilder.Car1AndBus());
}
}
//基本组件
interface Car {
}
//基本组件1
class Car1 implements Car{
int price = 20;
}
//基本组件2
class Car2 implements Car{
int price = 90;
}
//基本组件3
class Bus {
int price = 500;
}
class PriceBuilder {
//car1和car2的总价格
public int Car1AndCar2() {
int priceOfCar1 = new Car1().price;
int priceOfCar2 = new Car2().price;
return priceOfCar1+priceOfCar2;
}
//car1和bus的总价格
public int Car1AndBus() {
int priceOfCar1 = new Car1().price;
int priceOfBus = new Bus().price;
return priceOfCar1+priceOfBus;
}
}
原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
个人总结：将对象复制了一份并返还给调用者，对象需继承Cloneable并重写clone()方法
public class Prototype implements Cloneable{
private String message = "hello";
public Object clone() throws CloneNotSupportedException{
Prototype proto = (Prototype) super.clone();
//操作克隆对象
proto.message += " world!";
return proto;
}
public static void main(String[] args) throws CloneNotSupportedException {
Prototype p = (Prototype)new Prototype().clone();
//操作克隆对象
System.out.println(p.message);
}
}
|
|
收藏
淘帖
踩
