首页 > 代码库 > Java 接口

Java 接口

2024-10-08 08:52:01   221人阅读

接口的方法默认死public，接口的属性默认为public static final。

为什么要接口，而不是使用抽象类。一个对象只能继承一个类，却可以实现多个接口。

 

clone：

Object的浅拷贝

Object类的默认拷贝机制是浅拷贝：对于拷贝对象的属性：基本类型属性，拷贝值，对象属性，拷贝引用。

Object将clone设为protected方法，无法在外部调用。如果要使用，必须在使用的类里，将它设置为public。如下：

  1. @Override
  2.    public Person clone() throws CloneNotSupportedException {
  3.       return (Person)super.clone();
  4.    }

关于CloneNotSupportedException：

当调用 Object 类中的 clone 方法克隆对象，但该对象的类无法实现 Cloneable 接口时，抛出该异常。

重写 clone 方法的应用程序也可能抛出此异常，指示不能或不应克隆一个对象。

所以，还要在类的声明中加入implements Cloneable。

上面说的都是调用Object的默认clone的限制，如果你自己写Clone方法，是不会抛出CloneNotSupportedException异常的。如：

  1. @Override
  2.    public Person clone() {
  3.       Person p = new Person(this.id);
  4.       return p;
  5.    }

关于Cloneable 接口

此类实现了 Cloneable 接口，以指示 Object.clone() 方法可以合法地对该类实例进行按字段复制。

如果在没有实现 Cloneable 接口的实例上调用 Object 的 clone 方法，则会导致抛出 CloneNotSupportedException 异常。

按照惯例，实现此接口的类应该使用公共方法重写 Object.clone（它是受保护的）。请参阅 Object.clone()，以获得有关重写此方法的详细信息。

注意，此接口不包含 clone 方法。因此，因为某个对象实现了此接口就克隆它是不可能的。即使 clone 方法是反射性调用的，也无法保证它将获得成功。

所以，Cloneable是标记接口。

 

深拷贝

如果要实现深拷贝，就要手动会所有可变的对象属性进行克隆。

数组克隆

所有的数组都包含了一个clone方法，这个方法是public的，可以通过它对数组克隆。

 

内部类

内部类(inner class)是定义在另一个类中的类.为什么需要使用内部类呢?其主要原因有以下三点:

  • 内部类方法可以访问该类定义所在的作用域中的数据,包括私有数据.
  • 内部类可以对同一个包中的其他类隐藏起来.
  • 当想要定义一个回调函数且不想编写大量代码时,使用匿名(annoymous)内部类比较便捷.

只有内部类可以是私有类,而常规类只可以具有包可见性,或公有可见性.

内部类可以访问外部类的属性。即使是私有的。也可以直接访问，不需要this或者super这种。

内部类的特殊语法规则

内部类其实维护了一个外部类的引用。所以可以访问外部类的属性。

我们可以在内部类里使用OuterClass.this 来访问外部类的引用。

 

内部类是一种编译器现象,与虚拟机无关.编译器将会把内部类翻译成用$分隔外部类名与内部类名的常规类文件,而虚拟机则对此一无所知.

 

局部内部类

可以在一个方法中定义局部类.

  1. public void start()  
  2. {  
  3.     class TimePrinter implements ActionListener  
  4.     {  
  5.         public void actionPerformed(ActionEvent event)  
  6.         {  
  7.             Date now = new Date();  
  8.             System.out.println("At the tone, the time is " + now);  
  9.             if (beep)  
  10.                 Toolkit.getDefaultToolkit().beep();  
  11.         }  
  12.     }  
  13.     ActionListener listener = new TimePrinter();  
  14.     Timer t = new Timer(interval, listener);  
  15.     t.start();  
  16. }  

局部类不能用 public 或 private 访问说明符进行声明,它的作用域被限定在声明这个局部类的块中.

局部类有一个优势,即对外部世界可以完全地隐藏起来.即使TalkingClock类中的其他代码也不能访问它.

 

 

与其他内部类相比较,局部类还有一个优点,它们不仅能够访问它们的外部类,还可以访问局部变量.不过那些局部变量必须被声明为 final,下面是一个典型的示例.这里,将TalkingClock构造器的参数interval和beep移至start方法中.

  1. public void start(int interval, final boolean beep)  
  2. {  
  3.     class TimePrinter implements ActionListener  
  4.     {  
  5.         public void actionPerformed(ActionEvent event)  
  6.         {  
  7.             Date now = new Date();  
  8.             System.out.println("At the tone, the time is " + now);  
  9.             if (beep)  
  10.                 Toolkit.getDefaultToolkit().beep();  
  11.         }  
  12.     }  
  13.     ActionListener listener = new TimePrinter();  
  14.     Timer t = new Timer(interval, listener);  
  15.     t.start();  
  16. }  

    请注意,TalkingClock类不再需要存储实例变量beep了,它只是引用start方法中的beep参数变量.
    这看起来好像没什么值得大惊小怪的,程序

  1. if (beep) ...  

    毕竟在start方法内部,为什么不能访问beep变量的值呢?仔细看一下调用流程:
    1.调用start方法
    2.调用内部类TimePrinter的构造器,以便初始化对象变量listener
    3.将listener引用传递给Timer构造器,定时器开始计时,start方法结束.此时start方法的beep参数变量不复存在.
    4.然后,actionPerformed方法执行 if(beep) ...
    为了能够让actionPerformed方法工作,TimePrinter类在beep域释放之前将beep域用start方法的局部变量进行备份.实际上也是这样做的.
    局部类的方法只可以引用定义为 final 的局部变量.鉴于此情况,在列举的实例中,将beep参数声明为 final,对它进行初始化后不能够再进行修改,因此,就使得局部变量与局部类内建立的拷贝保持一致.

 

个人理解：因为局部变量在局部方法块结束之后就结束了它的生命，但是内部类其实是可以作为参数传递给外部的对象。所以把局部变量设置为final，所以其实内部类在引用外部的局部变量的时候，是引用的副本，我们对副本进行修改是不能映射到原始版本的，为了避免逻辑混乱，就把原始版本设置为final，不能修改它。

 

匿名局部类

将局部内部类的使用再深入一步,假如只创建这个类的一个对象,就不必命名了.这种被被称为匿名内部类(annoymous inner class).

匿名内部类，是一种局部内部类。所以也有局部内部类的特征。

 

静态内部类

如果使用内部类只是为了把一个类隐藏在另外一个类的内部,并不需要内部类引用外围类对象.为此,可以将内部类声明为 static,以便取消产生的引用.

静态内部类的不能对生成它的外围类对象的引用，因为它不是对象生成的，是属于包围它的类的。

注释:在内部类不需要访问外围类对象的时候,应该使用静态内部类.
注释:声明在接口中的内部类自动称为 static 和 public 类.

代理

 利用代理(proxy)可以在运行时创建一个实现了一组给定接口的新类.这个功能只有在编译时无法确定需要实现哪个接口时才有必要使用.对于应用程序设计人员来说,遇到这种情况的机会很少.但对于系统程序设计人员来说,代理带来的灵活性非常重要.
    假设有一个表示接口的Class对象,它的确切类型在编译时无法知道.这确实有些难度.要想构造一个实现这些接口的类,就需要使用newInstance方法或反射找出这个类的构造器.但是,不能实例化一个接口,需要在程序处于运行状态时定义一个新类.
    为了解决这个问题,有些程序将生成代码;将这些代码放置在一个文件中;调用编译器,然后再加载结果类文件.但这样做的速度会比较慢,并且需要将编译器与程序放在一起.而代理机制则是一种更好的解决方案.代理类可以在运行时创建全新的类.这样的代理类能够实现指定的接口.尤其是,它具有下列方法:
    指定接口所需要的全部方法
    Object类中的全部方法,例如,toString,equals等
    然而,不能在运行时定义这些方法的新代码,而是要提供一个调用处理器(invocation handler).调用处理器是实现了InvocationHandler接口的类对象.在这个接口中只有一个方法:

  1. Object invoke(Object proxy, Method method, Object[] args);  

    无论何时调用代理对象的方法,调用处理器的invoke方法都会被调用,并向其传递Method对象和原始的调用参数.

Java 接口


联系
我们