文档章节

JAVA编程思想——第五章.初始化与清理

leooooo
 leooooo
发布于 2016/11/23 21:45
字数 2142
阅读 240
收藏 0

阿里云携手百名商业领袖、技术大咖,带您一探行进中的数字新基建!>>>

    工作三年多了,做过不少的项目,越到最近越深深地感觉到自己的基础薄弱,所以最近买了《java编程思想》。希望通过这次的学习能够使自己有所收获。

    这也是我第一篇博客,以往只是看而没有自己写过,这次着重记录书本上习题的解答。

    5.1 用构造器确保初始化

    练习1:创建一个类,它包含一个未初始化的String引用。验证该引用被java初始化成了null。

package chapter5;

public class Session1 {

	/**
	 * 未初始化的变量会自动初始化为null
	 */
	String a;
	
    public static void main(String[] args) {
		Session1 session1 = new Session1();
		System.out.println(session1.a);
        //“null”
	}
}

    练习2:创建一个类,它包含一个在定义是就被初始化了的String域,以及另一个通过构造器初始化的String域。这两种方式有何差异?

package chapter5;

public class Session1 {
	
	/**
	 * 会先初始化类中的变量
	 */
	String b = "hello";
	String c;
	
	public Session1() {
		System.out.println(b);
		/**
		 * 后进行c的初始化
		 */
		c = "world";
	}
	
	public static void main(String[] args) {
		Session1 session1 = new Session1();
        //在类初始化前会先初始化类中的变量
        //“hello”
	}
}

    5.3 默认构造器

    练习3:创建一个带默认构造器(即无参构造器)的类,在构造器中打印一条消息。为这个类创建一个对象。

package chapter5;

public class Session2 {

	public Session2() {
		System.out.println("我是默认构造器");
	}
	
    public static void main(String[] args) {
		Session2 session2 = new Session2();
        //“我是默认构造器”
	}
	
}

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

package chapter5;

public class Session2 {

	public Session2() {
		System.out.println("我是默认构造器");
	}
	
	public Session2(String arg) {
		this();
		System.out.println("我是重载有参构造器,我接收的参数为:"+arg);
	}
	
	public static void main(String[] args) {
		Session2 session2 = new Session2("hello world");
        //“我是默认构造器”
        //“我是重载有参构造器,我接收的参数为:hello world”
	}
	
}

    练习5:创建一个名为Dog的类,它具有重载的bark()方法。此方法应根据不同的基本数据类型进行重载,并根据被调用的版本,打印出不同类型的狗吠(barking)、咆哮(howling)等信息。编写main()来调用所有不同版本的方法。

    

package chapter5;

public class Dog {

	
	void bark(String a){
		System.out.println("barking:狗吠");
	}
	
	void bark(Integer i){
		System.out.println("howling:咆哮");
	}
	
	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.bark("barking");
		dog.bark(1);
        //barking:狗吠
        //howling:咆哮
	}
}

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

package chapter5;

public class Dog {
	
	/**
	 * 参数顺序不同也可以重载
	 * @param i
	 * @param a
	 */
	void bark(Integer i,String a){
		System.out.println("barking:狗吠");
	}
	void bark(String a,Integer i){
		System.out.println("howling:咆哮");
	}
	
	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.bark(1,"barking");
		dog.bark("barking",1);
        //barking:狗吠
        //howling:咆哮
	}
}

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

package chapter5;

public class Session7 {
	
	public static void main(String[] args) {
		Session7 session7 = new Session7();
	}

}

    5.4 this关键字

    练习8:编写具有两个方法的类,在第一个方法内调用第二个方法两次:第一次调用时不使用this关键字,第二次调用时使用this关键字——这里只是为了验证它是起作用的,你不应该在实践中使用这种方式。

package chapter5;

public class TestThis {

	private void method1(){
		method2();
		/**
		 * this指当前对象的引用
		 */
		this.method2();
	}
	
	private void method2(){
		System.out.println("方法二");
	}
	
	public static void main(String[] args) {
		TestThis testThis = new TestThis();
		testThis.method1();
        //方法二
        //方法二
	}
}

    练习9:编写具有两个(重载)构造器的类,并在第一个构造器中通过this调用第二个构造器。

package chapter5;

public class Session4 {

	public Session4() {
		this("通过this调用有参构造器");
		System.out.println("无参构造器");
	}
	
	public Session4(String arg) {
		System.out.println(arg);
	}
	
	public static void main(String[] args) {
		Session4 session4 = new Session4();
        //通过this调用有参构造器
        //无参构造器
	}
	
}

    5.5 清理:终结处理和垃圾回收

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

package chapter5;

public class TestFinalize {
	
	@Override
	protected void finalize() throws Throwable {
		System.out.println("回收前执行的方法");
	}
	
	public static void main(String[] args) {
		TestFinalize finalize = new TestFinalize();
	}

}

    finalize()方法不一定会执行。

    练习11:修改前一个程序,让你的finalize()总会被调用。

package chapter5;

public class TestFinalize {
	
	@Override
	protected void finalize() throws Throwable {
		System.out.println("回收前执行的方法");
	}
	
	public static void main(String[] args) {
		TestFinalize finalize = new TestFinalize();
		finalize = null;
		System.gc();
        //回收前执行的方法
	}

}

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

package chapter5;

public class Tank {

	private boolean full = true;
	
	@Override
	protected void finalize() throws Throwable {
		if(!full){
			System.out.println("空了,不要了");
		}
	}
	
	public static void main(String[] args) {
		Tank t = new Tank();
		t = null;
		System.gc();
        //此时状态是“满的”所以回收时不会执行输出
	}
	
}
package chapter5;

public class Tank {

	private boolean full = true;
	
	@Override
	protected void finalize() throws Throwable {
		if(!full){
			System.out.println("空了,不要了");
		}
	}
	
	public static void main(String[] args) {
		Tank t = new Tank();
		t.full = false;
		t = null;
		System.gc();
        //状态是“空的”
        //回收时会输出
        //空了,不要了
	}
	
}

    5.7 初始化顺序

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

package chapter5;

public class Session7 {
	
	
	static String a = "hello world";
	
	static String b;
	
	static {
		b = "hello world 2";
	}
	
	public static void main(String[] args) {
		System.out.println(Session7.a);
		System.out.println(Session7.b);
        //hello world
        //hello world 2
	}

}

    练习15:编写一个含有字符串域的类,并采用实例初始化方式进行初始化。

package chapter5;


public class Session71 {

	String a;
	
	{
		a = "hello world";
	}
	
	public static void main(String[] args) {
		Session71 session71 = new Session71();
		System.out.println(session71.a);
        //hello world
	}
}

    5.8 数组初始化

    练习16:创建一个String对象数组,并为每一个元素都赋值一个String。用for循环来打印该数组。

package chapter5;

public class Session8 {

	String[] strs = {"h","e","l","l","o"};
	
	public static void main(String[] args) {
		Session8 session8 = new Session8();
		for (String string : session8.strs) {
			System.out.print(string);
		}
        //hello
	}
	
}

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

package chapter5;

public class Session81 {

	
	public Session81(String a) {
		System.out.println(a);
	}
	
	
	public static void main(String[] args) {
		Session81[] sss = new Session81[]{};
		//不会进行打印输出
	}
}

    练习18:通过创建对象赋值给引用数组,从而完成前一个练习。

package chapter5;

public class Session81 {

	
	public Session81(String a) {
		System.out.println(a);
	}
	
	
	public static void main(String[] args) {
		Session81[] sss = new Session81[]{new Session81("1"),new Session81("2")};
		//1
		//2
	}
}

    练习19:写一个类,他接受一个可变参数的String数组。验证你可以向该方法传递一个用逗号分隔的String列表,或是一个String[]。

package chapter5;

public class Session82 {

	public Session82(String ...a) {
		for (String string : a) {
			System.out.println(string);
		}
	}
	
	public static void main(String[] args) {
		Session82 session82 = new Session82("a","b");
		
		Session82 session821 = new Session82(new String[]{"a","b"});
	}
	
}

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

package chapter5;

public class Session82 {

	public Session82(String ...a) {
		for (String string : a) {
			System.out.println(string);
		}
	}
	
	public static void main1(String...args) {
		Session82 session82 = new Session82("a","b");
		
		Session82 session821 = new Session82(new String[]{"a","b"});
	}
	
}

    5.9 枚举类型

    练习21:创建一个enum,它包含纸币中最小面值的6种类型。通过values()循环并打印每一个值及其ordinal();

package chapter5;

public enum Session9 {

	YIMAO,YIKUAI,SHIKUAI,YIBAIKUAI
	//一毛,一块,十块,一百块
}
package chapter5;

public class TestSession9 {

	public static void main(String[] args) {
		for (Session9 string : Session9.values()) {
			System.out.println(string);
			System.out.println(string.ordinal());
		}
        //YIMAO
        //0
        //YIKUAI
        //1
        //SHIKUAI
        //2
        //YIBAIKUAI
        //3
	}

}

        练习22:在前面的例子中,为enum写一个switch语句,对于每一个case,输出该特定货币的描述

package chapter5;

public class TestSession9 {

	public static void main(String[] args) {
		TestSession9 session9 = new TestSession9(Session9.SHIKUAI);
		session9.descript();
	}

	public TestSession9(Session9 session9) {
		this.session9 = session9;
	}

	private Session9 session9;

	void descript() {
		switch (session9) {
		case YIMAO:
			System.out.println("一毛");
			break;
		case YIKUAI:
			System.out.println("一块");
			break;
		case SHIKUAI:
			System.out.println("十块");
			break;
		case YIBAIKUAI:
			System.out.println("一百块");
			break;
		default:
			break;
		}
	}

}

 

© 著作权归作者所有

leooooo
粉丝 16
博文 23
码字总数 21383
作品 0
西安
高级程序员
私信 提问
加载中

评论(0)

那些年,关于 Java 的那些事儿

版权声明:Follow your heart and intuition. https://blog.csdn.net/qq_35246620/article/details/78695893 温馨提示:本系列博文(含示例代码)已经同步到 GitHub,地址为「java-skills」,...

维C果糖
2017/12/02
0
0
Java编程思想(第4版)pdf

下载地址:网盘下载 内容简介编辑 从本书获得的各项大奖以及来自世界各地的读者评论中,不难看出这是一本经典之作。本书的作者拥有多年教学经验,对C、C++以及Java语言都有独到、深入的见解,...

osc_3www0d3o
2018/02/05
3
0
Java编程思想(第4版)pdf

下载地址:网盘下载 内容简介编辑 从本书获得的各项大奖以及来自世界各地的读者评论中,不难看出这是一本经典之作。本书的作者拥有多年教学经验,对C、C++以及Java语言都有独到、深入的见解,...

osc_3www0d3o
2018/02/05
1
0
《On Java 8》中文版,又名《Java 编程思想》中文第五版

来源:LingCoder/OnJava8 主译: LingCoder 参译: LortSir 校对:nickChenyx E-mail: lingcoder@gmail.com 本书原作者为 [美] Bruce Eckel,即(Thinking in Java 4th Edition,2006)的作者。......

ApacheCN_飞龙
2019/04/04
0
0
Java中String初始化了String域 和 构造器初始化的String域的差异

这是 java编程思想 第五章---初始化与清理 的一题 练习2 :  创建一个类,它 包含了一个定义时就被初始化了的String域,以及另一个通过构造器初始化的String域,这两种方式有何差异. 看这一段程...

osc_hga8xu1h
2019/10/22
2
0

没有更多内容

加载失败,请刷新页面

加载更多

假使年轻的时候鞭策自己

我自己就是浪费了很多时间的一个人。我不打麻将,我不经常的听戏看电影,几年中难得一次,我不长时间看电视,通常只看半个小时,我也不串门子闲聊天。有人问我:“那么你大部分时间都做了些什...

瑾123
16分钟前
7
0
文章错别字检测软件有哪些?蚁小二真的好用

文章错别字检测软件有哪些?蚁小二真的好用,据市场研究调查发现,我们对文章当中错别字的检测和修改这样的需求是一直存在的,只是市场上面还没有一个比较好用的软件来辅助我们做错别字检测。...

一键分发工具-蚁小二
18分钟前
22
0
文章原创度检测工具有哪些?这些工具你可以拥有

文章原创度检测工具有哪些?这些工具你可以拥有,随着自媒体行业的发展,现在很多自媒体人都进入到互联网行业,但是随着大家的深入发展,会发现有时候自己的文章在自媒体平台上推荐很少,其实...

易撰
19分钟前
9
0
FTP工具软件,FTP工具软件下载!

IIS7服务器管理工具是一款FTP的客户端软件,能够批量执行FTP的命令!可以提高FTP的传输效率! 同时,它也可以作为VNC的客户端,能够进行相关的VNC操作;同时,它还可以批量连接Windows和Lin...

Raymond13
20分钟前
7
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部