Initialization & Cleanup


Guaranteed initialization with the constructor

  • In Java, the class designer can guarantee initialization of every object by providing a constructor.
  • The coding style of making the first letter of all methods lowercase does not apply to constructors.
  • The constructor can also have arguments to allow you to specify how an object is created.
  • The constructor is an unusual type of method because it has no return value. This is distinctly different from a void return value, in which the method returns nothing but you still have the option to make it return something else.
  • The new expression does return a reference to the newly created object.

Method overloading

  • When you create an object, you give a name to a region of storage. A method is a name for an action.
  • Because the constructor’s name is predetermined by the name of the class, there can be only one constructor name.
  • Thus, method overloading is essential to allow the same method name to be used with different argument types.

Distinguishing overloaded methods

  • Each overloaded method must take a unique list of argument types.
  • Even differences in the ordering of arguments are sufficient to distinguish two methods.

Overloading with primitives

  • If you have a data type that is smaller than the argument in the method, that data type is promoted.
  • If your argument is wider, then you must perform a narrowing conversion with a cast.

Overloading on return values

  • You can also call a method and ignore the return value. Because of this sort of problem, you cannot use return value types to distinguish overloaded methods.

Default constructors

  • If you create a class that has no constructors, the compiler will automatically create a default constructor for you.
  • However, if you define any constructors (with or without arguments), the compiler will not synthesize one for you.

The this keyword

  • There’s a secret first argument passed to the method peel( ), and that argument is the reference to the object that’s being manipulated.
  • The this keyword—which can be used only inside a non-static method—produces the reference to the object that the method has been called for.
  • If you’re calling a method of your class from within another method of your class, you don’t need to use this. You simply call the method. The current this reference is automatically used for the other method.
  • The this keyword is used only for those special cases in which you need to explicitly use the reference to the current object.
  • It’s often used in return statements when you want to return the reference to the current object.
  • The this keyword is also useful for passing the current object to another method.

Calling constructors from constructors

  • There are times when you’d like to call one constructor from another to avoid duplicating code. You can make such a call by using the this keyword.
  • In a constructor, the this keyword takes on a different meaning when you give it an argument list.
  • While you can call one constructor using this, you cannot call two. In addition, the constructor call must be the first thing you do, or you’ll get a compiler error message.

The meaning of static

  • With the this keyword in mind, you can more fully understand what it means to make a method static. It means that there is no this for that particular method.
  • You cannot call non-static methods from inside static methods(although the reverse is possible), and you can call a static method for the class itself, without any object.
  • Putting the static method inside a class allows it access to other static methods and to static fields. It’s as if you’re creating the equivalent of a global method.

Cleanup: finalization and garbage collection

  • The garbage collector only knows how to release memory allocated with new.
  • When the garbage collector is ready to release the storage used for your object, it will first call finalize( ), and only on the next garbage-collection pass will it reclaim the object’s memory.
  • It gives you the ability to perform some important cleanup at the time of garbage collection.
  • In C++, objects always get destroyed, whereas in Java, objects do not always get garbage collected.
  • Java has no destructor or similar concept, so you must create an ordinary method to perform this cleanup.

What is finalize() for?

  • Garbage collection is only about memory.
  • The sole reason for the existence of the garbage collector is to recover memory that your program is no longer using.
  • It turns out that the need for finalize( ) is limited to special cases in which your object can allocate storage in some way other than creating an object.
  • This can happen primarily through native methods, which are a way to call non-Java code from Java.

You must perform cleanup

  • The presence of a garbage collector does not remove the need for or the utility of destructors.
  • If you want some kind of cleanup performed other than storage release, you must still explicitly call an appropriate method in Java, which is the equivalent of a C++ destructor without the convenience.
  • Neither garbage collection nor finalization is guaranteed.

The termination condition

  • In general, you can’t rely on finalize( ) being called, and you must create separate “cleanup” methods and call them explicitly.
  • There is an interesting use of finalize( ) that does not rely on it being called every time. This is the verification of the termination condition of an object.

How a garbage collector works

  • Allocating storage for heap objects in Java can be nearly as fast as creating storage on the stack in other languages.
  • The Java heap is more like a conveyor belt that moves forward every time you allocate a new object.
  • While the garbage collector collects the garbage it compacts all the objects in the heap so that you’ve effectively moved the “heap pointer” closer to the beginning of the conveyor belt and farther away from a page fault.
  • The garbage collector moves through the entire list of objects, and when it finds one with a reference count of zero it releases that storage.
  • The one drawback is that if objects circularly refer to each other they can have nonzero reference counts while still being garbage.
  • Any non-dead object must ultimately be traceable back to a reference that lives either on the stack or in static storage.
  • Copy collectors:The program is first stopped. Then, each live object is copied from one heap to another, leaving behind all the garbage. In addition, as the objects are copied into the new heap, they are packed end-to-end, thus compacting the new heap.
  • mark-and-sweep: when you know you’re generating little or no garbage, it’s fast. Only when the marking process is finished does the sweep occur.
  • generation count: only the blocks created since the last garbage collection are compacted; all other blocks get their generation count bumped if they have been referenced from somewhere.
  • A JIT compiler partially or fully converts a program into native machine code so that it doesn’t need to be interpreted by the JVM and thus runs much faster.
  • Lazy evaluation, which means that the code is not JIT compiled until necessary.

Member initialization

  • In the case of a method’s local variables, this guarantee comes in the form of a compile-time error.
  • Forcing the programmer to provide an initialization value is more likely to catch a bug.
  • Each primitive field of a class is guaranteed to get an initial value.
  • When you define an object reference inside a class without initializing it to a new object, that reference is given a special value of null.

Specifying initialization

Constructor initialization

  • You aren’t precluding the automatic initialization, which happens before the constructor is entered.

Order of initialization

  • The variable definitions may be scattered throughout and in between method definitions, but the variables are initialized before any methods can be called.

static data initialization

  • You can’t apply the static keyword to local variables, so it only applies to fields.
  • The constructor is actually a static method.
  • The Java interpreter must locate Dog.class, which it does by searching through the classpath.
  • Thus, static initialization takes place only once, as the Class object is loaded for the first time.

Explicit static initialization

  • The first time you make an object of that class or the first time you access a static member of that class

Non-static instance initialization

  • The instance initialization clause is executed before either one of the constructors.
  • This syntax is necessary to support the initialization of anonymous inner classes.
  • It also allows you to guarantee that certain operations occur regardless of which explicit constructor is called.

Array initialization

  • To define an array reference, you simply follow your type name with empty square brackets, The compiler doesn’t allow you to tell it how big the array is, All that you have at this point is a reference to an array.
  • To create storage for the array, you must write an initialization expression.
  • You can also use a special kind of initialization expression that must occur at the point where the array is created. This special initialization is a set of values surrounded by curly braces.
  • You simply use new to create the elements in the array. Here, new works even though it’s creating an array of primitives.
  • If you create a non-primitive array, you create an array of references.
  • It’s also possible to initialize arrays of objects by using the curly brace-enclosed list.
  • You can use the second and third forms anywhere, even inside a method call.

Variable argument lists

  • You can now use ellipses to define a variable argument list.
  • It’s possible to pass zero arguments to a vararg list.
  • It’s possible to use any type of argument in varargs, including a primitive type.
  • This verifies that using varargs does not depend on autoboxing, but that it actually uses the primitive types.
  • Varargs complicate the process of overloading, although it seems safe enough at first.
  • You should generally only use a variable argument list on one version of an overloaded method. Or consider not doing it at all.

Enumerated types

  • When you need to group together and use a set of enumerated types.
  • Because the instances of enumerated types are constants, they are in all capital letters by convention.
  • To use an enum, you create a reference of that type and assign it to an instance.
  • In many ways you can treat an enum as if it were any other class.
  • In fact, enums are classes and have their own methods.
  • Since a switch is intended to select from a limited set of possibilities, it’s an ideal match for an enum.
  • In general you can use an enum as if it were another way to create a data type, and then just put the results to work.

Thinking in Java——笔记(5)的更多相关文章

  1. Effective Java笔记一 创建和销毁对象

    Effective Java笔记一 创建和销毁对象 第1条 考虑用静态工厂方法代替构造器 第2条 遇到多个构造器参数时要考虑用构建器 第3条 用私有构造器或者枚举类型强化Singleton属性 第4条 ...

  2. java笔记00-目录

    --2013年7月26日17:49:59 学习java已久,趁最近有空,写一个总结: java笔记01-反射:

  3. java笔记整理

    Java 笔记整理 包含内容     Unix Java 基础, 数据库(Oracle jdbc Hibernate pl/sql), web, JSP, Struts, Ajax Spring, E ...

  4. 转 Java笔记:Java内存模型

    Java笔记:Java内存模型 2014.04.09 | Comments 1. 基本概念 <深入理解Java内存模型>详细讲解了java的内存模型,这里对其中的一些基本概念做个简单的笔记 ...

  5. servlet(6) - servlet总结 - 小易Java笔记

    垂阅前必看: 这都是我总结的我觉得是学习servlet应该掌握的,我在学习期间也做了一个博客项目来让所学的知识得以巩固.下面就是博客项目链接.前面的servlet相关的笔记总汇,还有就是我把觉得在学习 ...

  6. Java笔记 —— 继承

    Java笔记 -- 继承 h2{ color: #4ABCDE; } a{ text-decoration: none!important; } a:hover{ color: red !import ...

  7. Java笔记 —— 方法重载和方法重写

    Java笔记 -- 方法重载和方法重写 h2{ color: #4ABCDE; } a{ text-decoration: none !important; } a:hover{ color: red ...

  8. Java笔记 —— 初始化

    Java笔记 -- 初始化 h2{ color: #4ABCDE; } a{ text-decoration: none !important; } a:hover{ color: red !impo ...

  9. Java笔记 —— this 关键字

    Java笔记 -- this 关键字 h2{ color: #4ABCDE; } a{ color: blue; text-decoration: none; } a:hover{ color: re ...

  10. Java 笔记 —— java 和 javac

    Java 笔记 -- java 和 javac h2{ color: #4ABCDE; } a{ text-decoration: none !important; } a:hover{ color: ...

随机推荐

  1. 我的c++学习(6)默认参数和内联函数

    默认参数 一般情况下,函数调用时实参个数应与形参相同,但为了更方便地使用函数,C++也允许定义具有默认参数的函数,这种函数调用时实参个数可以与形参不相同.“默认参数”指在定义或声明函数时为形参指定默认 ...

  2. IE下Array.prototype.slice.call(params,0)

    i8 不支持 Array.prototype.slice.call(params,0) params可以是 HTMLCollection.类数组.string字符串

  3. HDU4609 3-idiots(母函数 + FFT)

    题目 Source http://acm.hdu.edu.cn/showproblem.php?pid=4609 Description King OMeGa catched three men wh ...

  4. WPF:依赖属性的数据绑定

    One of the strengths of WPF is its data binding capabilities. Although data binding is not new (in f ...

  5. BZOJ3607 : 数据网络

    首先答案一定是包含直径某个端点的一个连通块里所有边权值之和,设直径为$AB$,以$A$和$B$分别为根进行处理. 首先按照最长路法则将这棵树进行树链剖分,那么每个叶子的贡献为它与它所在链顶端的点的距离 ...

  6. ACM: FZU 2148 Moon Game - 海伦公式

     FZU 2148  Moon Game Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64 ...

  7. 【BZOJ】3621: 我想那还真是令人高兴啊

    http://www.lydsy.com/JudgeOnline/problem.php?id=3621 题意:给两个三角形,问A能否通过旋转伸缩到B. #include <bits/stdc+ ...

  8. Codeforces Beta Round #35 (Div. 2) E. Parade(扫描线)

    题目链接 只要会做,周长并,这题肯定有思路. 有个小地方敲错了,细心啊,扫描线,有一段时间没写过了,还有注意排序的问题,很重要. #include <iostream> #include ...

  9. iOS 电话在后台运行时,我的启动图片被压缩

    一,经历 <1> 第一感觉是启动图片没有设置好,长度设置小了.但是和网上说的正确方式相比,没什么差别. <2> 害怕是控制器影响的,又新建了一个项目,来检验启动图片是否设置成功 ...

  10. Crystal Reports 2008(水晶报表) JDBC连接mysql数据库

    在本blog中,主要介绍的是Crystal Reports 2008使用JDBC连接mysql数据库. 在连接之间,首先要确认你电脑上面都安装了mysql数据库. 其次,就是jdbc连接数据时候所使用 ...