Java编程思想练习题（四）

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java编程思想练习题（四），小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含11918字，纯文字阅读大概需要18分钟。

内容图文

一、创建一个类，它包含一个未初始化的String引用。验证该引用被Java初始化成了null。

public class Main {
    public static void main(String[] args) {
        Test test = new Test();
        if (test.str == null) {
            System.out.println("String default init is null.");
        }
    }
}
class Test {
    String str;
}

String default init is null.

二、创建一个类，它包含一个在定义时就被初始化了的String域，以及另一个通过构造器初始化的String域。这两种方式有何差异？

public class Main {
    public static void main(String[] args) {
        Test test = new Test("initing");
        System.out.println("inited:" + test.inited + ", initing:" + test.initing);
    }
}
class Test {
    String inited = "inited";
    String initing;
    public Test(String initing) {
        System.out.println("constructor inited:" + this.inited + ", initing:" + this.initing);
        this.initing = initing;
    }
}

constructor inited:inited, initing:null
inited:inited, initing:initing

三、创建一个带默认构造器的类，在构造器中打印一条消息。为这个类创建一个对象。

public class Main {                                     
    public static void main(String[] args) {            
        new Test();                                     
    }                                                   
}                                                       
class Test {                                            
    public Test() {                                     
        System.out.println("defaut constructor");       
    }                                                   
}

defaut constructor

四、为前一个练习中的类添加一个重载构造器，令其接受一个字符串参数，并在构造器中把你自己的消息和接收的参数一起打印出来。

public class Main {                                                       
    public static void main(String[] args) {                              
        new Test("param");                                                
    }                                                                     
}                                                                         
class Test {                                                              
    public Test() {                                                       
        System.out.println("defaut constructor");                         
    }                                                                     
    public Test(String s) {                                               
        System.out.println("has param constructor, param is {" + s + "}");
    }                                                                     
}

has param constructor, param is {param}

五、创建一个名为Dog的类，它具有重载的bark()方法。此方法应根据不同的基本数据类型进行重载，并根据被调用的版本，打印出不同类型的狗吠（barking）、咆哮（howing）等信息。编写mian()来调用所以不同版本的方法。

public class Main {
    public static void main(String[] args) {
        Bark bark = new Bark();
        bark.bark(1);
        bark.bark('c');
    }
}
class Bark {
    public void bark(int i) {
        System.out.println("barking");
    }
    public void bark(char c) {
        System.out.println("howling");
    }
}

barking
howling

六、修改前一个练习的程序，让两个重载方法各自接受两个类型的不同的参数，但二者顺序相反。验证其是否工作。

public class Main {
    public static void main(String[] args) {
        Bark bark = new Bark();
        bark.bark(1, 'c');
        bark.bark('c'， 1);
    }
}
class Bark {
    public void bark(int i, char c) {
        System.out.println("barking");
    }
    public void bark(char c, int i) {
        System.out.println("howling");
    }
}

barking
howling

七、创建一个没有构造器的类，并在main()中创建其对象，用以验证编译器是否真的自动加入了默认构造器。

public class Main {
    public static void main(String[] args) {
        Test test = new Test();
        test.fun();
    }
}
class Test {
    public void fun() {
        System.out.println("auto create default constructor");
    }
}

auto create default constructor

八、编写具有两个方法的类，在第一个方法内调用第二个方法两次；第一次调用时，不使用this，第二次调用时，使用this——这里只是为了验证它是起作用的，你不应该在实践中使用这种方法。

public class Main {
    public static void main(String[] args) {
        new Test().test2();
    }
}
class Test {
    public Test test1(String str) {
        System.out.println(str);
        return this;
    }
    public void test2() {
        test1("第一次调用");
        this.test1("第二次调用");
    }
}

第一次调用
第二次调用

九、编写具有两个构造器（重载）的类，并在第一个构造器中通过this调用第二个构造器。

public class Main {
    public static void main(String[] args) {
        new Test();
    }
}
class Test {
    private String str;
    public Test() {
        this("Test");
    }
    public Test(String str) {
        this.str = str + "1";
        System.out.println(this.str);
    }
}

Test1

十、编写具有finalize()方法的类，并在方法中打印消息。在main()中为该类创建一个对象。试解释这个程序的行为。

public class Main {
    public static void main(String[] args) {
        Test test = new Test();
        new Test();
        System.gc();
    }
}
class Test {
    private static int temp;
    private int id = temp++;
    public Test() {
        System.out.println("constructor id=" + this.id);
    }
    @Override
    public void finalize() {
        try {
            System.out.println("finalize id=" + this.id);
            super.finalize();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }
}

constructor id=0
constructor id=1
finalize id=1

十一、修改前一个练习的程序，让你的finalize()总会被调用。

public class Main {
    public static void main(String[] args) {
        Test test = new Test();
        new Test();
        test = null; // 失去引用，被回收
        System.gc();
    }
}
class Test {
    private static int temp;
    private int id = temp++;
    public Test() {
        System.out.println("constructor id=" + this.id);
    }
    @Override
    public void finalize() {
        try {
            System.out.println("finalize id=" + this.id);
            super.finalize();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }
}

constructor id=0
constructor id=1
finalize id=1
finalize id=0

　十二、编写名为Tank的类，此类的状态可以是“满的”或“空的”。其终结条件是：对象被清理时必须处于空状态。请编写finalize()以检验终结条件是否成立。在main()中测试Tank可能发生的几种使用方式。

public class Main {
    public static void main(String[] args) {
        Tank tank = new Tank();
        tank.empty();
        new Tank().empty();
        new Tank();
        tank = null;
        System.gc();
    }
}
class Tank {
    private static int temp;
    private int id = temp++;
    boolean empty;

    public Tank() {
        this.empty = false;
        System.out.println("Tank id=" + this.id);
    }

    public void empty() {
        this.empty = true;
        System.out.println("Tank id=" + this.id + ", empty=true");
    }
    @Override
    protected void finalize() {
        if (empty) {
            System.out.println("Tank id=" + this.id + " empty=true finalized");
        } else {
            System.out.println("Tank id=" + this.id + " empty=false can't finalize");
        }
    }
}

Tank id=0
Tank id=0, empty=true
Tank id=1
Tank id=1, empty=true
Tank id=2
Tank id=2 empty=false can't finalize
Tank id=1 empty=true finalized
Tank id=0 empty=true finalized

十三、验证前面段落中的语句。

public class Main {
    public static void main(String[] args) {
        System.out.println("Inside main()");
        // 无论是运行(1)代码访问静态的cup1对象，
        // 还是把(1)注释掉，运行(2)的代码，
        // Cups的静态初始化动作都会得到执行。
        Cups.cup1.f(99); // (1)
    }
//    static Cups cups1 = new Cups(); //(2)
//    static Cups cups2 = new Cups(); //(2)
}
class Cup {
    Cup(int marker) {
        System.out.println("Cup (" + marker + ")");
    }
    void f(int marker) {
        System.out.println("f (" + marker + ")");
    }
}
class Cups {
    static Cup cup1;
    static Cup cup2;
    static {
        cup1 = new Cup(1);
        cup2 = new Cup(2);
    }
    Cups() {
        System.out.println("Cups()");
    }
}

Inside main()
Cup (1)
Cup (2)
f (99)

注释掉(1)，运行(2)，返回：

Cup (1)
Cup (2)
Cups()
Cups()
Inside main()

十四、编写一个类，拥有两个静态字符串域，其中一个在定义处初始化，另一个在静态块中初始化。现在，加入一个静态方法用以打印出两个字段值。请证明它们都会在被使用之前完成初始化动作。

public class Main {
    public static void main(String[] args) {
        System.out.println("Inside main()");
        Cups.cup1.fun();
    }
}
class Cup {
    private int i;
    Cup(int i) {
        this.i = i;
        System.out.println("Cup (" + i + ")");
    }
    void fun() {
        System.out.println("fun (" + i + ")");
    }
}
class Cups {
    static Cup cup1;
    static Cup cup2 = new Cup(2);
    static {
        cup1 = new Cup(1);
    }
}

Inside main()
Cup (2)
Cup (1)
fun (1)

十五、编写一个含有字符串域的类，并采用实例初始化方式进行初始化。

public class Main {
    StringField stringField1;
    StringField stringField2;
    {
        stringField1 = new StringField("two");
        stringField2 = new StringField();
        System.out.println("stringField1 & stringField1 initialized");
    }
    Main() {
        System.out.println("Main()");
    }
    public static void main(String[] args) {
        System.out.println("Inside main()");
        new Main();
    }
}
class StringField {
    private String str1 = new String("one");
    private String str2;
    StringField() {
        System.out.println("StringField() [ str1=" + str1 + " ]");
        if (str2 != null) {
            System.out.println("StringField() [ str2=" + str2 + " ]");
        }
    }
    StringField(String str) {
        this.str2 = str;
        System.out.println("StringField(String) [ str2=" + str2 + " ]");
    }
}

Inside main()
StringField(String) [ str2=two ]
StringField() [ str1=one ]
stringField1 & stringField1 initialized
Main()

十六、创建一个String对象数据，并为每一个元素都赋值一个String。用for循环来打印该数组。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        String[] strArr = new String[3];
        for (int i = 0; i < strArr.length; i++) {
            strArr[i] = String.valueOf(i);
        }
        System.out.println(Arrays.toString(strArr));
    }
}

[0, 1, 2]

七、创建一个类，它有一个接受一个String参数的构造器。在构造阶段，打印该参数。创建一个该类的对象引用数组，但是不实际去创建对象赋值给该数组。当运行程序时，请注意来自对该构造器的调用中的初始化消息是否打印了出来。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        StringField[] strArr = new StringField[1];
        System.out.println(Arrays.toString(strArr));
    }
}
class StringField {
    StringField(String str) {
        System.out.println("StringField [ " + str + " ]");
    }
}

[null]

十八、通过创建对象赋值给引用数组，从而完成前一个练习。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        StringField[] strArr = new StringField[]{new StringField("str0"),new StringField("str1"),};
        System.out.println(Arrays.toString(strArr));
    }
}
class StringField {
    StringField(String str) {
        System.out.println("StringField [ " + str + " ]");
    }
}

StringField [ str0 ]
StringField [ str1 ]
[StringField@61a485d2, StringField@39fb3ab6]

十九、写一个类，它接受一个可变参数的String数组。验证你可以向该方法传递一个用逗号分隔的String列表，或是一个String[]。

public class Main {
    public static void main(String[] args) {
        new Test().fun("H", "e", "l", "l", "o", ",");
        new Test().fun("W", "o", "r", "l", "d", "!");
    }
}
class Test {
    public void fun(String... strArr) {
        for (String str : strArr) {
            System.out.print(str);
        }
        System.out.println();
    }
}

Hello,
World!

二十、创建一个使用可变参数列表而不是普通main()语法的main()。打印所产生的args数组的所有元素，并用各种不同数量的命令行参数来测试它。

public class Main {
    public static void main(String... args) {
        for(String param:args){
            System.out.print(param + " ");
        }
    }
}

在idea中做启动配置

Java编程思想练习题（四） - 文章图片

Hello World !

二十一、创建一个enum，它包含纸币中最小的面值的6种类型。通过values()循环并打印每一个值及其ordinal()。

public enum RMBEnum {
    ONE, TWO, FIVE, TEN, FIVTY, HUNDRED
}
public class Main {
    public static void main(String... args) {
        for (RMBEnum rmb : RMBEnum.values()) {
            System.out.println("No." + rmb.ordinal() + " is " + rmb + ".");
        }
    }
}

No.0 is ONE.
No.1 is TWO.
No.2 is FIVE.
No.3 is TEN.
No.4 is FIVTY.
No.5 is HUNDRED.

二十二、在前面的例子中，为enum写一个switch语句，对于每一个case，输出该特定货币的描述。

public class Main {
    public static void main(String... args) {
        for (RMBEnum rmb : RMBEnum.values()) {
            fun(rmb);
        }
    }
    private static void fun(RMBEnum rmb){
        switch (rmb) {
            case ONE:
                System.out.println("RMB face value " + rmb + " is smallest.");
                break;
            case TWO:
                System.out.println("RMB face value " + rmb + " is small");
                break;
            case FIVE:
                System.out.println("RMB face value " + rmb + " is middle.");
                break;
            case TEN:
                System.out.println("RMB face value " + rmb + " is large.");
                break;
            case FIVTY:
                System.out.println("RMB face value " + rmb + " is extra large.");
                break;
            case HUNDRED:
                System.out.println(rmb + " is largest.");
                break;
        }
    }
}

RMB face value ONE is smallest.
RMB face value TWO is small
RMB face value FIVE is middle.
RMB face value TEN is large.
RMB face value FIVTY is extra large.
RMB face value HUNDRED is largest.

内容总结

以上是互联网集市为您收集整理的Java编程思想练习题（四）全部内容，希望文章能够帮你解决Java编程思想练习题（四）所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/648801.html

来源：【匿名】

【上一篇】Java中值传递和引用传递【下一篇】JAVA/JSP学习系列之五

更多 ►

【Java编程思想练习题（四）】教程文章相关的互联网学习教程文章

吸血鬼数字：我最开始想的是把四位数拆开，然后进行自由组合然后相乘，最后比较得到结果，在网上去看了一些朋友的做法，让我大吃一惊啊，想到自己的算法也要好好看了，这样子下去是不行滴现贴出代码：package edu.cqu.main;import java.util.Arrays;/*** 问题描述：* 吸血鬼数字是指位数为偶数的数字，可以由一对数字相乘而得到，而这对数字各包含乘积的一半位数的数字，* 其中从最初的数字中选取的数字可以任意排序。* ...

JAVA编程思想笔记第四章控制执行流程【代码】

4.1 控制if-elseif(Boolean-expression)statement; else if(Boolean-expression)statement; elsestatement;switch选择语句switch(integral-selector) {case integral-value1 : statement; break;case integral-value2 : statement; break;case integral-value3 : statement; break;// ...default: statement; }4.2 迭代循环语句/迭代语句while语句while(Boolean-expression)statementdo-while语句至少执行一次dostatement while(Bo...

java 编程思想 22.11: java bean 案例代码【图】

java 编程思想 22.11: java bean 案例代码 thinking in java 4免费下载:http://download.csdn.net/detail/liangrui1988/7580155package org.rui.swing.bean;import java.awt.Color; import java.awt.event.ActionListener; import java.awt.event.KeyListener;import org.rui.classts.Pet; /*** 简单的bean* @author lenovo**/ public class Frog {private int jumps;private Color color;private Pet pet;private boolean jmpr...

java编程思想 -- 多态

一:?向上转型和向下转型面向对象中的转型只会发生在有继承关系的子类和父类中（接口的实现也包括在这里）。父类：人????子类：男人向上转型：?Person?p?=?new?Man()?;?//向上转型不需要强制类型转化向下转型：?Man?man?=?(Man)new?Person()?;?//必须强制类型转化?向上转型??子类创建对象时,可以使用向上转型的形式操作,方法程序的后期维护,??List队列也是使用的向上转型package com.wj.interfaceDemo;/***向上转型*/class People{ ...

Java编程思想

在整个开发过程中，最重要的事情就是：不要将自己迷失！应该时刻提醒自己注意以下几个问题：(1) 对象是什么？（怎样将自己的项目分割成一系列单独的组件？）(2) 它们的接口是什么？（需要将什么消息发给每一个对象？）在确定了对象和它们的接口后，便可着手编写一个程序。出于对多方面原因的考虑，可能还需要比这更多的说明及文档，但要求掌握的资料绝对不能比这还少。整个过程可划分为四个阶段，阶段 0 刚刚开始采用某些形式的结构...

Java编程思想学习笔记-第十章【代码】

.title { text-align: center; margin-bottom: .2em } .subtitle { text-align: center; font-size: medium; font-weight: bold; margin-top: 0 } .todo { font-family: monospace; color: red } .done { font-family: monospace; color: green } .priority { font-family: monospace; color: orange } .tag { background-color: #eee; font-family: monospace; padding: 2px; font-size: 80%; font-weight: normal } .timestamp {...

《 Java 编程思想》CH06 访问权限控制【代码】

访问控制（或隐藏具体实现）与“最初的实现并不恰当”有关。重构即重写代码，以使得它更可读，更容易理解，并因此而更具维护性。在面向对象设计中需要考虑一个基本问题：“如何把变动的事物与保持不变的事物区分开来”应该尽可能将一切方法都定为private，而仅向客户端程序员公开你愿意让他们使用的方法。包：库单元包内包含有一组类，它们在单一的名字空间之下被组织在一起为了解决潜在的名字冲突问题，Java使用 package 对名称空...

6.JAVA编程思想初始化和清除

欢迎转载，转载请标明出处：http://blog.csdn.net/notbaron/article/details/51040234随着计算机的进步，‘不安全’的程序设计已成为造成编程代价高昂的罪魁祸首之一。许多 C程序的错误都是由于程序员忘记初始化一个变量造成的。对于现成的库，若用户不知道如何初始化库的一个组件，就往往会出现这一类的错误。清除是另一个特殊的问题，因为用完一个元素后，由于不再关心，所以很容易把它忘记。这样一来，那个元素占用的资源会一直...

12.JAVA编程思想——集合的类型

12.JAVA编程思想——集合的类型欢迎转载，转载请标明出处：http://blog.csdn.net/notbaron/article/details/51100510标准Java 1.0 和1.1 库配套提供了非常少的一系列集合类。但对于自己的大多数编程要求，它们基本上都能胜任。Java 1.2 提供的是一套重新设计过的大型集合库。1 VectorVector 的用法很简单，大多数时候只需用addElement()插入对象，用elementAt()一次提取一个对象，并用elements()获得对序列的一个“枚举”。但...

Java编程思想笔记-类的初始化顺序【代码】

1、如果有父类，先初始化父类，然后初始化子类2、先初始化静态成员变量、静态代码块（static { }包围的代码），然后初始化非静态成员变量、非静态代码块（大括号包围的代码）。静态成员变量间、非静态成员变量间按定义顺序初始化。3、调用构造函数class Bowl {Bowl(int marker) {System.out.println("Bowl(" + marker + ")");}void f(int marker) {System.out.println("f(" + marker + ")");} }class Cupboard {Bowl b3 = new Bowl...

《java编程思想》第十章内部类【代码】

定义：将一个类定义放在一个类的内部，这就是内部类。10.1创建内部类OuterClassName。InnerClassName 10.2链接到外部类内部类能访问外围对象的所有成员，而不需要任何特殊条件。此外内部类还拥有其外部类的所有元素的访问权。包括private原因：当某个外围类的对象创建了一个内部类对象时，此内部类对象必定会秘密的捕获一个指向那个外围类对象的引用。然后，在你访问此外围类的成员时，就是用那个引用来选择外围类的成员。10.3 使...

《JAVA编程思想》学习笔记——第十三章字符串【图】

String对象是不可变的。查看JDk文档你就会发现，String类每一个看起来会修改String值的方法，实际上都是创建了一个全新的String对象，以包含修改后的字符串内容。而最初的String对象则丝毫未动。+和StringBuilder StringBuilder比+更高效 String常用操作 650) this.width=650;" src="/upload/getfiles/default/2022/11/9/20221109114104547.jpg" title="123.png" /> 正则表达式略本文出自 “小城运...

Java编程思想(九) —— 通过异常处理错误(1)【图】

前阵子看到一个编程的学习方法——橡皮鸭调试法，就是拿一只小黄鸭。面对面，跟他讲解你的编程思路，如果你没有橡皮鸭或者是一个能听你讲java，c，cpp，前端，io，系统内核，汇编，数据结构，计算机网络的女朋友，那么写博客也是你自己梳理好思路的一个好方法。书中原话：java的基本理念是结构不佳的代码不能运行。其实我之前也搞不懂为什么要弄个这样的东西出来，其实跟书上讲的一样，“异常”有“对此感到意...

net.mindview.util.TextFile 类 java编程思想【代码】【图】

转载参考 https://blog.csdn.net/kencolin/article/details/42246661关于对Java编程思想中，P546页TextFile这个类在Eclipse中运行出错，而在控制台编译运行正确的问题。今天在把Java编程思想这本书中的代码在Eclipse中执行的时候出现了一个问题，一直困扰着我。 1//: net/mindview/util/TextFile.java 2// Static functions for reading and writing text files as 3// a single string, and treating a file as an ArrayList...

《 Java 编程思想》CH03 操作符【代码】

《 Java 编程思想》CH03 操作符在最底层，Java中的数据是通过操作符来操作的。操作符+,-,*,*，=与其他语言类似几乎所有的操作符只能操作“基本类似”，而=，==，!=是例外String 类支持+和+=操作符，表示拼接操作，在进行拼接的操作会尝试将非 String 的元素转换为 String（调用tostring())赋值操作符=的左边（左值）必须是一个明确的已命名的变量。赋值在为对象“赋值”时，其实质是拷贝“引用”，需要注意“别名现象”package com...

JAVA - 技术教程分类

Java 教程 Java 简介 Java 开发环境配置 Java 基础语法 Java 对象和类 Java 基本数据类型 Java 变量类型 Java 修饰符 Java 运算符 Java 循环结构 Java 条件语句 Java switch case Java Number & Math 类 Java Character 类 Java String 类 Java StringBuffer Java 数组 Java 日期时间 Java 方法 Java Stream、File、IO Java Scanner 类 Java 异常处理 Java 继承 Java Override/Overload Java 多态 Java 抽象类 Java 封装 Java 接口 Java 枚举 Java 包(package) Java 数据结构 Java 集合框架 Java ArrayList Java LinkedList Java HashSet Java HashMap Java Iterator Java Object Java 泛型 Java 序列化 Java 网络编程 Java 多线程编程 Java Applet 基础 Java 文档注释 Java 实例 Java 8 新特性 Java MySQL 连接 Java 9 新特性 Java 测验 java 全部

JAVA - 最热教程

Java在运行项目时候，点击右键的弹框，...nacos配置中心超时问题：java.net.Conn...Java的设计模式（7）— 生产者-消费者模...基于DOM4j和POI实现的XML文件转换为XLS...如何在Java中创建一些变量类型别名使用java8的Stream统计字符串数组中每一...idea插件篇之java内存分析工具(JProfil...cannot cast 'java.lang.Integer' to '...java – Bootstrap.properties中Spring...Java8利用stream流实现数字排序和中文排...

首页 / JAVA / Java编程思想练习题（四）

Java编程思想练习题（四）

内容导读

内容图文

内容总结

内容备注

内容手机端

【Java编程思想练习题（四）】教程文章相关的互联网学习教程文章

Java编程思想——吸血鬼数字问题【代码】

JAVA编程思想笔记第四章控制执行流程【代码】

java 编程思想 22.11: java bean 案例代码【图】

java编程思想 -- 多态

Java编程思想

Java编程思想学习笔记-第十章【代码】

《 Java 编程思想》CH06 访问权限控制【代码】

6.JAVA编程思想初始化和清除

12.JAVA编程思想——集合的类型

Java编程思想笔记-类的初始化顺序【代码】

《java编程思想》第十章内部类【代码】

《JAVA编程思想》学习笔记——第十三章字符串【图】

Java编程思想(九) —— 通过异常处理错误(1)【图】

net.mindview.util.TextFile 类 java编程思想【代码】【图】

《 Java 编程思想》CH03 操作符【代码】

JAVA - 相关标签

编程 - 相关标签

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程

首页 / JAVA / Java编程思想 练习题（四）

Java编程思想 练习题（四）

内容导读

内容图文

内容总结

内容备注

内容手机端

【Java编程思想 练习题（四）】教程文章相关的互联网学习教程文章

JAVA - 相关标签

编程 - 相关标签

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程

首页 / JAVA / Java编程思想练习题（四）

Java编程思想练习题（四）

【Java编程思想练习题（四）】教程文章相关的互联网学习教程文章