java和c#区别--内部类

一、成员内部类

 1、C#

    class Program
    {
        static void Main(string[] args)
        {
            Order.Inner s = new Order.Inner();
            s.Visit();
        }
    }

    public class Order
    {
        static int radius = 1;
        public class Inner
        {
            public void Visit() {
                Console.WriteLine("visit outer variable:" + radius);
            }
        }
    }

  1.1、内部成员类访问外部类变量radius，外部类变量radius必须是静态成员，否则提示【无法通过嵌套类型“Order.StaticInner”来访问外部类型“Order”的非静态成员】。感觉java好一点

  1.2、内部类StaticInner的访问修饰符可以是public、internal。因为内部类默认修饰符是private，所以默认是错误的；因为protected是自身和子类可以访问，所以protected也是错误的。

 2、Java

public class Order
{
    private int radius = 1;
    public class Inner
    {
        public void visit() {
            System.out.println("visit outer variable:" + radius);
        }
    }
}

        Order o = new Order();
        Order.Inner inner =  o.new Inner();
        inner.visit();

   2.1、java内部类可以访问外部非静态成员变量。

   2.2、java内部类，不是静态类的内部类，不能使用【Order.Inner s = new Order.Inner();】创建，必须通过外部对象创建new Order().new Inner()

二、静态内部类

 1、C#

  1.1、静态内部类，就是静态类，静态类不能new，而且静态类里的非静态成员变量也没什么用，所以只能是静态类+静态变量。

    class Program
    {
        static void Main(string[] args)
        {
            Order.Inner.Visit();
        }
    }

    public class Order
    {
        static int radius = 1;
        public static class Inner
        {
            public static void Visit()
            {
                Console.WriteLine("visit outer variable:" + radius);
            }
        }
    }

 2、Java

  2.1、java只能内部类可以用static修饰，任何外部类用static修饰都会报错。

  2.2、java静态内部类，可以直接new

public class Order
{
    private static int radius = 1;
    public static class Inner
    {
        public void visit() {
            System.out.println("visit outer variable:" + radius);
        }
    }
}

        Order.Inner inner = new Order.Inner();
        inner.visit();

  2.3、java静态内部类中的静态方法，可有通过类直接调用，也可以通过对象调用，静态方法只能调用静态成员，不能调用非静态成员

public class Order
{
    private static int radius = 1;
    public static class Inner
    {
        public static void visit() {
            System.out.println("visit outer variable:" + radius);
        }
    }
}

        Order.Inner inner = new Order.Inner();
        inner.visit();
        Order.Inner.visit();

三、局部内部类：定义在方法中的类

1、C#方法内部不能定义类

2、Java

　　2.1、局部内部类需要先定义后使用

　　2.2、局部内部类权限修饰符：只能为空

public class Order
{
    public void OrderFunc()
    {
        class Inner
        {
            public void InnerFunc(){
                System.out.println("局部内部类");
            }
        }
        Inner inner = new Inner();
        inner.InnerFunc();
    }
}

        Order o = new Order();
        o.OrderFunc();

四、匿名内部类：就是没有名字的内部类，日常开发中使用的比较多。

1、C#没有匿名内部类，但是作用和匿名方法差不多（封装私有，只内部使用一次）

    class Program
    {
        static void Main(string[] args)
        {
            Order o = new Order();
            o.test();
            Console.Read();
        }
    }

    public class Order
    {
        public void test()
        {
            Func<string> f = () =>
            {
                return "匿名方法";
            };
            Console.WriteLine(f());
        }
    }

2、Java

　　2.1、匿名内部类必须继承一个抽象类或者实现一个接口。

　　2.2、匿名内部类不能定义任何静态成员和静态方法。（因为内部类必须继承或实现，是通过父类多态调用）

　　2.3、当所在的方法的形参需要被匿名内部类使用时，必须声明为final。

　　2.4、匿名内部类不能是抽象的，必须实现继承的类或者接口的所有抽象方法。

　　2.5、不能定义构造器，默认和父类相同的构造器

实现接口：

public class Order
{
    public void test(final int i)
    {
        new Service(){
            public void method(){
                for(int j=0;j<i;j++){
                    System.out.println("匿名内部类");
                }
            }
        }.method();
    }
}
interface Service
{
    void method();
}

        Order o = new Order();
        o.test(5);

继承类：

public class Order
{
    public void test()
    {
        Object o = new Object(){
            @Override
            public String toString() {
                return "内部类重写toString";
            }
        };
        System.out.println(o.toString());
    }
}

        Order o = new Order();
        o.test();