abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃魚");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨頭");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
   說一下核心:
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable {
    // 序列化id
private static final long serialVersionUID = 8683452581122892189L;
// 默認初始的容量
private static final int DEFAULT_CAPACITY = 10;
// 一個空對象
private static final Object[] EMPTY_ELEMENTDATA = new Object[0];
// 一個空對象，如果使用默認構造函數創建，則默認對象內容默認是該值
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = new Object[0];
// 當前數據對象存放地方，當前對象不參與序列化
transient Object[] elementData;
// 當前數組長度
private int size;
// 數組最大長度
private static final int MAX_ARRAY_SIZE = 2147483639;

// 省略方法。。
}

/**
 * Constructs an empty list with an initial capacity of ten.我們沒有傳變量的時候設置為空,此時還沒有開辟新的內存,直接指向類成員DEFAULTCAPACITY_EMPTY_ELEMENTDATA
 */
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//根據傳過來的容量來，大于0初始化,等于0，用到EMPTY_ELEMENTDATA，小于0報錯
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;//這個1.7版本是會直接 this.elementData = new Object[initialCapacity]; 這里避免了new 空對象
} else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
}
}
//這個構造方法直接可以傳Collection過來,Arrays.copyOf是深拷貝,相當于elementData用了新的地址了
public ArrayList(Collection<? extends E> c) { 
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
        // replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}

步驟1
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!  這里是保證容量的方法,調用calculateCapacity
elementData[size++] = e;
    return true;
} 
步驟2
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
步驟3 //計算容量的
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);//如果你剛開始沒有賦值，那我就給你默認值DEFAULT_CAPACITY 10
}
    return minCapacity;
}
步驟4
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

// overflow-conscious code
if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
步驟5  真正在擴容
private void grow(int minCapacity) {
    // overflow-conscious code
int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);//這里就是經常說的擴容1.5倍
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

看一下主要有兩個
/**
 * Pointer to first node.
 * Invariant: (first == null && last == null) ||
 *            (first.prev == null && first.item != null)
 */
//學過C就知道是指針的頭部，這里是指第一個對象 順便提一下transient 是不進行序列化
transient Node<E> first;

/**
 * Pointer to last node.
 * Invariant: (first == null && last == null) ||
 *            (last.next == null && last.item != null)
 */
//最后一個
transient Node<E> last;
//內部類 
private static class Node<E> {
    E item;//正在的對象，存放數據
Node<E> next;//下一個node地址
Node<E> prev;//前面一個node地址

Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
}
}
public boolean add(E e) {
    linkLast(e);//默認添加后末端
    return true;
}
void linkLast(E e) {
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
    if (l == null)//如果為空,說明加的第一個
        first = newNode;
    else
l.next = newNode;//下一個指向新add的node
size++;
modCount++;
}

//向某個下標插入E
public void add(int index, E element) {
    checkPositionIndex(index);

    if (index == size)
        linkLast(element);
    else
linkBefore(element, node(index));//node方法根據index遍歷獲取node對象
}

//主要看linkBefore，下面畫了個圖，大概可以描述清楚
void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
final Node<E> pred = succ.prev;
    final Node<E> newNode = new Node<>(pred, e, succ);
succ.prev = newNode;//
    if (pred == null)
        first = newNode;
    else
pred.next = newNode;
size++;
modCount++;
}

public synchronized void ensureCapacity(int minCapacity) {
    if (minCapacity > 0) {
        modCount++;
ensureCapacityHelper(minCapacity);
}
}

table為數組,然后每個Node為鏈表,簡稱散列表
transient Node<K,V>[] table;
添加時候主要調用
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)//數組的數量-1，和hash做與運算,初始值為16,16-1為15，二進制位1111,這種情況的哈希沖突是最少的
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
                    break;
}
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
p = e;
}
        }
        if (e != null) { // existing mapping for key
V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
afterNodeAccess(e);
            return oldValue;
}
    }
    ++modCount;
    if (++size > threshold)
        resize();
afterNodeInsertion(evict);
    return null;
}

public enum TestEnum {
    RED(1), GREEN(2), BLANK(3), YELLOW(41);

    int testStatus;
    TestEnum(int i) {//一定要構造方法

        testStatus=i;
    }

    public int getTestStatus() {
        return testStatus;
    }

    public void setTestStatus(int testStatus) {
        this.testStatus = testStatus;
    }
}

public static void main(String[] args) {
    System.out.println(TestEnum.YELLOW.testStatus);//這里有點類似于static的使用
}

Connected to the target VM, address: '127.0.0.1:57115', transport: 'socket'
41
Disconnected from the target VM, address: '127.0.0.1:57115', transport: 'socket'

public enum UseStatusEnum {
    PACKING_NOT_USE(1,"11"),  // 未領用
    PACKING_HAS_USED(2,"22"),  // 已領用
    PACKING_BACK_USE(3,"33");  // 已打回

    private Integer useStatus;
    private String str;
    private UseStatusEnum(int useStatus,String str) {
        this.useStatus = useStatus;
        this.str=str;
        CollectionUtils.isEmpty(new HashMap<>());
    }
    public Integer getUseStatus() {
        return useStatus;
    }

    public String getStr() {
        return str;
    }

    public static void main(String[] args) {
        System.out.println(UseStatusEnum.PACKING_NOT_USE.getStr());
    }
}
結果
Disconnected from the target VM, address: '127.0.0.1:57131', transport: 'socket'
11

Process finished with exit code 0

public class MySerial implements Serializable {
    private static final long serialVersionUID = 1L;
    String name="imfjj";
    byte age=18;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public byte getAge() {
        return age;
    }

    public void setAge(byte age) {
        this.age = age;
    }

    public static void main(String[] args) {
        try {
            ObjectOutputStream o=new ObjectOutputStream(new FileOutputStream("mySerial.out"));
            MySerial mySerial=new MySerial();
            o.writeObject(mySerial);
            o.flush();
            o.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        deserialize();
    }

    private static  void deserialize(){
        ObjectInputStream objectInputStream = null;
        try {
            objectInputStream =new ObjectInputStream(new FileInputStream("mySerial.out"));

        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            MySerial mySerial = (MySerial) objectInputStream.readObject();
            System.out.println(mySerial.getAge());
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }
}

結果:

Connected to the target VM, address: '127.0.0.1:58620', transport: 'socket'
Disconnected from the target VM, address: '127.0.0.1:58620', transport: 'socket'
18

Process finished with exit code 0

假如改動

byte age=18;改動為

transient byte age=18;
輸出則為 0;

public class Test {
    public static void main(String[] args) {
        String a="hello";
    }
}