精华内容
下载资源
问答
  • 一见不钟情的普通模式 普通模式以下的强悍操作 什么是操作符 什么是动作命令 误操作怎么办 那种操作更划算 普通模式下的神奇大招 Vim技巧之四大模式_普通模式 众所周知,vim里面最具特色的东西就是它...

    Vim技巧之四大模式_普通模式

    众所周知,vim里面最具特色的东西就是它能够切换模式,那什么是模式呢?能够简单的理解为在不同的模式以下按同样的键而得到不同的效果。比方Vim在插入模式以下连按两次d,那么就会在光标位置插入两个字母d,假设在普通模式以下连按两次d。那么光标所在当前行将会被删除。

    既然说是Vim的四大模式,那么Vim究竟有那四大模式呢?

    • 普通模式
    • 插入模式
    • 可视模式
    • 命令行模式

    用户能够通过按<ESC>来在各个模式之间进行切换,以下我们将具体的介绍普通模式,其它模式我们将在兴许的文章中进行具体介绍

    一见不钟情的普通模式

    Emacs,Sublime Text这些主流的编辑器在打开以后直接就能够向里面输入自己的想要的内容。可是对于第一次使用Vim的新手来说,并不和自己想象中的一样,倒腾了一会儿就会開始抓狂:

    1. 怎么在这个框框里面输入文本啊?
    2. 天啦噜,怎么退出这个黑框框???。!

      (博主一開始都是kill -9关掉的。哭死)

    Vim在开启的时候默认是使用普通模式的,例如以下图所看到的

    Alt text

    假设你须要在这个黑框框里面输入一些什么东西的话,你能够在屏幕上按以下随意一个健。Vim就会进入插入模式。接着就能够输入文本了

    按键 功能
    a 在光标后面进行插入
    A 在当前光标所在行末尾插入
    i 从光标所在出插入
    I 在当前光标所在行首插入
    o 在当前行以下新建一行,并进行插入
    O 在当前行上面新建一行。并进行插入

    那要是退出插入模式回到之间的普通模式呢?直接按<ESC>就能够啦

    这时候你可能就会问了。不是有一个插入模式就能够了么?为啥还要加一个普通模式呢?你看其它编辑器都没有这么多的模式。。。这就是Vim的精化所在,对于其它编辑器来说,假设要实现一个比較复杂的操作,基本上都是通过<Ctrl>,<Alt>,<Shilt>组合来完毕的,可是Vim偏不这样,Vim是通过在不同模式之间的切换来实现复杂的操作。简单来说。普通模式就是用来发动技能的。而插入模式则是进行简单的文本操作

    比方须要删除当前光标所在行,对于没有模式的编辑器是这样发动这个技能的

    <CTRL-K>(Emacs)
    <CTRL-L><Backspace>(Sublime Text)

    假设是Vim,那么首先进入普通模式,然后发动删除行的技能

    <ESC>(进入到普通模式)。dd(删除当前行)

    个人还是比較喜欢Vim一点。简洁明了。之前也试过Ctrl到死的Emacs,组合按键真是多。对与手小的人来说简直就是一种折磨!

    普通模式以下的强悍操作

    普通模式以下的操作能够解释为以下这个公式:

    +=

    什么是操作符?

    操作符就是你打算接下来要干什么?比方上文中提到的d,就是删除操作符,除了删了操作符。还有以下这些操作符:

    操作符 用途
    c 改动
    d 删除
    y 复制
    g~ 大写和小写反转
    gu 转为小写
    gU 转为大写
    > 向右缩进
    < 向佐缩进
    = 自己主动缩进

    什么是动作命令?

    操作符是用来指定一个操作,这个操作也不能瞎操作吧?我要删除一行文本,不能把整个文件的所有内容都给删了吧。。。所以,简单来说。动作命令就是用来指定操作符作用的范围

    那动作命令有那些呢?事实上动作命令比較灵活,这里我总结为有两类:

    • 一类是文本对象,比方aw , ap
    • 一类是位置范围, 比方l ,j,k,f{char},$,^,0…

    文本对象类型的动作命令

    文本对象 操作范围
    aw 光标所在单词加上一个空格
    iw 光标所在单词
    ap 光标所在段落
    i< <>里面的文本
    i{ {}里面的文本
    i” ""里面的文本

    假设如今有这样一行文本

    I am a Vimer

    我们须要删除Vimer这个单词

    $ (移动到行尾)
    daw(删除光标所在单词以及一个空格)

    最后得到:

    I am a

    位置范围类型的动作命令
    那什么是位置范围呢?就是从当前光标開始,经过一次移动命令以后新的光标位置之间的文本。比方3j,10<Space>,3l,f{char}等等等等。仅仅要能够移动光标的命令都能够

    假设如今有这样一行文本

    I am a Vimer

    我们要将Vimer这个单词字幕e之间的文本所有转为大写

    (移动到行首)
    gUte(操作符(gU)+(新的光标位置te))

    最后得到:

    I AM A VIMer

    注意一点:
    当一个操作符当被连续两次调用的时候。相应的作用范围就是当前行,比方dd就是删除当前行,yy就是复制当前行,gUgU就是将当前行转为大写

    误操作怎么办?

    我们能够切换到普通模式。然后u,就能够撤消之前进行的误操作,比方用dd误删了一行文本。我们直接输入u就能够撤消之前的删除操作

    以下我们来看一个栗子:
    输入一行文本

    I am a Vimer

    发现将Vimer误输为Vier,于是返回到普通模式,点击u希望撤消这个错误的单词输入,可是惊奇的发现之前输入的I am a文本也不见了,Vim撤消的太多了。!

    那该怎么办?怎么控制Vim撤消的粒度呢?

    u键会触发撤消命令,它会撤消最新的改动。一次改动能够是改变文档内文本的随意操作,当中包含了在普通模式,可视模式。以及命令行模式中所触发的命令,并且一次改动也包含了在一次插入模式中输入或者删除的文本,也就是说i{insert some stuff}<ESC>算是一次改动

    所以我们还是能够控制u撤消的粒度的。在插入模式中。每一次<ESC>就算是一次粒度的控制

    那种操作更划算?

    什么叫做划算?那就是用最少的按键操作完毕很多其它的文本操作

    举个栗子:
    如今须要删除以下文本的最后一个单词

    I am a Vimer

    操作一:

    $
    db(向前删除单词)
    x(删除x)

    操作二:

    $
    b(最后一个单词的词首)
    dw(删除单词)

    操作三:

    $
    daw

    上面三个操作都是用同样的按键数。这一步上大家打成平手,要是我们还要把剩下的两个单词都删除呢?前两个操作明显还须要从头反复一次。可是第三个操作我们仅仅须要用.操作就能够反复改动命令,所以操作三明显更划算!所以划算的更宽广的定义不仅是当前操作,还有将来的操作也要计算进来

    普通模式下的神奇大招

    这个神奇大招事实上就是

    • <C-a>:对数字进行加操作
    • <C-x>:对数字进行减操作

    <C-a>命令会把当前光标之上或者之上的数加1,假设须要加多次,能够[count]<C-a>,这样就会使数值加上count

    举个栗子:
    现有一段文本:

    I am 23 years old

    如今须要将23改为24,假设如今你不知道这个技巧,那就仅仅有

    f3(移动到3)
    r4(将3改为4)

    未免太繁琐了
    如今我们仅仅须要

    <Ctrl-a>(光标立刻跳转到23上,并将数值加1,变为24)

    要是如今需将23改为1023(千年老妖了)
    仅仅须要

    1000<Ctrl-a>

    同理可得<C-x>

    转载于:https://www.cnblogs.com/yfceshi/p/7102312.html

    展开全文
  • 系统是ubuntu18.04,vim版本8.0 我~/.vimrc里面设置了映射,leader为默认"\", ...在普通模式下输入"\"时会有系统提示音,但无任何报错信息 有尝试过文件第一行更改leader:let mapleader=";"(但还是无效)
  • 工厂模式

    千次阅读 2020-07-03 19:44:30
    就是首先创建一个手机的接口,定义构造方法,然后创建小米跟苹果两个实现类来实现接口,实现类里面重写手机接口里面的构造方法。然后定义一个工厂Foxconn来实现对于不同的输入字符串来创建不同的对象以实现调用...

    工厂模式分为三种:
    1、简单工厂模式
    2、工厂方法模式
    3、抽象工厂模式
    下面具体介绍着三种工作模式:
    首先是简单工作模式:
    1、普通工厂模式,就是建立一个工厂类,对实现了同一接口的一些类进行实例的创建。
    就是首先创建一个手机的接口,定义构造方法,然后创建小米跟苹果两个实现类来实现接口,在实现类里面重写手机接口里面的构造方法。然后定义一个工厂Foxconn来实现对于不同的输入字符串来创建不同的对象以实现调用不同的构造方法实现。简单来说就是我不知道工厂能干什么,这个模式需要告诉工厂我需要生产什么东西,我只管给工厂说我需要什么,工厂有的就生产,没有就不生产。

    package FactoryModel;
    
    import java.util.Scanner;
    
    public class Foxconn {
        public Phone creatPhoneByCondition(){
            Scanner scanner=new Scanner(System.in);
            System.out.println("请输入需要生产的手机类型:");
            String next = scanner.next();
            if (next.equals("小米")){
                return new Mi();
            }else if (next.equals("苹果")){
                return new Iphone();
            }else {
                System.out.println("无法生产该产品");
            }
            return null;
        }
    }
    interface Phone{
        void creat();
    }
    class Iphone implements Phone{
    
        @Override
        public void creat() {
            System.out.println("创造了一部Iphone x max ");
        }
    }
    class Mi implements Phone{
    
        @Override
        public void creat() {
            System.out.println("创造了一部小米10 Pro");
        }
    
    }
    class FactoryFoxconn {
        public static void main(String[] args) {
            while (true){
                Foxconn foxconn=new Foxconn();
                Phone phone = foxconn.creatPhoneByCondition();
                if (phone!=null){
                    phone.creat();
                 }
    
            }
        }
        }
    ---------------------------------------
    下面是运行结果
    ---------------------------------------
    请输入需要生产的手机类型:
    小米
    创造了一部小米10 Pro
    

    2、多个工厂方法模式,是对普通工厂方法模式的改进,在普通工厂方法模式中,如果传递的字符串出错,则不能正确创建对象,而多个工厂方法模式是提供多个工厂方法,分别创建对象。
    简单来说就是,工厂已经定义好自己能干什么,我知道工厂能干什么,我只需要调用生产方法就行。而简单工厂模式下我不知道工厂能干什么,而且需要传参数去对应相应的生产方法。

    package FactoryModel;
    
    import java.util.Scanner;
    
    public class Foxconn {
        public Phone creatPhoneByCondition(){
            Scanner scanner=new Scanner(System.in);
            System.out.println("请输入需要生产的手机类型:");
            String next = scanner.next();
            if (next.equals("小米")){
                return new Mi();
            }else if (next.equals("苹果")){
                return new Iphone();
            }else {
                System.out.println("无法生产该产品");
            }
            return null;
        }
    }
    interface Phone{
        void creat();
    }
    class Iphone implements Phone{
    
        @Override
        public void creat() {
            System.out.println("创造了一部Iphone x max ");
        }
    }
    class Mi implements Phone{
    
        @Override
        public void creat() {
            System.out.println("创造了一部小米10 Pro");
        }
    
    }
    class FactoryFoxconn {
        public static void main(String[] args) {
            while (true){
                Foxconn foxconn=new Foxconn();
                Phone phone = foxconn.creatPhoneByCondition();
                if (phone!=null){
                    phone.creat();
                 }
    
            }
        }
        }
    
    
    运行结果
    -----------------------
    创造了一部Iphone x max 
    

    /静态工厂方法模式,将上面的多个工厂方法模式里的方法置为静态的,不需要创建实例,直接调用即可。
    简单来说就相当于工厂工作模式加了一个static修饰符而已,目的是为了不用再去创建新的实例化对象,静态方法直接调用即可
    /

    总体来说,工厂模式适合:凡是出现了大量的产品需要创建,并且具有共同的接口时,可以通过工厂方法模式进行创建。在以上的三种模式中,第一种如果传入的字符串有误,不能正确创建对象,而静态跟非静态相比,不需要实例化工厂类,所以,大多数情况下,我们会选用静态工厂方法模式。

    4、抽象工厂模式(Abstract Factory)

    工厂方法模式有一个问题就是,类的创建依赖工厂类,也就是说,如果想要拓展程序,必须对工厂类进行修改,这违背了闭包原则,所以,从设计角度考虑,有一定的问题,如何解决?就用到抽象工厂模式,创建多个工厂类,这样一旦需要增加新的功能,直接增加新的工厂类就可以了,不需要修改之前的代码。
    下面用发送消息的例子来说明。

    package FactoryModel;
    public interface Sender {
        public void Send();
    }
    class MailSender implements Sender {
        @Override
        public void Send() {
            System.out.println("发送mail消息!");
        }
    }
    class SmsSender implements Sender {
    
        @Override
        public void Send() {
            System.out.println("发送sms消息!");
        }
    }
    class SendMailFactory implements Provider {
    
        @Override
        public Sender produce(){
            return new MailSender();
        }
    }
    class SendSmsFactory implements Provider{
    
        @Override
        public Sender produce() {
            return new SmsSender();
        }
    }
    
    interface Provider {
        public Sender produce();
    }
    class Test {
    
        public static void main(String[] args) {
            Provider provider = new SendMailFactory();
            Sender sender = provider.produce();
            sender.Send();
        }
    }
    
    
    运行结果
    ----------------------------
    发送mail消息!
    

    简单来说就是,如果你现在想增加一个功能:发及时信息,则只需做一个实现类,实现Sender接口,同时做一个工厂类,实现Provider接口,就OK了,无需去改动现成的代码。这样做,拓展性较好!

    展开全文
  • Vim技巧之四大模式_可视模式

    万次阅读 多人点赞 2015-07-20 00:15:02
    最好使用操作符命令而不是可视命令Vim技巧之四大模式_可视模式前面的两篇文章《Vim技巧之四大模式_插入模式》和《 Vim技巧之四大模式_普通模式》我们已经介绍了插入模式和普通模式里面的技巧,下面我们将继续介绍...

    Vim技巧之四大模式_可视模式

    在前面的两篇文章《Vim技巧之四大模式_插入模式》《 Vim技巧之四大模式_普通模式》我们已经介绍了插入模式普通模式里面的技巧,下面我们将继续介绍四大模式之一的可视模式

    什么是可视模式?

    可视模式简单来说就是选中一块编辑区域,然后在上面执行一些操作,比如删除,替换,改变大小写等。

    如何选中一块区域?

    Vim里面有三种激活可视模式,并选择一块区域的方法,他们分别是:

    模式类型 激活方式 选择效果
    字符文本 v(小写) 逐个字符选择文本
    行文本 V(大写) 逐行选择文本
    块文本 <C-v> 按照块的方式选择文本

    这上面说的什么字符文本行文本块文本指的是什么意思啊?其实就是一种控制选择粒度的方案,字符文本的选择粒度是一个字符,行文本的选择粒度是一行文本,如果你想只选中一行里面的几个连续字符,那么使用行文本就不太适合了,因为行文本的选择粒度是以行为最小单位的,每次最少都要选中一行内容,如果你想选中多行文本,那么使用字符文本明显是不合适的,因为太低效了。而块文本就是功能最强大的选择模式了,它可以完全无视行的存在,可以在文本中按照需要的区域自由选择。

    举个栗子:注意左下角的不同选择模式的提示

    字符文本的选择,移动到H,点击v开始选择,我们选中Hello World这几个字符

    Alt text


    行文本的选择,点击V开始,我们选中头两行文本

    Alt text


    块文本的选择,点击<C-v>开始,我们选中一块文本

    Alt text

    如何快速选中目标区域

    我们在普通模式博客中已经介绍了许多快速移动光标的命令,比如h,j,k,l,可以在四个方向移动光标,也可以用f{char}来跳转到某个字符上面,之后再用;,来重复跳转,或者用查找命令/target来进行光标的快速移动,再用n/N进行重复,还有许多这样的移动光标的命令,幸运的是,在可视模式下面,这些快速移动光标的命令我们都可以用

    举个栗子:

    比如在下面的栗子里面,我们要从25行字符c开始,一直选中直到行尾

    首先点击v切换到字符模式,键入fc,接着可以直接按$,这时光标会跳到行尾,字符c到行尾之间的内容就被选中了

    Alt text


    如果我们要选择Hello World这个字符串呢?

    我们可以直接fH,然后vi"就可以选中双引号"里面的内容了

    Alt text

    这样的用法还有很多,读者可以自我领会

    大家有没有发现在使用可视模式的时候,一旦切换到可视模式以后,选中的区域是由两个端点来界定的(一个在左上角,一个在右下角),我们在默认情况下只可以控制右下角的端点,但是有些时候发现我们需要调整左上角的端点,这时我们可以使用o按键来在左上角和右下角之间进行切换。

    举个栗子:

    假如我们在块选择模式下面已经选中了下面的区域

    Alt text

    现在我们需要将选择区域向左再扩充一点,可以点击o按键,再用移动光标的命令进行移动

    Alt text

    如何重复选择目标区域

    我们可以使用gv命令来重新选中之前可视模式选中的目标区域,但是如果之前的选中的区域文本被删除,那么gv命令就会表现的有点神经了

    举个栗子:

    假如我们选中字符串"Hello World",然后再将"Hello World"删除,如果我们再次调用gv命令,那么选中的区域不再是之前的"Hello World",而是相同字符宽度的内容

    Alt text

    删除"Hello World"gv选中的区域

    Alt text

    不仅如此,就算这行文本的列数有所偏移,比如将文本多缩进了几行,再次gv发现也是不对的

    Alt text

    所以,博主个人估计Vim底层的实现可能是记住目标区域的起始行和行数起始列和列数,键入gv以后就根据之前保存行列信息进行还原

    于是博主再次做实验,将上下两行进行调换,再次gv

    Alt text

    发现和预期的一样。

    如何在选中中切换选择模式

    可视模式有一个好处就是我们可以在三种选择模式之间进行随意的切换,比如在行文本模式下面希望进行更加细粒度的选择,我们可以直接按v切换到字符模式,同理可以得到在某一选择模式中切换到任意其他两种模式的方法。博主不再这里赘述

    如何对选中的区域进行操作?

    我们选中一块区域,最直接的目的就是对这块区域进行操作,比如删除,调换大小写,改变文本等等。那么要如何对选中的区域进行操作呢?在文章的上一节中我们提到可以在可视模式中使用普通模式的跳转命令,没错,在可视模式中也可以使用普通模式模式下的修改命令。

    命令 命令效果
    d 删除选中文本
    c 修改选中文本
    r 替换选中文本
    I 在选中文本前插入
    A 在选中文本后插入
    gu 选中区域转为小写
    gU 选中区域转为大写
    g~ 大小写互调
    > 向右缩进一个单位
    < 向左缩进一个单位

    比较常用的就是上面的几个。

    下面我们来举几个栗子:

    栗子一:

    假设现在我们有下面一个C++文件

    Alt text

    main函数的头三行代码忘了加;号了,现在我们要用可视模式为这三行代码加上分号

    首先<C-v>开启块选择模式,然后点击jj$号选择到行末尾,选中区域如下所示

    Alt text

    再用A在选中的区域后面添加文本;,虽然在编辑的过程中只有一行文本看上去添加了分号,如下图
    Alt text

    但是只用按下<Esc>,剩下的其余选中行也会自动添加分号,这里与其他编辑器稍有不同,新手应注意

    Alt text


    栗子二:

    下面是一个打开四个文件标识符的栗子

    Alt text

    如果我们已经将四个文件file1,file2,file3,file4移动到了新的目录/tmp/fileDir里面,于是我们要将testDir目录改为fileDir目录

    <C-v>进入块选择模式,并选中testDir区域,如下图

    Alt text

    点击c对选中区域进行替换,并输入fileDir

    Alt text

    跟之前的栗子一样,只有一行文本发生改变,点击<Esc>使改变作用于全部选中区域

    Alt text

    可视命令的重复

    说到重复,首先想到的肯定是.命令啦,可是这个重复命令可不一般,首先来看几个栗子:

    字符文本模式栗子:

    首先在字符文本模式下选中27行的open单词,并用g~命令来将open转为大写

    Alt text

    注意这里我们选中的是四个字符,之后我们将光标向右移动几位,移动到单词fileDir的开头,我们点击.重复上一个可视命令

    得到下面的结果:

    Alt text

    我们惊奇的发现OPEN并没有转为预期的转为小写,而是fileDir的前四个字符变成了大写


    行文本模式栗子:

    V27行选中,并用g~进行大小写转换

    Alt text

    现在跳转到31行,单击.重复命令

    Alt text

    发现31行的全部文本全都进行大小写互换


    块文本模式栗子:

    点击<C-v>进入块文本选择模式,随便选中一块区域,如下图

    Alt text

    g~进行大小写互换

    Alt text

    现在我们将光标下移一行,并将光标移到图示位置

    Alt text

    此时点击.,发现有下面的效果

    Alt text

    我们发现从光标开始的右下角的一个矩形范围被调换了大小写,该矩形范围的大小与上次可视模式选中的区域大小一样

    于是博主总结了一下,不同的选择模式有不同的重复效果

    选择模式 重复效果
    字符文本选择模式(Visual) 从当前光标开始,作用范围是上次操作的字符数
    行文本选择模式(Visual line) 从当前行开始,作用范围是上次操作的行数
    块文本选择模式(Visual Block) 从当前光标开始,作用范围是以当前光标为左上端点的上次操作的块范围

    最好使用操作符命令而不是可视命令

    为什么这么讲呢?比如在字符文本选择模式里面,如果我们要进行重复,那么重复的范围是通过上一次操作的字符数决定的,其中与上一次操作相同的字符数就是一个很大的限制条件,必须这次操作的字符数与上次操作的字符数相同我们才可以放心的使用重复操作。

    举个栗子:

    我们要将27-29printf打印的内容全都转为大写

    Alt text

    27行,我们采用vi"选中引号内的东西,U将选中的内容转化为大写

    如果我们下移一行,用.重复上次操作,得到

    Alt text

    发现只作用了前两个字符,后面的llo还是小写

    不能重复上次的操作,难道还需要手动再来一遍?其实并不需要,我们只用使用普通模式下面的操作符命令就可以啦

    上面的栗子我们可以用操作符命令更好的实现需求

    使用gUi",将"内的内容转化为大写,然后j.就可以重复上一行的操作啦

    Alt text

    展开全文
  • 设计模式----组合模式

    2021-05-16 11:55:31
    组合模式按照我理解是:把一组相似对象当作一个单一对象,对象中 除了对象自己有属性再加上一个属性list 这里面存放是本对象集合 比如:权限 权限有老板,管理员,普通人员 ,老板只有一个并且拥有...

    组合模式

    什么是组合模式

    组合模式按照我的理解是:把一组相似的对象当作一个单一的对象,在对象中 除了对象自己有的属性再加上一个属性list 这里面存放的是本对象的集合

    比如:权限 权限有老板,管理员,普通人员 ,老板只有一个并且拥有所有权限

    管理员:可以拥有对应的权限,不同的管理员负者不同的模块 并且管理不同的普通人员 HR:负责招人等,销售:负者买东西等

    普通人员:干事的人

    在组合模式中 我们可以只使用一个对象 ,在老板的list中是包含使用管理员的对象

    在管理员的list中又包含自己所对应的普通人员 一层管一层

    就好像是一颗树

    组合模式是做什么的

    它在我们树型结构的问题中,模糊了简单元素和复杂元素的概念,客户程序可以像处理简单元素一样来处理复杂元素,从而使得客户程序与复杂元素的内部结构解耦。

    组合模式的应用场景

    部分、整体场景,如树形菜单,文件、文件夹的管理。

    使用组合模式的好处

    1、高层模块调用简单。

    2、节点自由增加。

    代码

    对象

    public class Employee {
        //姓名
        private String name;
        //工作
        private String job;
        //工资
        private Integer salary;
        //用于存放下属
        private List<Employee> subordinates;
    
        //构造方法   用于创建对象的时候方便
        public Employee(String name, String job, Integer salary) {
            this.name = name;
            this.job = job;
            this.salary = salary;
            //创建集合
            subordinates = new ArrayList<Employee>();
        }
    
        //添加下属到集合中
        public void add(Employee e) {
            subordinates.add(e);
        }
    
        //删除集合中的下属
        public void remove(Employee e) {
            subordinates.remove(e);
        }
    
        //返回集合
        public List<Employee> getSubordinates(){
            return subordinates;
        }
    
        @Override
        public String toString() {
            return "Employee{" +
                    "name='" + name + '\'' +
                    ", job='" + job + '\'' +
                    ", salary=" + salary +
                    ", subordinates=" + subordinates +
                    '}';
        }
    }
    
    

    测试

    public class Demo {
        public static void main(String[] args) {
            //老板
            Employee CEO = new Employee("A","CEO", 300000);
    
            //HR经理
            Employee B1 = new Employee("B1","HR", 35000);
    
            //销售经理
            Employee B2 = new Employee("B2","销售", 50000);
    
            //HR(工作人员)
            Employee B1C1 = new Employee("B1C1","HR", 5000);
            Employee B1C2 = new Employee("B1C2","HR", 5000);
    
            //销售(工作人员)
            Employee B2C1 = new Employee("B2C1","销售", 20000);
            Employee B2C2 = new Employee("B2C2","销售", 20000);
    
            //现在我们把他们组合起来
            CEO.add(B1);
            CEO.add(B2);
    
            B1.add(B1C1);
            B1.add(B1C2);
    
            B2.add(B2C1);
            B2.add(B2C2);
    
            System.out.println(CEO);
            //查看CEO所管理的所有人员
            for (Employee headEmployee : CEO.getSubordinates()) {
                System.out.println(headEmployee);
                for (Employee employee : headEmployee.getSubordinates()) {
                    System.out.println(employee);
                }
            }
        }
    }
    
    //测试结果
    
    Employee{name='A', job='CEO', salary=300000, subordinates=[Employee{name='B1', job='HR', salary=35000, subordinates=[Employee{name='B1C1', job='HR', salary=5000, subordinates=[]}, Employee{name='B1C2', job='HR', salary=5000, subordinates=[]}]}, Employee{name='B2', job='销售', salary=50000, subordinates=[Employee{name='B2C1', job='销售', salary=20000, subordinates=[]}, Employee{name='B2C2', job='销售', salary=20000, subordinates=[]}]}]}
    Employee{name='B1', job='HR', salary=35000, subordinates=[Employee{name='B1C1', job='HR', salary=5000, subordinates=[]}, Employee{name='B1C2', job='HR', salary=5000, subordinates=[]}]}
    Employee{name='B1C1', job='HR', salary=5000, subordinates=[]}
    Employee{name='B1C2', job='HR', salary=5000, subordinates=[]}
    Employee{name='B2', job='销售', salary=50000, subordinates=[Employee{name='B2C1', job='销售', salary=20000, subordinates=[]}, Employee{name='B2C2', job='销售', salary=20000, subordinates=[]}]}
    Employee{name='B2C1', job='销售', salary=20000, subordinates=[]}
    Employee{name='B2C2', job='销售', salary=20000, subordinates=[]}
    
    
    
    展开全文
  • 一、单例模式的概念:  偶然想想到的如果把Java的构造方法弄成private,那里面的...我主要是应用使用普通类模拟枚举类型里,后来发现这就是传说中的单例模式。   构造函数弄成private 就是单例模式,即不想
  • 策略模式

    2019-05-15 21:03:59
    商场中我们会遇到这样问题,就是对于会员和普通顾客优惠不同,节假日和平常日子不同,如果我们只写一个算法话,维护时候就会出现很多麻烦 那么有什么解决办法呢? 我们这个时候就可以采用策略模式...
  • 前两篇文章都是提到了使用反射去解决... 别看我们大话设计模式上说那么玄乎,其实反射机制是搜索,还记得我们抽象工厂里面是怎么用反射吗?  IUser iuser=Assembly.Load("DAL").CreateInstance("DAL.UserDAO
  • 一.问题引入  偶然想想到如果把Java构造方法...我主要是应用使用普通类模拟枚举类型里,后来发现这就是传说中单例模式。构造函数弄成private 就是单例模式,即不想让别人用new 方法来创建多个对象,可以
  • 一,偶然想想到的如果把Java的构造方法弄成private,那里面的成员属性是不是只有通过static来访问呢;如果构造方法是private的话,那么有什么好处呢;如果构造方法是private的话,会不更好的封装该内呢?我主要是...
  • 解释器模式里面提到语言是指任何解释器对象能够解释任何组合。解释器模式中需要定义一个代表文法命令类等级结构,也就是一系列组合规则。每一个命令对象都有一个解释方法,代表对命令对象解释。命令...
  • 一.问题引入  偶然想想到如果把Java构造方法弄成...我主要是应用使用普通类模拟枚举类型里,后来发现这就是传说中单例模式。构造函数弄成private 就是单例模式,即不想让别人用new 方法来创建多个对象,可以
  • JAVA单例模式

    2017-10-18 18:45:00
    一.问题引入  偶然想想到如果把Java构造...我主要是应用使用普通类模拟枚举类型里,后来发现这就是传说中单例模式。构造函数弄成private 就是单例模式,即不想让别人用new 方法来创建多个对象,可以类...
  • java单例模式

    2017-11-01 14:30:21
    一.问题引入  偶然想想到如果把Java构造方法弄成...我主要是应用使用普通类模拟枚举类型里,后来发现这就是传说中单例模式。构造函数弄成private 就是单例模式,即不想让别人用new 方法来创建多个对象,可以
  • Java单例模式深入详解

    2017-09-28 10:43:22
    一.问题引入偶然想想到如果把Java...我主要是应用使用普通类模拟枚举类型里,后来发现这就是传说中单例模式。构造函数弄成private 就是单例模式,即不想让别人用new 方法来创建多个对象,可以里面先生...
  • C#23种设计模式

    2013-06-02 16:49:43
    朋友聚会上碰到了一个美女Sarah,从香港来,可我不会说粤语,她不会说普通话,只好求助于我朋友kent了,他作为我和Sarah之间Adapter,让我和Sarah可以相互交谈了(也不知道他会不会耍我) 适配器(变压器)...
  • 这样可以帮助来异步处理 许多事情,可是观察者模式中,一般都是针对于实体来进行封装操作,可大多数监听过程就需要写实体内部了,这样大大影响了实体封装原子性,如果 想实现什么监听事件,都需要实体...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 171
精华内容 68
关键字:

在什么里面的普通模式