6: Initialization & Cleanup

Transcription

1 6: Initialization & Cleanup 1

2 Constructors Constructors are methods that are automatically invoked when a class is instantiated. Their names are the same as the class. They may have no return type, not even void. 2

3 Guaranteed Initialization with the Constructor class Rock { Rock() { System.out.print("Rock "); public class SimpleConstructor { public static void main(string[] args) { for (int i = 0; i < 10; i++) new Rock(); 3

4 Constructors Can Take Arguments class Rock2 { Rock2(int i) { System.out.print("Rock " + i + " "); public class SimpleConstructor2 { public static void main(string[] args) { for (int i = 0; i < 8; i++) new Rock2(i); 4

5 The Default Constructor class Rock3 { int i; public class DefaultConstructor { public static void main (String[] args) { Rock3 r = new Rock3(); If you write no constructors, one will be provided and it will take no arguments. If you write at least one constructor, no others will be provided. 5

6 Nuance One may deduce meaning from context Wash the shirt. Wash the car. Wash the dog. In everyday language, it s not necessary to say shirtwash the myshirt. carwash the Ford. dogwash Fido. 6

7 Method Overloading In OOP languages identifiers (names) may be loaded up with multiple meanings. The ambiguity is always resolved through context. void wash(shirt s) {... void wash(car c) {... void wash(dog d) {... Dog fido; wash(fido); 7

8 Overloading Example... import static net.mindview.util.print.*; class Tree { int height; Tree() { print("planting a seedling"); height = 0; Tree(int initialheight) { height = initialheight; print("creating new Tree that is " + height + " feet tall"); void info() { print("tree is " + height + " feet tall"); void info(string s) { print(s + ": Tree is " + height + " feet tall"); 8

9 ...Overloading Example public class Overloading { public static void main(string[] args) { for (int i = 0; i < 5; i++) { Tree t = new Tree(i); t.info(); t.info("overloaded method"); new Tree(); 9

10 Overloading Rules The signature of a method is its name (identfier) and the list of its parameter types. Method names may be overloaded (redefined) within a class as long as the signatures differ. Differences in return type alone are not sufficient to constitute different signatures. Primitive arguments are subject to automatic promotion and forced demotion. 10

11 Overloading on Return Types Java permits expression statements that consist solely of a function invocation. As with all expression statements, the value of the expression is ultimately discarded. Given void f() { int f() { What would this mean? f(); 11

12 More Next Week Finalization and garbage collection Initialization Constructors static data Explicit static initialization Non-static instance initialization Arrays Variable argument lists Enumerated types 12

13 this: A Reference to the Current Object public class Leaf { int i = 0; Leaf increment() { i++; return this; void print() { System.out.println("i = " + i); public static void main(string[] args) { Leaf x = new Leaf(); x.increment().increment().increment().print(); 13

14 this: Calling Constructors from Constructors... import static net.mindview.util.print.*; public class Flower { int petalcount = 0; String s = "initial value"; Flower(int petalcount) { this.petalcount = petalcount; print("constructor w/ int arg only, petalcount= " + petalcount); Flower(String s) { print("constructor w/ String arg only, s = " + s); this.s = s; 14

15 ...this: Calling Constructors from Constructors Flower(String s, int petals) { this(petals); //! this(s); // Can't call two! this.s = s; print("string & int args"); Flower() { this("hi", 47); print("default constructor (no args)"); void printpetalcount() { //! this(11); // Not inside non-constructor! print("petalcount = " + petalcount + " s = " + s); public static void main(string[] args) { Flower x = new Flower(); x.printpetalcount(); 15

16 The Meaning of static There is no this for a static method. Non-static methods cannot be called from static methods. A static method can be called for the class itself, without any object. A static method is like an external function in C/C++. A static method can invoke a non-static method on an object. 16

17 The static Block Initializations for static fields may be grouped inside a special static clause. public class Spoon { static int i; static { i = 47; The code is executed only once: the first instantiation or the first access of a static member. 17

18 Data Initialization Local variables must be initialized before use. void f() { int i; //! i++; Primitive fields are initialized to zero. Object reference fields are initialized to null. class Data { int i; // = 0 Object o; // = null 18

19 Order of Initialization When a class is first referenced an object of class Class is created if it does not already exist, fields declared static are initialized and the static clause, if present, is executed. This happens in textual order. If an object is to be created fields are initialized, the appropriate constructor is executed. 19

20 Array Initialization An array reference only may be created. int a1[]; int[] a2; An array of primitives may be ititialized as in C. int a1[]= { 1, 2, 3, 4, 5 ; Arrays are true objects and their bounds are checked at run time. 20

21 Arrays cont d Arrays must be instatiated. int n = 50; int[] a3 = new int[n]; Arrays of objects initially hold only references. Random rand = new Random(); Integer[] a = new Integer[rand.nextInt(20)]; print("length of a = " + a.length); for(int i = 0; i < a.length; i++) a[i] = rand.nextint(500); // Autoboxing 21

22 Arrays cont d Arrays of objects may also be initialized. Integer i = new Integer(4); Integer[] a = { new Integer(1), new Integer(2), new Integer(3), i, ; Arays of arrays are permitted. Random rand = new Random(); int[][] a = new int[3][]; for (int i = 0; i < 3; i++) a[i] = new int[rand.nextint(10)]; 22

23 Cleanup Garbage collection: This is not destruction in the C++ sense. The garbage collector is not guaranteed to run. Only memory allocated on the heap is reclamed. The finalize() method: Runs only just before garbage collection. The runfinalizersonexit() method has been depricated. Is used mainly with native methods. It can also be used to verify the temination condition of an object. Use the finally clause in exception handling to finish destruction. 23

24 The Termination Condition class Book { boolean checkedout = false; Book(boolean checkedout) { this.checkedout = checkedout; void checkin() { checkedout = false; protected void finalize() { if(checkedout) System.out.println("Error: checked out"); // Normally, you'll also do this: // super.finalize(); // Call the base-class version public class TerminationCondition { public static void main(string[] args) { Book novel = new Book(true); // Proper cleanup: novel.checkin(); // Drop the reference, forget to clean up: new Book(true); // Force garbage collection & finalization: System.gc(); 24

25 Variable Argument Lists... An effect similar to what is obtained with vargs in C is now possible in Java. Unknown quantities and types of arguments can be accommodated. Genericity is obtained from the fact that all classes inherit from class Object. 25

26 ...Variable Argument Lists public class NewVarArgs { static void printarray(object... args) { for(object obj : args) one two three System.out.print(obj A@1bab50a + " "); A@c3c749 A@150bd4d System.out.println(); public static void main(string[] args) { // Can take individual elements: printarray(new Integer(47), new Float(3.14), new Double(11.11)); printarray(47, 3.14F, 11.11); printarray("one", "two", "three"); printarray(new A(), new A(), new A()); // Or an array: printarray((object[])new Integer[]{ 1, 2, 3, 4 ); printarray(); // Empty list is OK 26

27 Enumerated Types... The use of enum in place of class alows the creation of a set of symbolic constants. These are strongly-typed and have more features than the enums found in C/C++. The tostring() method is defined for convenient output. An ordinal() method returns an int indicating the order of a particular constant. A static values() produces an array of values of the enum constants in the order they were declared. 27

28 ...Enumerated Types... public enum Spiciness { NOT, MILD, MEDIUM, HOT, FLAMING public class SimpleEnumUse { public static void main(string[] args) { Spiciness howhot = Spiciness.MEDIUM; System.out.println(howHot); 28

29 ...Enumerated Types public enum Spiciness { NOT, MILD, MEDIUM, HOT, FLAMING public class EnumOrder { public static void main(string[] args) { for(spiciness s : Spiciness.values()) System.out.println(s + ", ordinal " + s.ordinal()); NOT, ordinal 0 MILD, ordinal 1 MEDIUM, ordinal 2 HOT, ordinal 3 FLAMING, ordinal 4 29