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

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

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

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
目录
相关文章
shuj
|
10天前
|
设计模式 安全 Java
Java编程中的单例模式深入剖析
【10月更文挑战第21天】在Java的世界里，单例模式是设计模式中一个常见而又强大的存在。它确保了一个类只有一个实例，并提供一个全局访问点。本文将深入探讨如何正确实现单例模式，包括常见的实现方式、优缺点分析以及最佳实践，同时也会通过实际代码示例来加深理解。无论你是Java新手还是资深开发者，这篇文章都将为你提供宝贵的见解和技巧。
shuj
90 65
东方睿赢
|
1天前
|
Java 开发者
在Java多线程编程的世界里，Lock接口正逐渐成为高手们的首选，取代了传统的synchronized关键字
在Java多线程编程的世界里，Lock接口正逐渐成为高手们的首选，取代了传统的synchronized关键字
东方睿赢
11 4
yuanzhengme
|
2天前
|
Java API Apache
Java编程如何读取Word文档里的Excel表格，并在保存文本内容时保留表格的样式？
【10月更文挑战第29天】Java编程如何读取Word文档里的Excel表格，并在保存文本内容时保留表格的样式？
yuanzhengme
14 5
丰宝宝
|
1天前
|
消息中间件 供应链 Java
掌握Java多线程编程的艺术
【10月更文挑战第29天】 在当今软件开发领域，多线程编程已成为提升应用性能和响应速度的关键手段之一。本文旨在深入探讨Java多线程编程的核心技术、常见问题以及最佳实践，通过实际案例分析，帮助读者理解并掌握如何在Java应用中高效地使用多线程。不同于常规的技术总结，本文将结合作者多年的实践经验，以故事化的方式讲述多线程编程的魅力与挑战，旨在为读者提供一种全新的学习视角。
丰宝宝
15 3
shuj
|
2天前
|
安全 Java 调度
Java中的多线程编程入门
【10月更文挑战第29天】在Java的世界中，多线程就像是一场精心编排的交响乐。每个线程都是乐团中的一个乐手，他们各自演奏着自己的部分，却又和谐地共同完成整场演出。本文将带你走进Java多线程的世界，让你从零基础到能够编写基本的多线程程序。
shuj
10 1
萝卜带泥
|
6天前
|
缓存 Java 调度
Java中的多线程编程：从基础到实践
【10月更文挑战第24天】 本文旨在为读者提供一个关于Java多线程编程的全面指南。我们将从多线程的基本概念开始，逐步深入到Java中实现多线程的方法，包括继承Thread类、实现Runnable接口以及使用Executor框架。此外，我们还将探讨多线程编程中的常见问题和最佳实践，帮助读者在实际项目中更好地应用多线程技术。
萝卜带泥
12 3
ShaFaChuang-36210
|
8天前
|
监控 安全 Java
Java多线程编程的艺术与实践
【10月更文挑战第22天】 在现代软件开发中，多线程编程是一项不可或缺的技能。本文将深入探讨Java多线程编程的核心概念、常见问题以及最佳实践，帮助开发者掌握这一强大的工具。我们将从基础概念入手，逐步深入到高级主题，包括线程的创建与管理、同步机制、线程池的使用等。通过实际案例分析，本文旨在提供一种系统化的学习方法，使读者能够在实际项目中灵活运用多线程技术。
ShaFaChuang-36210
22 5
游客moiomvrp3vyac2
|
9天前
|
存储 安全 Java
Java编程中的对象序列化与反序列化
【10月更文挑战第22天】在Java的世界里，对象序列化和反序列化是数据持久化和网络传输的关键技术。本文将带你了解如何在Java中实现对象的序列化与反序列化，并探讨其背后的原理。通过实际代码示例，我们将一步步展示如何将复杂数据结构转换为字节流，以及如何将这些字节流还原为Java对象。文章还将讨论在使用序列化时应注意的安全性问题，以确保你的应用程序既高效又安全。
游客moiomvrp3vyac2
13 4
萝卜带泥
|
6天前
|
缓存 安全 Java
Java中的多线程编程：从基础到实践
【10月更文挑战第24天】 本文将深入探讨Java中的多线程编程，包括其基本原理、实现方式以及常见问题。我们将从简单的线程创建开始，逐步深入了解线程的生命周期、同步机制、并发工具类等高级主题。通过实际案例和代码示例，帮助读者掌握多线程编程的核心概念和技术，提高程序的性能和可靠性。
萝卜带泥
10 2
叫个什么名字
|
7天前
|
Java
Java中的多线程编程：从基础到实践
本文深入探讨Java多线程编程，首先介绍多线程的基本概念和重要性，接着详细讲解如何在Java中创建和管理线程，最后通过实例演示多线程的实际应用。文章旨在帮助读者理解多线程的核心原理，掌握基本的多线程操作，并能够在实际项目中灵活运用多线程技术。
叫个什么名字
12 3

热门文章

最新文章

  • 1
    Rhino 是一个完全使用Java语言编写的开源JavaScript实现。Rhino通常用于在Java程序中，为最终用户提供脚本化能力。它被作为J2SE 6上的默认Java脚本化引擎。
  • 2
    深入java虚拟机学习 -- 类的加载机制(三)
  • 3
    再转一篇关于Memcached在JAVA项目里应用的入门文章
  • 4
    JAVA DES
  • 5
    Java类库中的一些常用的查找排序
  • 6
    Java本地文件操作(六）文件的简单读写
  • 7
    JAVA SERVLET 属性范围样例
  • 8
    Java魔法堂：类加载器入了个门
  • 9
    Java——基于java自身包实现消息系统间的通信（TCP/IP+BIO）
  • 10
    通过java api提交自定义hadoop 作业
  • 1
    flink最新master代码编译出现Java Runtime Environment 问题
    79
  • 2
    深入理解Java并发编程：线程池的应用与优化
    62
  • 3
    基于 java + Springboot + vue +mysql 大学生实习管理系统（含源码）
    443
  • 4
    使用JSON和XML：数据交换格式在Java Web开发中的应用
    100
  • 5
    构建RESTful API：Java中的RESTful服务开发
    84
  • 6
    【Java】仓库管理系统 SpringBoot+LayUI+DTree（源码）【独一无二】
    82
  • 7
    软件工程设计原理接口隔离原则 ，具体实现及JAVA代码举例
    52
  • 8
    软件工程设计原理依赖倒置原则 ，具体实现及JAVA代码举例
    60
  • 9
    软件工程设计原理开放封闭原则 ，具体实现及JAVA代码举例
    74
  • 10
    Java通过反射获取类调用方法
    51

    • 相关课程

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

    • 相关电子书

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

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 阿里云平台上进行Java程序的编译与运行
  • RocketMQ中使用Java客户端发送消息和消费的应用
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月