Day18-常用类(一)

Object类

超类、基类，所有类直接或间接继承父类

Object类是所有类的父类（错，java是单继承）

1、getClass()

public final Class<?> getClass()

返回引用中存储的实际对象类型

应用：通常用于判断两个引用中实际存储对象的类型是否一致（）

由模板new出来的对象称为“类的对象”，通过方法调用的对象是“类对象”

2、hashCode()

public int hashCode()

返回该对象的十进制的哈希码值。
哈希算法根据对象的地址或字符串或数字计算出来的int类型的数值。
哈希码并不唯一，可保证相同对象返回相同哈希码，尽量保证不同对象返回不同哈希码

3、toString()

public String toString()

返回该对象的字符串表示（表现形式）。
可以根据程序需求覆盖该方法，如：展示对象各个属性值。

4、equals()

public boolean equals(Object obj)

默认实现为(this == obj)，比较两个对象地址是否相同。
可进行覆盖，比较两个对象的内容是否相同。

可以进行覆盖（重写），步骤如下：

比较两个引用是否指向同一个对象。
判断obj是否为null。
判断两个引用指向的实际对象类型是否一致。
强制类型转换。
依次比较各个属性值是否相同。

5、finalize()方法

当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列。
垃圾对象：没有有效引用指向此对象时，为垃圾对象。
垃圾回收：由GC销毁垃圾对象，释放数据存储空间。
自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象。
手动回收机制：使用System.gc(); 通知JVM执行垃圾回收。

public class Student {
	private int stuNum;
	private String name;
	
	public Student() {
		
	}
	public int getStuNum() {
		return stuNum;
	}
	public void setStuNum(int stuNum) {
		this.stuNum = stuNum;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public void show() {
		System.out.println("学号是"+stuNum+"姓名是"+name);
	}
	
	public Student(int stuNum, String name) {
		super();
		this.stuNum = stuNum;
		this.name = name;
	}
	//重写toString()方法
	@Override
	public String toString() {
		return "Student [stuNum=" + stuNum + ", name=" + name + "]";
	}
	
	//重写equals()方法
	@Override
	public boolean equals(Object obj) {
		//1、判断obj是否为null
		if (obj == null) {
			return false;
		}
		//2、两对象是否为同一对象
		if (this == obj) {
			return true;
		}
		//3、判断obj是否为学生对象 区分子类和父类
//		if (this.getClass() != obj.getClass()) {
//			return false;
//		}
		if (obj instanceof Student) {
			//4、强转 向下转型
			Student s = (Student) obj;
			//唯一标识一样就行
			if (this.stuNum == s.stuNum && this.name.equals(s.name)) {
				return true;
			}
		}
		return false;
	}
	
	
	@Override
	protected void finalize() throws Throwable {
		System.out.println(this.stuNum+"被回收了");
	}
	
}

public class TestStudent {
	public static void main(String[] args) {
		
		Student xm = new Student();
		xm.show();
		Student xh = new Student();
		xh.show();
		//返回实际类型getClass() （类对象）
		Class class1 = xm.getClass();
		System.out.println(class1.getName());//getName()获取类名
		Class class2 = xh.getClass();
		System.out.println(class2.getName());
		
		
		System.out.println(class1 == class2);
		
		
		//hashCode()返回该对象的十进制哈希（hash）码值（对象的地址）
		System.out.println(xm.hashCode());
		System.out.println(xm.hashCode());
		System.out.println(xh.hashCode());
		String s1 = "hello";
		String s2 = "hello";
		System.out.println(s1.hashCode());//哈希值相同，计算方法相同，认为是同一个
		System.out.println(s2.hashCode());
		
		
		System.out.println(xm.toString());
		System.out.println(xh.toString());
		System.out.println(xm);//任何对象打印默认打印输出字符串
		System.out.println(xh);
		
		
		//equals()比较两个对象地址值是否相同
		Student zs = new Student(1001,"张三");
		Student zs2 = new Student(1001,"张三");
		System.out.println(zs.equals(zs2));
	}
}

public class TestStudent2 {
	public static void main(String[] args) {
		Student stu1 = new Student(1,"tom1");
		Student stu3 = new Student(3,"tom3");
		Student stu2 = new Student(2,"tom2");
		Student stu4 = new Student(4,"tom4");
		Student stu5 = new Student(5,"tom5");
		stu1 = null;
		stu2 = null;
		stu3 = null;
		stu4 = null;
		stu5 = null;
		//通过JVM执行垃圾回收
		System.gc();
		
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

包装类

基本数据类型所对应的引用数据类型，包装类的默认值是null

基本类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

/**
 * 1、什么是包装类
 * 	java是面向对象变成，基本数据类型实例不了对象
 * 	基本数据类型--->包装类
 * 2、作用
 * 	基本数据类型里面没有属性和方法，它可以转换成包装类，不但有了
 * 属性和方法，而且其基类为Object类
 * 3、包装类
 * 	4类8种
 * byte Byte
 * short Short
 * int Integer
 * long Long
 * float Float
 * double Double
 * boolean Boolean
 * char Character
 * 4、包装类里的方法
 * 1)基本数据类型转包装类
 * 	第一种：构造方法
 * 	第二种：valueOf()
 * 		该基本数据类型对应的包装类 = 包装类类型.valueOf(基本数据类型)
 * 2)包装类转基本数据类型
 * 	基本数据类型 = 包装类的对象名.XXXvalue();
 * 3)基本数据类型转字符串
 * 	基本数据类型 = 包装类.parseXXX(字符串);
 * 5、包装类的其他属性和方法
 * 6、JDK1.5之后自动转化拆箱
 */
public class Test1 {
	public static void main(String[] args) {
		
		int n = 12;
		System.out.println(n);
		
		//基本数据类型转换为包装类
		//1、构造方法
		Integer i1 = new Integer(n);
		System.out.println(i1);
		//2、valueOf()
		i1 = Integer.valueOf(n);
		System.out.println(i1);
		
		//包装类转基本数据类型
		n = i1.intValue();
		System.out.println(n);
		
		//基本数据类型转字符串
		int n2 = 2;
		String str =n2+"";
		System.out.println(str);
		
		
		//属性
		int max = Integer.MAX_VALUE;
		System.out.println(max);
		int min = Integer.MIN_VALUE;
		System.out.println(min);
		//方法
		//进制转换
		String nn = Integer.toBinaryString(12);
		System.out.println(nn);
		//boolean和字符串转换
		//boolean与String  "true" 是 true  非"true" 都是false
		String str1 = "123哈哈哈";
		boolean b = Boolean.parseBoolean(str1);
		System.out.println(b);
		
		//JDK1.5之后自动转换
		Integer ii=12;
		System.out.println(ii);
		int aa=ii;
		System.out.println(aa);
//		Integer ii = Integer.valueOf(12);
//		System.out.println(ii);
//		int aa = ii.intValue();
//		System.out.println(aa);
	}
}

public class Test2 {
	public static void main(String[] args) {
		//面试题
		Integer i1 = new Integer(100);
		Integer i2 = new Integer(100);
		System.out.println(i1 == i2);//false ==代表地址判断 new创建对象
		
		Integer i3 = 100;
		Integer i4 = 100;
		//Integer.valueOf(100)
		System.out.println(i3 == i4);//true
		
		Integer i5 = 100;
		Integer i6 = 100;
		System.out.println(i5 == i6);//false 源码分析 -128~127
	}	
}

字符串

面试题

import java.lang.reflect.Field;

public class TestString1 {
	public static void main(String[] args) throws Exception{
		String name = "hello";
		System.out.println(name);
		//面试题1
		//使用构造方法创建字符串
		//创建几个对象
		System.out.println("面试题");
		String address = new String("beijing");
		System.out.println(address);
		String address2 = "beijing";
		String address3 = "beijing";
		String address4 = new String("beijing");
		System.out.println(address == address2);//==比较的是地址值 false
		System.out.println(address2 == address3);//true
		System.out.println(address == address4);//false
		System.out.println(address.equals(address4));//true equals比较的是内容
		System.out.println(address);
		System.out.println(address2);
		System.out.println(address3);
		System.out.println(address4);
		System.out.println("===================================");
		
		//面试题2
		//String 真的不可变吗？从底层源码来看是这样的，它是final类型的，是对字符数组char[]的封装，但可以通过烦舍技术修改数组中的数据，地址值还是不变的
		Class class1=address.getClass();//获得类对象
		Field field=class1.getDeclaredField("value");//获取其私有属性
		field.setAccessible(true);//取消语言检查
		char [] value=(char [])field.get(address);//beijing
		value[0]='B';
		System.out.println(address);
		System.out.println(address2);
		System.out.println(address3);
		System.out.println(address4);
		System.out.println("=============================");
		
		
		//面试题3
		System.out.println("写出代码的输出结果");
		String s1="abc";
		String s2="xyz";
		String s3=s1+s2;//对象在堆中
		String s4="abc"+"xyz";//字符串拼接，放在常量池中
		String s5="abcxyz";
		System.out.println(s3==s4);//false 一个堆中，一个常量池中
		System.out.println(s3.equals(s4));//true 比较内容
		System.out.println(s4==s5);//true 都在常量池中
		
//		String s1 = "abc";
//		String s2 = "xyz";
//		String s3 = (new StringBuilder(String.valueOf(s1))).append(s2).toString();
//		String s4 = "abcxyz";
//		String s5 = "abcxyz";
//		System.out.println(s3 == s4);
//		System.out.println(s3.equals(s4));
//		System.out.println(s4 == s5);
		
	}
}

/**
 *  String intern() 
    返回字符串对象的规范化表示形式。 
 *当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（用 equals(Object) 方法确定），则返回池中的字符串。否则，将此 String 对象添加到池中，并返回此 String 对象的引用。 
 */
public class TestString2 {
	public static void main(String[] args) {
		//使用intern()方法如果常量池中没有，则把对象复制一份（或对象的引用）放入常量池中，返回常量池中对象 ，如果常量池中存在，则直接返回
		//JDK1.7复制一份放到常量池，JDK1.8将对象引用常量池
//		String name1="张三";
//		String name2="李四";
//		String name3=name1+name2;//name3在堆中存储
//		String name4=name3.intern();//判断常量池中是否有"张三李四" 没有JDK1.8会赋值一个引用
//		System.out.println(name3==name4);//true

		
		
		String name1="张三";
		String name2="李四";
		String n="张三李四";//常量池  0x0000A001
		String name3=name1+name2;//name3在堆中存储 0x0000B002
		String name4=name3.intern();//判断常量池中是否有"张三李四" 有  引用的是n的地址值0x0000A001
		System.out.println(name3==name4);//false
		System.out.println(n==name4);//true
		
		System.out.println("java特殊 运行时已经保存在常量池中了");
		String aa="ja";
		String bb="va";
		String cc=aa+bb;//堆中
		String dd=cc.intern();//常量池
		System.out.println(cc==dd);//false
	}
}

/**
 * String intern()
 * 	返回字符串对象的规范化表示形式
 * 当调用 intern方法时，如果池已包含一个等于此String对象的字符串（用equals（Object）方法确定，则返回池中的字符串，否则，将此String对象添加到池中，并返回此String对象的引用）
 */
public class TestString2 {
	public static void main(String[] args) {
		//面试题
		//使用intern()方法如果常量池中没有，则把对象复制一份（或对象的引用）放入常量池中，返回常量池中对象，如果常量池中存在，则直接返回
		//JDK1.7复制一份到常量池中，JDK1.8将对象引用常量池
//		String name1="张三";
//		String name2="李四";
//		String name3=name1+name2;//name3在堆中存储
//		String name4=name3.intern();//判断常量池中是否有"张三李四" 没有JDK1.8会赋值一个引用
//		System.out.println(name3==name4);//true
		
		String name1="张三";
		String name2="李四";
		String n="张三李四";//常量池
		String name3=name1+name2;//name3在堆中存储
		String name4=name3.intern();//判断常量池中是否有"张三李四" 有  引用的是n的地址值
		System.out.println(name3==name4);//false
		System.out.println(n==name4);//true
		
		System.out.println("java特殊 运行时已经保存在常量池中了");
		String aa="ja";
		String bb="va";
		String cc=aa+bb;//堆中
		String dd=cc.intern();//常量池
		System.out.println(cc==dd);//false
	}
}

posted @ 2021-07-29 21:22 CN_Darren 阅读(43) 评论(0) 收藏举报

刷新页面返回顶部

CN_Darren

羡长江之∞

Day18-常用类(一)

Day18-常用类(一)

Object类

1、getClass()

2、hashCode()

3、toString()

4、equals()

5、finalize()方法

包装类

字符串

公告