java面向对象(四)内部类和超类Object

一、内部类

内部类的分类

1.什么是内部类

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

  • 内部类可以访问外部类的私有属性和私有方法
  • 内部类对于外界来说可以认为是它是透明的
  1. /**
  2. * 定义一个树形类
  3. */
  4. public class Tree {
  5. private int size;
  6. private List<Node> nodes;
  7. /**
  8. * 树形节点类
  9. */
  10. class Node {
  11. private int value;
  12. }
  13. }
  • 上例中的Node类就是一个内部类
2.内部成员类
  • 内部类就像外部类的成员或者方法一样,与类的变量和方法同级的内部类
  1. /**
  2. * 团队类,团队是由一个人组员组成的
  3. */
  4. class Team {
  5. /**
  6. * 团队名称
  7. */
  8. private String name;
  9. /**
  10. * 组员列表
  11. */
  12. private List<Member> members;
  13. public Team() {
  14. members = new ArrayList<Member>(5);
  15. }
  16. public Team(String name) {
  17. this();
  18. this.name = name;
  19. }
  20. /**
  21. * 添加成员
  22. * @param id
  23. * @param nickname
  24. */
  25. public void addMember(int id, String nickname) {
  26. Member m = new Member();
  27. m.id = id;
  28. m.nickname = nickname;
  29. this.members.add(m);
  30. }
  31. public List<Member> getMembers() {
  32. return members;
  33. }
  34. /**
  35. * 1.成员内部类(组员类)
  36. */
  37. class Member {
  38. private int id;
  39. private String nickname;
  40. }
  41. }
3.局部内部类
  • 局部内部类是方法内部定义的类,方法外不可直接访问
  1. /**
  2. * 团队类,团队是由一个人组员组成的
  3. */
  4. class Team {
  5. /**
  6. * 团队名称
  7. */
  8. private String name;
  9. /**
  10. * 组员列表
  11. */
  12. private List<Member> members;
  13. public Team() {
  14. members = new ArrayList<Member>(5);
  15. }
  16. public Team(String name) {
  17. this();
  18. this.name = name;
  19. }
  20. /**
  21. * 添加成员
  22. * @param id
  23. * @param nickname
  24. */
  25. public void addMember(int id, String nickname) {
  26. Member m = new Member();
  27. m.id = id;
  28. m.nickname = nickname;
  29. this.members.add(m);
  30. }
  31. public List<Member> getMembers() {
  32. return members;
  33. }
  34. public Map<Integer, Object> getMemberMap() {
  35. /**
  36. * 2.局部内部类
  37. */
  38. class MemberMap {
  39. private Map<Integer, Object> dataMap;
  40. public MemberMap() {
  41. dataMap = new HashMap<Integer, Object>(5);
  42. }
  43. public void add(int k, String value) {
  44. dataMap.put(k, value);
  45. }
  46. public Map<Integer, Object> getAll() {
  47. return dataMap;
  48. }
  49. }
  50. MemberMap m = new MemberMap();
  51. for (Member member : members) {
  52. m.add(member.id, member.nickname);
  53. }
  54. return m.getAll();
  55. }
  56. /**
  57. * 1.成员内部类(组员类)
  58. */
  59. class Member {
  60. private int id;
  61. private String nickname;
  62. }
  63. }
4.匿名内部类
  • 没有名称的内部类,一般在方法内部调用(它和局部内部类很相似,只不过它没有名称)
  • 为了免去给内部类命名,或者只想使用一次,就可以选择使用匿名内部类
  1. public void start(){
  2. /**
  3. * 实例化线程类没有任何命名
  4. */
  5. new Thread(){
  6. @Override
  7. public void run() {
  8. }
  9. }.start();
  10. }
5.静态内部类
  • 以static关键词开头的内部类
    • 静态内部类只能访问它外部类的静态属性和静态方法
  1. class App {
  2. private String name;
  3. private String url;
  4. private static String DEFAULT_STYLE = "传统";
  5. static class Style {
  6. private String color;
  7. public Style() {
  8. }
  9. public Style(String color) {
  10. this.color = color;
  11. }
  12. public String getStyle() {
  13. /**
  14. * 静态内部类只能访问它外部类的静态属性和静态方法
  15. */
  16. String info = "[" + DEFAULT_STYLE + "]"+color;
  17. return info;
  18. }
  19. }
  20. }

二、超类Object

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

Object类的方法

1.hashCode
  • 对象的hash码,它的作用:为了配合基于散列的集合一起正常运行
  1. Integer a = 20;
  2. Map<String, Object> m = new HashMap<String, Object>(3);
  3. m.put("name", "shixinke");
  4. System.out.println(a.hashCode());
  5. System.out.println(m.hashCode());
2.equals
  • 判断两个对象是否相等
  1. class Computer {
  2. }
  3. public class ObjectDemo {
  4. public static void main(String[] args) {
  5. Integer a = 20;
  6. Integer b = 20;
  7. String m1 = "hello";
  8. String m2 = "hello";
  9. System.out.println(a.equals(b)); //true
  10. System.out.println(m1.equals(m2)); //true
  11. Computer c1 = new Computer();
  12. Computer c2 = new Computer();
  13. System.out.println(c1.equals(c2)); //false
  14. Computer c3 = c2;
  15. System.out.println(c3.equals(c2)); //true(c3和c2指向同一个内存地址)
  16. }
  17. }
  • 对于值类型(主要是基本类型的其包装类型和字符串)的来说,只要两个对象的值相等那么两个对象就相等
  • 对于引用类型,两个对象的属性值相等,两个对象不一定相等,因为引用类型是比较的两个对象存储的位置是否相等 (即对象的指针)
3.toString
  • 将对象转化为字符串(一般子类都有相应的实现,以覆盖Object的默认的实现)
  1. Computer c1 = new Computer();
  2. System.out.println(c1.toString()); //basic.oop.Computer@1540e19d
4.getClass
  • 获取当前对象对应的Class对象(主要是为了反射)
  1. Computer c1 = new Computer();
  2. System.out.println(c1.getClass()); //class basic.oop.Computer
5.线程相关的操作
  • wait : 将线程设置为等待状态,等待线程的唤起
  • notify/notifyAll : 通过线程不再需要等待(相当于唤醒线程)