精华内容
下载资源
问答
  • public class FuXi2 { public static void main(String[] args) ...* 所以可以直接通过类名引用静态方法 * 个人理解:只要lambda表达式中有对象在调用方法可以使用方法引用来简化lambda表达式*/ } private...
    
    
    public class FuXi2 {
    
        public static void main(String[] args) {
    
            demo01(Integer::valueOf,"222222222");//方法引用简化了lambda表达式
    /*Integer对象存在  valueOf静态方法也存在
    * 所以可以直接通过类名引用静态方法
    * 个人理解:只要lambda表达式中有对象在调用方法 就可以使用方法引用来简化lambda表达式*/
    
        }
    
    
        private static void demo01(Jiekou a, String w) {
            Integer.valueOf(w);//通过类名调用静态方法
            a.method(w);//将w传入a接口里面的方法中
            System.out.println(w);//打印最终的w
        }
    
    }
    
    
    
    
    
    
    

    展开全文
  • 通过对象名引用成员方法 使用前提是对象名已经存在了,成员方法也是已经存在的 就可以使用对象名引用成员方法 Printable 函数式接口 package Demo22; /* 定义一个打印的函数式接口 */ @FunctionalInterface ...

    1.对象名引用

    引用对对象和方法都存在的 起到优化Lambda的作用

    通过对象名引用成员方法
    使用前提是对象名已经存在了,成员方法也是已经存在的
    就可以使用对象名来引用成员方法
    Printable 函数式接口
    package Demo22;
    /*
    定义一个打印的函数式接口
     */
    @FunctionalInterface
    public interface Printable {
        //打印字符串
       public abstract  void print(String s);  //注意public abstract可以省略
    }
    
    MethodRerObject类中成员方法
    package Demo22;
    
    public class MethodRerObject {
        //定义一个成员方法,传递一个字符串,把字符串按照大写输出
        public void printUpperCaseString(String str){
            System.out.println(str.toUpperCase());
        }
    }
    

    psvm

    package Demo22;
    /*
    通过对象名引用成员方法
    使用前提是对象名已经存在了,成员方法也是已经存在的
    就可以使用对象名来引用成员方法
     */
    public class Demo01ObjectMethodRerObject {
        //定义一个方法,方法的参数传递Printable接口
        public static void printString(Printable p){
            p.print("Hello");
        }
    
        public static void main(String[] args) {
            //调用printString方法 方法的参数Printable
            printString((String s )->{
                //创建MethodRerObject对象
                MethodRerObject obj = new MethodRerObject();
                //调用MethodRerObject中的成员方法,把字符串按照大写输出
                obj.printUpperCaseString(s);
            });
            /*
            使用方法引用优化Lambda
            对象时已经存在的MethodRerObject
            成员方法也是已经存在的printUpperCaseString
            所以我们可以使用对象名引用成员方法
             */
            MethodRerObject obj = new MethodRerObject();
            printString(obj::printUpperCaseString);
        }
    }
    

    输出

    2.类名引用静态成员方法

    使用前提:

    1.类已经存在   2.静态成员方法也已经存在

    通过类名引用静态成员方法
    类已经存在,静态方法也已经存在
    就可以通过类名直接引用静态成员方法

    函数类接口

    package Demo22;
    @FunctionalInterface
    public interface Calculate {
        //定义一个抽象方法,传递一个整数,对整数进行绝对值计算并返回
        int calcAbs(int number);
    }
    

    psvm

    package Demo22;
    
    import Demo07.Calculator;
    import com.sun.jdi.PathSearchingVirtualMachine;
    
    /*
    通过类名引用静态成员方法
    类已经存在,静态方法也已经存在
    就可以通过类名直接引用静态成员方法
    
     */
    public class Demo02StaticMethodReference {
        //定义一个方法,方法的参数传递要计算绝对值的整数和函数式接口
        public static int method(int number, Calculate c){
        return c.calcAbs(number);
        }
    
        public static void main(String[] args) {
            int n = method(-10,(int nn)->{
                //对参数进行绝对值的计算并返回结果
                return Math.abs(nn);  //Math数学工具类中的abs方法取绝对值 是一个静态方法
            });
            System.out.println(n);
         /*
         使用方法引用优化Lambda表达式
         Math类是已经存在的
         abs这个静态方法是已经存在的
         所以我们可以直接通过类名引用静态方法
         */
            int number2 = method(-10, Math::abs);
            System.out.println(number2);
        }
    }
    

    输出

    10

    10

    3.super引用父类的成员方法

    函数式接口

    package Demo22;
    /*
    定义见面的函数式接口
     */
    @FunctionalInterface
    public interface Greetable {
        //定义一个见面的方法
        void greet();
    }
    

    父类

    package Demo22;
    /*
    定义父类
     */
    public class Human {
        //定义一个sayHello
        public void sayHello(){
            System.out.println("Hello 我是Human");
        }
    }
    

    子类 psvm

    package Demo22;
    
    /*
    定义子类
     */
    public class Man extends Human {
        //子类重写父类的sayHello方法
        @Override
        public void sayHello() {
            System.out.println("Hello 我是man");
        }
    
        //定义一个方法参数传递Greetable接口
        public void method(Greetable g) {
            g.greet();
        }
    
        public void show() {
            //调用method方法,方法的参数Greetable是一个函数式接口,所以可以传递Lambda
      /*  method(()->{
            //创建父类Human对象
            Human h = new Human();
            h.sayHello();
        });*/
        /*
        因为有子父类关系所以存在一个关键字super 代表父类
        所以我们可以直接使用super调用父类的成员方法
         */
            method(() -> {
                super.sayHello();
            });//此代码与上面表达意思一样
            //继续简化  使用super引用父类的成员方法 super是已经存在的 父类的成员方法sayHello也是存在的所以我们可以直接使用super引用父类的成员方法
            // method(super::sayHello);//此代码与上面表达意思一样
        }
    
        public static void main(String[] args) {
            new Man().show();
        }
    }
    

    输出 Hello 我是Human

    4.this引用本类的成员方法

    this是直接可以使用本类的方法和变量

    Richable函数式接口类

    package Demo22;
    /*
    定义一个富有的函数式接口
     */
    @FunctionalInterface
    public interface Richable {
        //定义一个想买什么就买什么的方法
        void buy();
    }
    

    Husband    psvm

    package Demo22;
    /*
    通过this来引用本类的成员方法
     */
    public class Husband {
        //定义一个买房子的成员方法
        public void buyHouse(){
            System.out.println("有钱北京二环内一套四合院");
        }
        //定义一个结婚的方法,参数传递Richable方法
        public void marry(Richable r){
            r.buy();
    
        }
        //定义一个非常高兴的方法
        public void soHappy(){
            //调用结婚的方法,方法的参数Richable是一个函数式接口,所以可以传递Lambda表达式
            marry(()->{
                //使用this.成员方法调用本类买房子的方法
                this.buyHouse();
            });
            //使用方法引用优化Lambda表达式
            //this已经存在 本类的成员方法buyHouse也是已经存在的所以我们可以直接使用this来引用本的成员方法buyHouse
            marry(this::buyHouse); //与上面代码意思相同
        }
    
        public static void main(String[] args) {
            new Husband().soHappy();
        }
    }
    

    输出:有钱北京二环内一套四

    展开全文
  • In the following code snippet, presumably it appears that it should issue some compilation error but it doesn't:class Outer {public static class Inner {static String obj = "Inner";...

    In the following code snippet, presumably it appears that it should issue some compilation error but it doesn't:

    class Outer {

    public static class Inner {

    static String obj = "Inner";

    }

    static Optional Inner = new Optional();

    //The (inner) class name and the object name are same.

    }

    class Optional {

    String obj = "Optional";

    }

    public class Main {

    public static void main(String[] args) {

    System.out.println(Outer.Inner.obj);

    //Refers to the string inside the optional class

    }

    }

    The class Outer has a static class inside it named Inner. Additionally, it declares an object (static) of the class Optional (static Optional Inner = new Optional();)

    This object and the class names (inside the class Outer) are same which is Inner. The program displays Optional. The only expression Outer.Inner.obj within main() is expected to display Inner but it doesn't. The actual output is however Optional which is the case of the Optional class.

    One way to display Inner is by changing the object name to something else.

    static Optional Inner1 = new Optional();

    From the output it displays, it appears that the object name (or a variable) is chosen over a type name (the class Inner) because they have the same name. What exact case is applied here?

    解决方案

    Paragraph 6.4.2 of the Java Language Specification has some information about the rules that apply in this case.

    A simple name may occur in contexts where it may potentially be interpreted as the name of a variable, a type, or a package. In these situations, the rules of §6.5 specify that a variable will be chosen in preference to a type, and that a type will be chosen in preference to a package. Thus, it is may sometimes be impossible to refer to a visible type or package declaration via its simple name. We say that such a declaration is obscured.

    This refers to paragraph 6.5 Determining the Meaning of a Name, which explains the rules in detail.

    In your example, Outer.Inner could refer to the type of the nested class named Inner, or the static member variable Inner. The rules say the variable will be chosen over the type.

    展开全文
  • 技巧: compare(T t1,T t2)方法的第一个参数t1,作为调用compareTo(t2)方法对象, Comparator com2 = String :: compareTo; System.out.println(com2.compare(“abd”,“abm”)); // 情况三:类 :: 实例方法 (有...

    // 类 :: 实例方法
    Comparator中的 int comapre(T t1,T t2)
    String中的 int t1.compareTo(t2)
    技巧: compare(T t1,T t2)方法的第一个参数t1,作为调用compareTo(t2)方法的对象,
    Comparator com2 = String :: compareTo;
    System.out.println(com2.compare(“abd”,“abm”));

    // 情况三:类 :: 实例方法  (有难度)
    	// Comparator中的 int comapre(T t1,T t2)
    	// String中的 int t1.compareTo(t2)
    	// 技巧: compare(T t1,T t2)方法的第一个参数t1,作为调用compareTo(t2)方法的对象,
    	//      Comparator<String> com2 = String :: compareTo;
    	//		System.out.println(com2.compare("abd","abm"));
    	@Test
    	public void test5() {
    		Comparator<String> com1 = (s1,s2) -> s1.compareTo(s2);
    		System.out.println(com1.compare("abc","abd"));
    
    		System.out.println("*******************");
    
    		Comparator<String> com2 = String :: compareTo;
    		System.out.println(com2.compare("abd","abm"));
    	}
    
    	//BiPredicate中的boolean test(T t1, T t2);
    	//String中的boolean t1.equals(t2)
    	@Test
    	public void test6() {
    		BiPredicate<String,String> pre1 = (s1,s2) -> s1.equals(s2);
    		System.out.println(pre1.test("abc","abc"));
    
    		System.out.println("*******************");
    		BiPredicate<String,String> pre2 = String :: equals;
    		System.out.println(pre2.test("abc","abd"));
    	}
    	
    	// Function中的R apply(T t)
    	// Employee中的String getName();
    	@Test
    	public void test7() {
    		Employee employee = new Employee(1001, "Jerry", 23, 6000);
    
    
    		Function<Employee,String> func1 = e -> e.getName();
    		System.out.println(func1.apply(employee));
    
    		System.out.println("*******************");
    
    
    		Function<Employee,String> func2 = Employee::getName;
    		System.out.println(func2.apply(employee));
    
    
    	}
    
    
    展开全文
  • try {//得到对象Class c = Class.forName("完整类名");Object yourObj = c.newInstance();//得到方法Method methlist[] = cls.getDeclaredMethods();for (int i = 0; i < methlist.length; i++) {Method m = ...
  • 当我想参考当前范围内的方法时,我仍然需要指定类名(对于静态方法)之前::操作符.例如,我需要写:import java.util.stream.Stream;public class StreamTest {public static int trimmedLength(String s) {return s....
  • 因为该类的静态方法是程序启动时自动放在内存中了的,是属于程序的公共内存(但只能访问),而类名在这里你可以理解为命名空间。 先通俗的分析下,我们把类看作是一个房子。房子里面有家具,桌椅板凳之类的,房子里面...
  • 我是初学者,最近看到了下面的代码: public class ActivityCollector {public static List ...不是应该先定义一个对象,然后引用对象吗?像这样: ActivityCollector A; A.addActivity(this); 谢谢解答!
  • 【填空题】类中的 方法是一个特殊的方法,该方法方法名类名相同。【填空题】当程序中需要引用 java.awt.event 包中的类时,导入该包中类的语句为______【单选题】已知如下代码: switch(m){ case 0: System.out....
  • “::”符号可以方法名对象或类的名称分开。实例方法引用引用任何类的实例方法。 在下面的示例中,我们可以使用类名实现实例方法引用。语法::示例importjava.util.*;;importjava.util.function.*;...
  • Naive attempts fail: e.g.from mypackage import SomeClass$givesjavax.script.ScriptException: SyntaxError: no viable alternative at character '$' in at line number 1This question is unrelated to java n....
  • 前言在我们开发过程中常常有一个需求,就是要知道实体类中Getter方法对应的属性名称(Field Name),例如实体类属性到数据库字段的映射,我们常常是硬编码指定 属性,这种硬编码有两个缺点。1、编码效率低:因为要硬...
  • 为什么构造方法名却是Car?我看见很多教程都是这么写的。晕。。。。。。。。。。。到底怎么样才是对的啊?public class TestCar_EX {public static void main(String[] args) {Car c1 = new Car("red", "xxx");}}...
  • Java中类名+方法的含义

    千次阅读 2020-12-29 11:09:48
    可以通过类名+方法名调用的方法叫做静态方法,属于类级别方法. 类方法可在不实例化对象的前提下调用. 一般类的静态方法和静态变量都是通过static关键字修饰的. 而且静态方法体里不能应用任何实例变量和实例方法, 至于...
  • 在类的作用域之外,普通的成员只能通过对象可以对象本身,也可以对象指针或对象引用)来访问,静态成员既可以通过对象访问,又可以通过类访问。 转载自:http://c.biancheng.net/view/vip_2234.html 类其实...
  • 访问时,类方法可以直接通过类名引用,而实例方法必须通过对象名来访问,也就是说要想使用实例方法,就必须创建一个该类的对象。Math类的方法都是类方法,在使用时,可以如下:double s=Math.sin(30);Properties ...
  • 有的时候我们想把代码中某个变量名或类名改一下但是如果改了,那好多地方都要一起改如果把所有都一个一个改的话会很浪费时间所以我们需要一些同时更改所有相同的变量名或类名方法多光标我们可以使用多光标选中所有...
  • 当父类和子类有同名的静态方法时, 声明父类变量引用子类实例, 调用该静态方法时候调用的是父类的静态方法, 而非子类的静态方法. 即: 父类和子类有同名非静态方法: 重写 父类和子类有同名静态方法: 隐藏 ...
  • 【单选题】设有两个类A、B,以下描述中表示B继承自A的是( ) 【判断题】有时候为了避免引起混淆,构造方法方法名可以不与所属类名同名。 【单选题】一下关于面向对象概念的描述中,不正确的一项是() 【单选题】下列...
  • 正常的得到类明的方法是:String clazz = this.getClass().getName();但这种方法无法在下面静态方法中使用public static void main(String[] args){//...}那么在main中就不能得到类的名称下面的类解决了这个难题...
  • header("content-type:text/html;charset=utf-8");classHuman{staticpublic$name="李四";//定义静态属性public$height=175;staticpublicfunctiontell(){echoself::$name;//静态方法调用静态属性,使用...
  • 说明:1....通过class对象创建实体类看本文补充部分Class对象的生成方式如下:1.类名.class 说明: JVM将使用类装载器, 将类装入内存(前提是:...返回Class的对象2.Class.forName(“类名字符串”) (注:类名字符串是包...
  • Java8-8-方法引用详解

    2021-03-10 02:45:40
    方法引用是lambda表达式的一种特殊形式,如果正好有某个方法满足一个lambda表达式的形式,那就可以将这个lambda表达式用方法引用的方式表示,但是如果这个lambda表达式的比较复杂就不能用方法引用进行替换。...
  • 通过Js更改元素标签类名

    千次阅读 2021-04-27 14:42:06
    setAttribute()方法是创建或者改变元素的某个属性,我们可以利用这个方法对元素的类名进行更改。具体方法是这样的 el.setAttribute(“class”,“classname”) <div id="box"></div> <scri
  • 类和对象引用 类和对象以及引用 类的定义 class 类名 { 类体; } 注意 通常情况下,当类名由多个单词组成时,要求每个单词首字母都要大写(大驼峰命名法) 因为类的本质是数据类型,而不是数据,所以不存在于...
  • 1. 方法引用介绍 2. 方法引用的5种类型 2.1 对象引用::实例方法名 2.2 类名::静态方法名 2.3 类名::实例方法名 2.4 类名::new 2.5 类名[]::new 3. 相关链接
  • 实例化对象调用方法,你就会发现使用接口 对象名 = new 类名; 方式实例化的对象只能调用接口中有的方法,而不能调用类中特有的方法。而使用类名 对象名 = new 类名;方式创建出来的对象可以调用所有的方法 但要是我...
  • I have seen some programmers using _ (underscore) in front of class names, and others using it for local variables.Does the Java standard require/suggest the use of _ (underscore) in front of an priva...
  • Kotlin 使函数和属性成为该语言的一级公民,而内省它们(即在运行时学习属性函数的名称类型)与简单地使用函数响应式风格紧密相连。 在 JavaScript 平台上,目前只支持类引用。更多信息请了解 Kotlin/JS 的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 224,526
精华内容 89,810
关键字:

方法可以通过对象名或类名引用