接口和内部类

忘是亡心i 2022-07-10 23:56 205阅读 0赞

接口中的所有方法自动地属于public。因此，在接口中声明方法时，不必提供关键字public。接口绝不能含有实例域，也不能在接口中实现方法。接口中的域将被自动设为public static final就是常量，在实现接口时，必须把方法声明为public；否则，编译器将认为这个方法的访问属性是包可见性，即类的默认访问属性。

接口不能实例化，但是可以声明变量，变量必须引用实现了接口的类对象。比如A是一个接口，Aa = new B();B必须实现了A。好像多态啊。

接口可以继承，类可以实现实现多个接口，只能继承一个类。instanceof可以用来判断是不是实现了接口。

拷贝是两个实例引用同一个对象，改变其中一个会另一个有影响。clone克隆是引用不同的对象,但是这两个实例的相等的，只要实例中没有可改变的子对象，那改变其中一个不会对另一个产生影响，子对象也用clone()方法就可以解决有可变子对象的情况。

对于类可以判断1.默认的clone方法是否满足要求。2.默认的clone方法是否能够通过调用可变子对象的clone得到修补。3.是否不应该使用clone.实际上，选项3是默认的。如果要选择1或2，类必须：实现Cloneable接口，使用public访问修饰符重新定义clone方法（Object类中的clone方法声明为protected）。

如果默认的clone()就可以实现的话，实现clone()方法就直接调用super.clone()就行了。

有子对象：

public xxx clone() throws xxx\{抛出CloneNot-SupportException

xxx a = (xxx)super.clone();返回object

a.b = (b的类型)b.clone();b是可变子对象，string不可变。

return a;

需要谨慎使用克隆。数组也有clone(),public类型的

内部类

普通内部类声明：B是A的内部类，Aa =new A();A.B b = a.new B();

1.内部类方法可以访问该类定义所在的作用域中的数据，包括私有的数据

2.内部类可以对同一个包中的其他类隐藏起来。

3.当想要定义一个回调函数且不想编写大量代码时，使用匿名（ anonymous）内部类比较便捷。

局部类不能用public或private访问说明符进行声明。它的作用域被限定在声明这个局部类的块中。局部类有一个优势，即对外部世界可以完全地隐藏起来。局部类访问局部变量，那些局部变量必须被声明为final。

由于构造器的名字必须与类名相同，而匿名类没有类名，所以，匿名类不能有构造器。取而代之的是，将构造器参数传递给超类（superclass）构造器。尤其是在内部类实现接口的时候，不能有任何构造参数，因为没有没有构造函数。

在内部类不需要访问外围类对象的时候，应该使用静态内部类。

声明在接口中的内部类自动成为static和public。

实现comparable接口，里面有compareTo();可以重写比较。

代理

利用代理可以在运行时创建一个实现了一组给定接口的新类。这种功能只有在编译时无法确定需要实现哪个接口时才有必要使用。

代理类要实现指定接口所需要的全部方法。Object类中的全部方法，例如， toString、 equals等。

代理类是在程序运行过程中创建的。所有的代理类都扩展于Proxy类。一个代理类只有一个实例域—调用处理器，它定义在Proxy的超类中。为了履行代理对象的职责，所需要的任何附加数据都必须存储在调用处理器中。  
对于特定的类加载器和预设的一组接口来说，只能有一个代理类。也就是说，如果使用同一个类加载器和接口数组调用两次newProxyInstance方法的话，那么只能够得到同一个类的两个对象。

代理类一定是public和final。如果代理类实现的所有接口都是public，代理类就不属于某个特定的包；否则，所有非公有的接口都必须属于同一个包，同时，代理类也属于这个包。可以通过调用Proxy类中的isProxyClass方法检测一个特定的Class对象是否代表一个代理类。

下面的例子使用代理对象对二分查找进行跟踪

package test;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.util.Arrays;
    import java.util.Random;
    public class Test{
    	public static void main(String[] args) {
    		Object[] element = new Object[1000];
    		for(int i=0;i<element.length;i++){
    			Integer value=i+1;
    			InvocationHandler handler = new T(value);
    			Object proxy = Proxy.newProxyInstance(null, new Class[]{Comparable.class},handler);
    			element[i]=proxy;
    		}
    		Integer key = new Random().nextInt(element.length)+1;
    		int result = Arrays.binarySearch(element, key);
    		if(result>=0)
    			System.out.println(element[result]);
    	}
    }
    
      class T implements InvocationHandler {
    	private Object target;
    	T(Object a){
    		target = a;
    	}
    	
    	public Object invoke(Object proxy,Method m,Object[] args)throws Throwable{
    		System.out.print(target);
    		System.out.print(","+m.getName()+"(");
    		if(args!=null){
    			for(int i=0;i<args.length;i++){
    				System.out.print(args[i]);
    				if(i<args.length-1){
    					System.out.print(",");
    				}
    			}
    		}
    		System.out.println(")");
    		return m.invoke(target, args);
    	}
    	
    }

结果为

500,compareTo(187)
    250,compareTo(187)
    125,compareTo(187)
    187,compareTo(187)
    187,toString()
    187

代理类实现了comparable接口，所以invoke就是compareTo方法。