一、内部类

1.什么是内部类

在类内部定义的类，就是内部类

• 内部类可以访问外部类的私有属性和私有方法
• 内部类对于外界来说可以认为是它是透明的

/**
* 定义一个树形类
*/
public class Tree {
  private int size;
  private List<Node> nodes;
  /**
  * 树形节点类
  */
  class Node {
    private int value;
  }
}

• 上例中的Node类就是一个内部类

2.内部成员类

• 内部类就像外部类的成员或者方法一样，与类的变量和方法同级的内部类

/**
 * 团队类，团队是由一个人组员组成的
 */
class Team {
    /**
     * 团队名称
     */
    private String name;
    /**
     * 组员列表
     */
    private List<Member> members;
    public Team() {
        members = new ArrayList<Member>(5);
    }
    public Team(String name) {
        this();
        this.name = name;
    }
    /**
     * 添加成员
     * @param id
     * @param nickname
     */
    public void addMember(int id, String nickname) {
        Member m = new Member();
        m.id = id;
        m.nickname = nickname;
        this.members.add(m);
    }
    public List<Member> getMembers() {
        return members;
    }
    /**
     * 1.成员内部类(组员类)
     */
    class Member {
        private int id;
        private String nickname;
    }
}

3.局部内部类

• 局部内部类是方法内部定义的类，方法外不可直接访问

/**
 * 团队类，团队是由一个人组员组成的
 */
class Team {
    /**
     * 团队名称
     */
    private String name;
    /**
     * 组员列表
     */
    private List<Member> members;
    public Team() {
        members = new ArrayList<Member>(5);
    }
    public Team(String name) {
        this();
        this.name = name;
    }
    /**
     * 添加成员
     * @param id
     * @param nickname
     */
    public void addMember(int id, String nickname) {
        Member m = new Member();
        m.id = id;
        m.nickname = nickname;
        this.members.add(m);
    }
    public List<Member> getMembers() {
        return members;
    }
    public Map<Integer, Object> getMemberMap() {
        /**
         * 2.局部内部类
         */
        class MemberMap {
            private Map<Integer, Object> dataMap;
            public MemberMap() {
                dataMap = new HashMap<Integer, Object>(5);
            }
            public void add(int k, String value) {
                dataMap.put(k, value);
            }
            public Map<Integer, Object> getAll() {
                return dataMap;
            }
        }
        MemberMap m = new MemberMap();
        for (Member member : members) {
            m.add(member.id, member.nickname);
        }
        return m.getAll();
    }
    /**
     * 1.成员内部类(组员类)
     */
    class Member {
        private int id;
        private String nickname;
    }
}

4.匿名内部类

• 没有名称的内部类，一般在方法内部调用(它和局部内部类很相似，只不过它没有名称)
• 为了免去给内部类命名，或者只想使用一次，就可以选择使用匿名内部类

public void start(){
    /**
    * 实例化线程类没有任何命名
    */
    new Thread(){
        @Override
        public void run() {
        }
    }.start();
}

5.静态内部类

• 以static关键词开头的内部类
  • 静态内部类只能访问它外部类的静态属性和静态方法

class App {
    private String name;
    private String url;
    private static String DEFAULT_STYLE = "传统";
    static class Style {
        private String color;
        public Style() {
        }
        public Style(String color) {
            this.color = color;
        }
        public String getStyle() {
            /**
             * 静态内部类只能访问它外部类的静态属性和静态方法
            */
            String info = "[" + DEFAULT_STYLE + "]"+color;
            return info;
        }
    }
}

二、超类Object

Object是所有类的祖先类(在java中的类，都自动继承Object类，而不需要显示声明extends Object)

1.hashCode

• 对象的hash码，它的作用：为了配合基于散列的集合一起正常运行

Integer a = 20;
Map<String, Object> m = new HashMap<String, Object>(3);
m.put("name", "shixinke");
System.out.println(a.hashCode());
System.out.println(m.hashCode());

2.equals

• 判断两个对象是否相等

class Computer {
}
public class ObjectDemo {
    public static void main(String[] args) {
        Integer a = 20;
        Integer b = 20;
        String m1 = "hello";
        String m2 = "hello";
        System.out.println(a.equals(b));    //true
        System.out.println(m1.equals(m2));  //true
        Computer c1 = new Computer();
        Computer c2 = new Computer();
        System.out.println(c1.equals(c2));  //false
        Computer c3 = c2;
        System.out.println(c3.equals(c2));  //true(c3和c2指向同一个内存地址)
    }
}

• 对于值类型(主要是基本类型的其包装类型和字符串)的来说，只要两个对象的值相等那么两个对象就相等
• 对于引用类型，两个对象的属性值相等，两个对象不一定相等，因为引用类型是比较的两个对象存储的位置是否相等 (即对象的指针)

3.toString

• 将对象转化为字符串(一般子类都有相应的实现，以覆盖Object的默认的实现)

Computer c1 = new Computer();
System.out.println(c1.toString());  //basic.oop.Computer@1540e19d

4.getClass

• 获取当前对象对应的Class对象(主要是为了反射)

Computer c1 = new Computer();
System.out.println(c1.getClass());  //class basic.oop.Computer

5.线程相关的操作

• wait : 将线程设置为等待状态，等待线程的唤起
• notify/notifyAll : 通过线程不再需要等待(相当于唤醒线程)