0413-多态、Object类方法、访问权限修饰符、装箱拆箱、128陷阱

1:A and A

2:A and A

3: A and D

4: B and A

5: B and A

6:A and D

7:B and A

8: B and A

9:A and D

package 第四章对象和类;

public class ForthThir {
	//多态：父类的引用指向子类的对象,只能调父类的方法和子类重写的方法，不能调子类独有的方法；子类则可以调父类独有的方法
	//条件：必须继承关系、必须要重写，父类的引用指向子类对象
	/*
	 * public class Parent{
	 * 	public void eat(){System.out.println("Parent"); }
	 * }
	 * 
	 * public class Child1 extends Parent{
	 * 	public void eat(){System.out.println("Child1");}
	 * }
	 * 
	 *  public class Child2 extends Parent{
	 * 		public void eat(){System.out.println("Child2");}
	 * }
	 * 
	 * public class Grand1 extends Child1{
	 * 	public void eat(){System.out.println("Grand1");}
	 * }
	 * 
	 * 
	 * public class Test{
	 * 		public static void main(String[] args){
	 * 			Parent xx=new Parent();
	 * 			xx.eat();
	 * 			xx=new Child1();
	 * 			xx.eat();//执行Child1里的方法
	 * 
	 * 
	 * 			aa(new Parent());
	 * 			aa(new Child1());
	 * 		}
	 * 		public static void aa(Parent xx){
	 * 			xx.eat();
	 * 		}
	 ///强制类型转换 大碗不能自动转成小碗
	  * Parent xx =new Grand1();
	  * Child1 yy=(Child1)xx;
	  * Child2 yy=(Child2)xx;//运行报错，xx内核为Grand类型数据
	  * 
	  * 引用类型到底能不能转，做判断：
	  * instanceof 判断xx是否位Child2类型的对象，或者Child2子孙后代的对象
	  * if(xx instanceof Child2){
	  * 	Child2 yy=(Child2)xx;
	  * 
	  * }
	  * 
	  * 
	  * int a=32;
	  * short b=(short)a;
	  * 
	  * int[] arr={100,2457,120,22};
	  * for(int i=0;i<arr.length;i++){
	  * 	char j =(char)arr[i];
	  * 	System.out.println(j);
	  * }
	 * }
	 */
	//基本数据类型
	/*
	 * int a=10;
	 * Integer b=10;
	 * 
	 * int Integer String 
	 * 
	 * int->Integer new Integer():
	 * int a=10;
	 * Integer a_p=new Integer(a);
	 * 
	 * Integer->int intValue()
	 * Integer a_p=new Integer(4);
	 * int a=a_p.intValue();
	 * 
	 * Integer->String toString();
	 * Integer a_p=new Integer(4);
	 * 
	 * 
	 * 
	 * String->/integer:new Integer()
	 * String a="888";
	 * Integer b=new Integer(a)
	 * 
	 * int->String String.valueOf()
	 * int a=10;
	 * String b=String.valueOf(a);
	 * 
	 * String->int Integer.parseInt()
	 * String a="999";
	 * int b=Integer.parseInt(a);
	 * 
	 */
	 //装箱：基本类型->包装类
	 /*
	  * int a=10;
	  * Integer i=Integer.valueOf(a);
	  * 或Integer j=new Integer(a);
	  */
	//拆箱 包装类->基本类型
	/*
	 * Integer k=new Integer(10);
	 * int b=k.intValue();
	 */
	//自动装箱 直接把一个int类型的数据直接赋值到Integer(java 5之后)
	/*
	 * int c=20;
	 * Integer p_auto=a;
	 * 或 Integer m=100;
	 */
	//自动拆箱（把一个包装类型的数据变成基本类型数据)
	/*
	 * Integer l=new Integer(10);
	 * int d_auto=l;
	 */
	//128陷阱
	/*
	 * Integer num1=100;/=150 调的是valueOf方法，避免频繁创建 
	 * Integer num2=100;/=150
	 * System.out.println(num1==num2);true/false 超过128就是false
	 * Integer num3=new Integer(100);
	 * Integer num4=new Integer(100);
	 *  System.out.println(num3==num4);false
	 *  
	 *  
	 */

}

package com.qc.Object;

public class Test {
	public static void main(String[] args) {
		Object aa=new Object();
		aa.equals(obj);
		aa.hashCode();
		//equals()比较内存地址指向是否相同
		//getClass()获取类的信息 反射邻域
		//hashCode()获取散列码 根据地址生成
		//哈希表：数组+链表结构
		String a="ok";
		String b=new String("ok");
		
		Person x1=new Person();
		Person x2=new Person();
		System.out.println(x1.hashCode());
		//x1,x2的hashCode不同；a,b的hashCode相同，因为String重写了方法
		
		//（Objects里）equals判断是否为同一个对象；hashCode判断是否是同一类 大部分类在重写equals方法时会重写hashCode方法
		//如果两个对象相同（equals方法返回true）,那么他们的hashCode值一定相同
		//如果两个对象不同（equals方法返回false），他们的hashCode值可能相同 可能不同
		//如果两个对象hashCode值相同（存在哈希冲突），他们可能相同可能不同（equals方法可能返回false，可能返回true）
		//如果两个对象hashCode值不同，那么他们两个肯定不同（equals方法返回false）
		
		//面试题1：两个不同的对象，hashCode有没有可能相同？ 可能，有极小概率
		//面试题2：重写equals方法为什么要重写hashCode方法？一定要重写吗？
		//跟hashmap 如果不使用hashmap则不需要重写hashCode；equals和hashCode在hashmap里是配合使用的
		//hashmap比较key值的时候使用equals方法比较是否重复，存入values时要使用hashCode确定位置
		
		
		//访问权限修饰符（修饰变量/方法） 当前类       同包       子类 跨包    其他包
		//public                        ✔                ✔            ✔                   ✔
		//protected                     ✔                ✔            ✔                   ✖
		//默认  不写                    ✔                ✔              ✖                 ✖
		//private                       ✖                 ✖             ✖                 ✖


		
		//wait() 线程进入等待状态 让出CPU和锁
		//notify() 唤醒等待的线程
		//toString() 输出对象的类型和内存地址
		
		//hashCode()
	}
}

"128陷阱"是Java中关于整数缓存机制的一个经典问题，主要涉及Integer类的缓存行为和自动装箱/拆箱机制。

1. Integer缓存机制：

   • Java对-128到127之间的Integer对象进行了缓存

   • 当使用自动装箱或Integer.valueOf()方法时，会优先从缓存中获取对象

底层原理

1. IntegerCache类：

   • Java在Integer类内部维护了一个静态的IntegerCache类

   • 默认缓存了-128到127之间的Integer对象

2. 自动装箱行为：

   • 当使用Integer i = 100这样的语法时，实际调用的是Integer.valueOf(100)

   • valueOf()方法会先检查是否在缓存范围内

目的：

• 减少对象创建：对于常用的小整数（-128~127），通过缓存复用对象，避免重复创建