1.java中什么是函数的signature,2.java中什么是enclosing method

1.java中什么是函数的signature,2.java中什么是enclosing method
1.java中什么是函数的signature,2.java中什么是enclosing method

1.java中什么是函数的signature,2.java中什么是enclosing method

方法的签名可以唯一的确定这个函数

方法签名由方法名称和一个参数列表(方法的参数的顺序和类型)组成

比如：void test();和void test(int i)是两个不同的方法,但是int test()和float test()是相同的,java会报错的,因为同个类中有两个相同的方法

下面仅仅测试如果返回值不同的情况,如果是参数列表和方法名不同,它们是不同的方法,没有什么好测试的：

public class Test {
\x09//Duplicate method test() in type Test
\x09public void test(){}
\x09public int test(){}
}

测试一下如果继承的子类的返回类型是不同,结果如何：

public class Test {
\x09public void test(){}
}

看看子类的情况：

public class SubTest extends Test{
\x09//The return type is incompatible with Test.test()
\x09float test(){}
}

2.JAVA中的闭包.

　　在JAVA中,闭包是通过“接口+内部类”实现,像C#的delegate一样,JAVA的内部类也可以有匿名内部类.我们现在就来详细认识一下JAVA内部类.

1、内部类.

　　顾名思义,内部类就是将一个类定义在另一个类的内部.在JAVA中,内部类可以访问到外围类的变量、方法或者其它内部类等所有成员,即使它被定义成private了,但是外部类不能访问内部类中的变量.这样通过内部类就可以提供一种代码隐藏和代码组织的机制,并且这些被组织的代码段还可以自由的访问到包含该内部类的外围上下文环境.

这里提供了一个例子展示这种机制：

public interface ILog {
\x09 public void Write(String message);
}
public class DemoClass1 {
    private int length =0;

    //private|public
    private class InnerClass implements ILog
    {
        @Override
        public void Write(String message) {
            //DemoClass1.this.length = message.length();
            length = message.length();
            System.out.println("DemoClass1.InnerClass:" + length);
        }
    }
    
    public ILog logger() {
        return new InnerClass();
    }
 
    public static void main(String[] args){
        DemoClass1 demoClass1 = new DemoClass1();
        demoClass1.logger().Write("abc");
        
        //.new
        DemoClass1 dc1 = new DemoClass1();
        InnerClass ic = dc1.new InnerClass();
        ic.Write("abcde");
    }
}

如果你用过javascript的,肯定是很不喜欢这种模仿的实现

1.2、.this

 

　　如何通过this显式引用外围类的变量?通过此格式进行引用：{外围类名}.this.{变量名称}.如：

　　DemoClass1.this.length = message.length();

 

2、局部内部类.

　　局部内部类是指在方法的作用域内定义的的内部类.

public class DemoClass2 {
    private int length =0;

    public ILog logger() {
        //在方法体的作用域中定义此局部内部类
        class InnerClass implements ILog
        {
            @Override
            public void Write(String message) {
                length = message.length();
                System.out.println("DemoClass2.InnerClass:" + length);
            }
        }
        return new InnerClass();
    }
}

因为InnerClass类是定义在logger()方法体之内,所以InnerClass类在方法的外围是不可见的.

 

3、匿名内部类.

　　顾名思义,匿名内部类就是匿名、没有名字的内部类,通过匿名内部类可以更加简洁的创建一个内部类.

public class DemoClass3 {
    private int length =0;
    
    public ILog logger() {
    return new ILog() {
        @Override
        public void Write(String message) {
              length = message.length();
              System.out.println("DemoClass3.AnonymousClass:" + length);
        }
    };
    }
}

由此可见,要创建一个匿名内部类,可以new关键字来创建.

 

格式：new 接口名称(){}

格式：new 接口名称(args...){}

4、final关键字.

　　闭包所绑定的本地变量必须使用final修饰符,以表示为一个恒定不变的数据,创建后不能被更改.

public class DemoClass4 {
\x09private int length = 0;

\x09public ILog logger(int level) {//final int level
        //final
        final int logLevel = level+1;
        
        switch(level)
        {
            case 1:
                return new ILog() {
                    @Override
                    public void Write(String message) {
                        length = message.length();
                        System.out.println("DemoClass4.AnonymousClass:InfoLog " + length);
                        System.out.println(logLevel);
                    }
                };    
            default:
            return new ILog() {
                @Override
                public void Write(String message) {
                    length = message.length();
                    System.out.println("DemoClass4.AnonymousClass:ErrorLog " + length);
                    System.out.println(logLevel);
                }
            };
                
        }
    }

\x09public static void main(String[] args) {
\x09\x09DemoClass4 demoClass4 = new DemoClass4();
\x09\x09demoClass4.logger(1).Write("abcefghi");
\x09}

}

从例子中可以看到,logger方法接受了一个level参数,以表示要写的日志等级,这个level参数如果直接赋给内部类中使用,会导致编译时错误,提示level参数必须为final,这种机制防止了在闭包共享中变量取值错误的问题.解决方法可以像例子一样在方法体内定义一下新的局部变量,标记为final,然后把参数level赋值给它： 

 

 final int logLevel = level ;

或者直接参数中添加一个final修饰符：

   public ILog logger(final int level {

 

5、实例初始化.

　　匿名类的实例初始化相当于构造器的作用,但不能重载.

public ILog logger(final int level) throws Exception {
        
        return new ILog() {
            {
                //实例初始化,不能重载 
                if(level !=1)
                    throw new Exception("日志等级不正确!");
            }
            
            @Override
            public void Write(String message) {
                length = message.length();
                System.out.println("DemoClass5.AnonymousClass:" + length);
            }
        };
    }