public class varTest {
   public static void main(String[] args) {

      test t1 = new test();
      t1.testMethod();
   }
}

class test {
   int instance_variable;         // OK not to initialize this as it will get the default value 0

   // Test constructor
   test() {
      System.out.println("instance_variable is " + instance_variable);
   }

   void test() {
      int method_variable;        // Must initialize this variable otherwise the compiler will complain.
      System.out.println("method_count: " + method_count);
   }
}

Note: when you try to compile this, the compiler will error stating that method_count might not have been initialized, remember that you should initialize memember variables

char a = 'a';
char b = '@';
char letterN = '\u004E';   // The letter N
char c = (char) 70000;     // casting is required because 7000 is out of range
char d = 70000;            // ERROR: casting rquired

byte b8 = 0b_00000001;     // Cannot have underscore directly after 0b 
char c8 = 0x_007F;         // Cannot have underscore directly after 0x 
int i8 = 1000000_;         // Underscore cannot be at end of literal 
long d8 = 1000000_L;       // Underscore cannot be prior to suffix  (L/l,F/f,D/d) 
float f8 = _1000.000000;   // Underscore cannot be at start of literal 
double l8 = 1.0000000_e10; // Underscore cannot prefix exponential in literal

byte b1 = 128; 
char c1 = 65536;
short s1 = 32768;

int i1 = 10; 
long l1 = i1;
float f1 = i1;
double d1 = i1;

int a = 100;
long b = a;            // Implicit cast, an int value always fits in a long

float a = 100.001f;
int b = (int) b;       // Explicit cast, a float can loose info as an int

Note: with explicit casting you let the compiler know that you know that you may loose info

public class Person {
    static String name = "UNKNOWN";  // Class Variable
    String instanceName = "UNKNOWN"; // Instance Variable;
    String age = "25";  // Instance Variable initialized;

    // Single Parameter Constructor.
    public Person(String age) {
        // Constructors are perfect examples of how a method parameter
        // name can have same name as class or instance variable name.

        // In this constructor,  the Person instance age does not get
        // set at all, because age not qualified by 'this'.
        // This is a common mistake and may be tested on exam
        age = age;
    }

    // Two Args Constructor
    public Person(String name, String age) {
        // constructor parameters are named and typed the same as the
        // class variable 'name' and the instance variable 'age'

        // Correctly setting object's age using 'this' qualifier
        this.age = age;

        // instanceName is an instance variable and has different
        // name from the parameter which will be assigned to it, so
        // this not required, but good practice to use it

        // Also setting static variable name in same assignment
        // statement
        this.instanceName = Person.name = name;
    }
    // Simple setter for age
    public void setAge(String age) {
        // method sets instance variable age to the parameter passed.
        this.age = age;
    }

    // Simple setter for instanceName
    public void setInstanceName(String instanceName) {
        this.instanceName = instanceName;
    }
    
    // Simple get decade to explain loop scope
    public String getDecade(int age) {
      // a method local variable
      String decadeString = "";
      
      // A method local variable
      int decadeNumver = age/10;
      
      // A method local variable
      int j = 0;
      for (int i = j = 0; i < (decadeNumber + 1); i++, j++) {
        // local loop block variable named decade, scope is loop
        String decade = "Decade " + (age / 10);
        
        // i variable is local to the loop
        if (i == (decadeNumber)) {
           decadeString = decade;
        }
      }
      int modyear = age % 10;
      decadeString += ", Year " + modyear;
      return decadeString;
    }
}

public class NestedScope {
    public static void main(String[] args) {
        // local variable i declared and initialized
        int i = 10;
        class locallyDefinedClass {
            {
                // i from method scope still visible in nested local class
                System.out.println("value of i BEFORE LOOP  " + i);
                System.out.println("---------------");

                // Because this for loop is within a local class,this is valid
                for (int i = 0; i< 5; i++) {
                    System.out.println("value of i during FIRST loop " + i);
                }
                System.out.println("---------------");

                // the local variable i from previous loop has gone out of scope
                // so it is ok to create another local variable in the second loop
                // declaration of the same name.
                for (int i = 5; i > 0; i--) {
                    System.out.println("value of i during SECOND loop " + i);
                }
                System.out.println("---------------");

                //  assign local loop variable j to local variable i from the
                // surrounding method of the nested class,
                for (int j = i; j < 15; j++) {
                    System.out.println("value of i,j during THIRD loop " + i + "," + j);
                }
                System.out.println("value of i AFTER LOOP  " + i);
            }
        }
        System.out.println("value of i before local class instantiated " + i);
        new locallyDefinedClass();
        System.out.println("value of i after local class instantiated " + i);
    }
}

public class VarTest {
    public static void main(String[] args) {
        var p1 = new Person();
        p1.setName("Paul");
        System.out.println(p1);

        // Adding some other var declarations:
        // i is inferred to be an int, since it's assigned a literal int
        var i = 1;

        // An array can be assigned to an LVTI variable
        var aVarArray = new int[3];

        // Valid to assign a method return value to an LVTI variable
        var methodVal = p1.getName();

        // OK to assign a null object to LVTI variable but not literal null
        // Note that i am using var as a variable name which is valid
        Object nullObject = null;
        var var = nullObject;

        // Invalid var declarations:

//        // cannot use var declaration in a compound statement
//        var j = 0, k = 0;
//
//        // again, cannot use var declaration in a compound statement
//        var m, n = 0;
//
//        // Cannot declare a var variable without also initializing it
//        var someObject;
//
//        // Cannot assign null to var variable, type cannot be inferred
//        var newvar = null;
//
//        // Cannot use array initializer in var declaration/initialization
//        var myArray = {"A", "B"};
//
//        // Cannot have an array of var
//        var[]newarray = new int[2];
    }
}

// Using the new keyword means a String object will be created
// there are many String constructors that can be used
String s = new String();
s = "Using the new keyword";

String s = new String("Using a one liner");

// the below creates the string in the string constant pool (see below for more information)
// this actually makes Java more efficient
String s = "Using the shorthand version";

String s = new String("Using a one liner");

s = s.concat("you are not supposed to be able to change this");

Note: what happens is the following

1. A new string object is created using the original string with the concatenation
2. the string variable s now points to the new string object
3. the old string object is removed by the garbage collector as long as nothing else is attached to it.

String x = "Hello World!";
System.out.println("Character 3 in String x is " + x.charAt(2));

Note: The charAt returns the character at a specific index, remember we start at zero

String t = "Hello";
String t1 = "World";
String t2 = t;

System.out.println( t + " compareTo " + t2 + " results in " + t.compareTo(t2));   // results in 0 (match)
System.out.println( t + " compareTo " + t1 + " results in " + t.compareTo(t1));   // results in -15

Note: a reult of zero means that they are equal, a negative values means it is less than the string passed, and a positive values means it is more than the value passed

String x = "Taxi";

System.out.println( x.concat(" cab");
System.out.println("Original String x has now been changed : " + x);

Note: concat method does not update x as there was no assignment

String x = "hello";

if ( x.equalsIgnoreCase("hello")
   System.out.prinln("String x is equal to Hello, hello, etc");

Note: see equals for more information on this method

String x = "hello";

if ( x.equalsIgnoreCase("Hello")
   System.out.prinln("String x is equal to Hello, hello, etc");

Note: the equalsIgnoreCase returns true if the value is the same as the argument passed, otherwise false

# getChars(int srcBegin, int srcEnd, char[] dest, int destBegin)

String h = "Hello World";
char[] ca = new char[5];

h.getChars(0, 5, ca, 0);
System.out.println(ca);

String t1 = "abcdefghiklmnopqrstuvwxyz";
String t2;

t2 = t1.intern();   // see note below

if ( t1 == t2)
   System.out.println("t1 and t2 are the same object");

if ( t1.equals(t2) )
   System.out.println("t1 and t2 have the same contents");

Note: when using intern you are looking in the string constant pool a special area in the heap memory, you can force a string to be added to the pool by calling the intern method on the string

String x = "this is a very long string that hopefully will have a total of 76 characters";

System.out.println("String x has " + x.length() + " Character");

Note: return the length of a String (includes whitespace)

String x = "XXaXX";

System.out.println("String before: " + x);
System.out.println("String replaced: " + x.replace('X','x'));

String x = "1234567890";

System.out.println("Part of String x: " + x.substring(5));    // start from position 5 return rest of string
System.out.println("Part of String x: " + x.substring(5,8));  // start from position 5 return upto character 8

Note: used to return part of a string

String lower = "all lower case";
String upper = "ALL UPPER CASE";

System.out.println("String lower is now upper case: " + lower.toUpperCase());
System.out.println("String upper is now lower case: " + upper.toLowerCase());

String x = "Hello World!";

System.out.println("toString method returns: " + x.toString());

Note: all objects in Java have a toString method, normally returns a meaningful way to describe the object

String x = "     x     ";

System.out.println("Blank spaces removed from x: " + x.trim());

Note: trim removes any leading or trailing blank spaces

StringBuffer sb1 = new StringBuffer();              // this will have an initial capacity of 16 characters
StringBuffer sb2 = new StringBuffer(10);            // this will have a capacity of 10 characters

StringBuffer sb3 = new StringBuffer("Hello World!");  // the capacity will be string size 12 plus 16 = 32

System.out.println("StringBuffer sb3 is: " + sb3);    // Just use it like a String

StringBuffer sb = new StringBuffer("abcd");

System.out.println("Appends efgh to StringBuffer sb :" + sb.append("efgh");
System.out.println("StringBuffer sb is now: " + sb);

Note: There are 10 overloaded append methods which allow you to add various data type values

StringBuffer sb1 = new StringBuffer();
StringBuffer sb1 = new StringBuffer(10);
StringBuffer sb1 = new StringBuffer("Hello World");

System.out.prntln("StringBuffer sb1(character count): " + sb1);     // displays 0
System.out.prntln("StringBuffer sb2(character count): " + sb2);     // displays 0
System.out.prntln("StringBuffer sb3(character count): " + sb3);     // displays 11

System.out.prntln("StringBuffer sb1(capacity): " + sb1);     // displays 16
System.out.prntln("StringBuffer sb2(capacity): " + sb2);     // displays 10
System.out.prntln("StringBuffer sb3(capacity): " + sb3);     // displays 27

Note: increasing the size is a performance hit, so if you do change the StringBuffer make sure it has the capacity already so it does not need to grow

StringBuffer sb1 = new StringBuffer();
sb1.ensureCapacity(75);                 // minimum capacity will be 75 characters

Note: if the character length is greater then the method ensures a capacity that is the greater of the number specified as an argument or twice the original capacity plus 2.

## sb.delete(start position, end position)
StringBuffer sb = new StringBuffer("1234567890");

System.out.println("Inserted text into StringBuffer sb: " + sb.delete(4, 6));  / displays 12347890

## sb.insert(start, data type) there are many diffrent data types i.e boolean, char, String, etc
StringBuffer sb = new StringBuffer("1234567890");

System.out.println("Inserted text into StringBuffer sb: " + sb.insert(4, "----"));

Note: again the offset is zero based

StringBuffer sb1 = new StringBuffer();
StringBuffer sb2 = new StringBuffer(10);
StringBuffer sb3 = new StringBuffer("Hello World");

System.out.println("StringBuffer sb1: " + sb1.length());     // displays 0 
System.out.println("StringBuffer sb2: " + sb2.length());     // displays 0
System.out.println("StringBuffer sb3: " + sb3.length());     // displays 11

Note: the length method only returns the character count not the size of the StringBuffer - see capacity

StringBuffer sb = new StringBuffer("1234567890");

System.out.println("Reversed StringBuffer sb:" + sb.reverse());

StringBuffer sb1 = new StringBuffer("Hello World");
sb1.setLength(5);
System.out.prntln("sb1: " + sb1);     // displays Hello, it truncated the original

Note: setLength will truncate any characters if the capacity is less than the String contained inside it

StringBuffer sb = new StringBuffer("1234567890");

System.out.println("StringBuffer sb:" + sb.toString());