JAVA基础知识_05

面试点：88.Object默认自带这几个方法

面试点：89.equals(Object obj)：比较两个句柄引用的地址是否是同一个地址，如果返回值为
true，证明两个句柄引用的是同一个对象
getClass()：反射获取类信息
hashCode()：获取对象的散列码 散列：本身代表虽然无规则，但分布的相对均匀，就相当
于把一堆数据分布，大体上分布的均匀。通常用数组来实现散列
notify()：唤醒线程（让线程从等待状态进入就绪状态）
notifyAll()：唤醒全部线程
toString()：默认的是输出对象所属的类信息以及对象地址
wait()：让线程进入等待状态(未就绪状态)

面试点：90.equals方法
在Object类中表示比较两个句柄引用的地址是否是同一个地址，但字符串对equals方法进行
了重写，所以只对比字面意思是否相等
重写equals要注意什么：重写equals一定要重写hashCode方法
为什么重写equals一定要重写hashCode方法：因为hashmap里边需要equals和hashCode需
要协同，由equals判断两个对象值是否相等，然后根据hashcode存储

面试点：91.hashCode方法
获取对象的散列码
如果两个不同的对象他们的hashCode一定不相等是不对的，他们也会有小概率相等
如果两个对象hashCode不相同，那这两个对象一定不相同，这两个一定是独立的对象，
因为即使哈希值相同，两个对象仍然有可能不相同。

s是直接等于的，t是new出来的，所以他们的地址一定不同
因为字符串重写了equals，但重写equals一定要重写hashCode方法，字符串重写了equals使s和t相等，所以s和t的hashcode是相等的，判断是否相等和计算hashcode都不再根据地址了，而是根据字面值

new Double(salary).hashCode();

不创建具体的句柄，用完就回收了，优化算法。如果在堆中的对象，发现没有任何地方记录他的地址就会被回收掉。

Double.hashCode(salary);

调用静态方法，没有创建对象

92.泛型
代表任意类型，但不能用基本类型，只能代表引用类型
定义一个泛型：

public class Arrayx<XXX> { //xxx代表他可以是任意类型
	public XXX flag;
	public XXX[] arr = (XXX[])new Object[20];//数组不能用=new XXX[]来创建
	public int index = 0;
	public void add(XXX z) {
		arr[index++] = z;
	}
}

调用泛型：

public class Person {
	public int age;
}
public class Test {
	public static void main(String[] args) {
		Arrayx<String> a = new Arrayx<String>();
		a.flag = "aaaa";
		Arrayx<Person> b = new Arrayx<>();
		b.flag = new Person();
		b.flag.age = 89;
	}
}

93.由于泛型不能代表基本类型，所以定义了几个包装器类：Integer、Long、Float、Double、
Short、Byte、Character 、Void 和 Boolean

面试点：94.调用list.add(3);
将自动的变换为

list.add (Integer.value0f(3));

这种变换被称为自动装箱

当将一个 Integer 对象赋给一个 int 值时， 将会自动地拆箱。也就是说， 编译器

将下列语句：

int n = list.get(i);

翻译成

int n = list.get(i).intValue();

什么是128陷阱？：

public class Test3 {
	public static void main(String[] args) {
		Integer x1 = 900;
		Integer x2 = 900;//-128~127
		System.out.println(x1==x2);
	}
}

在-128~127这个范围里就是true，超出这个范围就是false，这几个包装类都是这样的
如果他们的值在-128~127内，值相等的话引用的是同一块内存，超出了才会各自申请各
自的，便于节省内存，之所以规定在128，是因为128使用频率高
由于将基本类型变为了包装类，==变为了判断他们的地址是否相同，而不是像基本类型
那样判断他们的值是否相等
要想让他们像基本类型一样就要执行拆箱操作：

System.out.println(x1.intValue()==x2.intValue());

String x1 = "111";
     int x2 = Integer.parseInt(x1);//将数据转化为数值类型

      System.out.println(x2);

96.参数数量可变：

public static void main(String[] args) {
		m1(1);
		m1(1,2,3,4,5,677,7,8);
		m1(1,13,45,6);
		m1("qq");
		m1("qq","qq","asdas","qqeasda");
	}
	public static void m1(int ... a) {//int[] a
		
	}
	public static void m1(String ... a) {//String[] a
		
	}

int ... a和String ... a表示可以传任意数量的参数，接受的时候是一个数组

97.枚举类
如果构造方法是public类型，外界方法调用它可以产生新的实例
只有把构造方法设为privat类型的才无法通过new的方式产生新的实例
创建一个枚举类：

public enum Person1 {
	A(10,"小明1"),B(11,"小明2"),C(12,"小明3"),D(13,"小明4"),E(14,"小明5");//对象
	private int age;
	private String name;
	private Person1(int x,String y) {
		age = x;
		name = y;
	}
	public String toString() {
		return "name:" + name + "age:" + age;
	}
}

在枚举类里定义了几个对象，就尽量只有这几个对象，构造方法有参数，这几个对象也要加上参数
调用枚举类：

public class Test3 {
	public static void main(String[] args) {
		Person1 a = Person1.A;
		Person1 b = Person1.B;
		Person1 c = Person1.C;
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		
	}
}