应用开发笔记

Android开发 ListView singleChoiceMode 用代码选中某行

发表于 2014-01-20 更新于 2022-11-07 分类于 Android开发

listview有个setSelection方法，在SingleChoiceMode下，经实验无效，获取选中项是用getCheckedItemPosition(),不是getSelectedItemId()。如果要给用户默认选中一项呢？可以调用performItemClick方法，顾名思义，该方法就是触发Item点击事件，也就实现了选中指定项的功能。选中第0项：

boolean b=listview_selection.performItemClick(listview_selection.getAdapter().getView(0, null, null), 0, 0);

Java设计模式之命令模式

发表于 2014-01-18 更新于 2022-11-07 分类于 Java

命令模式由三部分组成： Receiver:命令接收者，最终执行命令的角色 Command:待执行的命令 Invoker:调用者，接收到Command后让Receiver执行代码来自《您的设计模式》. Receiver:

package com.pocketdigi.patterns.command;
/**
 * Receiver,命令执行者
 */
public abstract class Group {
    public abstract void find();
    public abstract void add();
    public abstract void delete();
    public abstract void change();
    public abstract void plan();
}




package com.pocketdigi.patterns.command;
/**
 * 代码组
 */
public class CodeGroup extends Group {

    @Override
    public void find() {
        // TODO Auto-generated method stub
        System.out.println("找到代码组");
    }

    @Override
    public void add() {
        // TODO Auto-generated method stub
        System.out.println("客户要求增加一项功能");

    }

    @Override
    public void delete() {
        // TODO Auto-generated method stub
        System.out.println("客户要求删除一项功能");
    }

    @Override
    public void change() {
        // TODO Auto-generated method stub
        System.out.println("客户要求修改一项功能");
    }

    @Override
    public void plan() {
        // TODO Auto-generated method stub
        System.out.println("客户要求代码变更计划");
    }

}




package com.pocketdigi.patterns.command;
/**
 * 美工组
 */
public class PageGroup extends Group {

    @Override
    public void find() {
        // TODO Auto-generated method stub
        System.out.println("找到美工组");
    }

    @Override
    public void add() {
        // TODO Auto-generated method stub
        System.out.println("客户要求增加一个页面 ");

    }

    @Override
    public void delete() {
        // TODO Auto-generated method stub
        System.out.println("客户要求删除一个页面");
    }

    @Override
    public void change() {
        // TODO Auto-generated method stub
        System.out.println("客户要求修改一个页面");
    }

    @Override
    public void plan() {
        // TODO Auto-generated method stub
        System.out.println("客户要求页面变更计划");
    }

}



package com.pocketdigi.patterns.command;

/**
 * 需求组
 */
public class RequirementGroup extends Group {

    @Override
    public void find() {
        // TODO Auto-generated method stub
        System.out.println("找到需求组");
    }

    @Override
    public void add() {
        // TODO Auto-generated method stub
        System.out.println("客户要求增加一项需求 ");

    }

    @Override
    public void delete() {
        // TODO Auto-generated method stub
        System.out.println("客户要求删除一项需求");
    }

    @Override
    public void change() {
        // TODO Auto-generated method stub
        System.out.println("客户要求修改一项需求");
    }

    @Override
    public void plan() {
        // TODO Auto-generated method stub
        System.out.println("客户要求需求变更计划");
    }

}

Command:

package com.pocketdigi.patterns.command;

public abstract class Command {
    protected RequirementGroup rg=new RequirementGroup();
    protected PageGroup pg=new PageGroup();
    protected CodeGroup cg=new CodeGroup();
    
    public abstract void execute();
}



package com.pocketdigi.patterns.command;
/**
 * 添加需求Command
 */
public class AddRequirementCommand extends Command {

    @Override
    public void execute() {
        // TODO Auto-generated method stub
        super.rg.find();
        super.rg.add();
        super.rg.plan();
    }

}




package com.pocketdigi.patterns.command;
/**
 * 添加需求Command
 */
public class DeletePageCommand extends Command {

    @Override
    public void execute() {
        // TODO Auto-generated method stub
        super.pg.find();
        super.pg.delete();
        super.pg.plan();
    }

}

Invoker:

package com.pocketdigi.patterns.command;

/**
 * 命令接收，执行
 */
public class Invoker {
    private Command command;
    public void setCommand(Command command)
    {
        this.command=command;
    }
    public void action()
    {
        command.execute();
    }
}

使用：

        //命令模式
        Invoker invoker=new Invoker();
        invoker.setCommand(new DeletePageCommand());
        invoker.action();

Java设计模式之桥梁模式

发表于 2014-01-18 更新于 2022-11-07 分类于 Java

桥梁模式特点在于，多个维度都可自由扩展，而继承只能向一个维度扩展。代码来自《您的设计模式》

package com.pocketdigi.patterns.bridge;

public abstract class Product {
    public abstract void beProducted();
    public abstract void beSelled();
}



package com.pocketdigi.patterns.bridge;
/**
 * 可根据需求扩展crop类
 */
public class HouseCrop extends Crop {
    /**
     * 只能生产House,所以参数为House,不是Product
     * @param product
     */
    public HouseCrop(House product) {
        super(product);
        // TODO Auto-generated constructor stub
    }
    @Override
    public void makeMoney() {
        // TODO Auto-generated method stub
        super.makeMoney();
        System.out.println("房地产公司赚大钱了...");
    }

}



package com.pocketdigi.patterns.bridge;
/**
 * 扩展Crop
 */
public class ShanZhaiCrop extends Crop {

    /**
     * 根据传入的Product不同，生产出不同的产品
     * @param product
     */
    public ShanZhaiCrop(Product product) {
        super(product);
        // TODO Auto-generated constructor stub
    }
    @Override
    public void makeMoney() {
        // TODO Auto-generated method stub
        super.makeMoney();
        System.out.println("我赚钱啦...");
    }

}



package com.pocketdigi.patterns.bridge;
/**
 * 产品，也可以根据需求自由扩展
 */
public abstract class Product {
    public abstract void beProducted();
    public abstract void beSelled();
}



package com.pocketdigi.patterns.bridge;

public class House extends Product {

    @Override
    public void beProducted() {
        // TODO Auto-generated method stub
        System.out.println("生产出的房子是这样的...");
    }

    @Override
    public void beSelled() {
        // TODO Auto-generated method stub
        System.out.println("生产出的房子卖出去了...");
    }

}



package com.pocketdigi.patterns.bridge;

public class Clothes extends Product {

    @Override
    public void beProducted() {
        // TODO Auto-generated method stub
        System.out.println("生产出的衣服是这样的...");
    }

    @Override
    public void beSelled() {
        // TODO Auto-generated method stub
        System.out.println("生产出的衣服卖出去了...");
    }

}




package com.pocketdigi.patterns.bridge;

public class IPod extends Product{

    @Override
    public void beProducted() {
        // TODO Auto-generated method stub
        System.out.println("生产出的IPod是这样的...");
    }

    @Override
    public void beSelled() {
        // TODO Auto-generated method stub
        System.out.println("生产出的IPod卖出去了...");
    }

}

使用:

        //桥梁模式
        Crop crop1=new HouseCrop(new House());
        crop1.makeMoney();
        
        Crop crop2=new ShanZhaiCrop(new Clothes());
        crop2.makeMoney();
        
        Crop crop3=new ShanZhaiCrop(new IPod());
        crop3.makeMoney();

Java设计模式之建造者模式

发表于 2014-01-18 更新于 2022-11-07 分类于 Java

代码转自：http://www.importnew.com/6841.html 建造者模式，使用不同的Builder，构建出形态不同的产品。与工厂模式最大区别在于，建造者模式最主要的功能是基本方法调用顺序的安排，而工厂方法重点在创建对象，不关心基本方法调用顺序

package com.pocketdigi.patterns.builder;

/**
 * 最终构建出的产品
 */
public class Starbucks {
    private String size;
    private String drink;
    public void setSize(String size) {
        this.size = size;
    }
    public void setDrink(String drink) {
        this.drink = drink;
    }
    
}



package com.pocketdigi.patterns.builder;
/**
 * 抽象建造者
 */
public abstract class StarbucksBuilder {
    protected Starbucks starbucks;

    public Starbucks getStarbucks() {
        return starbucks;
    }
    public void createStarbucks()
    {
        starbucks=new Starbucks();
        System.out.println("a drink is created");
    }
    
    public abstract void buildSize();
    public abstract void buildDrink();
}



package com.pocketdigi.patterns.builder;
/**
 * Tea建造者
 */
public class TeaBuilder extends StarbucksBuilder {

    @Override
    public void buildSize() {
        // TODO Auto-generated method stub
        starbucks.setSize("large");
        System.out.println("build large size");
    }

    @Override
    public void buildDrink() {
        // TODO Auto-generated method stub
        starbucks.setDrink("tea");
        System.out.println("build tea");
    }

}



package com.pocketdigi.patterns.builder;
/**
 * Tea建造者
 */
public class CoffeeBuilder extends StarbucksBuilder {

    @Override
    public void buildSize() {
        // TODO Auto-generated method stub
        starbucks.setSize("medium");
        System.out.println("build medium size");
    }

    @Override
    public void buildDrink() {
        // TODO Auto-generated method stub
        starbucks.setDrink("Coffee");
        System.out.println("build Coffee");
    }

}



package com.pocketdigi.patterns.builder;
/**
 * Builder封装
 */
public class Waiter {
    private StarbucksBuilder starbucksBuilder;

    public Starbucks getStarbucksDrink() {
        return starbucksBuilder.getStarbucks();
    }

    public void setStarbucksBuilder(StarbucksBuilder starbucksBuilder) {
        this.starbucksBuilder = starbucksBuilder;
    }
    
    public void build()
    {
        starbucksBuilder.createStarbucks();
        starbucksBuilder.buildDrink();
        starbucksBuilder.buildSize();
    }
}

调用：

        //建造者模式
        Waiter waiter=new Waiter();
        StarbucksBuilder starbuksBuilder=new TeaBuilder();
        waiter.setStarbucksBuilder(starbuksBuilder);
        waiter.build();
        Starbucks starBucks=waiter.getStarbucksDrink();

Activity横竖屏切换不重建(高版本有效)

发表于 2014-01-15 更新于 2022-11-07 分类于 Android开发

原先老版本的系统，只需要在AndroidManifest.xml中声明Activity时加上android:configChanges=”orientation|keyboardHidden”，切换屏幕方法时就不会重建Activity,不会再执行onCreate方法，但新版的Android(Api 13以后)，在屏幕切换时screen size也会改变，导致上面的方法无效，所以还要加上screenSize，改成 android:configChanges=”orientation|keyboardHidden|screenSize” 即可，会调用Activity中的onConfigurationChanged方法.

Java设计模式之模板方法模式

发表于 2014-01-14 更新于 2022-11-07 分类于 Java

模板方法模式是由模板（抽象类）定义子方法执行顺序，子类实现子方法，其实很简单，我们平时很常用，只是不知道这个叫模板方法模式罢了。定义模板(父类)：

package com.pocketdigi.patterns.templatemethod;

public abstract class HummerModel {
    /**
     * 这个叫基本方法，子类可以覆盖
     * 基本方法分三类，在抽象类中实现了的基本方法叫做具体方法；
     * 在抽象类中没有实现，在子类中实现了叫做抽象方法
     * 可以改变模板方法行为的叫钩子方法
     * 不允许外部直接调用这些方法，所以用protected
     */
    protected abstract void start();
    protected abstract void stop();
    protected abstract void alarm();
    protected abstract void engineBoom();
    /**
     * 这个叫钩子方法
     * @return
     */
    protected boolean isAlarm()
    {
        return true;
    }
    /**
     * 定义了其他方法的执行顺序，并且子类不能修改，叫模板方法
     */
    public final void run(){
        start();
        engineBoom();
        //钩子方法改变行为
        if(isAlarm())
        {
            alarm();
        }
        stop();
        
    }
}

不同的子类实现:

package com.pocketdigi.patterns.templatemethod;

public class HummerH1 extends HummerModel {

    @Override
    protected void start() {
        // TODO Auto-generated method stub
        System.out.println("悍马H1启动");
    }

    @Override
    protected void stop() {
        // TODO Auto-generated method stub
        System.out.println("悍马H1停止");
    }

    @Override
    protected void alarm() {
        // TODO Auto-generated method stub
        System.out.println("悍马H1鸣笛");
    }

    @Override
    protected void engineBoom() {
        // TODO Auto-generated method stub
        System.out.println("悍马H1引擎轰鸣");
    }

}



package com.pocketdigi.patterns.templatemethod;

public class HummerH2 extends HummerModel {
    boolean isAlarm;
    @Override
    protected void start() {
        // TODO Auto-generated method stub
        System.out.println("悍马H2启动");
    }

    @Override
    protected void stop() {
        // TODO Auto-generated method stub
        System.out.println("悍马H2停止");
    }

    @Override
    protected void alarm() {
        // TODO Auto-generated method stub
        System.out.println("悍马H2鸣笛");
    }

    @Override
    protected void engineBoom() {
        // TODO Auto-generated method stub
        System.out.println("悍马H2引擎轰鸣");
    }
    /**
     * 覆盖钩子方法
     */
    @Override
    protected boolean isAlarm() {
        // TODO Auto-generated method stub
        return isAlarm;
    }

    public void setAlarm(boolean isAlarm) {
        this.isAlarm = isAlarm;
    }
    
}

Java设计模式之适配器模式

发表于 2014-01-13 更新于 2022-11-07 分类于 Java

当自身系统接入第三方系统（调用第三方接口）时，Model一般都是不一样的，解决方法一般有两种，一是单独为每个第三方接口开发相应的功能，二是使用适配器模式，把第三方返回的对象转换成我们系统定义的对象。使用适配器模式，是现有系统修改最小的方案。下面的例子假设两个系统的User类定义不同，需要交互。本地IUser接口:

package com.pocketdigi.patterns.adapter;

public interface IUser {
    public String getUserName();
    public String getUserId();
    public String getPassword();
}

实现类:

package com.pocketdigi.patterns.adapter;

public class UserImp implements IUser {
    String userName;
    String userId;
    String password;
    @Override
    public String getUserName() {
        // TODO Auto-generated method stub
        return userName;
    }

    @Override
    public String getUserId() {
        // TODO Auto-generated method stub
        return userId;
    }

    @Override
    public String getPassword() {
        // TODO Auto-generated method stub
        return password;
    }

}

另一个系统的User：

package com.pocketdigi.patterns.adapter;

/**
 * 假设这是另一个系统中的User对象
 * 
 */
public class UserInfo {
    String user;
    String id;
    String pwd;
    public String getUser() {
        return user;
    }
    public void setUser(String user) {
        this.user = user;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getPwd() {
        return pwd;
    }
    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
    
}

适配器模式又分对象适配器模式和类适配器模式下面是类适配模式:

package com.pocketdigi.patterns.adapter;
/**
 * 类适配器模式
 */
public class UserAdapter1 extends UserInfo implements IUser {

    @Override
    public String getUserName() {
        // TODO Auto-generated method stub
        return this.getUser();
    }

    @Override
    public String getUserId() {
        // TODO Auto-generated method stub
        return this.getId();
    }

    @Override
    public String getPassword() {
        // TODO Auto-generated method stub
        return this.getPwd();
    }

}

对象适配模式:

package com.pocketdigi.patterns.adapter;
/**
 * 对象适配器模式
 */
public class UserAdapter2 implements IUser {
    UserInfo info;
    public UserInfo getInfo() {
        return info;
    }

    public void setInfo(UserInfo info) {
        this.info = info;
    }

    @Override
    public String getUserName() {
        // TODO Auto-generated method stub
        return info.getUser();
    }

    @Override
    public String getUserId() {
        // TODO Auto-generated method stub
        return info.getId();
    }

    @Override
    public String getPassword() {
        // TODO Auto-generated method stub
        return info.getPwd();
    }

}

Java设计模式之外观模式

发表于 2014-01-11 更新于 2022-11-07 分类于 Java

外观模式(Facade Pattern)，将一个操作要完成的子步骤整合到一个方法里，调用者无需担心调用顺序，以及具体的子步骤。

package com.pocketdigi.patterns.facade;
/**
 * 信件处理接口
 */
public interface LetterProcess {
    public void writeContext(String context);
    public void fillEnvelope(String address);
    public void letterIntoEnvelope();
    public void sendLetter();
}

实现

package com.pocketdigi.patterns.facade;

public class LetterProcessImp implements LetterProcess {

    @Override
    public void writeContext(String context) {
        // TODO Auto-generated method stub
        System.out.println("写内容"+context);
    }

    @Override
    public void fillEnvelope(String address) {
        // TODO Auto-generated method stub
        System.out.println("写信封"+address);
    }

    @Override
    public void letterIntoEnvelope() {
        // TODO Auto-generated method stub
        System.out.println("装信封");
    }

    @Override
    public void sendLetter() {
        // TODO Auto-generated method stub
        System.out.println("送信");

    }

}



package com.pocketdigi.patterns.facade;

public class PostOffice {
    LetterProcess letterProcess=new LetterProcessImp();
    /**
     * 将几个步骤并在一起，调用者不需要具体的实现过程
     * @param context
     * @param address
     */
    public void sendLetter(String context,String address)
    {
        letterProcess.writeContext(context);
        letterProcess.fillEnvelope(address);
        letterProcess.letterIntoEnvelope();
        letterProcess.sendLetter();
    }
}

调用

        PostOffice po=new PostOffice();
        po.sendLetter("内容", "地址");

Java设计模式之工厂模式

发表于 2014-01-11 更新于 2022-11-07 分类于 Java

其实工厂模式跟策略模式有点相似，只不过，策略模式是通过中Contex调用具体实现类的相应方法，而工厂模式是生成实现类的实例。

package com.pocketdigi.patterns.factory;

public interface Human {
    public void laugh();
    public void cry();
}



package com.pocketdigi.patterns.factory;

public class YellowHuman implements Human {
    /**
     * 不加public 使得在外包无法new
     */
    YellowHuman()
    {
        
    }
    @Override
    public void laugh() {
        // TODO Auto-generated method stub
        System.out.println("黄色人种笑");
    }

    @Override
    public void cry() {
        // TODO Auto-generated method stub
        System.out.println("黄色人种哭");
    }
}



package com.pocketdigi.patterns.factory;

public class BlackHuman implements Human {
    /**
     * 不加public 使得在外包无法new
     */
    BlackHuman()
    {
        
    }
    @Override
    public void laugh() {
        // TODO Auto-generated method stub
        System.out.println("黑色人种笑");
    }

    @Override
    public void cry() {
        // TODO Auto-generated method stub
        System.out.println("黑色人种哭");
    }
}

工厂:

package com.pocketdigi.patterns.factory;


public class HumanFactory {
    public static Human createHuman(Class c)
    {
        try {
            Object obj=c.newInstance();
            return (Human)obj;
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }

    public static BlackHuman createBlackHuman()
    {
        return (BlackHuman)createHuman(BlackHuman.class);
    }
    
    public static YellowHuman createYellowHuman()
    {
        return (YellowHuman)createHuman(YellowHuman.class);
    }
}

调用:

        Human human=HumanFactory.createHuman(YellowHuman.class);
        human.laugh();
        HumanFactory.createBlackHuman().laugh();

Java设计模式之多例模式

发表于 2014-01-11 更新于 2022-11-07 分类于 Java

多例模式是相对于单例模式而言的，指的是最多有固定数量的实例，如果数量不限，直接new就可以了，不存在模式一说。这个用得比较少。

package com.pocketdigi.patterns.multition;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * 多例模式
 */
public class Multition {
    String name;
    // 实例数
    private static final int MAX_INSTANCE = 2;
    private static List instanceList = new ArrayList(MAX_INSTANCE);
    private static List instanceInfoList = new ArrayList(MAX_INSTANCE);
    static {
        for (int i = 0; i < MAX_INSTANCE; i++) {
            String n1 = "name" + i;
            Multition m1 = new Multition(n1);
            instanceList.add(m1);
        }
    }

    /**
     * 随机返回一个实例
     */
    public static Multition getInstance() {
        Random r = new Random();
        return instanceList.get(r.nextInt(MAX_INSTANCE));
    }

    /**
     * 返回指定的实例
     * @param name
     * @return
     */
    public static Multition getInstance(String name) {
        int index = instanceInfoList.indexOf(name);
        if (index >= 0)
            return instanceList.get(instanceInfoList.indexOf(name));
        return null;
    }

    private Multition(String name) {
        this.name = name;
        instanceInfoList.add(name);
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return name;
    }

}

调用:

        for(int i=0;i<10;i++)
        {
            System.out.println(Multition.getInstance());
        }
        System.out.println(Multition.getInstance("name1"));