标签: inner-classes

比方说我有:

public class A {
  public A() {
    ...
  }
  ...

  public class B {
    public B() {
      ...
    }
    public void doSomething() {
      ...
    }
    ...
  }

  public class C {
    public C() {
      ...
    }
    public void doSomething() {
      ...
    }
    ...
  }
}

如果我想创建一个可以同时包含B和C的ArrayList,我可以myArray.get(i).doSomething()在A中调用,我想要声明我的ArrayList是什么类型的？

我有一个Java类将有许多内部类.这是为组织完成的,并将事物保存在单独的文件中.

public class PUCObjects
{

    public static class PUCNewsItem
    {

        public String title;
        public String summary;
        public String body;
        public String url;
        public String imageUrl;

    }

}

然后我尝试创建该内部类的新实例(在另一个解析一些远程XML的类中执行此操作),但由于某种原因,它似乎没有被创建:

public static ArrayList<PUCObjects.PUCNewsItem> getPUCNews() throws IOException {

        String url = "http://api.puc.edu/news/list?key="+API_KEY+"&count=30";
        InputStream is = downloadUrl(url);
        XmlPullParserFactory pullParserFactory;

        try {
            pullParserFactory = XmlPullParserFactory.newInstance();
            XmlPullParser parser = pullParserFactory.newPullParser();
            parser.setInput(is, null);

            ArrayList<PUCObjects.PUCNewsItem> items = null;
            int eventType = parser.getEventType();
            PUCObjects.PUCNewsItem item = null;
            Log.d("Debug: ", "Start: "+url);
            while (eventType != XmlPullParser.END_DOCUMENT){
                String name …

我创建了这个AsyncTask内部类,现在我想把它变成外层.这是代码:

    private class DownloadDataFromServer extends AsyncTask<String, Integer, String> {
        ProgressDialog dialog;
        boolean connErr = false;
        boolean soErr = false;

        @Override
        protected void onPreExecute() {
            dialog = new ProgressDialog(HomePage.this); !!!!PROBLEM!!!!
            dialog.setIndeterminate(false);
            dialog.setMax(100);
            dialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
            dialog.setCancelable(false);
            dialog.setTitle("Download");
            dialog.setMessage("Updating...");
            dialog.show();

            super.onPreExecute();
        }

        @Override
        protected String doInBackground(String... urls) {
            // do something
        }

        protected void onProgressUpdate(Integer... progress) {
            // Update the progress
            dialog.setProgress(progress[0]);
        }

        @Override
        protected void onPostExecute(String result) {
            if (connErr || soErr) {
                String msg = "Bad connection";
                AlertDialog.Builder builder;
                builder = new …

请看下面的代码

private void displayInitialRevenue_Method() {
    //Get the dates from the combo
    String selectedCouple = revenueYearCombo.getSelectedItem().toString();
    if (selectedCouple.equals("Select Year")) {
        return;
    }
    String[] split = selectedCouple.split("/");
    //Related to DB
    double totalAmount = 0.0;
    //Get data from the database
    dbConnector = new DBHandler();
    dbConnector.makeConnection();
    DefaultTableModel model = (DefaultTableModel) initialRevenueTable.getModel();
    model.setRowCount(0);
    ResultSet selectAllDetails = dbConnector.selectAllDetails("SQL CODE ");
    try {
        if (selectAllDetails.isBeforeFirst() == false) {
            JOptionPane.showMessageDialog(null, "This table is empty");
        } else {
            while (selectAllDetails.next()) {
                String clientName = selectAllDetails.getString("Client Name");
                String providerName = …

我有声明类的功能

>>> def a():
...     class A:
...         print "a"
...

当我调用函数时,为什么要打印a？

>>> a()
a

我尝试从另一个内部类访问内部类方法.两个内部类都在同一个外部类中声明:

class OuterFoo{

    class innerFoo1{

        public void methodFoo1(){
            System.out.println(" Hello, i am in the inner foo 1");
        }
    }

    class innerFoo2{

        public void methodFoo2(){
           System.out.println(" Hello, i am in the inner foo 2");
        }
    }
}

现在,我想访问methodFoo1的methodFoo2.

任何帮助将不胜感激.

为什么这段代码有效:

class Parent {
    private void methodA(String a){
        System.out.println(a);
    }

    class Inner {

        void test(int a){
            methodA("1");
        }
    }
}

但是这段代码不起作用(我只是将方法添加到具有相同名称和另一个签名的内部类):

class Parent {
    private void methodA(String a){
        System.out.println(a);
    }

    class Inner {

        private void methodA(int a){
            System.out.println(a);
        }

        void test(int a){
            methodA("1");
        }
    }
}

我不问如何让它发挥作用.我想说明为什么第二个选项不起作用？我想要一个解释,而不是解决方案.

下面显示的是程序的粗略结构。

class Room 
{
private:
    Node* content;
public:
    void someRoomMethod();
};

void Room::someRoomMethod() {}


class Node
{
private:
    Node* nextNode;
    std::variant<int, float> data;
public:
    void someNodeMethod();
};

void Node::someNodeMethod() {}

正如我在标题中提到的，Node除了 inside 之外没有在任何地方使用Room。我试图通过将 Node 设置为嵌套类来封装它，但它不起作用。

// Room.hh

class Room 
{
private:
    Room::Node* content; // ERROR: no type named "Node" in "Room" -- GCC

public:
    void roomMethod();

    class Node()
    {
    private:
        Node* nextNode;
        std::variant<int, float> data;
    public:
        void someNodeMethod();
    }
};

// Room.cpp
void Room::someRoomMethod() {} // …

您好，我想从其他类访问嵌套类。

class OutSideClass
{
public:
    class InSideClass
    {
       ...
    };
    friend class InSideClass;
};

class Other
{
    InSideClass x; // This doesn't work
};

InSideClass 类是一个公共类，所以我不明白为什么我可以从外部访问它

我也想访问

template <typename T>
class OutSideClass
{
public:
    class InSideClass
    {
        class InSideClassIterator
        {

        };
    };


public:
    class Other
    {
    OutSideClass<T>::InSideClass::InSideClassIterator x;
    };


};

要调用内部类的函数，我只需要一个内部类的对象。但是如果我已经创建了对象，为什么我不能在任何我想要的地方调用内部类的方法？试图暗示的错误是什么？

class Outer 
{
    int x;
    
    class Inner // creating an Inner class
    {
        public void display()
        {
            System.out.println("Hello from Inner class"+x);
        }
    }
    
    Inner i = new Inner();
    i.display(); // This is where the error comes. Why do I have to create a method to call
                 // methods of my inner class. Why Can't I call it anywhere I want?
}


public class Main
{
    public static void main(String[] args) 
    {
        System.out.println("Hello World");
    }
}