精华内容
下载资源
问答
  • 主要给大家介绍了关于Kotlin中双冒号::使用的相关资料,文中通过示例代码介绍的非常详细,对大家学习或者使用Kotlin具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • 在C++中经常使用双冒号::,很多朋友不知道是什么意思,这篇文章主要介绍了C++中双冒号::的作用,需要的朋友可以参考下
  • 深入理解Java双冒号(::)运算符的使用

    万次阅读 多人点赞 2019-02-20 15:12:53
    我们先看一个关于Lambda的使用 /** * 输出list */ @Test public void test() { String[] array = {"aaaa", "bbbb&...

    Jdk8中有好多新的特性,比如引入Lambda,简化代码的书写等等

    我们先看一个关于Lambda的使用

    /**
    * 输出list
     */
    @Test
    public void test() {
    	String[] array = {"aaaa", "bbbb", "cccc"};
    	List<String> list = Arrays.asList(array);
    	
    	//Java 7 
    	for(String s:list){
    		System.out.println(s);
    	}
    	
    	//Java 8
    	list.forEach(System.out::println);
    }
    

    其中list.forEach(System.out::println);就是Java 8中的Lambda写法之一, 有没有特别注意到输出语句跟我们平时写的syso语句不一样,常规输出语句是这样的:

    System.out.println("流浪地球拍的不错哦!");
    

    这里面使用到了::, 有点意思,来认识一下这个新东西!

    双冒号(::)

    英文:double colon,双冒号(::)运算符在Java 8中被用作方法引用(method reference),方法引用是与lambda表达式相关的一个重要特性。它提供了一种不执行方法的方法。为此,方法引用需要由兼容的函数接口组成的目标类型上下文。

    Method References
    You use lambda expressions to create anonymous methods. Sometimes, however, a lambda expression does nothing but call an existing method. In those cases, it’s often clearer to refer to the existing method by name. Method references enable you to do this; they are compact, easy-to-read lambda expressions for methods that already have a name.
    关于方法引用的描述,摘自oracle官网

    大致意思是,使用lambda表达式会创建匿名方法, 但有时候需要使用一个lambda表达式只调用一个已经存在的方法(不做其它), 所以这才有了方法引用!

    以下是Java 8中方法引用的一些语法:

    1. 静态方法引用(static method)语法:classname::methodname 例如:Person::getAge
    2. 对象的实例方法引用语法:instancename::methodname 例如:System.out::println
    3. 对象的超类方法引用语法: super::methodname
    4. 类构造器引用语法: classname::new 例如:ArrayList::new
    5. 数组构造器引用语法: typename[]::new 例如: String[]:new

    如果上的语法太枯燥,那就通过一些例子来加强对它的理解:

    静态方法语法使用例子:

    import java.util.Arrays;
    import java.util.List;
    
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    /**
     * 
     * @author zhoufy
     * @date 2019年2月20日 下午2:19:13
     */
    @RunWith(SpringJUnit4ClassRunner.class)
    @ComponentScan("com.zhoufy")
    public class Demo {
    	@Test
    	public void test() {
    		List<String> list = Arrays.asList("aaaa", "bbbb", "cccc");
    		
    		//静态方法语法	ClassName::methodName
    		list.forEach(Demo::print);
    	}
    	
    	public static void print(String content){
    		System.out.println(content);
    	}
    }
    

    类实例方法语法使用例子:

    import java.util.Arrays;
    import java.util.List;
    
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    /**
     * 
     * @author zhoufy
     * @date 2019年2月20日 下午2:19:13
     */
    @RunWith(SpringJUnit4ClassRunner.class)
    @ComponentScan("com.zhoufy")
    public class Demo {
    	@Test
    	public void test() {
    		List<String> list = Arrays.asList("aaaa", "bbbb", "cccc");
    		
    		//对象实例语法	instanceRef::methodName
    		list.forEach(new Demo()::print);
    	}
    	
    	public void print(String content){
    		System.out.println(content);
    	}
    }
    

    超类方法语法使用例子:

    import java.util.Arrays;
    import java.util.List;
    
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    
    
    /**
     * @author zhoufy
     * @date 2019年2月20日 下午2:41:38
     */
    @RunWith(SpringJUnit4ClassRunner.class)
    @ComponentScan("com.zhoufy")
    public class Example extends BaseExample{
    
    	@Test
    	public void test() {
    		List<String> list = Arrays.asList("aaaa", "bbbb", "cccc");
    		
    		//对象的超类方法语法: super::methodName 
    		list.forEach(super::print);
    	}
    }
    
    class BaseExample {
    	public void print(String content){
    		System.out.println(content);
    	}
    }
    

    类构造器语法使用例子:

    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    /**
     * 
     * @author zhoufy
     * @date 2019年2月20日 下午2:19:13
     */
    @RunWith(SpringJUnit4ClassRunner.class)
    @ComponentScan("com.zhoufy")
    public class Example {
    
    	@Test
    	public void test() {
    		InterfaceExample com =  Example::new;
    		Example bean = com.create();	
    		System.out.println(bean);
    	}
    }
    
    interface InterfaceExample{
    	Example create();
    }
    

    如果是带参数的构造器,示例如下:

    /**
     * @author zhoufy
     * @date 2019年2月20日 下午2:19:13
     */
    public class Example {
    	
    	private String name;
    	
    	Example(String name){
    		this.name = name;
    	}
    	
    	public static void main(String[] args) {
    		InterfaceExample com =  Example::new;
    		Example bean = com.create("hello world");
    		System.out.println(bean.name);
    	}
    }
    interface InterfaceExample{
    	Example create(String name);
    }
    

    这里需要特别注意的是:Example 类并没有implements InterfaceExample接口哦!!!

    数组构造器语法使用例子:

    import java.util.function.Function;
    
    /**
     * @author zhoufy
     * @date 2019年2月20日 下午2:19:13
     */
    public class Example {
    	public static void main(String[] args) {
    		Function <Integer, Example[]> function = Example[]::new;
    		Example[] array = function.apply(4);	//这里的4是数组的大小
    		
    		for(Example e:array){
    			System.out.println(e);	//如果输出的话,你会发现会输出4个空对象(null)
    		}
    	}
    }
    

    这里是借用jdk自带的java.util.function.Function类实现的,如果想要自定义接口

    
    /**
     * 
     * @author zhoufy
     * @date 2019年2月20日 下午2:19:13
     */
    public class Example {
    	
    	public static void main(String[] args) {
    		Interface <Integer, Example[]> function = Example[]::new;
    		Example[] array = function.apply(4);	//这里的4是数组的大小
    		
    		for(Example e:array){
    			System.out.println(e);
    		}
    	}
    }
    
    @FunctionalInterface
    interface Interface<A, T>{
    	T apply(A a); 
    }
    
    展开全文
  • ES6 双冒号运算符

    千次阅读 2018-10-04 20:46:52
    箭头函数可以绑定this对象,大大减少了显式绑定this对象的写法...函数绑定运算符是并排的两个冒号(::),双冒号左边是一个对象,右边是一个函数。该运算符会自动将左边的对象,作为上下文环境(即this对象),...

    箭头函数可以绑定this对象,大大减少了显式绑定this对象的写法(callapplybind)。但是,箭头函数并不适用于所有场合,所以现在有一个提案,提出了“函数绑定”(function bind)运算符,用来取代callapplybind调用。

    函数绑定运算符是并排的两个冒号(::),双冒号左边是一个对象,右边是一个函数。该运算符会自动将左边的对象,作为上下文环境(即this对象),绑定到右边的函数上面。

    foo::bar;
    // 等同于
    bar.bind(foo);
    
    foo::bar(...arguments);
    // 等同于
    bar.apply(foo, arguments);
    
    const hasOwnProperty = Object.prototype.hasOwnProperty;
    function hasOwn(obj, key) {
      return obj::hasOwnProperty(key);
    }

    如果双冒号左边为空,右边是一个对象的方法,则等于将该方法绑定在该对象上面。

    var method = obj::obj.foo;
    // 等同于
    var method = ::obj.foo;
    
    let log = ::console.log;
    // 等同于
    var log = console.log.bind(console);

     

    展开全文
  • 主要给大家介绍了关于java8 中的:: 用法(JDK8双冒号用法)的相关资料,文中通过示例代码介绍的非常详细,对大家学习或者使用java8具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • c++中 双冒号作用

    千次阅读 2020-05-07 16:07:27
    System::Math::Sqrt() 可以理解为 System是全局命名空间 Math是类名 Sqrt是函数名 3、双冒号也常常用于在类变量内部作为当前类实例的元素进行表示 class CA { public: int ca_var; int add(int a, int b); int ...

    1、作用域符号::的前面一般是类名称,后面一般是该类的成员名称,C++为例避免不同的类有名称相同的成员而采用作用域的方式进行区分
    如:A,B表示两个类,在A,B中都有成员member。那么
          A::member 就表示 类A 中的 成员member
          B::member 就表示 类B 中的 成员member 

     

    2、全局作用域符号:

    #include <stdio.h>
    
    int count = 0; //全局变量 0
    
    void main()
    {
        int count = 10; //局部变量10
    
        printf("count =%d\n", count);//局部变量屏蔽了全局变量 所以输出结果是10
        {
            int count = 20;
    
            printf("count =%d\n", ::count); //作用域符号指出引用全局变量0
            //::sort
        }
    }
    

    作为全局作用域符号,双冒号要放在开头。这和linux下的文件路径类似,“/”放在开头表示绝对路径,放在中间表示子目录。

    ::符号既可以指定类,也可以指定变量和命名空间:

    如果函数放在全局,就是全局函数

    如果变量定义在全局,就是全局变量

    如果一个命名空间放在全局,就是全局命名空间。

    System::Math::Sqrt()

    可以理解为 System是全局命名空间  Math是类名  Sqrt是函数名

     

    3、双冒号也常常用于在类变量内部作为当前类实例的元素进行表示

    class CA {
    public:
        int ca_var;
        int add(int a, int b);
        int add(int a);
    };
    
    //作用域
    int CA::add(int a, int b)
    {
        return a + b;
    }
    
    //另外,双冒号在类变量内部作为当前类实例的元素进行表示
    int CA::add(int a)
    {
        return a + ::ca_var;
    }
    //表示当前类实例中的变量ca_var
    

     

     

    展开全文
  • ES6 允许使用“箭头”(=>)定义函数。 var cat= function (name) { return "tom";}; var cat = name => "tom"; 如果箭头函数不需要参数或需要多个参数,就使用一个圆括号代表参数部分。 var cat = (name) =&...

    1、箭头函数
    ES6 允许使用“箭头”(=>)定义函数。
    var cat= function (name) { return "tom";};    var cat = name => "tom";
    如果箭头函数不需要参数或需要多个参数,就使用一个圆括号代表参数部分。 var cat = (name) => "tom";
    如果箭头函数的代码块部分多于一条语句,就要使用大括号将它们括起来    var cat = (name) => {return  "tom"};

    箭头函数有几个使用注意点。
    (1)函数体内的this对象,就是定义时所在的对象,而不是使用时所在的对象。
    (2)不可以当作构造函数,也就是说,不可以使用new命令,否则会抛出一个错误。
    (3)不可以使用arguments对象,该对象在函数体内不存在。如果要用,可以用 rest 参数代替。

    上面三点中,第一点尤其值得注意。this对象的指向是可变的,但是在箭头函数中,它是固定的。
    由于箭头函数使得this从“动态”变成“静态”,下面两个场合不应该使用箭头函数。
    第一个场合是定义函数的方法,且该方法内部包括this。
    const cat = {
      lives: 9,
      jumps: () => {
        this.lives--;
      }
    }   指向的是全局的变量    

    第二个场合是需要动态this的时候,也不应使用箭头函数。
    button.addEventListener('click', () => {
           this.classList.toggle('on');
    });  指向的是全局的变量    
     
    2、双冒号运算符

    箭头函数可以绑定this对象,大大减少了显式绑定this对象的写法(call、apply、bind)。
    但是,箭头函数并不适用于所有场合,所以现在有一个提案,提出了“函数绑定”(function bind)运算符,用来取代call、apply、bind调用。

    函数绑定运算符是并排的两个冒号(::),双冒号左边是一个对象,右边是一个函数。
    该运算符会自动将左边的对象,作为上下文环境(即this对象),绑定到右边的函数上面。
    run.bind(cat);
    cat::run;
    // 等同于

    cat::run(...arguments);
    // 等同于
    run.apply(cat, arguments);

    如果双冒号左边为空,右边是一个对象的方法,则等于将该方法绑定在该对象上面
    let log = ::console.log;
    // 等同于
    var log = console.log.bind(console);

    如果双冒号运算符的运算结果,还是一个对象,就可以采用链式写法。
     

    展开全文
  • 前几天在百度知道里面看到有人问PHP中双冒号::的用法,当时给他的回答比较简洁因为手机打字不大方便!今天突然想起来,所以在这里总结一下我遇到的双冒号::在PHP中使用的情况
  • Kotlin 双冒号 :: 使用

    2021-04-18 14:53:39
    Kotlin 中 双冒号操作符 表示把一个方法当做一个参数,传递到另一个方法中进行使用,通俗的来讲就是引用一个方法。先来看一下例子: fun main(args: Array<String>) { println(lock("param1", "param2", ::...
  • java中双冒号使用

    2021-08-08 10:45:56
    java中双冒号使用 java中双冒号主要用于静态方法的使用,在使用forEach方法时使用,案例如下: package com.example.api.test; public class Test2 { //有参调用 public static void test(int i){ System.out...
  • #include<iostream> using namespace std; int atk = 200;... // 双冒号 作用域运算符 :: 全局作用域, 冒号前没有任何值,表示全局作用域, // std::cout 表示std作用域中的cout函数 cout&l.
  • 关于Python切片:双冒号使用 #Python sequence slice addresses can be written as a[start:end:step] and any of start, stop or end can be dropped. #所以出现双冒号是省略了“end”的结果,默认为最后 >>...
  • Kotlin 中 双冒号操作符 表示把一个方法当做一个参数,传递到另一个方法中进行使用,通俗的来讲就是引用一个方法。先来看一下例子: fun main(args: Array<String>) { println(lock("param1", "param2", ::...
  • 简介 Lambda 表达式(lambda expression)是一个匿名函数,Lambda表达式基于数学中的λ演算得名,直接对应于其中的lambda抽象(lambda abstraction),是一个...使用 Lambda 表达式可以使代码变的更加简洁紧凑。 语法 l
  • java中的双冒号使用介绍

    千次阅读 2019-11-17 01:17:49
    双冒号运算操作符是类方法的句柄,lambda表达式的一种简写,这种简写的学名叫eta-conversion或者叫η-conversion 2.通常的情况下: 把 x -> System.out.println(x) 简化为 System.out::println 的过程称之为 eta-...
  • 详解C++中的双冒号 ::

    2020-12-17 00:52:34
    C++中的双冒号 ::第一种,类作用域,用来标明类的变量、函数 Human::setName(char* name); 第二种,命名空间作用域,用来注明所使用的类、函数属于哪一个命名空间的 std::cout << "Hello World" << ...
  • java 8 双冒号操作

    万次阅读 2018-10-04 15:03:45
    本文我们讨论java 8 中的双冒号(::)操作以及其使用场景。 从lambda表达式到双冒号(::)操作 我们知道使用lambda表达式可以让代码非常简洁。举例,创建比较器,使用下面语法: Comparator c = (Computer c1, Computer ...
  • 以下是对c++中冒号和双冒号的用法进行了介绍,需要的朋友可以过来参考下
  • 本博客部分参考: ... ... 我们在遍历一个list列表中常常用到的方法是: for(String s:list){ System.out.println(s); } 他进一步使用Lambda表达式优化得到: list.forEach(s->Sy
  • 双冒号(::)运算符是跟函数式接口相关的运算符,作为函数式接口的赋值操作。 双冒号用于静态方法 使用方法:将类的静态方法赋值给一个函数式接口,静态方法的参数个数、类型要跟函数式的接口一致。调用这个函数...
  • java 双冒号用法

    千次阅读 2020-08-29 17:36:48
    JDK8中有双冒号的用法,形如Class::methodname,符号左边是调用方法所处的类名,符号右边是调用的静态方法。简单的说,就是逐一传入参数值到某个类的静态方法并调用该静态方法。 以前的方式 public static void ...
  • java中lambda表达式双冒号::的使用

    千次阅读 2019-11-20 15:06:38
    1:当 ::前面为一个类名,后面跟一个静态方法时,如下所示,此时等号左边的函数式接口中的方法和静态方法签名一致即可,即方法参数个数和类型一致,如果左边的函数式接口中的方法返回值不是void则要求右边lambda静态...
  • 一直搞不明白双冒号运算要怎么使用,今天在《Java8实战》中看到相关内容,讲解的比较详细,参考这篇文章,总结一下,希望能帮助大家,如果有兴趣,也可以直接看《Java8实战》这本书 双冒号运算就是Java中的方法引用...
  • Java8新特性2:方法引用--深入理解双冒号::的使用

    千次阅读 多人点赞 2019-10-16 15:49:37
    java8允许我们使用lambda表达式创建匿名方法。但有时lambda表达式除了调用现有方法之外什么也不做。在这些情况下,通过名称引用现有的方法,通常能更直白的表现出方法的调用过程。对于已经存在的且具有方法名称的...
  • python中双冒号[::]的使用

    千次阅读 2019-09-22 11:06:46
    1. range(n)生成[0,n)区间的整数 (左闭右开) 2.a[start:end:step] [start,end) (左闭右开) 3.当step等于负数的时候,从右向左取数。注意:numpy支持负数,torch.tensor不支持 ...4.a[:end]:取得范围为[0,end)...
  • 双冒号规则就是使用“::”代替普通规则的“:”得到的规则。当同一个文件作为多个规则的目标时,双冒号规则的处理和普通规则的处理过程完全不同(双冒号规则允许在多个规则中为同一个目标指定不同的重建目标的命令)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 62,622
精华内容 25,048
关键字:

双冒号如何使用