钱柜游戏官网 > 综合体育 > 源码文件 Button.

综合体育

源码文件 Button.

 

以下内容是解析安卓源码所得:

1: 使用暗许样式创设View的不二秘籍, 源码文件 Button.Java 
图片 1

注:此文参照他事他说加以调查 中的内容所写,如侵删!

2: 要求评释暗中同意样式的属性, 源码文件 attrs.xml 
图片 2

3:成立暗中同意样式, 源码文件 styles.xml 
图片 3

4:在APP主旨中,引用暗许样式 themes.xml (注意那步不能忘却卡塔尔(英语:State of Qatar) 
图片 4

源码分析结束.


以下是自己个人的利用经历:

1:宗旨中援用 radioButton样式 
图片 5

2:阐明暗中同意样式属性 
图片 6

3:创造暗中认可样式 
图片 7

4:使用私下认可样式成立View 
图片 8

这篇博客我们来介绍一下计策格局(Strategy Pattern,或许叫 Policy 帕特tern),也是行为型方式之大器晚成。经常在软件开垦中,大家为了一个作用恐怕会规划多样算法和攻略,然后依照实际行使状态动态采用相应的算法和政策,举例排序算法中的神速排序,冒泡排序等等,依据时空的汇总思考举行运作时精选。 
  针对这种情形,一个正规的主意是将各个算法写在三个类中,每二个方法对应三个现实的排序算法,恐怕写在多少个主意中,通过 if…else 或许 switch…case 条件来筛选具体的排序算法。那三种办法大家都产生硬编码,即使很简短,可是随着算法数量的充实,这些类就会变得尤为丰腴,维护的资本就能够变高,改革生龙活虎处轻松酿成别之处的荒诞,增添大器晚成种算法就需要更正封装算法类的源代码,即违背了开闭原则和单纯职务规范。 
  即使将那个算法或许政策抽象出来,提供二个联结的接口,不相同的算法只怕政策有两样的兑现类,那样在程序客商端就能够透过注入差异的贯彻指标来得以完结算法大概政策的动态替换,这种方式的可扩张性、可维护性也就更加高,那就是底下讲到的攻略格局。    

设计形式总目录

  java/android 设计方式学习笔记目录

特点

  攻略情势定义了风华正茂两种的算法,并将每八个算法封装起来,并且使她们得以并行替换,让算法独立于选拔它的客商而单独变化。 
  战略情势的使用情状:

  • 针对同生机勃勃档期的顺序难点的种种管理情势,仅仅是切实行为有异样时;
  • 必要安全地卷入多样一直以来档期的顺序的操作时;
  • 现身同等抽象类有八个子类,而又要求利用 if-else 可能 switch-case 来筛选具体子类时。

 

UML类图

  大家来探视计策情势的 uml 类图: 
  图片 9 
计谋形式有多少个脚色:

  • Context:用来操作计谋的上下文景况;
  • Stragety:计谋的空洞;
  • ConcreteStrategy:具体的政策完毕。

  据此大家得以写出政策格局的通用代码: 
Stragety.class

 

public interface Stragety {
    void algorithm();
}
  • 1
  • 2
  • 3
  • 1
  • 2
  • 3

ConcreteStragetyA.class 和 ConcreteStragetyB.class

public class ConcreteStragetyA implements Stragety{
    @Override
    public void algorithm() {
        System.out.print("ConcreteStragetyAn");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
public class ConcreteStragetyB implements Stragety{
    @Override
    public void algorithm() {
        System.out.print("ConcreteStragetyBn");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

暗许计谋类ConcreteStragetyDefault.class

public class ConcreteStragetyDefault implements Stragety{
    @Override
    public void algorithm() {
        System.out.print("null stragety");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

Context.class 和测验代码

public class Context {

    private Stragety stragety;

    public Context() {
        stragety = new ConcreteStragetyDefault();
    }

    public void algorithm() {
        stragety.algorithm();
    }

    public void setStragety(Stragety stragety) {
        if (stragety == null) {
            throw new IllegalArgumentException("argument must not be null!!!");
        }
        this.stragety = stragety;
    }

    public static void main(String args[]) {
        Context context = new Context();
        context.setStragety(new ConcreteStragetyA());
        context.algorithm();
        context.setStragety(new ConcreteStragetyB());
        context.algorithm();
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

代码很粗大略,一清二楚,未有if-else,未有switch-case。宗旨正是树立抽象,将差异的战略营造变成三个个绘声绘色的国策完成,通过差别的铺排实现算法替换,在简化逻辑、构造的同一时候,加强系统的可读性、牢固性和可扩大性,那对于相比复杂的政工逻辑显得非常直观,扩充也尤为便于。

示范与源码

Android 源码中政策方式

  其实在 Android 源码中政策方式选取的次数也是大多,我们遍布的动漫片中就有使用到政策情势:

public abstract class Animation implements Cloneable {
    /**
     * The interpolator used by the animation to smooth the movement.
     */
    Interpolator mInterpolator;
    ....
    /**
     * Sets the acceleration curve for this animation. Defaults to a linear
     * interpolation.
     *
     * @param i The interpolator which defines the acceleration curve
     * @attr ref android.R.styleable#Animation_interpolator
     */
    public void setInterpolator(Interpolator i) {
        mInterpolator = i;
    }
    ....
    /**
     * Gets the transformation to apply at a specified point in time. Implementations of this
     * method should always replace the specified Transformation or document they are doing
     * otherwise.
     *
     * @param currentTime Where we are in the animation. This is wall clock time.
     * @param outTransformation A transformation object that is provided by the
     *        caller and will be filled in by the animation.
     * @return True if the animation is still running
     */
    public boolean getTransformation(long currentTime, Transformation outTransformation) {
        ......

            final float interpolatedTime = mInterpolator.getInterpolation(normalizedTime);
            applyTransformation(interpolatedTime, outTransformation);
        ......
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

Animation 类便是很优越用到政策方式的类,它里面会有贰个 Interpolator 插值器对象,用来在实行动画的时候到达所须要的进程变化意义,系统提供的插值器有 LinearInterpolator(线性插值器,动漫的进行进程十三分),AccelerateDecelerateInterpolator (加速减速插值器,动漫的实施先河加快,结尾减速),DecelerateInterpolator(减速插值器,速度随着动漫的施行变慢),以至回弹插值器等等,感兴趣的上网查阅一下相关资料就可以(笔者早就在android下拉刷新框架用过插值器的连带类,是叁个很有用的类)。

wiki example

  这里自个儿就照旧以 wiki 上的代码为例,商铺在分裂期段会有促销巨惠活动,客商在差异的时段分别实行购买,最终得出叁个价格: 
BillingStragety.class

interface BillingStrategy {
    public double getActPrice(double rawPrice);
}
  • 1
  • 2
  • 3
  • 1
  • 2
  • 3

NormalStrategy.class 和 HappyHourStragety.class

// Normal billing strategy (unchanged price)
class NormalStrategy implements BillingStrategy {
    @Override
    public double getActPrice(double rawPrice) {
        return rawPrice;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
// Strategy for Happy hour (50% discount)
class HappyHourStrategy implements BillingStrategy {
    @Override
    public double getActPrice(double rawPrice) {
        return rawPrice * 0.5;
    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

Customer.class

class Customer {

    private List<Double> drinks;
    private BillingStrategy strategy;

    public Customer(BillingStrategy strategy) {
        this.drinks = new ArrayList<Double>();
        this.strategy = strategy;
    }

    public void add(double price, int quantity) {
        drinks.add(strategy.getActPrice(price * quantity));
    }

    // Payment of bill
    public void printBill() {
        double sum = 0;
        for (Double i : drinks) {
            sum += i;
        }
        System.out.println("Total due: " + sum);
        drinks.clear();
    }

    // Set Strategy
    public void setStrategy(BillingStrategy strategy) {
        this.strategy = strategy;
    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

main

public class StrategyPatternWiki {

    public static void main(String[] args) {
        Customer firstCustomer = new Customer(new NormalStrategy());

        // Normal billing
        firstCustomer.add(1.0, 1);

        // Start Happy Hour
        firstCustomer.setStrategy(new HappyHourStrategy());
        firstCustomer.add(1.0, 2);

        // New Customer
        Customer secondCustomer = new Customer(new HappyHourStrategy());
        secondCustomer.add(0.8, 1);
        // The Customer pays
        firstCustomer.printBill();

        // End Happy Hour
        secondCustomer.setStrategy(new NormalStrategy());
        secondCustomer.add(1.3, 2);
        secondCustomer.add(2.5, 1);
        secondCustomer.printBill();

    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

昔不前段时间时段买的事物,最终得出一个价钱,种种算法动态切换,客商不用去关切具体的里边细节。

总结

  计策形式主如果用来分别算法,在同风度翩翩的行事抽象下有区别的实际达成政策。那么些形式很好的亲自去做了开闭原则:定义抽象,扩充新的国策只须要追加新的类,然后在运作中动态转变就能够,未有影响到原本的逻辑,进而达成了很好的可扩大性。 
  优点:

  • 布局清晰明了、使用简单直观;
  • 耦合度相对来讲很低,扩大方便;
  • 操作封装也越发透彻,数据进一层安全。

  短处也很分明,这自然也是累累设计格局的破绽:类的扩展,随着政策的扩充,子类也会变得有滋有味。

上一篇:没有了 下一篇:渠道商的渠道