Object is a kind of structure.
But primitive and reference, they are just somehow, values.
public static void main(String[] args]){
List list = new ArrayList();
list.add("abc"); // list.add(Object e), means only an object can be added to a list
list.add(new Object());
list.add(100); // boxing automatically
System.out.println(list.size()); // output: 3
System.out.println(list.get(2).getClass().getName()); // output: java.lang.Integer
}
int is a kind of primitive type but integer is a kind of reference type, means int can be converted to integer so that it can be treated as an object.
-
byte Byte
-
short Short
-
int Integer
-
long Long
-
float Float
-
double Double
-
char Character // Important
-
boolean Boolean
pubilc static void f(int i){
}
public static void main(String[] args){
Integer I1 = 128;
Integer I2= 128;
System.out.println(I1 == I2); // false, because I1 and I2 are not the same
// But if I1 and I2 are between -128 and 127, it will be true. Because of they are in constant pool.
// ----------------------------------------------------------------
Integer I1 = new Integer(100);
f(I1); // Correct, for unboxing is also automatically
}
Wrapper classes along with class String are immutable. Which means, any values from the objects of these classes CANNOT be changed.
Which means, if you run the code below:
String[] s1 = {"abc","123",""};
String all = "";
for (String s:s1){
all += s;
}
Then you will create a lot of Garbage objects. Because you are not changing this string but creating a new one.
System.out.println(System.out.getClass().getName()); // output: java.io.PrintStream
int[] ints = new int[4];
System.out.println(ints.getClass().getName()); // output: [I
Wrapper classes have an attribute called "TYPE", which means Integer.TYPE == int.class
will return true.
Long and Integer are all extended from class Number, which means int can be converted long but Integer cannot be converted to Long.
Father classes can not be converted into son classes only if you force convert them
Son classes can convert to father classes directly
BUT ONE SON WILL NOT BE A FATHER'S OTHER SONS!!!
String s = "123";
System.out.println(Integer.parseInt(s)); // output: 123
Every wrapper class can provide a method named parse*
(Like parseInt()
,parseDouble()
)to convert this object into this type.
import java.lang.System;
or
import java.lang.*;
Not needed for compiler will automatically.
import java.lang.*;
will only import packages of this file but will not sub-packages of this.
For example,import java.lang.*
will not import java.lang.reflect.Method
;
You can also use java.awt.List l
to make a difference from import java.util.*; List l;
java.io.File f;
// This is called full qualified
Objects created by new() will automatically placed into heap
Stack and heap are different for the different accessing method
One thread will maintain one stack so that there is only one heap but not only one stack
When calling int i=100
, i will be stored into a frame of stack, one function or say one method will have one stack frame.
You can easily achieve overload by different inputs
But you can not simply override one function by returning
Calling which method with rewritten ones depends on the environment
Method in class always have a parameter ClassName
this
Static method will not give the parameter of itself.
Thread.sleep()
is a static method, which means the running thread will sleep
Also, static int i have only one, but int i can have many copies for each object of this class.
All class objects are in Method Area, static variables will be stored here along with class.
When you want to sleep one thread then write Thread.sleep()
in this thread.
class Person{ // singleton
static Person person = new Person();
private Person(){}
pubilc static Person getPerson(){
return person;
}
}
public static void main(String[] args){
Person p = person.getPerson();
}
Class object will never be collected, so static object of class will not never be collected
This is a stable GC Root, so remember to do p = null;
When analyzing memory leak problems, remember to check static members of the class
In UML, "-" stands for private and "+" stands for public
Inherit, using extends, is a kind of "is-a" relationship
Association, is a kind of "has-a" relationship, such like Teacher-Student (关联)
Aggregation, is a kind of "has-a" relationship, such like Car-Engine (聚合)
Composition, is a kind of "has-a" relationship, such like Body-Heart (组合)
Rely, is a kind of "depends-a" relationship
Constructor is used to initialize an object
class Person{
String pname = "abc"; // Specifying Initialization
Person(){ // Constructor Initialization
this.pname = "xyz";
}
}
Specifying Initialization will be copied to every Constructor and be firstly executed.
You can call this()
to call the overloaded constructor
Static Constructor:
class Person{
static int PersonCount;
static{
PersonCount=100;
}
static{
PersonCount=110;
}
}
Only one static constructor created
Problem remained: When will call the static constructor?