java重写内部类_java：面向对象（接口（续），Compareble重写，Comparator接口：比较器的重写，内部类，垃圾回收机制）...

接口：

*接口定义:使用interface关键字

* [修饰符] interface 接口名 [extends 父接口1,父接口2...]{

* //常量的声明

* //方法的声明

* }

*接口成员的特点:

*1.接口中所有的成员变量是常量，默认修饰符为public static final

*2.接口中所有的方法都是抽象方法，默认修饰符为:public abstract

*3.接口不能实例化，接口不能构造方法(抽象类不能实例化，但可以有构造方法)

*4.java类是单继承，但接口可以是多继承

*5.一个非抽象类实现实现接口，必须重写接口中的抽象方法，抽象类实现接口可以重写部分抽象方法。

*6.一个类只能继承一个父类，但可以实现多个接口

*7.接口中被重写N次的方法，最后调用，调用的都是最后一次被重写的方法。

*如果一个类继承父类并实现了接口如何编写?

* [修饰符] class 类名 [extends 父类名 implements 接口名1,接口名2..]{

* }

* eg:

* public class E extends D implements A,B{

*

* }

public interfaceA {void m1();//public abstract void m();

}

public interfaceB {voidm2();

}

public interfaceC extends A,B{//void m1();//从接口A继承而来//void m2();//从接口B继承而来

voidm3();

}

public classD {public voidtest(){

System.out.println("D类中的test方法.....");

}

}

/**

*因为抽象类中是可以存在抽象方法的，所以一个抽象类实现了接口，可以重写或不重新接口中的抽象方法。

**/

public abstract classF implements C{//public abstract void m1();//public abstract void m2();//public abstract void m3();

}

/**

* 该类继承了父类D并实现了接口A和接口B

* 必须实现(重写)接口A和接口B的抽象方法

**/

public classE extends D implements A,B{

@Overridepublic voidm2() {

System.out.println("实现了接口B中的m2抽象方法");

}

@Overridepublic voidm1() {

System.out.println("实现了接口A中m1抽象方法");

}public static voidmain(String[] args) {

E e= new E();//类本身进行new

e.m1();

e.m2();

e.test();

System.out.println("-------------------------");

D e2= new E();//用父类new子类,向上转型,只能访问父类中的test方法

e2.test();

System.out.println("-------------------------");

A e3= new E();//利用接口A创建实现类,向上转型,只能访问接口A中定义的m1方法

e3.m1();

System.out.println("--------------------------");

B e4= new E();//利用接口B创建实现类,只能访问接口A中定义的m2方法

e4.m2();

}

}

java.lang.Comparable接口:此接口强行对实现它的每个类的对象进行整体排序。

* 排序规则在compareTo()方法中定义。

* 当调用java.util.Arrays类中sort(Object[] objs)时，

* 程序会调用compareTo()方法对对象进行比较，

* 如果该方法返回正整数(1)时，代表当前对象大于待比较对象；

* 如果返回0，代表当前对象等于待比较对象

* 如果该方法返回负整数(-1)时，代表当前对象小于待比较对象；

*实现思路:

*1.实现Comparable接口，并重新其compareTo方法

*2.在compareTo方法中定义比较规则。返回值应该是正整数&#