当前位置:首页 > Java技术 > Java编程思想 练习题(六)

Java编程思想 练习题(六)

2022年08月05日 16:21:14Java技术4

一、创建一个简单的类。在第二个类中,将一个引用定义为第一个类的对象。运用惰性初始化来实例化这个对象。

public class Soap {
    private String s;
    Soap() {
        System.out.println("Soap()");
        s = "Constructed";
    }
    public void setS(String s) {
        this.s = s;
    }
    @Override
    public String toString() {
        return s;
    }
}
class Test {
    private Soap soap;
    public Test() {
        soap = new Soap();
        System.out.println("init soap");
    }
    @Override
    public String toString() {
        return soap.toString();
    }
    public static void main(String... args) {
        Test test = new Test();
        System.out.println(test);
    }
}

返回:

Soap()
init soap
Constructed

二、 从Detergent中继承产生一个新的类。覆盖scrub()并添加一个名为sterilize()的新方法。

public class Cleanser {
    private String s = "Cleanser";
    public void append(String a) {
        s += a;
    }
    public void dilute() {
        append(" dilute()");
    }
    public void apply() {
        append(" apply()");
    }
    public void scrub() {
        append(" scrub()");
    }
    @Override
    public String toString() {
        return s;
    }
    public static void main(String[] args){
        Cleanser x = new Cleanser();
        x.dilute();x.apply();x.scrub();
        System.out.println(x);
    }
}
public class Detergent extends Cleanser {
    // change a method
    public void scrub() {
        append(" Detergent.scrub()");
        super.scrub();
    }
    // add methods to the interface
    public void foam(){append(" foam()");}
    public static void main(String[] args){
        Detergent x = new Detergent();
        x.dilute();x.apply();x.scrub();x.foam();
        System.out.println(x);
        System.out.println("Testing base class:");
        Cleanser.main(args);
    }
}
class Zi extends Detergent{
    public void scrub() {
        append(" Zi.scrub()");
        super.scrub();
    }
    public void sterilize(){append(" sterilize()");}
    public static void main(String[] args){
        Zi x = new Zi();
        x.dilute();x.apply();x.scrub();x.foam();x.sterilize();
        System.out.println(x);
        System.out.println("Testing base class:");
        Detergent.main(args);
    }
}

返回:

Cleanser dilute() apply() Zi.scrub() Detergent.scrub() scrub() foam() sterilize()
Testing base class:
Cleanser dilute() apply() Detergent.scrub() scrub() foam()
Testing base class:
Cleanser dilute() apply() scrub()

三、 证明“即使不为子类创建构造器,编译器也会合成一个默认构造器,该构造器将调用基类的构造器”。

class Art{
    Art(){System.out.println("Art constructor");}
}
class Drawing extends Art{
    public Drawing() {System.out.println("Drawing constructor");}
}
public class Cartoon extends Drawing {
//    public Cartoon() {System.out.println("Cartoon constructor");}
    public static void main(String... args){
        Cartoon cartoon = new Cartoon();
    }
}

编译后:

public class Cartoon extends Drawing {
    public Cartoon() {
    }

    public static void main(String... args) {
        new Cartoon();
    }
}

返回:

Art constructor
Drawing constructor

四、证明基类构造器:a.总是会被调用;b.在导出类构造器之前被调用。

见上题

五、创建两个带有默认构造器(空参数列表)的类A和类B。从A中继承产生一个名为C的新类,并在C内创建一个B类的成员。不要给C编写构造器。创建一个C类对象并观察其结果。

class A {
    A(){System.out.println("A constructor");}
}
class B{
    public B() {System.out.println("B constructor");}
}
public class C extends A {
    private B b;
    public static void main(String... args){
        C c = new C();
    }
}

返回:

A constructor

六、用Chess.java来证明“调用基类构造器必须是在导出类构造器中要做的第一件事”。

Java编程思想 练习题(六) _ JavaClub全栈架构师技术笔记

 

 七、修改练习5,使A和B以带参数的构造器取代默认的构造器。为C写一个构造器,并在其中执行所有的初始化。

 

class A {
    A(int i){
        System.out.println("A constructor, i:"+i);
    }
}
class B{
    B(int i) {System.out.println("B constructor, i:"+i);}
}
public class C extends A {
    private B b;
    C(){
        super(2);
        System.out.println("C constructor");
        b = new B(3);
    }
    public static void main(String... args){
        C c = new C();
    }
}

 

返回:

A constructor, i:2
C constructor
B constructor, i:3

八、创建一个基类,它仅有一个非默认构造器;再创建一个导出类,它带有默认构造器和非默认构造器。在导出类的构造器中调用基类的构造器。

class A {
    A(int i){
        System.out.println("A constructor, i:"+i);
    }
}
public class C extends A {
    C(){
        super(0);
        System.out.println("C constructor");
    }
    C(int i){
        super(i-1);
        System.out.println("C constructor, i:"+i);
    }
    public static void main(String... args){
        C c1 = new C();
        C c2 = new C(2);
    }
}

返回:

A constructor, i:0
C constructor
A constructor, i:1
C constructor, i:2

九、创建一个Root类,令其含有名为Component1、Component2、Component3的类的各一个实例。从Root中派生一个类Stem,也含有上述各“组成部分”。所有的类都应带有可打印出类的相关信息的默认构造器。

class Component1 {
    Component1() {
        System.out.println("Component1 constructor");
    }
}

class Component2 {
    Component2() {
        System.out.println("Component2 constructor");
    }
}

class Component3 {
    Component3() {
        System.out.println("Component3 constructor");
    }
}

class Root {
    private Component1 c1 = new Component1();
    private Component2 c2 = new Component2();
    private Component3 c3 = new Component3();
    public Root() {
        System.out.println("Root constructor");
    }
}

public class Stem extends Root {
    private Component1 c1 = new Component1();
    private Component2 c2 = new Component2();
    private Component3 c3 = new Component3();
    public Stem() {
        System.out.println("Stem constructor");
    }
    public static void main(String[] args) {
        new Stem();
    }
}

 

返回:

Component1 constructor
Component2 constructor
Component3 constructor
Root constructor
Component1 constructor
Component2 constructor
Component3 constructor
Stem constructor

十一、修改Detergent.java,让它使用代理。

class Cleanser1 {
    private String s = "Cleanser";
    public void append(String a) {
        s += a;
    }
    public void dilute() {
        append(" dilute()");
    }
    public void apply() {
        append(" apply()");
    }
    public void scrub() {
        append(" scrub()");
    }
    @Override
    public String toString() {
        return s;
    }
}

public class Detergent1 {
    private Cleanser1 cleanser1 = new Cleanser1();
    public void dilute() {
        cleanser1.dilute();
    }
    public void apply() {
        cleanser1.apply();
    }
    public void scrub() {
        cleanser1.scrub();
    }
    @Override
    public String toString() {
        return cleanser1.toString();
    }
    public static void main(String[] args) {
        Detergent1 x = new Detergent1();
        x.dilute();
        x.apply();
        x.scrub();
        System.out.println(x.toString());
    }
}

 

返回:

Cleanser dilute() apply() scrub()

 

 十三、创建一个类,它应带有一个被重载了三次的方法。继承产生一个新类,并添加一个该方法的新的重载定义,展示这四个方法在导出类中都是可以使用的。

class Father {
    public void method(){
        System.out.println("method()");
    }
    public void method(int i){
        System.out.println("method(i)");
    }
    public void method(String s){
        System.out.println("method(s)");
    }
}
public class Child extends Father{
    @Override
    public void method(){
        System.out.println("Child method()");
    }
    public void method(boolean b){
        System.out.println("method(b)");
    }

    public static void main(String... args){
        Child child = new Child();
        child.method(); child.method(true); child.method(1); child.method("");
    }
}

返回:

Child method()
method(b)
method(i)
method(s)

十四、 在Car.java中给Engine添加一个service()方法,并在mian()中调用该方法。

class Engine{
    public void start(){}
    public void rev(){}
    public void stop(){}
    public void service(){System.out.println("Engine service()");}
}

class Wheel{
    public void inflate(int psi){System.out.println("Wheel inflate(), param:["+psi+"]");}
}

class Window{
    public void rollup(){System.out.println("Window rollup()");}
    public void rolldown(){}
}

class Door{
    public Window window = new Window();
    public void open(){}
    public void colse(){}
}

public class Car {
    public Engine engine = new Engine();
    public Wheel[] wheels = new Wheel[4];
    public Door left = new Door();
    public Door right = new Door();
    public Car(){
        for (int i=0;i<4;i++){
            wheels[i]=new Wheel();
        }
    }
    public static void main(String... args){
        Car car = new Car();
        car.left.window.rollup();
        car.wheels[0].inflate(72);
        car.engine.service();
    }
}

返回:

Window rollup()
Wheel inflate(), param:[72]
Engine service()

十五、在包中编写一个类,类应具备一个protected方法。在包外部,试着调用该protected方法并解释其结果。然后,从你的类中继承产生一个类,并从该导出类的方法内部调用该protected方法。

class Father {
    protected void method(){
        System.out.println("method()");
    }
}

class Other{
    private Father father = new Father();
    public void otherMethod(){
        System.out.print("otherMethod ");
        father.method();
    }
}

public class Child extends Father{
    public static void main(String... args){
        Child child = new Child();
        child.method();
        Other other = new Other();
        other.otherMethod();
    }
}

返回:

method()
otherMethod method()

十六、创建一个名为Amphibian的类。由此继承产生一个称为Frog的类。在基类中设置适当地方法。在mian()中,创建一个Frog并向上转型至Amphibian,然后说明所有方法都可工作。

class Amphibian{
    void method(){
        System.out.println("Amphibian method()");
    }
}

public class Frog extends Amphibian {
    public static void main(String... args) {
        // 子类向上转型为基类
        Amphibian frog = new Frog();
        frog.method();
    }
}

 

返回:

Amphibian method()

十七、修改十六,使Frog覆盖基类中方法的定义(令新定义使用相同的方法特征签名)。请留心main()中都发生了什么。  

class Amphibian{
    void method(){
        System.out.println("Amphibian method()");
    }
}

public class Frog extends Amphibian {
    @Override
    void method() {System.out.println("Frog method()");}
    public static void main(String... args) {
        Amphibian frog = new Frog();
        frog.method();
    }
}

返回:

Frog method()

十八、创建一个含有static final域和final域的类,说明二者间的区别。

注:类初始化的时候就已经决定了NUM_1的值,而且全局唯一;而num2是在初始化对象的时候赋值的,一个对象一个值。

public class FinalData {
    private static final int NUM_1;
    private final int num2;
    static {
        NUM_1 = new Random(47).nextInt();
        System.out.println("NUM_1:"+NUM_1);
    }
    public FinalData(int num2) {
        this.num2 = num2;
        System.out.println("NUM_1:"+NUM_1+", num2:"+num2);
    }
    public static void main(String... args) {
        FinalData finalData1 = new FinalData(1);
        FinalData finalData2 = new FinalData(2);
    }
}

 

返回:

NUM_1:-1172028779
NUM_1:-1172028779, num2:1
NUM_1:-1172028779, num2:2

 

作者:jojo.wang
来源链接:https://www.cnblogs.com/jojo-wang/p/12249360.html

版权声明:
1、JavaClub(https://www.javaclub.cn)以学习交流为目的,由作者投稿、网友推荐和小编整理收藏优秀的IT技术及相关内容,包括但不限于文字、图片、音频、视频、软件、程序等,其均来自互联网,本站不享有版权,版权归原作者所有。

2、本站提供的内容仅用于个人学习、研究或欣赏,以及其他非商业性或非盈利性用途,但同时应遵守著作权法及其他相关法律的规定,不得侵犯相关权利人及本网站的合法权利。
3、本网站内容原作者如不愿意在本网站刊登内容,请及时通知本站(javaclubcn@163.com),我们将第一时间核实后及时予以删除。


本文链接:https://www.javaclub.cn/java/17714.html

分享给朋友:

“Java编程思想 练习题(六)” 的相关文章

读Java编程思想随笔の数组

  数组与其他种类的容器之间区别有三:效率、类型和保存基本类型的能力。在Java中,数组是一种最高的存储和随机访问对象引用序列的方式。数组就是一个简单的线性序列,这使得元素访问非常快速。但是为这种速度所付出的代价是数组对象的大小被固定,并且在其生命周期中不可改变。你可以能会建议使用Ar...

Java编程思想学习(五)----第5章:初始化与清理

随着计算机革命的发展,“不安全”的编程方式已逐渐成为编程代价高昂的主因之一。 C++引入了构造嚣(constructor)的概念,这是一个在创建对象时被自动调用的特殊方法。Java中也采用了构造器,并额外提供了“垃圾回收器”。对于不再使用的内存资源,垃圾回收器能自动将其释放。...

Java编程思想 学习笔记5

五、初始化与清理   1.用构造器确保初始化      在Java中,通过提供构造器,类的设计者可确保每个对象都会得到初始化。创建对象时,如果其类具有构造器,Java就会在用户有能力操作对象之前自动调用相应的构造器,从而保证了初始化的进行。构造器的...

回顾Java编程思想篇(一)

本文主要介绍Java中对象的理解。 很久以前看过Java编程思想这本书,当时看得不是很懂,重新拿起这本书,感觉非常陌生,于是产生了重新研究的念头,并做一些读书笔记。   一、一切都是对象 1、Java与...

JAVA编程思想三

第三章主要是对JAVA控制执行流程的介绍,在这里注意到了几点与C++的不同之处: (1)Java不允许像C++中对一个数字作为布尔类型的判断,即0为false,非0为true; (2)逗号操作符在C++中是取最后一个表达式的值作为整个表达式的值;在Java中将逗号操作符一般...

【Java编程思想】8.多态

【Java编程思想】8.多态

在面向对象的程序设计语言中,多态是继数据抽象和继承之后的第三种基本特征。 多态分离了“做什么”和“怎么做”,让接口和实现分离开,改善了代码的可读性和组织结构,创建了可拓展的程序。 封装,通过合并特征和行为来创建新的数据类型。 实现隐藏,通过将细节“私有化”把接口...

[JAVA]java编程思想-第一章-对象入门

第1章 对象入门 “为什么面向对象的编程会在软件开发领域造成如此震憾的影响?” 面向对象编程(OOP)具有多方面的吸引力。对管理人员,它实现了更快和更廉价的开发与维护过程。对分析与设计人员,建模处理变得更加简单,能生成清晰、易于维护的设计方案。对程序员,对象模...

Java编程思想第四版勘误

  坊间传说这本书翻译得很烂,我倒觉得还好。虽然看原文更准确,但是如果在具备一定编程思维和基础、能够看出来疑问的情况下,还是看中文更快一些,而且这本书本身也不适合初学者看。当然,错误和不通顺还是有的,而且官方和网上居然没有一份公开的勘误表,至少我没有搜到,搜索“Java编程思想第四版勘...

Java编程思想【温故知新】

第一章:对象导论 1. 抽象过程(类与对象的关系)   类是一类对象的共同行为(成员函数)与状态(成员变量),对象是具体类的实例化。(Eg.人类是一个类,共同的行为:吃,状态:名字。)   【类创建者需要考虑这件事情,回头看看这个概念四个字醍醐灌顶,每次创建这...

java异常捕获案例,此题的出处是《Java编程思想》一书

转自:https://blog.csdn.net/jackfrued/article/details/44921941   class Annoyance extends Exception {} class Sneeze extends Annoyan...

发表评论

访客

◎欢迎参与讨论,请在这里发表您的看法和观点。