开头首先推荐一下,也是我的老师老杨在授课时给我们强烈推荐的一本书,《Java与模式》,作者叫闫宏,此书中洋洋洒洒几十万字讨论了Java著名的“剑23”——23种设计模式,书很长,1000多页,大家有兴趣可以慢慢看看。今天结合学习到的案例,来谈谈一谈设计模式中最简单的单例模式和简单工厂模式的皮毛,这也是为什么我把标题定位“浮谈”一下设计模式。在这本1000多页皇皇巨著面前,我连浅谈的资格恐怕都不够,所以我的浮谈仅供拍砖。
什么是模式:
人们多年生产经营活动中会遇到各种问题,然后会想办法解决各种问题。当反复的遇到同样的问题,逐渐的使用一种或几种方式去解决这种问题,这种遇到问题解决问题的方式就是:模式。它是由之前的经验总结而来的。
Java与模式:
当我们开发Java程序时,也会去遇到各种问,也会去解决各种问题。当一种问题经常的出现,反复的使用一种方式去解决,就形成了一种模式。它使用Java语言的特征:构造方法、继承、多态、接口、抽象类等构建出种种解决问题的模式。
Java中的模式分为三类:
1.创建型模式:类如何创建对象。
2.行为型模式:类的对象之间如何配合,分工,做事情。
3.结构型模式:类之间怎样搭建结构。
简单工厂模式:需要一个工厂,工厂生产产品。 用户如果需要使用产品, 不用自己造,通过工厂获取。
工厂类 某些特定对象 程序中如果需要某个对象不用自己创建,通过工厂对象获得。
好处:前段使用者不需要自己创建对象,由工厂去统一创建,前端只需要调用工厂的方法获取对象就可以。
弊端:当增加新的动物时,要修改工厂类。
public class Demo {
public static void main(String[] args) {
//这种方式,需要什么对象,就自己实例化这个类的对象。
/*Dog dog = new Dog();
Cat cat = new Cat();
dog.eat();
cat.eat(); */
//使用简单工厂--方式一,获取
Dog dog = AnimalFactory.getDog();
Cat cat = AnimalFactory.getCat();
//简单工厂--方式二,获取
Object obj = AnimalFactory.getAnimal("狗");//返回Dog
Object obj2 = AnimalFactory.getAnimal("猫");//返回Cat
//向下转型
if(obj instanceof Dog){
Dog dog2 = (Dog)obj;
dog2.eat();
}
if(obj2 instanceof Cat){
Cat cat2 = (Cat)obj2;
cat2.eat();
}
}
}
简单工厂模式:
动物工厂类:
方式一:为每一种对象分别提供方法
提供获取狗对象的方法
提供获取猫对象的方法
方式二:可以提供一个方法,提供一个标记,通过标记标示需要哪个对象,然后我返回哪个对象;
public class AnimalFactory {
//********方式一*************//
public static Dog getDog(){
return new Dog();
}
public static Cat getCat(){
return new Cat();
}
//********方式二*************//
public static Object getAnimal(String type){
if(type.equals("狗")){
return new Dog();
}
if(type.equals("猫")){
return new Cat();
}
return null;
}
}
public class Dog {
public void eat(){
System.out.println("狗吃肉");
}
}
public class Cat {
public void eat(){
System.out.println("猫吃鱼");
}
}
工厂方法模式:
模式是基于简单工厂模式的,即实现了前端不需要实例化对象,由工厂提供,也实现了当新增一个新动物时,无需修改工厂类。
如果需要增加新的动物,增加一个新的动物类,实现IAnimal接口,然后再增加一个工厂类,实现IAnimalFactory接口此在主类中就可以使用了。任何工厂类的代码不用修改。
弊端:使用的类太多。
public class Demo {
public static void main(String[] args) {
IAnimalFactory fac1 = new DogFactory();//狗工厂
IAnimalFactory fac2 = new CatFactory();//猫工厂
IAnimal a = fac1.getAnimal();//Dog对象
IAnimal b = fac2.getAnimal();//Cat对象
a.eat();//
b.eat();
}
}
public interface IAnimal {
void eat();
}
public interface IAnimalFactory {
IAnimal getAnimal();
}
public class CatFactory implements IAnimalFactory {
@Override
public IAnimal getAnimal() {
return new Cat();
}
}
public class DogFactory implements IAnimalFactory {
@Override
public IAnimal getAnimal() {
return new Dog();
}
}
public class Dog implements IAnimal{
public void eat(){
System.out.println("狗吃肉");
}
}
public class Cat implements IAnimal{
public void eat(){
System.out.println("猫吃鱼");
}
}
什么是单例模式?
单:一个 例:对象 单例:一个对象
单例模式:在整个应用程序运行期间,有些类,全局只需要一个对象。这个时候这个类
需要进行一些设计,否则,其它类可能会去实例化它。
单例模式之饿汉式:
思路:
1.首先不能让其他类任意的实例化;
2.由类本身去实例化;
3.提供一个对外的公有方法,返回这个对象的引用;
将Student类作为单例模式的对象。
public class Demo {
public static void main(String[] args) {
Student stu = Student.getInstance();
stu.show();
Student stu2 =Student.getInstance();
stu2.show();
Student stu3 =Student.getInstance();
stu3.show();
System.out.println(stu == stu2);
System.out.println(stu2 == stu3);
}
}
1.类内部持有一个静态的本类对象的引用,作为成员属性;并初始化
2.提供公有的对外的方法返回此引用;
public class Student {
private Student(){
}
private static Student stu = new Student();//0x2233
public static Student getInstance(){
return stu;//每次调用都会返回:0x2233
}
public void show(){
System.out.println("is show()");
}
}
单例模式之懒汉式:
public class Demo {
public static void main(String[] args) {
Student stu1 = Student.getInstance();
stu1.show();
Student stu2 = Student.getInstance();
stu2.show();
System.out.println(stu1 == stu2);
}
}
懒汉式:
1.私有成员变量声明时不初始化;
2.在公有方法内部判断成员是否为null, 是:再初始化;
3.在公有方法内部返回成员变量;
public class Student {
private Student(){
Runtime r;
}
private static Student stu = null;//初始化为null,这里与饿汉式不同
public static Student getInstance(){
if(stu == null){
stu = new Student();
}
return stu;
}
public void show(){
System.out.println("懒汉式-->show()");
}
}
总结:
对于设计模式的学习,一开始我是拒绝的!
“一开始我是不懂”为什么要把很简单的东西搞得那么复杂。后来随着代码量的增加才开始明白我所看到的“复杂”恰恰就是设计模式的精髓所在,我所理解的“简单”就是一把钥匙开一把锁的模式,目的仅仅是着眼于解决现在的问题,而设计模式的“复杂”就在于它是构造一个“万能钥匙”,目的是提出一种对所有锁的开锁方案。
在真正理解设计模式之前我一直在编写“简单”的代码。这个“简单”不是功能的简单,二是设计的简单。简单的设计意味着缺少灵活性,代码很强硬的,只在这个项目里有用,拿到其它的项目中就是垃圾。要使代码可被反复使用,就需要使用“设计模式”对代码进行设计,这样才能达到“以柔克刚”之效。代码深处等着我们的是道家的阴阳哲学,繁即简,少亦多。