精华内容
下载资源
问答
  • 在回忆+搜索+查笔记之后,把我知道的几种方法总结如下,若你有更好的方法,欢迎交流分享~ 1.做好一个方框+对勾的图片,添加在需要的地方——上一次我就是这么解决的,虽然这是一个不是方法的方法; 这是一张已经...

    刚刚遇到“在Word中无法在方框内打对勾”的问题,由于已经不是第一次碰到这个problem却仍一时没辙,甚为恼火。在回忆+搜索+查笔记之后,把我知道的几种方法总结如下,若你有更好的方法,欢迎交流分享~

    1.做好一个方框+对勾的图片,添加在需要的地方——上一次我就是这么解决的,虽然这是一个不是方法的方法;

    这是一张已经做好的图片:对号

    2.点击“插入>特殊符号”,找到“对勾”,确定。然后在文中选中对勾,点击“中文版式>带圈字符”,并选择方形圈,搞定!

    特殊符号

    图1

    对勾

    图2

    中文版式

    图3

    带圈字符

    图4

    3.在Word中输入大写字母“R”,选中它,更换字体为Wingdings 2,发现什么啦?简直是奇迹,网友的力量太强大了!

    更换字体

    4.使用控件。点击菜单“视图>工具栏>控件工具箱”,调出工具箱(图6)。在控件工具箱面板,看到那个带对勾的方框了吗?对就是那个,毫不犹豫地点下去吧!点击之后,在文本编辑区域生成图如7所示复选框,右击调出菜单,修改其属性。通过属性修改面板,修改其Caption(名称)就可以了。当然,如果有更高级需要,可以修改其他参数。修改完毕后,关闭属性面板,推出编辑模式(点击空间工具箱面板最上角按钮),就可以随时给方框打勾了(点击则打上,再点便取消)。

    控件菜单

    图5

    控件工具箱面板

    图6

    修改属性

    图7

    属性修改面板

    图8

    转载至:清溪长河 » 在Word中实现方框中打对号的几种方法

    展开全文
  • Word中输入乘号和除号的几种方法(转) 在使用Word时,经常会遇到输入数学运算符号,尤其是乘号“×”和“÷”更要经常遇到。怎样才能快速、准确地输入呢?下面是我常用的几种方法: 1.在Word中点击“插入...
    在Word中输入乘号和除号的几种方法(转)

        在使用Word时,经常会遇到输入数学运算符号,尤其是乘号“×”和“÷”更要经常遇到。怎样才能快速、准确地输入呢?下面是我常用的几种方法:

        1.在Word中点击“插入”→“特殊符号”→“数学符号”,然后选择“×”即可输入乘号。

        2.顺次点击“视图”→“工具栏”→“符号栏”,然后选择“×”即可。

        3.打开任意一种输入法,右键点击“软键盘”图标,选择“数字符号”,选择“×”即可。

        4.在智能ABC输入法下,按“V+数字键1”,在出现的选择框中选择“×”即可。

        5.在拼音加加输入法下,输入“ch”,再按数字键“2”或左边的Shift键即可选中“×”。事实上,其他输入法下也有“×”的输入方法,大家可以自行摸索。

        6.在Word中依次点击“插入”→“符号”,在“字体(F)”下拉列表中选择“Symbol”,然后在第六行第九列选择“×”即可插入乘号。

        如果要输入“÷”,按前五种方法输入即可。事实上,输入乘号和除号的方法还有很多,大家可以自己摸索,找到了不要忘记告诉我们呀。

    来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/14102/viewspace-115328/,如需转载,请注明出处,否则将追究法律责任。

    转载于:http://blog.itpub.net/14102/viewspace-115328/

    展开全文
  • Word 2000状态栏左下角的四个按钮用来在几种最常用的视图间切换,Word 2000提供了针对文字输入的“普通视图”、针对网页制作的“Web版式视图”、针对排版打印的“页面视图”、针对组织文稿的“大纲视图”。各视图...

    Word 2000状态栏左下角的四个按钮用来在几种最常用的视图间切换,Word 2000提供了针对文字输入的“普通视图”、针对网页制作的“Web版式视图”、针对排版打印的“页面视图”、针对组织文稿的“大纲视图”。各视图功能各异,用户可视具体情况有选择地应用适宜的视图。

    普通视图

    在Word 2000中,普通视图是默认的视图方式,普通视图简化了页面的布局,这样可快速键入或编辑文字。普通视图的重新分页和屏幕刷新速度在各种视图中是最快的,在普通视图下有些信息诸如页眉/页脚、图形标注等都不显示,若要在普通视图中进行页眉/页脚操作,则需要从“视图”菜单项中选择“页眉和页脚”,打开页眉/页脚窗口。普通视图下的自动分页符以点线表示,人工分页符以带有“分页符”字样的虚线来表示,分节符以带有“分节符”字样的双点线表示,如图1所示。如果要在普通视图下进一步提高Word 2000的显示和处理文档的速度,可以从“工具”菜单中选择“选项”,在打开的“选项”对话框中单击“视图”标签,选中“草稿字体”,“确定”即可。

    2.Web版式视图

    Web版式视图是Word 2000中新增的用以取代Word 97的联机版式视图来满足用户需要的。Web版式视图主要用于HTML文档的编辑,HTML(*)是Web网页格式文件,在Web版式视图方式下编辑文档,可以更准确地看到其在Web浏览器中显示的效果。此外,在该视图方式下还可以应用Word 2000创建和编辑Web页面。

    3.页面视图

    在页面视图中,可以看到对象在实际打印页面的位置,在该视图中可以查看和编辑页眉和页脚,只需用鼠标双击页眉/页脚区,Word 2000就会自动显示“页眉/页脚”工具栏,还可以在该视图中调整页边距,以及处理分栏、图形对象和边框。屏幕顶端和两边的暗灰色背景就是对应于所设置的打印纸张类型之外的区域,如图2所示。在页面视图中可以显示或隐藏非打印字符,这些非打印字符不会被打印出来,只是作为控制字符显示在屏幕上,以便于查看或编辑文档,例如回车符、段落标记、制表符、空格等。这样就可以很容易地看到是否在单词之间添加了多余的空格,键入的是空格还是制表符。Word使用箭头代表制表符,圆点代表空格。如果在文档中绘制图形或加入标注时,Word 2000将自动切换到页面视图模式。

    4.大纲视图

    大纲视图显示文档的层次结构,如章、节、标题等,这对于长文档来说,可以让用户清晰地看到它的概况简要。在大纲视图中,可折叠文档只查看到某级标题,或者扩展文档以查看整个文档,还可以通过拖动标题来移动、复制或重新组织正文。进入大纲视图时会自动出现大纲工具栏,其中就包括有关主控文档的按钮,主控文档用来组织和维护一个长文档,主控文档视图可以将多篇Word文档组成一篇主控文档,然后对长文档进行修改编辑。在浏览或编辑文档中相距较远的两部分信息可以使用屏幕拆分方式,将显示窗口拆分成两个窗口,拆分后的上下两个窗口可以使用不同的视图。

    展开全文
  • 从Android代码中来记忆23设计模式

    万次阅读 多人点赞 2016-05-30 19:56:22
    我的简书同步发布:从Android代码中来记忆23设计模式 相信大家都曾经下定决心把23设计模式牢记于心,每次看完之后过一段时间又忘记了~,又得回去看,脑子里唯一依稀记得的是少数设计模式的大致的定义。其实,...

    我的简书同步发布:从Android代码中来记忆23种设计模式

    相信大家都曾经下定决心把23种设计模式牢记于心,每次看完之后过一段时间又忘记了~,又得回去看,脑子里唯一依稀记得的是少数设计模式的大致的定义。其实,网上很多文章讲得都非常好,我也曾经去看过各种文章。也曾一直苦恼这些难以永久记下的设计模式,直到我接触到了《Android源码设计模式解析与实战》——何红辉与关爱明著,发现原来其实我们在Android中都接触过这些设计模式,只是我们不知道而已。既然我们都接触过,我们只需一一对号入座,对设计模式的记忆就不用死记硬背了!这里自愿无偿做个广告,《Android源码设计模式解析与实战》这本书真心不错,每个Android程序员最好都去翻翻…正如你所想的那样,本文是从这本书中的总结,相信你也会跟我一样,从中获益。

    面向对象的六大原则

    首先,我们为什么要学习设计模式。主要是这些模式是前人总结的经验,使用这些模式能让我们的程序更健壮、更稳定、容易扩展等等优点。在编写面向对象程序时,我们需要遵循以下6个原则,能让我们的程序维护起来更轻松~(当然还有其它好处)。

    1 单一职责原则
    单一原则很简单,就是将一组相关性很高的函数、数据封装到一个类中。换句话说,一个类应该有职责单一。

    2 开闭原则

    开闭原则理解起来也不复杂,就是一个类应该对于扩展是开放的,但是对于修改是封闭的。我们知道,在开放的app或者是系统中,经常需要升级、维护等,这就要对原来的代码进行修改,可是修改时容易破坏原有的系统,甚至带来一些新的难以发现的BUG。因此,我们在一开始编写代码时,就应该注意尽量通过扩展的方式实现新的功能,而不是通过修改已有的代码实现。

    3 里氏替换原则

    里氏替换原则的定义为:所有引用基类的地方必须能透明地使用其子类对象。定义看起来很抽象,其实,很容易理解,本质上就是说,要好好利用继承和多态。简单地说,就是以父类的形式声明的变量(或形参),赋值为任何继承于这个父类的子类后不影响程序的执行。看一组代码你就明白这个原则了:

    //窗口类
    public class Window(){
        public void show(View child){
            child.draw();
        }
    }
    public abstract class View(){
        public abstract void draw();
        public void measure(int widht,int height){
            //测量视图大小
        }
    }
    public class Button extends View{
        public void draw(){
            //绘制按钮
        }
    }
    
    public class TextView extends View{
        public void draw(){
            //绘制文本
        }
    }

    Window 类中show函数需要传入View,并且调用View对象的draw函数。而每个继承于View的子对象都有draw的实现,不存在继承于View但是却没实现draw函数的子类(abstract方法必须实现)。我们在抽象类设计之时就运用到了里氏替换原则。

    4 依赖倒置原则

    依赖倒置主要是实现解耦,使得高层次的模块不依赖于低层次模块的具体实现细节。怎么去理解它呢,我们需要知道几个关键点:

    (1)高层模块不应该依赖底层模块(具体实现),二者都应该依赖其抽象(抽象类或接口)
    (2)抽象不应该依赖细节(废话,抽象类跟接口肯定不依赖具体的实现了)
    (3)细节应该依赖于抽象(同样废话,具体实现类肯定要依赖其继承的抽象类或接口)

    其实,在我们用的Java语言中,抽象就是指接口或者抽象类,二者都是不能直接被实例化;细节就是实现类,实现接口或者继承抽象类而产生的类,就是细节。使用Java语言描述就简单了:就是各个模块之间相互传递的参数声明为抽象类型,而不是声明为具体的实现类;

    5 接口隔离原则

    接口隔离原则定义:类之间的依赖关系应该建立在最小的接口上。其原则是将非常庞大的、臃肿的接口拆分成更小的更具体的接口。

    6 迪米特原则

    描述的原则:一个对象应该对其他的对象有最少的了解。什么意思呢?就是说一个类应该对自己调用的类知道的最少。还是不懂?其实简单来说:假设类A实现了某个功能,类B需要调用类A的去执行这个功能,那么类A应该只暴露一个函数给类B,这个函数表示是实现这个功能的函数,而不是让类A把实现这个功能的所有细分的函数暴露给B。

    开始学设计模式

    学习了上面的六大原则之后,提前做了预热。现在开始,一起学习设计模式吧~

    1 单例模式

    单例模式可以说是最容易理解的模式了,也是应用最广的模式之一,先看看定义吧。

    定义:确保单例类只有一个实例,并且这个单例类提供一个函数接口让其他类获取到这个唯一的实例。

    什么时候需要使用单例模式呢:如果某个类,创建时需要消耗很多资源,即new出这个类的代价很大;或者是这个类占用很多内存,如果创建太多这个类实例会导致内存占用太多。

    关于单例模式,虽然很简单,无需过多的解释,但是这里还要提个醒,其实单例模式里面有很多坑。我们去会会单例模式。最简单的单例模式如下:

    public class Singleton{
        private static Singleton instance;
        //将默认的构造函数私有化,防止其他类手动new
        private Singleton(){};
        public static Singleton getInstance(){
            if(instance==null)
                instance=new Singleton();
             return instatnce;
        }
    }

    如果是单线程下的系统,这么写肯定没问题。可是如果是多线程环境呢?这代码明显不是线程安全的,存在隐患:某个线程拿到的instance可能是null,可能你会想,这有什么难得,直接在getInstance()函数上加sychronized关键字不就好了。可是你想过没有,每次调用getInstance()时都要执行同步,这带来没必要的性能上的消耗。注意,在方法上加sychronized关键字时,一个线程访问这个方法时,其他线程无法同时访问这个类其他sychronized方法。的我们看看另外一种实现:

    public class Singleton{
        private static Singleton instance;
        //将默认的构造函数私有化,防止其他类手动new
        private Singleton(){};
        public static Singleton getInstance(){
            if(instance==null){
                sychronized(Singleton.class){
                    if(instance==null)
                        instance=new Singleton();
                }
            }
            return instatnce;
        }
    }
    

    为什么需要2次判断是否为空呢?第一次判断是为了避免不必要的同步,第二次判断是确保在此之前没有其他线程进入到sychronized块创建了新实例。这段代码看上去非常完美,但是,,,却有隐患!问题出现在哪呢?主要是在instance=new Singleton();这段代码上。这段代码会编译成多条指令,大致上做了3件事:

    (1)给Singleton实例分配内存
    (2)调用Singleton()构造函数,初始化成员字段
    (3)将instance对象指向分配的内存(此时instance就不是null啦~)

    上面的(2)和(3)的顺序无法得到保证的,也就是说,JVM可能先初始化实例字段再把instance指向具体的内存实例,也可能先把instance指向内存实例再对实例进行初始化成员字段。考虑这种情况:一开始,第一个线程执行instance=new Singleton();这句时,JVM先指向一个堆地址,而此时,又来了一个线程2,它发现instance不是null,就直接拿去用了,但是堆里面对单例对象的初始化并没有完成,最终出现错误~ 。
    看看另外一种方式:

    public class Singleton{
        private volatile static Singleton instance;
        //将默认的构造函数私有化,防止其他类手动new
        private Singleton(){};
        public static Singleton getInstance(){
            if(instance==null){
                sychronized(Singleton.class){
                    if(instance==null)
                        instance=new Singleton();
                }
            }
            return instatnce;
        }
    }

    相比前面的代码,这里只是对instance变量加了一个volatile关键字volatile关键字的作用是:线程每次使用到被volatile关键字修饰的变量时,都会去堆里拿最新的数据。换句话说,就是每次使用instance时,保证了instance是最新的。注意:volatile关键字并不能解决并发的问题,关于volatile请查看其它相关文章。但是volatile能解决我们这里的问题。

    那么在安卓中哪些地方用到了单例模式呢?其实,我们在调用系统服务时拿到的Binder对象就是个单例。比如:

    //获取WindowManager服务引用
    WindowManager wm = (WindowManager)getSystemService(getApplication().WINDOW_SERVICE);  
    

    其内部是通过单例的方式返回的,由于单例模式较简单,这里不去深究。

    2 Builder模式

    Builder模式是什么情况呢?我不想去提它的定义,因为他的定义:将一个复杂对象的构造与它的表示分离,使得同样的构造过程可以创建不同的表示。好吧,我还是提了。但是看了这个定义并没有什么luan用。我们看看具体在什么情况下用到Builder模式:主要是在创建某个对象时,需要设定很多的参数(通过setter方法),但是这些参数必须按照某个顺序设定,或者是设置步骤不同会得到不同结果。举个非常简单的例子:

    public class MyData{
        private int id;
        private String num; 
        public void Test(){
    
        } 
        public void setId(int id){
            this.id=id;
        }
    
        public void setNum(String num){
            this.num=num+"id";
        }
    
    
    }

    当然了,没有人会这么去写代码。这里只是举例子,或者是有时候很多参数有这种类似的依赖关系时,通过构造函数未免太多参数了。回到主题,就是如果是上面的代码,该怎么办呢?你可能会说,那还不简单,先调用setId函数,再调用setNum函数。是的,没错。可是,万一你一不小心先调用了setNum呢?这是比较简单的示例,如果是比较复杂的,有很多变量之间依赖的关系,那你每次都得小心翼翼的把各个函数的执行步骤写正确。
    我们看看Builder模式是怎么去做的:

    public class MyBuilder{
        private int id;
        private String num;
        public MyData build(){
            MyData d=new MyData();
            d.setId(id);
            d.setNum(num);
            return t;
        }
        public MyBuilder setId(int id){
            this.id=id;
            return this;
        }
        public MyBuilder setNum(String num){
            this.num=num;
            return this;
        }
    
    }
    
    public class Test{
        public static void  main(String[] args){
            MyData d=new MyBuilder().setId(10).setNum("hc").build();
        }
    
    }
    

    注意到,Builer类的setter函数都会返回自身的引用this,这主要是用于链式调用,这也是Builder设计模式中的一个很明显的特征。

    Android中用过的代码来记忆

    记忆我这个例子没啥意义,我们前面说过,要通过Android中用过的代码来记忆,这样才可以不用死记硬背。那么在Android中哪里用到了Builder设计模式呢?哈哈~在创建对话框时,是不是跟上面有点类似呢?

    AlertDialog.Builer builder=new AlertDialog.Builder(context);
    builder.setIcon(R.drawable.icon)
        .setTitle("title")
        .setMessage("message")
        .setPositiveButton("Button1", 
            new DialogInterface.OnclickListener(){
                public void onClick(DialogInterface dialog,int whichButton){
                    setTitle("click");
                }   
            })
        .create()
        .show();

    这里的create()函数就想到上面代码中的build函数。看到这里是不是在内心中默默的把Builder设计模式拿下了?你并不用死记硬背~

    3 原型模式

    原型设计模式非常简单,就是将一个对象进行拷贝。对于类A实例a,要对a进行拷贝,就是创建一个跟a一样的类型A的实例b,然后将a的属性全部复制到b。
    什么时候会用到原型模式呢?我个人认为,可以在类的属性特别多,但是又要经常对类进行拷贝的时候可以用原型模式,这样代码比较简洁,而且比较方便。

    另外要注意的是,还有深拷贝和浅拷贝。深拷贝就是把对象里面的引用的对象也要拷贝一份新的对象,并将这个新的引用对象作为拷贝的对象引用。说的比较绕哈~,举个例子,假设A类中有B类的引用b,现在需要对A类实例进行拷贝,那么深拷贝就是,先对b进行一次拷贝得到nb,然后把nb作为A类拷贝的对象的引用,如此一层一层迭代拷贝,把所有的引用都拷贝结束。浅拷贝则不是。

    原型模式比较简单,看看Android怎么运用原型模式:

    Uri uri=Uri.parse("smsto:10086");
    Intent shareIntent=new Intent(Intent.ACTION_SENDTO,uri);
    
    //克隆副本
    Intent intent=(Intetn)shareIntent.clone();
    startActivity(intent);
    

    或许我们平时不会这么去写,但是Intent对象确实提供了原型模式的函数clone()

    4 工厂方法模式

    定义:定义一个创建对象的接口,让子类决定实例化哪个类
    先看一个例子:

    public abstract class Product{
        public abstract void method();
    } 
    
    public class ConcreteProductA extends Prodect{
        public void method(){
            System.out.println("我是产品A!");
        }
    }
    
    public class ConcreteProductB extends Prodect{
        public void method(){
            System.out.println("我是产品B!");
        }
    }
    public  abstract class Factory{
        public abstract Product createProduct();
    }
    
    public class MyFactory extends Factory{
    
        public Product createProduct(){
            return new ConcreteProductA();
        }
    }

    看到上面的代码,是不是觉得工厂模式很简单呢?还可以通过传参的方式,让MyFactory的createProduct方法根据传入的参数决定是创建ConcreteProductA还是ConcreteProductB。

    同样的,我们不希望记住这个例子,而是通过Android中的代码来记忆:
    其实,在getSystemService方法中就是用到了工厂模式,他就是根据传入的参数决定创建哪个对象,当然了,由于返回的都是以单例模式存在的对象,因此不用new了,直接把单例返回就好。

    public Object getSystemService(String name) {
        if (getBaseContext() == null) {
            throw new IllegalStateException("System services not available to Activities before onCreate()");
        }
        //........
        if (WINDOW_SERVICE.equals(name)) {
             return mWindowManager;
        } else if (SEARCH_SERVICE.equals(name)) {
            ensureSearchManager();
            return mSearchManager;
        }
        //.......
        return super.getSystemService(name);
      }
    

    5 抽象工厂模式

    抽象工厂模式:为创建一组相关或者是相互依赖的对象提供一个接口,而不需要制定他们的具体类
    看个例子吧,将它跟工厂方法模式做个对比:

    public abstract class AbstractProductA{
        public abstract void method();
    }
    public abstract class AbstractProdectB{
        public abstract void method();
    }
    
    public class ConcreteProductA1 extends AbstractProductA{
        public void method(){
            System.out.println("具体产品A1的方法!");
        }
    }
    public class ConcreteProductA2 extends AbstractProductA{
        public void method(){
            System.out.println("具体产品A2的方法!");
        }
    }
    public class ConcreteProductB1 extends AbstractProductB{
        public void method(){
            System.out.println("具体产品B1的方法!");
        }
    }
    public class ConcreteProductB2 extends AbstractProductB{
        public void method(){
            System.out.println("具体产品B2的方法!");
        }
    }
    
    public abstract class AbstractFactory{
        public abstract AbstractProductA createProductA();
    
        public abstract AbstractProductB createProductB();
    }
    
    public  class ConcreteFactory1 extends AbstractFactory{
        public  AbstractProductA createProductA(){
            return new ConcreteProductA1();
        }
    
        public  AbstractProductB createProductB(){
            return new ConcreteProductB1();
        }
    }
    
    public  class ConcreteFactory2 extends AbstractFactory{
        public  AbstractProductA createProductA(){
            return new ConcreteProductA2();
        }
    
        public  AbstractProductB createProductB(){
            return new ConcreteProductB2();
        }
    }

    其实Android源码中对抽象工厂出现的比较少,好在抽象工厂方法并不复杂,很容易记住,我们可以从Service中去理解,Service的onBind方法可以看成是一个工厂方法,从framework角度来看Service,可以看成是一个具体的工厂,这相当于一个抽象工厂方法模式的雏形。

     public class BaseService extends Service{
        @Nullable
        @Override
        public IBinder onBind(Intent intent){
            return new Binder();
        }
    
    }

    6 策略模式

    定义:有一系列的算法,将每个算法封装起来(每个算法可以封装到不同的类中),各个算法之间可以替换,策略模式让算法独立于使用它的客户而独立变化。

    举个例子来理解吧,比如,你现在又很多排序算法:冒泡、希尔、归并、选择等等。我们要根据实际情况来选择使用哪种算法,有一种常见的方法是,通过if…else或者case…等条件判断语句来选择。但是这个类的维护成本会变高,维护时也容易发生错误。

    如何使用策略模式呢,我不打算写示例代码了,简单描述一下,就将前面说的算法选择进行描述。我们可以定义一个算法抽象类AbstractAlgorithm,这个类定义一个抽象方法sort()。每个具体的排序算法去继承AbstractAlgorithm类并重写sort()实现排序。在需要使用排序的类Client类中,添加一个setAlgorithm(AbstractAlgorithm al);方法将算法设置进去,每次Client需要排序而是就调用al.sort()。

    不知道简单描述能不能让你理解~

    看看Android中哪里出现了策略模式,其中在属性动画中使用时间插值器的时候就用到了。在使用动画时,你可以选择线性插值器LinearInterpolator、加速减速插值器AccelerateDecelerateInterpolator、减速插值器DecelerateInterpolator以及自定义的插值器。这些插值器都是实现根据时间流逝的百分比来计算出当前属性值改变的百分比。通过根据需要选择不同的插值器,实现不同的动画效果。这些比较好理解,就不去粘贴Android源码了。

    7 状态模式

    状态模式中,行为是由状态来决定的,不同状态下有不同行为。状态模式和策略模式的结构几乎是一模一样的,主要是他们表达的目的和本质是不同。状态模式的行为是平行的、不可替换的,策略模式的行为是彼此独立可相互替换的。
    举个例子把,比如电视,电视有2个状态,一个是开机,一个是关机,开机时可以切换频道,关机时切换频道不做任何响应。

    public interface TvState{
        public void nextChannerl();
        public void prevChannerl();
        public void turnUp();
        public void turnDown();
    }
    
    public class PowerOffState implements TvState{
        public void nextChannel(){}
        public void prevChannel(){}
        public void turnUp(){}
        public void turnDown(){}
    
    }
    
    
    public class PowerOnState implements TvState{
        public void nextChannel(){
            System.out.println("下一频道");
        }
        public void prevChannel(){
            System.out.println("上一频道");
        }
        public void turnUp(){
            System.out.println("调高音量");
        }
        public void turnDown(){
            System.out.println("调低音量"); 
        }
    
    }
    
    public interface PowerController{
        public void powerOn();
        public void powerOff();
    }
    
    public class TvController implements PowerController{
        TvState mTvState;
        public void setTvState(TvStete tvState){
            mTvState=tvState;
        }
        public void powerOn(){
            setTvState(new PowerOnState());
            System.out.println("开机啦");
        }
        public void powerOff(){
            setTvState(new PowerOffState());
            System.out.println("关机啦");
        }
        public void nextChannel(){
            mTvState.nextChannel();
        }
        public void prevChannel(){
            mTvState.prevChannel();
        }
        public void turnUp(){
            mTvState.turnUp();
        }
        public void turnDown(){
            mTvState.turnDown();
        }
    
    }
    
    
    public class Client{
        public static void main(String[] args){
            TvController tvController=new TvController();
            tvController.powerOn();
            tvController.nextChannel();
            tvController.turnUp();
    
            tvController.powerOff();
            //调高音量,此时不会生效
            tvController.turnUp();
        }
    
    
    }

    在Android源码中,哪里有用到状态模式呢?其实很多地方用到了,举一个地方例子,就是WIFI管理模块。当WIFI开启时,自动扫描周围的接入点,然后以列表的形式展示;当wifi关闭时则清空。这里wifi管理模块就是根据不同的状态执行不同的行为。由于代码太多,我就不手打敲入了~我们只要知道大致Android里面在哪里用到了以及大概是怎么用的就好。

    8 责任链模式

    定义:使多个对象都有机会处理请求,从而避免请求的发送者和接受者直接的耦合关系,将这些对象连成一条链,并沿这条链传递该请求,直到有对象处理它为止。

    相信聪明的你很容易理解吧,基本不需要例子来解释了,直接进如到Android源码中哪里用到了责任链:在Android处理点击事件时,父View先接收到点击事件,如果父View不处理则交给子View,依次往下传递~

    9 解释器模式

    定义:给定一个语言,定义它的语法,并定义一个解释器,这个解释器用于解析语言。

    从定义中看起来比较抽象,其实,很简单,很容易理解!就是相当于自定义一个格式的文件,然后去解析它。不用理解的那么复杂!

    我们看看Android中哪里用到了,从我们第一次学Android时就知道,四大组件需要在AndroidManifest.xml中定义,其实AndroidManifest.xml就定义了<Activity><Service>等标签(语句)的属性以及其子标签,规定了具体的使用(语法),通过PackageManagerService(解释器)进行解析。

    10 命令模式

    定义:命令模式将每个请求封装成一个对象,从而让用户使用不同的请求把客户端参数化;将请求进行排队或者记录请求日志,以及支持可撤销操作。

    举个例子来理解:当我们点击“关机”命令,系统会执行一系列操作,比如暂停事件处理、保存系统配置、结束程序进程、调用内核命令关闭计算机等等,这些命令封装从不同的对象,然后放入到队列中一个个去执行,还可以提供撤销操作。

    那么Android中哪里用到了命令模式呢?在framework层还真不多。但是在底层却用到了,一个比较典型的例子就是在Android事件机制中,底层逻辑对事件的转发处理。每次的按键事件会被封装成NotifyKeyArgs对象。通过InputDispatcher封装具体的事件操作。

    11 观察者模式

    定义:定义了对象之间的一对多的关系,其实就是1对n,当“1”发生变化时,“n”全部得到通知,并更新。

    观察者模式一个比较经典的应用就是:订阅——发布系统。很容易理解,发布消息时,将消息发送给每个订阅者。我们常用的微信公众号就是典型,当我们关注某个公众号时,每当公众号推送消息时,我们就会去接收到消息,当然了,每个订阅(关注)公众号的的人都能接收到公众号推送的消息。

    那么Android哪里用到了观察者模式呢?我们看看ListView的适配器,有个函数notifyDataSetChanged()函数,这个函数其实就是通知ListView的每个Item,数据源发生了变化,请各位Item重新刷新一下。

    12 备忘录模式

    备忘录模式定义:在不破坏封闭的前提下,捕获一个对象的内部状态,并在对象之外保存这个状态,这样,以后就可将对象恢复到原先保存的状态中。

    其实就是相当于一个提前备份,一旦出现啥意外,能够恢复。像我们平时用的word软件,意外关闭了,它能帮我们恢复。其实就是它自动帮我们备份过。

    那么Android哪里用到了备忘录模式呢?ActivityonSaveInstanceStateonRestoreInstanceState就是用到了备忘录模式,分别用于保存和恢复。

    13 迭代器模式

    迭代器模式定义:提供一种方法顺序访问一个容器对象中的各个元素,而不需要暴露该对象的内部表示。

    相信熟悉Java的你肯定知道,Java中就有迭代器Iterator类,本质上说,它就是用迭代器模式。

    按照惯例,看看Android中哪里用到了迭代器模式,Android源码中,最典型的就是Cursor用到了迭代器模式,当我们使用SQLiteDatabasequery方法时,返回的就是Cursor对象,通过如下方式去遍历:

    cursor.moveToFirst();
    do{
    //cursor.getXXX(int);
    }while(cursor.moveToNext);

    14 模板方法模式

    定义:定义一个操作中的算法框架,而将一些步骤延迟到子类中,使得子类可以不改变一个算法的结构即可重定义该算法的某些特定的步骤。

    不用解释太多,感觉越解释越糊涂,直接拿Android中的源码来说事!

    我们知道,启动一个Activity过程非常复杂,如果让开发者每次自己去调用启动Activity过程无疑是一场噩梦。好在启动Activity大部分代码时不同的,但是有很多地方需要开发者定制。也就是说,整体算法框架是相同的,但是将一些步骤延迟到子类中,比如ActivityonCreateonStart等等。这样子类不用改变整体启动Activity过程即可重定义某些具体的操作了~。

    15 访问者模式

    定义:封装一些作用于某种数据结构中各元素的操作,它可以在不改变这个数据结构的前提下定义作用于这些元素的新的操作。

    访问者模式是23种设计模式中最复杂的一个,但他的使用率并不高,大部分情况下,我们不需要使用访问者模式,少数特定的场景才需要。

    Android中运用访问者模式,其实主要是在编译期注解中,编译期注解核心原理依赖APT(Annotation Processing Tools),著名的开源库比如ButterKnife、Dagger、Retrofit都是基于APT。APT的详细使用这里不提,后面我会写关于APT相关的文章,敬请期待~

    16 中介者模式

    定义:中介者模式包装了一系列对象相互作用的方式,使得这些对象不必相互明显调用,从而使他们可以轻松耦合。当某些对象之间的作用发生改变时,不会立即影响其他的一些对象之间的作用保证这些作用可以彼此独立的变化,中介者模式将多对多的相互作用转为一对多的相互作用。

    什么时候用中介者模式呢?其实,中介者对象是将系统从网状结构转为以调停者为中心的星型结构。

    举个简单的例子,一台电脑包括:CPU、内存、显卡、IO设备。其实,要启动一台计算机,有了CPU和内存就够了。当然,如果你需要连接显示器显示画面,那就得加显卡,如果你需要存储数据,那就要IO设备,但是这并不是最重要的,它们只是分割开来的普通零件而已,我们需要一样东西把这些零件整合起来,变成一个完整体,这个东西就是主板。主板就是起到中介者的作用,任何两个模块之间的通信都会经过主板协调。

    那么Android中那些地方用到了中介者模式呢?在Binder机制中,就用到了中介者模式,对Binder不是很熟悉的童鞋请参考我的《 简单明了,彻底地理解Binder》。我们知道系统启动时,各种系统服务会向ServiceManager提交注册,即ServiceManager持有各种系统服务的引用 ,当我们需要获取系统的Service时,比如ActivityManagerWindowManager等(它们都是Binder),首先是向ServiceManager查询指定标示符对应的Binder,再由ServiceManager返回Binder的引用。并且客户端和服务端之间的通信是通过Binder驱动来实现,这里的ServiceManagerBinder驱动就是中介者。

    17 代理模式

    定义:为其他类提供一种代理以控制这个对象的访问。
    其实代理模式我们平时用的也比较多,其实比较好理解,就是当我们需要对一个对象进行访问时,我们不直接对这个对象进行访问,而是访问这个类的代理类,代理类能帮我们执行我们想要的操作。代理模式比较容易理解,既然你来看这篇文章相信你对代理模式不陌生。

    我们直接看看代理模式在Android中的应用,如果你查看AIDL生成的代码就知道,它会根据当前的线程判断是否要跨进程访问,如果不需要跨进程就直接返回实例,如果需要跨进程则返回一个代理,这个代理干什么事情呢?我们在《 简单明了,彻底地理解Binder》提到,在跨进程通信时,需要把参数写入到Parcelable对象,然后再执行transact函数,我们要写的代码挺多的。AIDL通过生成一个代理类,代理类中自动帮我们写好这些操作。

    18 组合模式

    定义:将对象组成成树形结构,以表示“部分-整体”的层次结构,使得用户对单个对象和组合对象的使用具有一致性。

    上面的定义不太好理解,我们直接从Android中用到的组合模式说起。我们知道,Android中View的结构是树形结构,每个ViewGroup包含一系列的View,而ViewGroup本身又是View。这是Android中非常典型的组合模式。

    19 适配器模式

    定义:把一个类的接口变换成客户端所期待的另一个接口,从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。

    其实适配器模式很容易理解,我们在Android开发时也经常用到。比较典型的有ListView和RecyclerView。为什么ListView需要使用适配器呢?主要是,ListView只关心它的每个ItemView,而不关心这个ItemView具体显示的是什么。而我们的数据源存放的是要显示的内容,它保存了每一个ItemView要显示的内容。ListView和数据源之间没有任何关系,这时候,需要通过适配器,适配器提供getView方法给ListView使用,每次ListView只需提供位置信息给getView函数,然后getView函数根据位置信息向数据源获取对应的数据,根据数据返回不同的View。

    20 装饰模式

    定义:动态的给一个对象添加额外的智者,就增加功能来说,装饰模式比子类继承的方式更灵活。
    通过简单代码来理解装饰模式:

    public abstract class Component{
        public abstract void operate();
    }
    
    public class ConcreteComponent extends Component{
        public void operate(){
            //具体的实现
        }
    
    }
    
    public class Decorator{
        private Component component;
        public Decorator(Component component){
            this.component=component;
        }
        public void operate(){
            operateA();
            component.operate();
            operateB();
        }
        public void operateA(){
            //具体操作
        }
        public void operateB(){
            //具体操作
        }
    }

    那么在Android哪里出现了装饰模式呢?我们平时经常用到Context类,但是其实Context类只是个抽象类,具体实现是ContextImpl,那么谁是ContextImpl的装饰类呢?我们知道Activity是个Context,但是Activity 并不是继承于Context,而是继承于ContextThremeWrapper.而ContextThremeWrapper继承于ContextWrapper,ContextWrapper继承Context.说了这么多,跟装饰模式有啥关系?主要是引入ContextWrapper这个类。ContextWrapper内部有个Context引用mContext,并且ContextWrapper中对Context的每个方法都有实现,在实现中调用的就是mContext相同的方法。

    21 享元模式

    定义:使用享元对象有效地支持大量的细粒度对象。

    享元模式我们平时接触真的很多,比如Java中的常量池,线程池等。主要是为了重用对象。

    在Android哪里用到了享元模式呢?线程通信中的Message,每次我们获取Message时调用Message.obtain()其实就是从消息池中取出可重复使用的消息,避免产生大量的Message对象。

    22 外观模式

    定义:要求一个子系统的外部与其内部的通信必须通过一个统一的对象进行。

    怎么理解呢,举个例子,我们在启动计算机时,只需按一下开关键,无需关系里面的磁盘、内存、cpu、电源等等这些如何工作,我们只关心他们帮我启动好了就行。实际上,由于里面的线路太复杂,我们也没办法去具体了解内部电路如何工作。主机提供唯一一个接口“开关键”给用户就好。

    那么Android哪里使用到了外观模式呢?依然回到Context,Android内部有很多复杂的功能比如startActivty、sendBroadcast、bindService等等,这些功能内部的实现非常复杂,如果你看了源码你就能感受得到,但是我们无需关心它内部实现了什么,我们只关心它帮我们启动Activity,帮我们发送了一条广播,绑定了Activity等等就够了。

    23 桥接模式

    定义:将抽象部分与实现部分分离,使他们独立地进行变化。
    其实就是,一个类存在两个维度的变化,且这两个维度都需要进行扩展。

    在Android中桥接模式用的很多,举个例子,对于一个View来说,它有两个维度的变化,一个是它的描述比如Button、TextView等等他们是View的描述维度上的变化,另一个维度就是将View真正绘制到屏幕上,这跟Display、HardwareLayer和Canvas有关。这两个维度可以看成是桥接模式的应用。

    24 MVC、MVP、MVVP模式

    MVC
    全称为Model-View-Controller,也就是模型-视图-控制器。MVC结构如下图所示:
    MVC

    在Android中对MVC的应用很经典,我们的布局文件如main.xml就是对应View层,本地的数据库数据或者是网络下载的数据就是对应Model层,而Activity对应Controller层。

    MVP
    MVP全称为Model View Presenter,目前MVP在Android应用开发中越来越重要了,它的结构图如下:
    MVP
    它降低了View与Model之间的耦合。彻底将View与Model分离。MVP不是一种标准化的模式,它由很多种实现。

    MVVM

    全称是Mode View ViewModel,它的结构如下所示:

    MVVM
    我们在使用ListView时,会自定义一个ViewHolder,在RecyclerView中是必须使用ViewHolder,这主要是提高性能,因为不需要每次去调用findViewById来获取View。其实ViewHolder就是个ViewModel。

    展开全文
  • SQL视图的概念和使用

    千次阅读 2017-12-13 19:16:47
    SQL视图的创建和使用视图这个东西在其他的软件中,我们也经常看得到,例如word中就有视图,我们不难发现,视图似乎是一种显示方式,就像WORD一样,有几种显示版面,这就是视图,那么SQL中的视图又该怎么定义呢?...
  • 设计模式_23设计模式详细解析

    千次阅读 多人点赞 2020-05-22 08:55:54
    文章目录参考单例模式 Singleton定义与特点结构与实现饿汉式单例懒汉式单例(静态内部类实现)懒汉式单例(DCL实现)应用场景Spring中的单例模式原型模式Prototype定义与特点结构与实现应用场景工厂方法模式...
  • Python之23设计模式

    万次阅读 多人点赞 2019-02-13 13:28:48
    设计模式介绍  GoF该书设计了23个设计模式  设计模式(Design Patterns)——可复用面向对象软件的基础  设计模式分类  1 创建型模式  2 结构型模式  3 行为型模式 设计模式6大原则 实战示例  创建...
  • 数据库的查询与视图

    万次阅读 2012-05-28 20:13:03
    第4章 数据库的查询和视图 4.1.1 选择列 通过SELECT语句的项组成结果表的列。 ::= SELECT [ ALL |DISTINCT ] [ TOP n [ PERCENT ] [ WITH TIES ] ] { * /*选择当前表或视图的所有列*/ | { table_name |view_...
  • 下面是我确认的六关键模式,将产生每一种模式的特定层和头都进行可视化展示。 模式1:注意下一个词 在这种模式中,每个位置主要注意序列中的下一个词(token)。下面将看到第2层0号头的一个例子。(所选头部由...
  • 二十三设计模式及其python实现

    千次阅读 多人点赞 2017-08-01 18:44:52
    参考文献: 《大话设计模式》——吴强 《Python设计模式》——pythontip.com 《23设计模式》——http://www.cnblogs.com/beijiguangyong/ 设计模式是什么? 设计模式是经过总结、优化的,对我们经常
  • 在日常工作中,我们完成了文档编辑,经常会出现一个或者多个空白页,上面没有任何内容,却删不掉,这种问题让很多人感到头疼,今天小编整理了以下几种方法,轻松删除文档中的空白页,提高工作效率。 文档中出现空白...
  • word技巧

    千次阅读 2018-03-01 21:40:22
    word 高效经典教程(整理版)目录一分钟驾驭word 高效经典教程(整理版)... 6A、基础知识... 61、度量单位... 62、WORD中文字字号与磅的对应关系... 63、字体文件格式... 7B、文本编辑... 71、快速移动文档... 72、...
  • 下面是我确认的六关键模式,将产生每一种模式的特定层和头都进行可视化展示。 模式1:注意下一个词 在这种模式中,每个位置主要注意序列中的下一个词(token)。下面将看到第2层0号头的一个例子。(所选头部由...
  • 本人在写论文的时候,用到了很多工具,可用说这些工具可以大大提高写论文的效率,本文分享下我常用的论文神器。(作者:黄海广)本文介绍以下几种工具:论文管理神器ZoteroOCR神器(公式识别...
  • 详解MFC框架窗口、文档和视图

    万次阅读 2014-05-21 07:31:32
    尽管窗口、文档和视图是MFC的基础,但可能也是最不容易理解的部分,因为其概念比传统编程所需要的Windows函数更强一些,因此,须在本章做进一步详细讨论框架窗口、文档和视图的方法和技巧。 6.1框架窗口 分两类:...
  • 关于Word、Execl、Outlook的个小问题

    千次阅读 2006-03-23 09:20:00
     点选视图菜单中尺规选项,就可以了。2、Word的文件菜单不见了? 双击工具栏外的空白处,打开自订窗口,在工具列选项中,选择功能列表。3、怎样将我的Word文件加上密码? 选择工具菜单下的安全选项进行设置。
  • 大多数用户都知道,在打开文档时,经常会出现“受保护视图模式。该模式会防御很多以前出现的Office安全问题,导致诸如IP地址、操作时间戳、操作系统/Office版本,甚至NTLMv2等信息被窃取! ...
  • IOS之多视图应用程序 ...4.1 多视图应用程序介绍 ...4.2 UIViewController多视图程序 ...4.4 导航视图控制器应用 ...控制器类型4视图程序: " 自定义视图控制器 " 标签栏控制器 " 导航控制器 " 表视
  • 在文档/视图设计时需要考虑Undo/Redo,而最好的方法是使用Command设计模式实现。在实际应用Command模式实现Undo/Redo时遇到了一些问题。在开始的时候,逻辑非常混乱,不过经过讨论之后,问题开始清晰,实际上良好的...
  • 开发时几种常见的建模工具

    万次阅读 2016-11-18 13:24:45
    UML的统一性(Unified)表现为以下点: (1)UML是人类思想和计算机代码的一个连接桥梁 我们知道,计算机能直接识别的语言就是二进制的CPU指令,早期工程师们都是直接输入这些指令让计算机直接执行的,效率...
  • Word 2016使用技巧

    千次阅读 2017-11-19 13:08:03
    Word 2016使用技巧 Word 2016提供了更简单的云端共享和协作方式,协作编辑文档更加方便。在版本历史记录中可找到每次修改的记录,并可与当前文档进行对比。智能查找可让您在无需离开Word窗口的情况下,利用互联网...
  • WORD经典实用!

    千次阅读 2016-07-21 17:30:31
    WORD经典实用!较全面!
  • 推荐 Word、EXCEL必备工具箱

    千次阅读 2019-09-20 09:41:36
    增加了直接截取和四舍六入五成双模式,增加整数位取整的方式,并增加了将数据取整结果“放在原单元格右侧”的选项 7、财税工具→折合功能改进,增加了将数据折合的结果“放在原单元格右侧”的选项 8、财税工具→...
  • Word学习笔记分享

    千次阅读 2019-02-22 13:57:10
    第一章、Word 的常规排版 1-5 文字选择 Ctrl+鼠标选取——多选 Alt+鼠标选取——框选 1-11 文字效果 为文字添加填充与边框 1-13 字体其他效果 为字体添加着重号、删除线、上下标等效果 Ctrl+D ——打开字体选项栏 1-...
  • 本文是WORD 模板复制过来的,效果不好。 ... 使用word写论文全部详细过程 - 子木的文章 - 知乎 ...写论文时对哪一步疑惑直接用word打开本文档,勾上视图里面的导航窗格,点击相应标题就行。 ...
  • Clerk Ma ,LuaTeX-ja开发者 ...不过对于我来说,这几种战争都跟我没关系,尤其是LaTeX和Word,我都用。 LaTeX和Word完全不是一个类型的排版工具,但是目的一样:排版。 LaTeX是仿照Scribe

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,331
精华内容 5,332
关键字:

word的几种视图模式