接口

概念

接口不是类，而是对类的一组需求描述，这些类要遵从接口描述的统一格式进行定义。

域与方法

接口中的域被自动设为public static final，因此不必写public static final。
接口中的所有方法都自动地属于public，因此不必写public。

特性

可以声明变量，但不能构造对象，只能借由实现了接口的类来构造对象。
可以用instanceof来检查一个对象是否实现了某一个特定的接口。
接口也可以被扩展，有较高通用性接口扩展到较高专用性接口。

接口与抽象类

不使用抽象类而使用接口的原因是一个子类只允许有一个超类（java是单继承的），而一个类可以实现多个接口。

默认方法

public class Main implements A {
	public static void main(String[] args) {
		Main a = new Main();
		a.print();
	}
}

interface A {
	default void print() {
		System.out.println("hello");//直接使用
	}
}

解决默认方法冲突

如果类本身或者超类提供了一个具体方法，相同签名的默认方法就会被忽略。（类优先原则）
如果有两个接口提供了签名相同的默认方法，就要去解决二义性。

public class Main implements A, B {
	public void print() {
		B.super.print();//只要其中有一个提供了默认实现,就必须解决这个二义性。
	}

	public static void main(String[] args) {
		Main a = new Main();
		a.print();
	}
}

interface A {
	default void print() {
		System.out.println("hello");
	}
}

interface B {
	default void print() {
		System.out.println("worldhh");
	}
}

克隆

clone 方法是 Object 的一个 protected 方法。

浅拷贝

class Employee implements Cloneable
{ 
   ...
   public Employee clone() throws CloneNotSupportedException
   {
         return (Employee) super.clone();
   }
   ...
}

深拷贝

class Employee implements Cloneable
{
  ...
  public Employee cloneO throws Cl oneNotSupportedException
  {
      Employee cloned = (Employee) super.clone();
      cloned.hireDay = (Date) hireDay. clone();
      return cloned;
   }
   ...
}

内部类

public class Hello {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Px s = new Px(3);
        //内部类不能独立存在，必须依附于外部类实例
		Px.Tx p = s.new Tx();//构造内部类
		p.print();
        //will print 2 3 3
	}
}

class Px {
	public int a;

	public Px(int a) {
		this.a = a;
	}

	public void fprint() {
		System.out.println(a);
	}

	class Tx {
		private int a = 2;

		public void print() {
			System.out.println(a);
			Px.this.fprint();//显示类
			fprint();//可以隐式调用外部类
		}

	}
}

匿名类

语法格式如下：

new SuperType(construction parameters)
{
       inner class methods and data
}

示例：

public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer("Nested");
        outer.asyncHello();
    }
}

class Outer {
    private String name;

    Outer(String name) {
        this.name = name;
    }

    void asyncHello() {
        //定义了一个实现runnable接口的匿名类
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello, " + Outer.this.name);
            }
        };
        new Thread(r).start();
    }
}

静态内部类

public class Main {
    public static void main(String[] args) {
        Outer.StaticNested sn = new Outer.StaticNested();
        //静态内部类不依附于外部类的实例，完全独立
        //无法引用Outer.this实例
        //可以访问外部类的private字段和方法
        sn.hello();
    }
}

class Outer {
    private static String NAME = "OUTER";

    private String name;

    Outer(String name) {
        this.name = name;
    }

    static class StaticNested {
        void hello() {
            System.out.println("Hello, " + Outer.NAME);
        }
    }
}

总结：