当前位置:  编程技术>软件工程/软件设计
本页文章导读:
    ▪设计模式原则之二:开闭原则      开闭原则定义 :一个软件实体应当对扩展开放,对修改关闭。也就是说在设计一个模块的时候,应当使这个模块可以在不被修改的前提下被扩展。 开闭原则总结:面对需求,对程序的改动是.........
    ▪mp3头解析,id3v2.3.0 id3v2.4.0      # -*- coding:utf-8 -*- import struct def decode(x): #如果按照正常算法得到的synchsafe integer,解析成 真正的整数大小 a = x & 0xff; b = (x >> 8) & 0xff; c = (x >> 16) & 0xff; d = (x >>.........
    ▪深入理解原型模式(Singleton Pattern)               通过克隆对象来创建一个新的对象叫做原型模式(prototype pattern)。原型模式属于创建设计模式的范畴,与它相对的单例模式(Singleton Pattern)相对,都很简单,也很常用。.........

[1]设计模式原则之二:开闭原则
    来源: 互联网  发布时间: 2013-11-19

开闭原则定义 :一个软件实体应当对扩展开放,对修改关闭。也就是说在设计一个模块的时候,应当使这个模块可以在不被修改的前提下被扩展。

开闭原则总结:面对需求,对程序的改动是通过增加新代码进行的,而不是改变原来的代码。

我们前面提到的模板方法模式和观察者模式都是开闭原则的极好体现

从到

代码如下(其实就是模板模式):

package com.google.desingn;  
//银行业务员接口,是所有银行业务员的抽象父类。 
public interface BankWorker { 
    public void operation(); 
}

package com.google.desingn;  
//负责存款业务的业务员 
public class SavingBankWorker implements BankWorker { 
    public void operation() { 
        System.out.println("进行存款操作"); 
    } 
}

package package com.google.desingn;  
// 负责取款业务的业务员 
public class DrawingBankWorker  implements BankWorker{ 
    public void operation() { 
        System.out.println("进行取款操作"); 
    } 
}

package com.google.desingn;  
public class TestClass { 
    public static void main(String[] args) { 
        BankWorker bankWorkerSave = new SavingBankWorker(); 
        bankWorkerSave.operation(); 


        BankWorker bankWorkerDraw = new DrawingBankWorker(); 
        bankWorkerDraw.operation(); 
    } 
}

作者:chuangzaozhe1 发表于2013-5-8 23:24:37 原文链接
阅读:70 评论:0 查看评论

    
[2]mp3头解析,id3v2.3.0 id3v2.4.0
    来源: 互联网  发布时间: 2013-11-19

# -*- coding:utf-8 -*-  
import struct
def decode(x):  #如果按照正常算法得到的synchsafe integer,解析成 真正的整数大小
    a = x & 0xff;
    b = (x >> 8) & 0xff;
    c = (x >> 16) & 0xff;
    d = (x >> 24) & 0xff;
    x_final = 0x0;
    x_final = x_final | a;
    x_final = x_final | (b << 7);
    x_final = x_final | (c << 14);
    x_final = x_final | (d << 21);
    return x_final

def encode(x): #和上边相反
    a = x & 0x7f;
    b = (x >> 7) & 0x7f;
    c = (x >> 14) & 0x7f;
    d = (x >> 21) & 0x7f;
    
    x_final = 0x0;
    x_final = x_final | a;
    x_final = x_final | (b << 8);
    x_final = x_final | (c << 16);
    x_final = x_final | (d << 24);
    return x_final


name = "4.mp3"; #要读取的文件
print name
fp = open(name,'rb');
head = fp.read(10)
id3,ver,revision,flag,length  = struct.unpack("!3sBBBI",head);
length = decode(length)


print 'total:',length

while True:
    frame = fp.read(10)
    fid,size,flag,flag2 = struct.unpack("!4sI2B",frame)
    
    if size==0: #有时候会留1024的白 不知道为啥
        break
    
    if ver==4:   #就是这一点 4和3的不同之处,4的这儿也采用synchsafe integer 了,注意啊
        size = decode(size)
    print fid,'frame:',size
    fp.read(size)
    length-= (size+10)
    if length<=0:
        break

#如果要给该mp3加张图片 那就方便了

找了一堆文章,走了许多弯路,发现许多同学的文档是错误滴,现在总结如下


虽然说 百度找来的每篇资料都说 现在的id3v2 都是3 版本,但是不知道是不是太古老啦,现在许多都四了噢,而且3和4有一点非常严重的不同,你如果把4当3来解,肯定会出错


参考文章

http://id3.org/id3v2.3.0

http://id3.org/id3v2.4.0-structure

http://fanzhichao.blog.hexun.com/28574021_d.html   这个是针对2.3的


作者:qiushi888 发表于2013-5-8 23:20:35 原文链接
阅读:71 评论:0 查看评论

    
[3]深入理解原型模式(Singleton Pattern)
    来源: 互联网  发布时间: 2013-11-19

         通过克隆对象来创建一个新的对象叫做原型模式(prototype pattern)。原型模式属于创建设计模式的范畴,与它相对的单例模式(Singleton Pattern)相对,都很简单,也很常用。

       使用场景:

  1. 当有许多子类,并且仅仅是对象的类型不同而已。
  2. 引用程序中,需要创建大量的类实例且这些实例的状态等差异很小。
  3. 动态的绑定或加重方法。
  4. 使用一个实例,仅仅通过改变它的状态或参数去完成一个工作。
  5. 在运行时,添加和删除对象。
  6. 通过修改实例的结构来指定新对象。
  7.  动态地用类配置一个应用程序。

        需要记住的是:当使用clone去复制时,是否需要一个浅度克隆还是深度克隆(deep clone or shallow clone). 基于具体的业务需要,选择不同的克隆方式。如果你想使用深度克隆,你能够使用内存序列化( using in memory serialization)技术来实现。当实现原型设计模式时,使用克隆去复制完全是一个设计决策。请阅读如下例子。

public class Prototype {
    /**
     * Dynamic loading is a typical object-oriented feature and prototype example.
     * For example, overriding method is a kind of prototype pattern.
     */
   static Complex c1 = new Complex();

    /**
     * Cloning is a shallow copy of the original object.
     * If the cloned object is changed, the original object
     * will be changed accordingly. See the following alteration.
     * @return  Complex
     */
   static Complex makeCopy() {
      return (Complex)c1.clone();
   }

   public static void main(String []args){
       //Dynamically load method
        Shape s1 = new Line();
        Shape s2 = new Square();
        Shape s3 = new Circle();
        paint(s1);
        paint(s2);
        paint(s3);

/**
* If we want to make code more readable or do more stuff,
* we can code the paint method in the following way:
static void paint(Shape s){
    if ( s instanceof Line)
       s.draw();
       //more job here
    if (s instanceof Square)
       s.draw();
       //more job here
    if (s instanceof Circle)
       s.draw();
       //more job here
}
*/
       Complex c1 = makeCopy();
       int[] mycopy = c1.getNums();
       for(int i = 0; i < mycopy.length; i++)
          System.out.print(mycopy[i]);
   }
   
   static void paint(Shape s) {
        s.draw();
    }
  
}

interface Shape {
   public void draw();
}

class Line implements Shape {
   public void draw() {
       System.out.println("line");
   }
  }

class Square implements Shape {
   public void draw() {
       System.out.println("square");
   }
  }

class Circle implements Shape {
   public void draw() {
       System.out.println("circle");
   }
  }

/**
 *The prototype is typically used to clone an object,
 *  i.e. to make a copy of an object. When an object
 *  is complicated or time consuming to be created ,
 *  you may take prototype pattern to make such object
 *  cloneable. Assume the Complex class is a complicated,
 *  you need to implement Cloneable interface and override
 *  the clone method(protected Object clone()).
 */
class Complex implements Cloneable {
    int[] nums = {1,2,3,4,5};
    public Object clone() {
        try {
           return super.clone();
        }catch(CloneNotSupportedException cnse) {
            System.out.println(cnse.getMessage());
            return null;
        }
    }
    int[] getNums() {
       return nums;
    }
}

      这个例子使用了prototype模式,减少了创建对象的花费(这个实例只是作为阐明原型设计模式,不能作为实际用途。)。值得使出的是, 对于原型模式而言,克隆不是一个强制的选择。

      也许你感觉上面的例子不够接近实际应用,那么就认真看看下面的实例吧,也许能够在实际的项目中应用。


       PrototypeCapable.java接口,扩展 Cloneable。

public interface PrototypeCapable extends Cloneable{
    public PrototypeCapable clone() throws CloneNotSupportedException;
}
     定义三个子类Album.java, Movie.java, Show.java, 实现PrototypeCapable接口。

public class Album implements PrototypeCapable{
    private String name = null;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public Album clone() throws CloneNotSupportedException {
        System.out.println("Cloning Album object..");
        return (Album) super.clone();
    }
    @Override
    public String toString() {
        return "Album";
    }
}

      
public class Movie implements PrototypeCapable{
    private String name = null;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
    @Override
    public Movie clone() throws CloneNotSupportedException {
        System.out.println("Cloning Movie object..");
        return (Movie) super.clone();
    }
    
    @Override
    public String toString() {
        return "Movie";
    }
}
       
public class Show implements PrototypeCapable
{
    private String name = null;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public Show clone() throws CloneNotSupportedException {
        System.out.println("Cloning Show object..");
        return (Show) super.clone();
    }
    @Override
    public String toString() {
        return "Show";
    }
}
        定义工厂类PrototypeFactory,根据类名字符克隆对象。

public class PrototypeFactory{

    private static java.util.Map<String , PrototypeCapable> prototypes = new java.util.HashMap<String , PrototypeCapable>();
 
    static{
        prototypes.put(ModelType.MOVIE, new Movie());
        prototypes.put(ModelType.ALBUM, new Album());
        prototypes.put(ModelType.SHOW, new Show());
    }
 
    public static PrototypeCapable getInstance(final String s) throws CloneNotSupportedException {
        return ((PrototypeCapable) prototypes.get(s)).clone();
    }
    
    public static class ModelType {
        public static final String MOVIE = "movie";
        public static final String ALBUM = "album";
        public static final String SHOW = "show";
    }
}

      测试这个类,测试代码如下:

import static org.junit.Assert.*;
import junit.framework.Assert;

import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.pattern.rationaljava.creationalpattern.prototype.PrototypeFactory;
import org.pattern.rationaljava.creationalpattern.prototype.PrototypeFactory.ModelType;

public class TestPrototypeFactory {

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
	}

	@Before
	public void setUp() throws Exception {
	}

	@After
	public vo      
    
最新技术文章:
▪主-主数据库系统架构    ▪java.lang.UnsupportedClassVersionError: Bad version number i...    ▪eclipse项目出现红色叉叉解决方案
▪Play!framework 项目部署到Tomcat    ▪dedecms如何做中英文网站?    ▪Spring Batch Framework– introduction chapter(上)
▪第三章 AOP 基于@AspectJ的AOP    ▪基于插件的服务集成方式    ▪Online Coding开发模式 (通过在线配置实现一个表...
▪观察者模式(Observer)    ▪工厂模式 - 程序实现(java)    ▪几种web并行化编程实现
▪机器学习理论与实战(二)决策树    ▪Hibernate(四)——全面解析一对多关联映射    ▪我所理解的设计模式(C++实现)——解释器模...
▪利用规则引擎打造轻量级的面向服务编程模式...    ▪google blink的设计计划: Out-of-Progress iframes    ▪FS SIP呼叫的消息线程和状态机线程
▪XML FREESWITCH APPLICATION 实现    ▪Drupal 实战    ▪Blink: Chromium的新渲染引擎
▪(十四)桥接模式详解(都市异能版)    ▪你不知道的Eclipse用法:使用Allocation tracker跟...    ▪Linux内核-进程
▪你不知道的Eclipse用法:使用Metrics 测量复杂度    ▪IT行业为什么没有进度    ▪Exchange Server 2010/2013三种不同的故障转移
▪第二章 IoC Spring自动扫描和管理Bean    ▪CMMI简介    ▪目标检测(Object Detection)原理与实现(六)
▪值班总结(1)——探讨sql语句的执行机制    ▪第二章 IoC Annotation注入    ▪CentOS 6.4下安装Vagrant
▪Java NIO框架Netty1简单发送接受    ▪漫画研发之八:会吃的孩子有奶吃    ▪比较ASP和ASP.NET
▪SPRING中的CONTEXTLOADERLISTENER    ▪在Nginx下对网站进行密码保护    ▪Hibernate从入门到精通(五)一对一单向关联映...
▪.NET领域驱动设计—初尝(三:穿过迷雾走向光...    ▪linux下的块设备驱动(一)    ▪Modem项目工作总结
▪工作流--JBPM简介及开发环境搭建    ▪工作流--JBPM核心服务及表结构    ▪Eclipse:使用JDepend 进行依赖项检查
▪windows下用putty上传文件到远程Linux方法    ▪iBatis和Hibernate的5点区别    ▪基于学习的Indexing算法
▪设计模式11---设计模式之中介者模式(Mediator...    ▪带你走进EJB--JMS编程模型    ▪从抽象谈起(二):观察者模式与回调
▪设计模式09---设计模式之生成器模式(Builder)也...    ▪svn_resin_持续优化中    ▪Bitmap recycle方法与制作Bitmap的内存缓存
▪Hibernate从入门到精通(四)基本映射    ▪设计模式10---设计模式之原型模式(Prototype)    ▪Dreamer 3.0 支持json、xml、文件上传
▪Eclipse:使用PMD预先检测错误    ▪Jspx.net Framework 5.1 发布    ▪从抽象谈起(一):工厂模式与策略模式
▪Eclipse:使用CheckStyle实施编码标准    ▪【论文阅读】《Chain Replication for Supporting High T...    ▪Struts2 Path_路径问题
▪spring 配置文件详解    ▪Struts2第一个工程helloStruts极其基本配置    ▪Python学习入门基础教程(learning Python)--2 Python简...
▪maven springmvc环境配置    ▪基于SCRUM的金融软件开发项目    ▪software quality assurance 常见问题收录
▪Redis集群明细文档    ▪Dreamer 框架 比Struts2 更加灵活    ▪Maven POM入门
▪git 分支篇-----不断更新中    ▪Oracle非主键自增长    ▪php设计模式——UML类图
▪Matlab,Visio等生成的图片的字体嵌入问题解决...    ▪用Darwin和live555实现的直播框架    ▪学习ORM框架—hibernate(二):由hibernate接口谈...
▪(十)装饰器模式详解(与IO不解的情缘)    ▪无锁编程:最简单例子    ▪【虚拟化实战】网络设计之四Teaming
▪OSGi:生命周期层    ▪Javascript/Jquery——简单定时器    ▪java代码 发送GET、POST请求
▪Entity Framework底层操作封装(3)    ▪HttpClient 发送GET、POST请求    ▪使用spring框架,应用启动时,加载数据
▪Linux下Apache网站目录读写权限的设置    ▪单键模式的C++描述    ▪学习ORM框架—hibernate(一):初识hibernate
 


站内导航:


特别声明:169IT网站部分信息来自互联网,如果侵犯您的权利,请及时告知,本站将立即删除!

©2012-2021,,E-mail:www_#163.com(请将#改为@)

浙ICP备11055608号-3