cs884 (prasad)java11extn1 java 1.1 extensions nested classes static public/protected/private

CS884 (Prasad) java11Extn 1

Java 1.1 Extensions

Nested classes

static public/protected/private


Nested classes

• StaticStatic Top-level Classes and Interfaces • Like ordinary package member except for its name.

• May use static members of its enclosing class.

• Member Classes• Each instance has an enclosing instance.Each instance has an enclosing instance.

• May use members of its enclosing classes.

• Local Classes• Defined in a block of code.

• May also use final local variables and parameters.

• Anonymous classes• One instance only.


public class LinkedList {

// static by default

public interface Linkable {

public Linkable getNext();

public void setNext(Linkable node);

}

Linkable head;

public void insert(Linkable node) {...}

public void remove(Linkable node) {...}

}


class LinkableInt implements

LinkedList.Linkable {

int i;

public LinkableInt(int _i){i= _i;}

LinkedList.Linkable next;

public LinkedList.Linkable

getNext() {return next;}

public void setNext(LinkedList.Linkable node)

{next = node;}

}


Member Class

• Every instance of a member class is internally associated with an instance of the enclosing class.

• The methods of a member class can implicitly refer to the fields defined within the member class, as well as those defined by any enclosing class (including private fields.)

• static final members permitted.


public class BankAccount{ private long number; private int balance; private Action lastAct; public class Action { private String act; private int amount; Action(String a, int amt) { act = number + “:” + a; amount = amt;

} } public void deposit(int amt) { balance += amt; lastAct = new Action(“deposit”,amt); } public void withdraw(int amt) { balance -= amt; lastAct = new Action(“withdraw”,amt); }}


public class BankAccount{ private long number; private int balance; private Action lastAct;

public class Action { … } public void deposit(int amt) { … } public void withdraw(int amt) { … }

public void transfer(BankAccount ac, int amt) { ac.withdraw(amt);

deposit(amt); lastAct = new Action(“transfer”,amt); ac.lastAct = ac.new Action(“transfer”,amt); }}


Scope of Fieldspublic class A { public String name="a"; public class B { public String name="b"; public class C { public String name="c";

public void printNames() {…}

} } public static void main(String[] a){…}}


public void printNames() { // class C System.out.println(name); // c System.out.println(this.name); // c System.out.println(B.this.name); // b System.out.println(A.this.name); // a

}

public static void main(String[] a){ //class A

A a = new A();

B b = a.new B();

A.B.C c = b.new C();

c.printNames();}


javap -p A$B$Cpublic class A.B.C extends

java.lang.Object {

/* ACC_SUPER bit NOT set */

private final A.B this$1;

public java.lang.String name;

public A.B.C(A.B);

public void printNames();

}


javap -p A.B

public class A. B extends java.lang.Object {

private final A this$0;

public java.lang.String name;

public A.B(A);

static A access$0(A.B);

// related to accessing private

{...A.B.C...}

}


Scope vs Inheritance

• Top-level class can extend a member class.• Class hierarchy

– superclass to subclass

• Containment hierarchy – containing class to nested class

• Whenever there is a name conflict between an inherited member and a member of an enclosing class, Java requires explicit disambiguation. • The name of a member class must differ from the name

of the enclosing package or class.


class A

extends A.B {

int i = 0;

class B {

int i = 1;

}

}

Pathological cases

• Cyclic Inheritance: illegal

• Static subclass of a member class: legal

class A { int i = 0; class B { int i = 1; } static class C extends B { int i = 2; C(A a) { a.super(); } } public static void main(String[] args) { A a = new A(); B b = a.new B(); C c = new C(a); }}


Local Class (vs Member class)

• A local class is similar to a member class except that its methods can also access final local variables, final formal method parameters, and final exception parameters.

• An instance of a local class has private fields to hold values of final local variables, final exception parameter, and final method parameters, in addition to a private reference to the enclosing class instance.


EnumerationEnumeration myEnumerate(final Object[] arr) {

class E implements EnumerationEnumeration {

int count = 0;

public boolean hasMoreElements()public boolean hasMoreElements()

{ return count < arr.length; }

public Object nextElement()public Object nextElement()

{ return arr[count++]; }

}

return new E();

}

– Scope of arr is the body of myEnumerate function.

– Lifetime of the array instance referenced by arr should

be at least as long as the Enumeration object.


import java.util.*;

class XYZ {

int i;

Enumeration myEnumerate(final Object[]arr) {

class E implements Enumeration {

int count = i;

public boolean hasMoreElements()

{ return count < arr.length; }

public Object nextElement()

{ return arr[count++]; }

}

return new E();

}

}


class XYZ$1$E extends java.lang.Object implements

java.util.Enumeration {

private final java.lang.Object val$arr[];

int count;

XYZ$1$E(java.lang.Object[], XYZ);

public boolean hasMoreElements();

public java.lang.Object nextElement();

}

javap -p XYZ$1$E


public class Weird { // cf. closure

interface IntHolder { int getValue(); }interface IntHolder { int getValue(); }

public static void main(String[] args) {

IntHolder[] holders = new IntHolder[10];IntHolder[] holders = new IntHolder[10];

for(int i=0; i<10; i++) {

final int fi = i;

class MyIntHolder implements IntHolderIntHolder {

public int getValue() { return fi; }

}

holders[i] = new MyIntHolder();

} // MyIntHolder invisible here

for(int i=0; i<10; i++) for(int i=0; i<10; i++)

System.out.println(holders[i].getValue());System.out.println(holders[i].getValue());

}

}


Anonymous Class• Local class without a name.

• Combines class definition and instantiation.

• No constructor.

• Can implement an interface (by implicitly extending class Object).

new <class-name> ( <arg-list> ) { <class-body> }

new <interface-name> ( ) { <class-body> }


import java.applet.*;

import java.awt.*;

import java.awt.event.*;

public class Scribble extends Applet {

public void init() {

this.addMouseMotionListener(

new MouseMotionAdapter() { public void mouseDragged(MouseEvent e) { Graphics g = getGraphics();

int x = e.getX(), y = e.getY();

g.drawLine(0, 0, x, y);

}

} ); }}


class LocalVarThreads {

public static void main(final String[] args) {

for (int i = 0; i < args.length; i++) {

final int ii = i;

Runnable r = new Runnable() {

public int count;

public void run() { System.out.println("<<"+ii+">>

"+count++);

};

}

new Thread(r).start();

}

}}


Other new features • Instance Initializers

• similar to class initializers

• serves as a constructor in anonymous classes

• “Blank” finals• assign only once prior to use instead of in decl.

• Anonymous arrays• int[] a; a = new int[] {1,2,3,4};

• Class literals• String.class, Integer.class, Integer.TYPE, etc

• In Java 1.1, class is a keyword and a field.


Reflection

Introspection

Meta-programming


What does Reflection API do?

Java Runtime Environment maintains an immutable Class object that contains information about a class. Reflection API enables a program to: Determine the class of an object.

Get information about a class's modifiers, fields, methods, constructors, and superclasses.

Find out what constants and method declarations belong to an interface.


Create an instance of a class whose name is not

known until runtime.

Get and set the value of an object's field, even if

the field name is unknown to your program

until runtime.

Invoke a method on an object, even if the

method is not known until runtime.

Create a new array, whose size and component

type are not known until runtime, and then

modify the array's components.


Applications: Construction of development tools.

• Tools that need to discover and use public members of a target object based on its class.– GUI builders

• selecting and creating a component.• determining properties, methods, events, etc

supported by a JavaBean.• customizing a component to running a

method.


(cont’d)

• Tools that need to discover and use members declared in a given class.– Class browsers

• requires information about classes to display their fields, methods, constructors, etc.

– Debuggers

• accessing and modifying field values.

– Interpreters


Java Core Reflection APIs

• package java.lang.reflect• new interface: Member

• new classes: Field, Method, Constructor.

• new class: Array

• new utility class: Modifier

• package java.lang• new wrapper classes: Byte, Short

• updated class: ClassClass

• new objects: instances of class ClassClass to represent primitive types.

cs884 (prasad)java11extn1 java 1.1 extensions nested classes static public/protected/private

Documents