标签: nested-class

这两个内部类声明有什么区别？还评论优点/缺点？

案例A:类中的类.

public class Levels {   
  static public class Items {
    public String value;
    public String path;

    public String getValue() {
      return value;}
  }
}

和案例B:接口内的类.

public interface Levels{

  public class Items {
    public String value;
    public String path;

    public String getValue() {
      return value;}
  }
}

纠正:放置getvalue方法.

进一步的信息:我能够在另一个没有实现接口AT ALL的类中实例化A和B两种情况下的Items类.

public class Z{//NOTE: NO INTERFACE IMPLEMENTED here!!!!
 Levels.Items items = new Levels.Items();
}

由于接口未实例化,因此接口内的所有元素都可以通过点符号访问,而无需实例化LEVELS接口,因为您无法实例化接口 - 有效地在可渗透静态引用的接口内定义类.

所以说B案例中的Items类不是静态的没有意义.由于情况A和B都以相同的方式实例化,我不是在寻找静态或内部或嵌套的语义.停止给我关于语义的答案.我想要编译器,运行时和行为差异/优点,或者如果没有,那么就这么说.没有更多的语义答案请!!!!! JVM或.NET VM规范的专家请求这个答案问题,而不是教科书语义学.

在这个stackoverflow回答中,一位评论者提到" 私有嵌套类"可能非常有用,所以我在这篇文章中阅读它们,这些文章倾向于解释嵌套类在技术上如何起作用,但不是为什么要使用它们.

我想我会使用私有嵌套类来处理属于更大类的小助手类,但是我经常需要来自另一个类的辅助类,所以我只需要额外的努力来(1)使嵌套类非-nested或(2)将其公开,然后使用外部类前缀访问它,这两者似乎都是额外的工作,没有任何附加值,因为首先使用嵌套类.因此,一般来说,我真的没有看到嵌套类的用例,除了可能将类更加有条理地组成组,但我也违背了我已经享受的每个文件的一级清晰度.

您以何种方式使用嵌套类来使代码更易于管理,更易读,更高效？

我正在重构示例中的代码:

• 24.129.21.
  来自C#/ CSharp教程的主细节绑定 »Windows Presentation Foundation»绑定)

而排除技能等级后,与相应的变化
在MainWindow.xaml

<local:Team>
  <local:Employee Name="Larry" Age="21">
    <local:Employee.Skills>
      <!--  local:Skills -->
       <local:Skills>

在MainWindow1.xaml.cs中:

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Windows;
namespace WpfApplication
{
  public class Skill
  {//I'd like to exclude class Skill having moved it into class Employee as nested one
    public string Description { get; set; }
  }

   public class Employee 
   {
    public string Name { get  ; set; }
    public int Age  { get; set; } …

我只是遇到了一个奇怪的效果,在跟踪它时,我注意到收集内部和静态嵌套类似乎有很大的性能差异.考虑以下代码片段:

public class Test {
    private class Pointer {
        long data;
        Pointer next;
    }
    private Pointer first;

    public static void main(String[] args) {
        Test t = null;
        for (int i = 0; i < 500; i++) {
            t = new Test();
            for (int j = 0; j < 1000000; j++) {
                Pointer p = t.new Pointer();
                p.data = i*j;
                p.next = t.first;
                t.first = p;
            }
        }
    }
}

那么代码所做的就是使用内部类创建一个链表.该过程重复500次(用于测试目的),丢弃上次运行中使用的对象(受GC影响).

在内存限制严格(例如100 MB)下运行时,此代码在我的计算机上执行大约需要20分钟.现在,通过简单地用静态嵌套类替换内部类,我可以将运行时减少到不到6分钟.以下是更改:

    private static class Pointer {

和

                Pointer p …

鉴于我所知道的其他类型的静态编程功能 - 我认为答案是'不'.然而,看到这样的陈述OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();让我感到奇怪.

我正在尝试执行以下操作:

class Animal
{
    class Bear : public Animal
    {
        // …
    };

    class Giraffe : public Animal
    {
        // …
    };
};

...但是我的编译器似乎对此嗤之以鼻.这是合法的C++,如果没有,是否有更好的方法来完成同样的事情？基本上,我想创建一个更清晰的类命名方案.(我不想Animal从公共基类派生和内部类)

我已经开始学习用于Android应用程序开发的Java语言.

根据我对静态类的理解,我们无法实例化静态类的对象.

但为什么静态嵌套类对象的实例化允许在后面的situaltion？

class EnclosingClass 
{     
      //...     
      class static StaticInnerClass 
      {         
          //...     
      } 
} 

为什么我们可以创建内部类的对象,如果它被标记为静态？

EnclosingClass.StaticInnerClass s = new EnclosingClass.StaticInnerClass()

请参阅下面的示例代码:

class A
{
private:
    class B
    {
    public:
        foobar();
    };
public:
    foo();
    bar();
};

在A&B级实施中:

A::foo()
{
    //do something
}

A::bar()
{
    //some code
    foo();
    //more code
}

A::B::foobar()
{
    //some code
    foo(); //<<compiler doesn't like this
}

编译器在方法foobar()中标记对foo()的调用.早些时候,我把foo()作为A类的私有成员函数,但是改为public,假设B的函数看不到它.当然,它没有帮助.我试图重新使用A的方法提供的功能.为什么编译器不允许这个函数调用？在我看来,它们是同一个封闭类(A)的一部分.我认为嵌套类meebers在C++标准中封闭类的可访问性问题已得到解决.

如果不重写B的相同方法(foo()),保持B嵌套在A中,我怎样才能实现我想做的事情？

我使用的是VC++编译器ver-9(Visual Studio 2008).谢谢您的帮助.

使用嵌套类对常量进行分组有什么问题？

像这样:

public static class Constants
{
    public static class CategoryA
    {
        public const string ValueX = "CatA_X";
        public const string ValueY = "CatA_Y";
    }
    public static class CategoryB
    {
        public const string ValueX = "CatB_X";
        public const string ValueY = "CatB_Y";
    }
}

像这样使用:

Console.WriteLine(Constants.CategoryA.ValueY);
Console.WriteLine(Constants.CategoryB.ValueX);

你也可以使"常数" - 类偏...

在以下代码中:

 class EnclosingClass
 { 
     public static class BiNode extends Sub.IBiLink { }
     private static class Sub
     {
         private static class IBiLink
         {  
         } 
     }
}

在与其他.class文件一起编译时,我还看到一个名为"EnclosingClass $ 1.class"的文件.为什么这是自动创建的？这是怎么回事？