Numbers

final: Variables, Methods and Classes

Sometimes we don’t want child classes to override the implementation in the parent!

Java keyword final. – Using this keyword will prevent child classes (or anyone else) modifying the variable/method this applies to.We can prevent a class from being inherited at all!

Suppose we want to keep track of how many instances of a class are made. – Question: How can we automatically keep track? • cannot leave it to the objects; • cannot use an instance variable. – Answer: Use a class variable. • A class variable is created when the class is created, rather than when an object is created. – There may be n instances of the class, but there will only be one instance of the class variable. – To declare a class variable, use the modifier static.

Normally every instance of an object has its own copy of all variables and methods defined in the class.If you declare something as static, it means that all objects have the same copy of that variable/method.

Static methods can only reference static variables!

Static is like global variables but applies classwide. • Static methods become available when the class is loaded (created), not when you make an instance of it

Can access static methods even when no instance of a class has been created!

Math Class and Methods

Methods of class Math: almost like global methods! – Act on the argument but are not affected by an instance variable state.

Example: int x = Math.min(56,12); always does the same thing and doesn’t use instance variables.  Method’s behaviour doesn’t need to know about a given object.

Math Class: – Doesn’t have instance variables. – Can’t make an instance of class.

For static method ,it is no sense to use them as instance method

Classes that can’t be instantiated: – Abstract classes and interfaces. – Classes with private constructors. • Only code inside the class can invoke a private constructor! • Methods in class Math are static.

– Invoking a Math method:Math.max(10,20);//calling a static method: use the class name

A non-initialised static variable will have the default value of that variable type.

naming convention for static final variables: all caps

static block to initialise static final variables

final class: cannot extend the class

final classes and abstract classes: not the same!

Math.random(): returns a double in range 0.0-1.0 (excluding).

• Math.abs(double num): returns a double that is the absolute value of num; method is overloaded to take/return an int value.

• Math.round(float value): returns a value rounded to the nearest int value; method is overloaded to take a double value and return a long value.

• Math.min(int a, int b): returns an int that is the minimum value between a and b; method is overloaded to take/return a long, float or double value.

• Math.max(int a, int b): returns an int that is the maximum value between a and b; method is overloaded to take/return a long, float or double value.

Wrapping Classes: used when a variable of a primitive type needs to be treated as an object. – Every primitive type has a wrapper class. – Wrapper classes are part of java.lang package  no need to import them

Autoboxing: automatic wrapping  conversion from primitive type to wrapper object is automatic!

Integer i = new Integer(10); i++; System.out.println(“New value is: “ + i);

Integer d = x;int x = 10;Integer x = 10;

Wrappers have parse methods: they take a String and return a primitive value.

String str1 = “10”; String str2 = “123.45”; String str3 = “true”; int i = Integer.parseInt(str1); // i=10 double d = Double.parseDouble(str2); // d=123.45 boolean b = new Boolean(str3).booleanValue(); // b=true

All wrapper classes are subclasses of the Number abstract class (part of the java.lang package).

Number num = new Integer(10);

Subclasses of Number provide constants to, e.g. represent the upper and lower bounds of the corresponding data type (MIN_VALUE and MAX_VALUE, respectively). • Example: System.out.println(Long.MIN_VALUE);  –263

Methods that call themselves, directly or indirectly, are known as recursive

Extra memory required + time to manage the extra space.

• use an iterative approach if that is the obvious solution; • avoid using recursion if there are concerns about the program’s performance.