一、内部类
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 : 通过线程不再需要等待(相当于唤醒线程)