Java编程思想第四版第十章习题
这张东西有点多，闲话少说，直接上题。
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的内部类以实现那个接口。在第三个包中，继承这个类，并在一个方法中返回该protected内部类对象，在返回的时候向上转型为第一个包中的接口的类型。
package package1;
/**
* @ClassName: A
* @Description: A
* @author: hszjj
* @date: 2019/7/18 9:01
*/
public interface A {
void show();
}
package package2;
import package1.*;
/**
* @ClassName:
* @Description:
* @author: hszjj
* @date: 2019/7/19 10:16
*/
public class B {
protected class C implements A{
@Override
public void show() {
}
}
}
package job;
import java.util.*;
import package1.A;
import package2.*;
class D extends B{
C show2() {
//return this.new C();//Error:(8, 21) java: C() 在 package2.B.C 中是 protected 访问控制
//return new C();//Error:(9, 16) java: C() 在 package2.B.C 中是 protected 访问控制
}
}
public class Main {
public static void main(String[] args) {
}
}
7.创建一个含有private域和private方法的类。创建一个内部类，它有一个方法可用来修改外部类的域，并调用外围类的方法。在外围类的另一个方法中，创建此内部类的对象，并且调用它的方法，然后说明对外围类对象的影响。
package job;
import java.util.*;
class A{
private int x=1;
private void way1(){
System.out.println("x="+x);
}
class B{
void way2(int y){
x=y;
way1();
}
}
void way3(){
B b=new B();
b.way2(3);
}
}
public class Main {
public static void main(String[] args) {
}
}
8.确定外部类是否可以访问其内部类的private元素。
package job;
import java.util.*;
class A{
static class B{
private int x=1;
}
static void show(){
B a=new B();
System.out.println(a.x);
}
}
public class Main {
public static void main(String[] args) {
A.show();
}
}
9.创建一个至少有一个方法的接口。在某个方法内定义一个内部类以实现此接口，该方法返回对此接口的引用。
package job;
import java.util.*;
interface A{
void show();
}
public class Main {
static A get(){
class B implements A{
@Override
public void show() {
}
}
B b=new B();
return b;
}
public static void main(String[] args) {
A a = get();
}
}
10.重复前一个练习，但将内部类定义在某个方法的一个作用域内。
package job;
import java.util.*;
interface A{
void show();
}
public class Main {
static A get(){
if(true) {
class B implements A {
@Override
public void show() {
}
}
B b = new B();
return b;
}
else{
return null;
}
}
public static void main(String[] args) {
A a = get();
}
}
11.创建一个private内部类，让它实现一个public接口。写一个方法，它返回一个指向此private内部类的实例的引用，并将此引用向上转型为该接口类型。通过尝试向下转型，说明此内部类被完全隐藏了。
package package2;
/**
* @ClassName:
* @Description:
* @author: hszjj
* @date: 2019/7/19 10:16
*/
public interface C {
void show();
}
package job;
import java.util.*;
import package2.*;
public class Main {
private class B implements C {
@Override
public void show() {
}
}
public C back() {
C c = new Main.B();
return c;
}
public static void main(String[] args) {
Main a = new Main();
C c = a.back();
}
}
12.重复练习7，这次使用匿名内部类。
package job;
import java.util.*;
class A{
private int x=1;
private void way1(){
System.out.println("x="+x);
}
public B getB(final int y){
return new B(){
@Override
public void change() {
x=y;
way1();
}
};
}
}
interface B{
void change();
}
public class Main {
public static void main(String[] args) {
A a=new A();
B b=a.getB(2);
b.change();
}
}
13.重复练习9，这次使用匿名内部类。
package job;
import java.util.*;
interface A{
void show();
}
public class Main {
public A getA() {
return new A() {
@Override
public void show() {
System.out.println("showing");
}
};
}
public static void main(String[] args) {
Main a=new Main();
A b=a.getA();
b.show();
}
}
14.修改interface/HorrorShow.java,用匿名类实现DangerousMonster和Vampire。
package job;
import java.util.*;
public class Main {
public Monster getDangerousMonster(){
return new Monster() {
@Override
public void menace() {
System.out.println("menace");
}
public void destroy(){//扩展的方法
System.out.println("destroy");
}
};
}
public Lethal getVampire(){
return new Lethal() {
@Override
public void kill() {
System.out.println("kill");
}
public void drinkBlood(){
System.out.println("dringkBlood");
}
};
}
}
interface Monster{
void menace();
}
interface Lethal{
void kill();
}
没写main，就看个大概意思的了。
15.创建一个类，它有非默认的构造器（既需要参数的构造器），并且没有默认构造器（没有无参数的构造器）。创建第二个类，它包含一个方法，能够返回对第一个类的对象的引用。通过写一个继承自第一个类的匿名内部类，来创建一个返回对象。
package job;
import java.util.*;
class A{
A(String a){
System.out.println(a);
}
}
class B{
public A getA(final String s){
return new A(s){
};
}
}
public class Main {
public static void main(String[] args) {
B b=new B();
A a=b.getA("handsome jj");
}
}
16.修改第九章中练习18的解决方案，让它使用匿名内部类。
package job;
import java.util.*;
public class Main {
interface Cycle {
void run();
}
interface CycleFactory {
Cycle getCycle();
}
class Unicycle implements Cycle {
@Override
public void run() {
System.out.println("Unicycle Running");
}
}
class Bicycle implements Cycle {
@Override
public void run() {
System.out.println("Bicycle Running");
}
}
class Tricycle implements Cycle {
@Override
public void run() {
System.out.println("Tricycle Running");
}
}
public CycleFactory UncycleFactory = new CycleFactory() {
@Override
public Cycle getCycle() {
return new Unicycle();
}
};
public CycleFactory BicycleCycleFactory = new CycleFactory() {
@Override
public Cycle getCycle() {
return new Bicycle();
}
};
public CycleFactory TricycleCycleFactory = new CycleFactory() {
@Override
public Cycle getCycle() {
return new Tricycle();
}
};
static class Factory {
static void Consumer(CycleFactory fact) {
Cycle c = fact.getCycle();
c.run();
}
}
public static void main(String[] args) {
Main a=new Main();
Factory.Consumer(a.UncycleFactory);
}
}
17.修改第9章练习19的解决方案，让它使用匿名内部类。
package job;
import java.util.*;
public class Main {
interface Game {
void play();
void getresult();
}
interface GameFactory {
Game getGame();
}
class Coin implements Game {
Random rand = new Random();
int coin = 0;
@Override
public void play() {
switch (rand.nextInt(2)) {
case 0:
coin = 0;
break;
case 1:
coin = 1;
break;
default:
}
}
public void getresult() {
if (coin == 0) {
System.out.println("硬币为正");
} else {
System.out.println("硬币为反");
}
}
}
GameFactory CoinFactory = new GameFactory() {
@Override
public Game getGame() {
return new Coin();
}
};
static class Factories {
public static void PlayGame(GameFactory fact) {
Game a = fact.getGame();
a.play();
a.getresult();
}
}
public static void main(String[] args) {
Main a=new Main();
for (int i = 0; i < 10; i++) {
Factories.PlayGame(a.CoinFactory);
}
}
}
18.创建一个包含嵌套类的类。在main()中创建起内部类的实例。
package job;
import java.util.*;
class A{
static public class B{
}
}
public class Main {
public static void main(String[] args) {
A.B b=new A.B();
}
}
19.创建一个包含内部类的类，而此内部类又包含有内部类。使用嵌套类重复这回过程。注意编译器生成的.class文件的名字。
package job;
import java.util.*;
class A{
static public class B{
static public class C{
}
}
}
public class Main {
public static void main(String[] args) {
A.B.C b=new A.B.C();
}
}
20.创建一个包含嵌套类的接口，实现此接口并创建嵌套类的实例。
package job;
import java.util.*;
interface A{
public class B implements A{
}
}
public class Main {
public static void main(String[] args) {
A.B b=new A.B();
}
}
21.创建一个包含嵌套类的接口，该嵌套类中有一个static方法，它将调用接口中的方法并显示结果。实现这个接口，并将这个实现的一个实例传递给这个方法。
package job;
import java.util.*;
interface A{
void way();
public class B implements A{
@Override
public void way() {
System.out.println("way");
}
static void show(){
new B().way();
}
}
}
public class Main {
public static void main(String[] args) {
A.B.show();
}
}
22.实现Sequence.Java中的reverseSelector()方法。
略
23.创建一个接口U，它包含三个方法。创建第一个类A，它包含一个方法，在此方法中通过创建一个匿名内部类，来生成指向U的引用。创建第二个类B，它包含一个由U构成的数组。B应有几个方法，第一个方法可以接受对U的引用并存储到数组中；第二个方法将数组中的引用设为null；第三个方法遍历此数组，并在U中调用这些方法。在main()中，创建一组A的对象和一个B的对象。用那些A类对象所产生的U类型的引用填充B对象的数组。使用B回调所有A的对象。再从B中移除某些U的引用。
package job;
import java.util.*;
interface U{
void way1();
void way2();
void way3();
}
class A{
U getU(){
return new U() {
@Override
public void way1() {
}
@Override
public void way2() {
}
@Override
public void way3() {
}
};
}
}
class B{
U[] u=new U[3];
int index=0;
void putU(U a){
if(index24和25，22章再写。
26.创建一个包含内部类的类，此内部类有一个非默认的构造器（需要参数的构造器）。创建另一个也包含内部类的类，此内部类继承自第一个内部类。
package job;
import java.util.*;
class A{
class B{
B(int i){
System.out.println("E26B");
}
}
}
public class Main extends A.B {
Main(A a) {
a.super(1);
System.out.print("E26");
}
public static void main(String[] args) {
Main a = new Main(new A());
}
}
结束~
我的另一个博客：https://www.cnblogs.com/hsjj/
会不定时的更新算法题
有问题欢迎发送邮件至[email protected]
我们下次见哦~