AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

java编程思想第四版第十章习题

2022-05-07 126
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 编译后的文件结构

1.第一题


package net.mindview.innerclasses;
public class Outer {
    class Inner {
        Inner(){
            System.out.println("这是一个内部类");
        }
    }
    public Inner in(){
        return new Inner();
    }
    public static void main(String[] args) {
        Outer out = new Outer();
        Outer.Inner inner = out.in();
    }
}


2.第二题


package net.mindview.innerclasses;
/**
 * 选择器
 */
interface Selector3 {
    //是否结束
    boolean end();
    //当前
    Object current();
    //下一个
    void next();
}
class OtherObject3 {
    String obj;
    OtherObject3(String obj){
        this.obj = obj;
    }
    @Override
    public String toString() {
        return obj;
    }
}
/**
 * 次序
 */
public class Sequence3 {
    private Object[] items;
    private int next = 0;
    //定义数组的个数
    public Sequence3(int size){
        items = new Object[size];
    }
    //添加
    public void add(Object x){
        items[next ++] = x;
    }
    //内部类--顺序选择器
    private class SequenceSelector implements Selector {
        //选择器最开始指向第一个元素
        private int i = 0;
        @Override
        public boolean end() {
            return i == (items.length);
        }
        @Override
        public Object current() {
            // TODO Auto-generated method stub
            return items[i];
        }
        @Override 
        public void next() {
            if(i<items.length){
                i++;
            }
        }
    }
    public Selector selector() {
        return new SequenceSelector();
    }
    public static void main(String[] args) {
        Sequence3 s = new Sequence3(10);
        for(int i=0; i<10; i++){
            s.add(new OtherObject("对象"+i));
        }
        Selector selector = s.selector();
        while(!selector.end()){
            System.out.println(selector.current());
            selector.next();
        }
    }
}


3.第三题


package net.mindview.innerclasses;
/**
 * 选择器
 */
interface Selector3 {
    //是否结束
    boolean end();
    //当前
    Object current();
    //下一个
    void next();
    @Override
    public String toString();
}
class OtherObject3 {
    String obj;
    OtherObject3(String obj){
        this.obj = obj;
    }
    @Override
    public String toString() {
        return obj;
    }
}
/**
 * 次序
 */
public class Sequence3 {
    private Object[] items;
    private int next = 0;
    private String str;
    //定义数组的个数
    public Sequence3(int size, String str){
        items = new Object[size];
        this.str = str;
    }
    //添加
    public void add(Object x){
        items[next ++] = x;
    }
    //内部类--顺序选择器
    private class SequenceSelector implements Selector3 {
        //选择器最开始指向第一个元素
        private int i = 0;
        @Override
        public boolean end() {
            return i == (items.length);
        }
        @Override
        public Object current() {
            // TODO Auto-generated method stub
            return items[i];
        }
        @Override 
        public void next() {
            if(i<items.length){
                i++;
            }
        }
        public String toString() {
            return str;
        }
    }
    public Selector3 selector() {
        return new SequenceSelector();
    }
    public static void main(String[] args) {
        Sequence3 s = new Sequence3(10, "三星");
        for(int i=0; i<10; i++){
            s.add(new OtherObject("对象"+i));
        }
        Selector3 selector = s.selector();
        while(!selector.end()){
            System.out.println(selector.current());
            selector.next();
            System.out.println(selector.toString());
        }
    }
}


4.第四题


package net.mindview.innerclasses;
/**
 * 选择器
 */
interface Selector {
    //是否结束
    boolean end();
    //当前
    Object current();
    //下一个
    void next();
}
class OtherObject {
    String obj;
    OtherObject(String obj){
        this.obj = obj;
    }
    @Override
    public String toString() {
        return obj;
    }
}
/**
 * 次序
 */
public class Sequence {
    private Object[] items;
    private int next = 0;
    //定义数组的个数
    public Sequence(int size){
        items = new Object[size];
    }
    //添加
    public void add(Object x){
        items[next ++] = x;
    }
    //内部类--顺序选择器
    private class SequenceSelector implements Selector {
        //选择器最开始指向第一个元素
        private int i = 0;
        @Override
        public boolean end() {
            return i == (items.length);
        }
        /**
         * 新增方法: 在内部类中引用外部类
         */
        public Sequence outer(){
            return Sequence.this;
        }
        @Override
        public Object current() {
            // TODO Auto-generated method stub
            return items[i];
        }
        @Override 
        public void next() {
            if(i<items.length){
                i++;
            }
        }
    }
    public Selector selector() {
        return new SequenceSelector();
    }
    public static void main(String[] args) {
        Sequence s = new Sequence(10);
        for(int i=0; i<10; i++){
            s.add("对象"+i);
        }
        Selector selector = s.selector();
        while(!selector.end()){
            System.out.println(selector.current());
            selector.next();
        }
    }
}


5.第五题


package net.mindview.innerclasses;
class Outter{
    class Inner{
    }
}
public class Test5 {
    public void getInner(){
        Outter outter = new Outter();
        Outter.Inner in = outter.new Inner();
    }
}


6.第六题


package net.mindview.innerclasses.test6.one;
public interface One {
    public String one();
}


package net.mindview.innerclasses.test6.two;
import net.mindview.innerclasses.test6.one.One;
public class Two {
    protected class TwoInner implements One{
        public TwoInner() {
            System.out.println("这时two的内部类,继承自One");
        }
        @Override
        public String one() {
            return "Two->one()";
        }
    }
}


package net.mindview.innerclasses.test6.three;
import net.mindview.innerclasses.test6.one.One;
import net.mindview.innerclasses.test6.two.Two;
public class Three extends Two{
    private Two two;
    public Three(Two two){
        System.out.println("这时Three类");
        this.two = two;
    }
    public One three(){
        return two.new TwoInner();
    }
    public static void main(String[] args) {
        Three three = new Three(new Two());
        One one = three.three();
        System.out.println(one.one());
    }
}


7.第七题


package net.mindview.innerclasses.test7;
interface Update{
    String update();
}
public class Show {
    private String str;
    private String showStr(){
        return str;
    }
    private class InnerUpdate implements Update{
        private int abc = 123;
        public String update(){
            str = "内部类修改";
            System.out.println(str);
            return showStr();
        }
    }
    public void visitInner(){
        InnerUpdate update = new InnerUpdate();
        System.out.println(update.abc);
        update.update();
    }
    public static void main(String[] args) {
        Show show = new Show();
        show.visitInner();
    }
}


8.(略)


9.第九题


package net.mindview.innerclasses.test9;
interface Show{
    String show();
}
public class Test9 {
    public String update(){
        class Inner implements Show{
            @Override
            public String show() {
                return "学习";
            }
        }
        Inner inner = new Inner();
        return inner.show();
    }
    public static void main(String[] args) {
        Test9 t = new Test9();
        System.out.println(t.update());
    }
}


10.第十题


package net.mindview.innerclasses.test9;
interface Show{
    String show();
}
public class Test9 {
    public String update(boolean flag){
        String str=null;
        if(flag){
            class Inner implements Show{
                @Override
                public String show() {
                    return "学习";
                }
            }
            Inner inner = new Inner();
            str = inner.show();
        }
        return str;
    }
    public static void main(String[] args) {
        Test9 t = new Test9();
        System.out.println(t.update(true));
    }
}


11.第十一题


package net.mindview.innerclasses.test10;
interface InterfaceClass{
    void i();
}
public class Test10 {
    private class Inner implements InterfaceClass{
        @Override
        public void i() {
        }
    }
    public InterfaceClass inner(){
        return new Inner();
    }
    public static void main(String[] args) {
        Test10 test10 = new Test10();
        InterfaceClass inner = test10.inner();
        //这样不可以,所以被隐藏了
        //Inner inner = test10.inner();
    }
}


12.第十二题


package net.mindview.innerclasses.test12;
interface Update{
    String update();
}
public class Show {
    private String str;
    private String showStr(){
        return str;
    }
    private class InnerUpdate implements Update{
        private int abc = 123;
        public String update(){
            str = "内部类修改";
            System.out.println(str);
            return showStr();
        }
    }
    public Update visitInner(){
        return new Update(){
            private int abc = 123;
            @Override
            public String update() {
                str = "内部类修改";
                System.out.println(str);
                return showStr();
            }
        };
    }
    public static void main(String[] args) {
        Show show = new Show();
        show.visitInner().update();
    }
}


13.第十三题


package net.mindview.innerclasses.test13;
interface Show{
    String show();
}
public class Test13 {
    public String update(boolean flag){
        String str=null;
        if(flag){
            return new Show(){
                @Override
                public String show() {
                    return "学习";
                }
            }.show();
        }
        return str;
    }
    public static void main(String[] args) {
        Test13 t = new Test13();
        System.out.println(t.update(true));
    }
}


14.(略)


15.第十五题


package net.mindview.innerclasses.test15;
class Person {
    private String name;
    public Person(String name){
        this.name = name;
    }
    @Override
    public String toString() {
        return name;
    }
}
public class Test15 {
    public Person method(String name){
        return new Person(name){
            @Override
            public String toString() {
                return super.toString();
            }
        };
    }
    public static void main(String[] args) {
        Test15 t = new Test15();
        System.out.println(t.method("张三").toString());
    }
}


16.第十六题


package net.mindview.innerclasses.test16;
interface Cycle {
    void make();
}
interface CycleFactory {
    Cycle getCycle();
}
class Unicycle implements Cycle{
    private Unicycle(){}
    @Override
    public void make() {
        System.out.println("make Unicycle");
    }
    public static CycleFactory factory = new CycleFactory(){
        @Override
        public Cycle getCycle() {
            return new Unicycle();
        }
    };
}
class Bicycle implements Cycle{
    private Bicycle(){}
    @Override
    public void make() {
        System.out.println("make Bicycle");
    }
    public static CycleFactory factory = new CycleFactory(){
        @Override
        public Cycle getCycle() {
            return new Bicycle();
        }
    };
}
class Tricycle implements Cycle{
    private Tricycle(){}
    @Override
    public void make() {
        System.out.println("make Tricycle");
    }
    public static CycleFactory factory = new CycleFactory(){
        @Override
        public Cycle getCycle() {
            return new Tricycle();
        }
    };
}
public class Cycles {
    public static void serice(CycleFactory factory){
        Cycle c = factory.getCycle();
        c.make();
    }
    public static void main(String[] args) {
        //我想要什么样的车,就找这种车的工厂去制作一辆车就可以了
        serice(Unicycle.factory);
        serice(Bicycle.factory);
        serice(Tricycle.factory);
    }
}


17.第十七题


package net.mindview.innerclasses.test17;
import java.util.Random;
/**
 * 这时一个抛硬币和掷骰子等类型的框架
 */
interface ThrowProduct {}
interface ThrowFactory{
    ThrowProduct getProduct();
}
class ThrowCorn implements ThrowProduct{
    Random rand = new Random();
    private ThrowCorn(){
        if(rand.nextInt(100) % 2 ==0){
            System.out.println("硬币的正面");
        }else{
            System.out.println("硬币的反面");
        }
    }
    public static ThrowFactory factory = new ThrowFactory(){
        @Override
        public ThrowProduct getProduct() {
            return new ThrowCorn();
        }
    };
}
class ThrowDice implements ThrowProduct{
    Random rand = new Random();
    private ThrowDice(){
        System.out.println("掷的骰子数是"+(rand.nextInt(6)+1));
    }
    public static ThrowFactory factory = new ThrowFactory(){
        @Override
        public ThrowProduct getProduct() {
            return new ThrowDice();
        }
    };
}
public class ThrowFrame {
    public static void service(ThrowFactory f){
        ThrowProduct p = f.getProduct();
    }
    public static void main(String[] args) {
        service(ThrowCorn.factory);
        service(ThrowDice.factory);
    }
}


18.第十八题


package net.mindview.innerclasses.test18;
public class Test18 {
    public static class QianTao{
    }
    public static void main(String[] args) {
        QianTao q = new QianTao();
    }
}


19.第十九题


package net.mindview.innerclasses.test19;
public class Test19 {
    //这时一个嵌套类
    public static class Inner1{
        //这时定义在嵌套类中的嵌套类
        static class Inner2{
            public static int i = 100; 
        }
    }
    public static void main(String[] args) {
        System.out.println(Inner1.Inner2.i);
    }
}

微信图片_20220507215354.png


20.第二十题 


package net.mindview.innerclasses.test20;
interface InnerInInterface{
    static class Inner{
        public Inner(){
            System.out.println("嵌套类构造方法");
        }
    }
}
public class Test20 {
    public static void main(String[] args) {
        //直接使用  new 外围类.嵌套类
        InnerInInterface.Inner inner = new InnerInInterface.Inner();
    }
}


21.第二十一题


package net.mindview.innerclasses.test21;
interface InterfaceClass {
    void f();
    void b();
    class InnerClass{
        static void get(InterfaceClass impl){
            impl.f();
        }
    }
}
public class Test21 implements InterfaceClass{
    public Test21(){
        System.out.println("这是Test21构造函数的方法");
    }
    public static void main(String[] args) {
        Test21 t = new Test21();
        new InterfaceClass.InnerClass().get(t);;
    }
    @Override
    public void f() {
        System.out.println("实现类   f()");
    }
    @Override
    public void b() {
        System.out.println("实现类   b()");    
    }
}


22.第二十二题


package net.mindview.innerclasses.test22;
//选择器
interface Selecotr {
    //选择器是否到达尾部
    boolean end();
    //下一个元素编号
    void next();
    //当前元素
    Object current();
}
public class Sequence {
    private Object[] items ;
    static int counter = 0;
    public Sequence(int size){
        items = new Object[size];
        for(int i=0; i<size; i++){
            add("对象"+i);
        }
    }
    public void add(Object o){
        items[counter++] = o;
    }
    public  Selecotr sequenceSelector = new Selecotr(){
        int i = 0;
        @Override
        public boolean end() {
            // TODO Auto-generated method stub
            return i == items.length;
        }
        @Override
        public void next() {
            if(i<items.length)
                i++;
        }
        @Override
        public Object current() {
            if(i<items.length){
                return items[i];
            }
            return null;
        }
    };
    //反序
    public Selecotr reverseSelector = new Selecotr(){
        int i = 9;
        @Override
        public boolean end() {
            return i<0;
        }
        @Override
        public void next() {
            i--;
        }
        @Override
        public Object current() {
            if(i>=0){
                return items[i];
            }
            return null;
        }
    };
    public static void main(String[] args) {
        Sequence s = new Sequence(10);
        //正序
        Selecotr se = s.sequenceSelector;
        while(!se.end()){
            System.out.println(se.current());
            se.next();
        }
        System.out.println("-----------");
        //反序
        Selecotr re = s.reverseSelector;
        while(!re.end()){
            System.out.println(re.current());
            re.next();
        }
    }
}


23.第二十三题


package net.mindview.innerclasses.test23;
public interface U {
    void method1();
    void method2();
    void method3();
}


package net.mindview.innerclasses.test23;
public class A {
    U methodA1(){
        return new U(){
            @Override
            public void method1() {
                System.out.println("A methodA1 method1()");
            }
            @Override
            public void method2() {
                System.out.println("A methodA1 method2()");
            }
            @Override
            public void method3() {
                System.out.println("A methodA1 method3()");
            }
        };
    }
}


package net.mindview.innerclasses.test23;
public class B {
    U[] us ;
    private static int counter = 0; 
    public B(int size){
        us = new U[size];
    }
    void methodB1(U u){
        us[counter++] = u;
    }
    void methodB2(int i){
        us[i] = null;
    }
    void methodB3(){
        for(int i=0; i<us.length; i++){
            U u = us[i];
            u.method1();
            u.method2();
            u.method3();
        }
    }
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new A();
        A a3 = new A();
        A a4 = new A();
        A a5 = new A();
        B b1 = new B(5);
        b1.methodB1(a1.methodA1());
        b1.methodB1(a2.methodA1());
        b1.methodB1(a3.methodA1());
        b1.methodB1(a4.methodA1());
        b1.methodB1(a5.methodA1());
        b1.methodB3();
        System.out.println("----------------");
        b1.methodB2(2);
        b1.methodB3();
    }
}


24.f


25.f


26.f


27.f

文章标签：
Java
关键词：
Java编程
Java习题
Java编程思想
Java编程思想习题
p2jbaco26vdds
目录
相关文章
叫个什么名字
|
1月前
|
Java 开发者
Java多线程编程中的常见误区与最佳实践####
本文深入剖析了Java多线程编程中开发者常遇到的几个典型误区，如对`start()`与`run()`方法的混淆使用、忽视线程安全问题、错误处理未同步的共享变量等，并针对这些问题提出了具体的解决方案和最佳实践。通过实例代码对比，直观展示了正确与错误的实现方式，旨在帮助读者构建更加健壮、高效的多线程应用程序。 ####
叫个什么名字
57 5
mrq4nk6ni2neg
|
1月前
|
安全 Java UED
深入浅出Java多线程编程
【10月更文挑战第40天】在Java的世界中，多线程是提升应用性能和响应能力的关键。本文将通过浅显易懂的方式介绍Java中的多线程编程，从基础概念到高级特性，再到实际应用案例，带你一步步深入了解如何在Java中高效地使用多线程。文章不仅涵盖了理论知识，还提供了实用的代码示例，帮助你在实际开发中更好地应用多线程技术。
mrq4nk6ni2neg
45 5
艾利克斯冰
|
1月前
|
JSON Java Apache
非常实用的Http应用框架，杜绝Java Http 接口对接繁琐编程
UniHttp 是一个声明式的 HTTP 接口对接框架，帮助开发者快速对接第三方 HTTP 接口。通过 @HttpApi 注解定义接口，使用 @GetHttpInterface 和 @PostHttpInterface 等注解配置请求方法和参数。支持自定义代理逻辑、全局请求参数、错误处理和连接池配置，提高代码的内聚性和可读性。
艾利克斯冰
132 3
游客moiomvrp3vyac2
|
19天前
|
Java 程序员
Java编程中的异常处理：从基础到高级
在Java的世界中，异常处理是代码健壮性的守护神。本文将带你从异常的基本概念出发，逐步深入到高级用法，探索如何优雅地处理程序中的错误和异常情况。通过实际案例，我们将一起学习如何编写更可靠、更易于维护的Java代码。准备好了吗？让我们一起踏上这段旅程，解锁Java异常处理的秘密！
游客moiomvrp3vyac2
34 0
互联网课堂
|
3天前
|
算法 Java 调度
java并发编程中Monitor里的waitSet和EntryList都是做什么的
在Java并发编程中，Monitor内部包含两个重要队列：等待集（Wait Set）和入口列表（Entry List）。Wait Set用于线程的条件等待和协作，线程调用`wait()`后进入此集合，通过`notify()`或`notifyAll()`唤醒。Entry List则管理锁的竞争，未能获取锁的线程在此排队，等待锁释放后重新竞争。理解两者区别有助于设计高效的多线程程序。 - **Wait Set**：线程调用`wait()`后进入，等待条件满足被唤醒，需重新竞争锁。 - **Entry List**：多个线程竞争锁时，未获锁的线程在此排队，等待锁释放后获取锁继续执行。
互联网课堂
27 12
游客5fdji2pvmf8888
|
23天前
|
设计模式 Java 开发者
Java多线程编程的陷阱与解决方案####
本文深入探讨了Java多线程编程中常见的问题及其解决策略。通过分析竞态条件、死锁、活锁等典型场景，并结合代码示例和实用技巧，帮助开发者有效避免这些陷阱，提升并发程序的稳定性和性能。 ####
游客5fdji2pvmf8888
53 16
aliyun0641063962-48771
|
23天前
|
缓存 Java 开发者
Java多线程编程的陷阱与最佳实践####
本文深入探讨了Java多线程编程中常见的陷阱，如竞态条件、死锁和内存一致性错误，并提供了实用的避免策略。通过分析典型错误案例，本文旨在帮助开发者更好地理解和掌握多线程环境下的编程技巧，从而提升并发程序的稳定性和性能。 ####
aliyun0641063962-48771
47 11
游客nmbcre4jd7shs
|
16天前
|
安全 算法 Java
Java多线程编程中的陷阱与最佳实践####
本文探讨了Java多线程编程中常见的陷阱，并介绍了如何通过最佳实践来避免这些问题。我们将从基础概念入手，逐步深入到具体的代码示例，帮助开发者更好地理解和应用多线程技术。无论是初学者还是有经验的开发者，都能从中获得有价值的见解和建议。 ####
游客nmbcre4jd7shs
33 4
mg的嘟嘟
|
16天前
|
Java 调度
Java中的多线程编程与并发控制
本文深入探讨了Java编程语言中多线程编程的基础知识和并发控制机制。文章首先介绍了多线程的基本概念，包括线程的定义、生命周期以及在Java中创建和管理线程的方法。接着，详细讲解了Java提供的同步机制，如synchronized关键字、wait()和notify()方法等，以及如何通过这些机制实现线程间的协调与通信。最后，本文还讨论了一些常见的并发问题，例如死锁、竞态条件等，并提供了相应的解决策略。
mg的嘟嘟
40 3
肥猪肥猪-17824
|
26天前
|
Java 程序员
Java编程中的异常处理：从基础到高级
在Java的世界里，异常是程序运行中不可忽视的“惊喜”。它们可能突如其来，也可能悄无声息地潜伏。掌握异常处理的艺术，意味着你能够优雅地面对程序的不完美，并确保它即使在风雨飘摇中也能继续航行。本文将引导你理解Java异常的本质，探索捕获和处理这些异常的方法，并最终学会如何利用自定义异常为你的代码增添力量。
肥猪肥猪-17824
39 8

热门文章

最新文章

  • 1
    从零搭建Web所需服务（四）Java连接ES进行分词并获取结果
  • 2
    迅速了解多例模式竞争者-枚举 | 带你学《Java面向对象编程》之七十四
  • 3
    java源码 - ReentrantLock
  • 4
    关于JAVA中子类和父类的构造方法
  • 5
    Java Poi 创建与读取Excel
  • 6
    Java并发系列（6）java关键字-final
  • 7
    【java】值传递和引用传递---对象作为方法的参数传入属于哪种传递
  • 8
    Java.nio vs Java.io
  • 9
    Java程序内存分析：使用mat工具分析内存占用
  • 10
    java debug 渗透测试
  • 1
    【Java开发指南 | 第三十一篇】Java 包(package)
    72
  • 2
    【Java开发指南 | 第二十九篇】Java接口
    46
  • 3
    【Java开发指南 | 第二十八篇】Java封装
    53
  • 4
    【Java开发指南 | 第二十六篇】Java多态
    40
  • 5
    【Java开发指南 | 第二十四篇】Java继承
    59
  • 6
    【Java开发指南 | 第九篇】访问实例变量和方法、继承、接口
    53
  • 7
    【Java开发指南 | 第八篇】Java变量、构造方法、创建对象
    93
  • 8
    Java Stream API详解与使用
    94
  • 9
    Java医院绩效考核系统源码B/S+avue+MySQL助力医院实现精细化管理
    81
  • 10
    《手把手教你》系列技巧篇（四十三）-java+ selenium自动化测试-处理https 安全问题或者非信任站点-上篇（详解教程）
    133

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    DataWorks售前咨询