Java编程思想第四版第十章习题_创建一个包含嵌套类类的接口,该嵌套类中有一个-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_43632070/article/details/96472889

本文提供了一系列关于Java编程的练习题目，涵盖了内部类、接口、构造器和匿名类的应用，包括创建内外类对象、实现接口、访问权限、回调方法等概念的实践操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

这张东西有点多，闲话少说，直接上题。

PS：编译环境——IDEA

1.编写一个名为Outer的类，它包含一个名为Inner的类。在Outer中添加一个方法，它返回一个Inner类型的对象。在main()中，创建并初始化一个指向某个Inner对象的引用。

package job;
import java.util.*;
class Outer{
    class Inner{

    }
    Inner way(){
        return new Inner();
    }
}
public class Main {

    public static void main(String[] args) {
        Outer a=new Outer();
        Outer.Inner b=a.way();
    }
}

2.创建一个类，它持有一个String，并且有一个显示这个String的toString()方法，将你的新类的若干个对象添加到一个Sequence对象中，然后显示它们。

package job;

class A {
    String s = "aaa";

    A(String a) {
        s = a;
    }

    public String toString() {
        return s;
    }
}
interface Selector {
    boolean end();

    void next();

    Object current();
}

public class Main {
    private Object[] item;
    private static int i = 0;
    private static int j = 0;

    public Main(int size) {
        item = new Object[size];
    }

    private class SequenceSelector implements Selector {
        public Object current() {
            return item[j];
        }

        public void next() {
            j++;
        }

        public boolean end() {
            if (j < item.length) return true;
            else {
                j = 0;
                return false;
            }
        }
    }

    Selector selector() {
        return new SequenceSelector();
    }

    void add(Object s) {
        if (i < item.length) {
            item[i] = s;
            System.out.println(item[i]);
            ++i;
        }
    }


    public static void main(String[] args) {
        Main a = new Main(3);
        a.add(new A("aaaa"));
        a.add(new A("bbbb"));
        a.add(new A("cccc"));
        Selector b = a.selector();
        while (b.end()) {
            System.out.println(b.current());
            b.next();
        }
    }
}

3.修改练习1，使得Outer类包含一个private string域（由构造器初始化），而Inner包含一个显示这个域的toString()方法。创建一个Inner类型的对象并显示它。

package job;
import java.util.*;
class Outer{
    private String a="moren";
    class Inner{
        public String toString(){
            return a;
        }
    }
    Inner way(){
        return new Inner();
    }
}
public class Main {

    public static void main(String[] args) {
        Outer a=new Outer();
        Outer.Inner b=a.way();
        System.out.println(b.toString());
    }
}

4.在Sequence.SequenceSelector类中增加一个方法，它可以生成对外部类Sequence的引用。

 public Main way1(){
            return Main.this;
        }

5.创建一个包含内部类的类，在另一个独立的类中，创建此内部类的实例。

package job;
import java.util.*;
class A{
    class B{
        
    }
}
class C{
    A a=new A();
    A.B b=a.new B();
}
public class Main {

    public static void main(String[] args) {

    }
}

6.在第一个包中创建一个至少有一个方法的接口。然后在第二个包内创建一个类，在其中增加一个protected的内部类以实现那个接