概念

表示一类事物可以干什么，如：有生命的，可移动的
接口的目的是指明相关或者不想关的多个对象共同的行为
接口体现了程序设计的多态和高内聚低耦合的设计思想
接口命名时建议采用 可以什么的，提供什么的，有什么能力的

基本语法

接口声明

【修饰符】interface 接口名称{}

继承接口

【修饰符】interface 子接口名称 extends 父接口名称1，父接口名称2，…{}

实现接口

【修饰符】 class 类名 implement 接口名1，接口名2，… {}

特点

接口不是类，没有构造方法，不能实例化
接口之间的继承也是使用extends实现，但接口可以继承多个父类接口
接口中所有的方法（无方法体的方法）都是public abstract修饰的
所有的接口都是抽象的。
接口中只能声明常量（所有的成员变量默认都是 public static final修饰的）

从Java8开始允许在接口中定义static修饰的方法

访问修饰符可以是public或者private
不可以是protected或默认

一个接口可以继承多个父接口
当一个接口继承多个父接口时，父接口之间用逗号隔开

实现接口的类除了可以调用接口中的方法，还可以调用object方法。

举例

eg:
package malajava;
/*
 可充电的接口
*/
public interface Chargeable {

void charge() ; // 充电
}

package malajava;
/*
 可以传输数据的接口
*/
public abstract interface Transfer { // 所有的接口都是抽象的 ( abstract )

void transmission() ; // 接口中所有的”没有方法体的”方法都是 public abstract 修饰的
}

package org.malajava;
/*
 1、在 Java 语言中一个接口 可以同时继承多个 父接口
2、当一个接口继承多个父接口时，父接口名称 之间使用 逗号 隔开
/
public interface USB extends Chargeable , Transfer { // USB : Universal Serial Bus ( 通用串行总线 )
// USB 接口继承了 Chargeable , Transfer 接口中的抽象方法
}

//实现USB接口，重写抽象方法
package malajava;
public class UGreen implements USB {
@Override
public void charge() {
System.out.println( “UGreen : charge” );
}
@Override
public void transmission() {
System.out.println( “UGreen : transmission” );
}
}

//实现
package malajava;
public class TransferTest {
public static void main(String[] args) {

Transfer t = null ; // 变量 t 的编译时类型是 Transfer 类型

t = new UGreen();

// 通过 变量 t 只能调用直接在 Transfer 中声明的方法 和 Object 类中声明的方法
t.transmission();//UGreen : transmission

String s = t.toString() ; // 调用 Object 类中声明的方法
System.out.println( s );//malajava.UGreen@880ec60

Class<?> c = t.getClass(); // 获得 运行时类型
System.out.println( c.getName() );//malajava.UGreen

}
}

clone 方法

1.被克隆对象对应的类需要实现Cloneable接口
2.被克隆的对象对应的类要重写从Object类中继承的clone方法（return super。clone（））
3.在重写后的clone方法中首先要调用Object的clone方法完成对象的浅克隆 浅克隆 : 仅仅克隆当前对象本身，而当前对象关联的其它对象是不克隆的
4.克隆一个对象时将对象所关联的其他其他对象也克隆被称作深克隆。

public class Master extends Object implements Cloneable {

  1. **protected** **String** name ;<br />    **public** **Master**(**String** name) {<br />        **super**();<br />        **this**.name = name;<br />    }<br />    @Override<br />    **protected** **Object** **clone**() **throws** **CloneNotSupportedException** {<br />        // 一定要重写 从 Object 继承的 clone 方法<br />        // 才能保证本包中的其它类能够调用本类实例的 clone 方法<br />        // protected 修饰的方法 的访问权限 与 声明该方法的类所在的包 有关<br />        **return** **super**.clone(); // 子类可以调用父类中的 protected 方法<br />    }

}

浅克隆

public class Monkey extends Object implements Cloneable {
private String name ;

  1. private int age ;
  3. private Master master ;<br />    public Monkey(String name , int age , Master master ) {<br />        super();<br />        this.name = name;<br />        this.age = age ;<br />        this.master = master ;<br />    }
  5. // Object 类中的 clone 方法: protected native Object clone() throws CloneNotSupportedException ;<br />    @Override<br />    public Object clone() throws CloneNotSupportedException {<br />        // 子类重写后的方法 的 访问修饰符 的范围 不能比父类相应方法的 权限小<br />        return super.clone() ; // 仍然是调用由 Object 提供的 clone 支持 ( 一定要调用 )<br />    }<br />    public static void main(String[] args) throws CloneNotSupportedException {
  7.     Master a = new Master( "唐三藏" );
  9.     Monkey m = new Monkey( "孙悟空"  , 1000 , a );
  12.     Object o = m.clone();
  14.     System.out.println( m == o ); // false
  16.     Monkey n = (Monkey) o ;<br />        System.out.println( m == n ); // false
  18.     System.out.println( "~ ~ ~ ~ ~ ~ ~" );
  20.     // == 比较两个变量所存储的值<br />        System.out.println( m.name == n.name ); // true<br />        System.out.println( m.age == n.age ); // true : 比较基本数据类型的值<br />        System.out.println( m.master == n.master ); // true : 说明内部关联的对象没有被克隆
  22. }<br />}

深克隆：

public class Pig extends Object implements Cloneable {

  1. private String name ; // 引用类型
  3. private int age ; // 基本类型
  5. private Master master ; // 引用类型<br />    public Pig(String name , int age , Master master ) {<br />        super();<br />        this.name = name;<br />        this.age = age ;<br />        this.master = master ;<br />    }
  7. @Override<br />    public Object clone() throws CloneNotSupportedException {
  9.     Object o = super.clone() ; // 仍然是调用由 Object 提供的 clone 支持 ( 一定要调用 )
  11.     if( o != null ) {<br />            // 将 变量 o 中存储的 地址 赋值给 变量 p 并转换类型<br />            Pig p = (Pig) o ;
  13.         // name 是 java.lang.String 类型，而 String 从 Object 继承的 clone 方法 修饰符是 protected<br />            // String 类没有子类，因此 不可能通过 String 子类来调用其 clone 方法 ( Pig 也不是 String 的子类 )<br />            // Pig 与 String 类不在同一个包中，因此不能够调用 Stirng 类的 clone 方法<br />            // p.name = (String)this.name.clone();
  15.         p.master = (Master)this.master.clone(); // 把 master 也克隆<br />        }
  17.     return o ; // 要理解 变量 o 和 变量 p 指向的 是同一个对象<br />    }<br />    public static void main(String[] args) throws CloneNotSupportedException {
  19.     Master a = new Master( "唐三藏" );
  21.     Pig m = new Pig( "猪悟能"  , 1200 , a );
  24.     Object o = m.clone();
  26.     System.out.println( m == o ); // false
  28.     Pig n = (Pig) o ;<br />        System.out.println( m == n ); // false
  30.     System.out.println( "~ ~ ~ ~ ~ ~ ~" );
  32.     // == 比较两个变量所存储的值<br />        System.out.println( m.name == n.name ); // true<br />        System.out.println( m.age == n.age ); // true : 比较基本数据类型的值<br />        System.out.println( m.master == n.master ); // false : 说明内部关联的对象没有被克隆
  34. }<br />}