内部类的基本使用（用匿名内部类排序数组）

package third;


import java.util.Arrays;
import java.util.Comparator;
/**内部类外部类的基本使用
 * 匿名内部类的基本使用（包括String数组排序）
 * 
 * */

//分别用接口和抽象类实现匿名内部类


abstract class AbstractClass{
    int i;
    public AbstractClass(int i) {this.i=i;};
    abstract void abstrac();
}
interface Interfa{
    //接口不能含有构造函数
    void interfa();
}

//外部类
public class Outer {
    private int age;

    public static class Inner{
        int age ;
        void ff() {
            System.out.println(age);
        }
    }





    public static void main(String []args) {
        Outer o=new Outer();

        /**调用静态内部类的非静态方法必须实例化内部类
         * */
        Inner i=new Outer.Inner();
        i.ff();
        new Outer() {
            void ss() {
                System.out.println("ss");
            }
        }.ss();;
        //方法ss在Outer不存在
        //想要调用ss 必须在后面. 不能向下转型成子类


        AbstractClass n=new AbstractClass(0) {
            //必须实现父类所有方法，可以增添，相当于子类；
            //匿名内部类不能含有构造方法，可以由初始化代码块

            void ss() {
                System.out.println("ss");
            }
            @Override
            void abstrac() {
                // TODO Auto-generated method stub

            }
        };
        new Interfa() {



            @Override
            public void interfa() {
                // TODO Auto-generated method stub

            }

        };
        //使用匿名内部类对string 数组排序
        String[] s= {"q321","21433","43"};
        Arrays .sort(s, new Comparator() {


            @Override
            public int compare(String o1, String o2) {

                if(o1.length()>o2.length())
                return 1;
                else return -1;
            }
        } );

        for(String ss:s) {
            System.out.println(ss);
        }

    }
}