常用类(Object)和包装类及一些常用方法

一、常用类(Object)

Object类 : Java所有类的父类 类继承关系树的树根
作用:
1.Object o; o中可以装任何对象
2.Object类中的方法 是所有对象都具有的方法

finalize(): 由垃圾收集器在回收垃圾对象时,最后调用
理解:
a.垃圾回收器如何认定垃圾对象 零引用算法(也就是没有任何引用指向该对象)
b.垃圾回收器如何释放垃圾对象 必须释放的时候(也就是内存用完了)

getClass(): 返回对象的实际类型

toString(): 返回对象的String形式
打印一个对象的引用就是打印这个对象的toString方法的返回值

boolean equals(Object o):判断当前对象和o对象内容是否相同
注意: Object里面默认的equals是比较地址的,想要比较内容你得覆盖这个方法
sum默认把String对象类型的equals覆盖成了比较内容的方法

equals的覆盖步骤
(1)判断自反性(是否为同一个对象)
if (this== o) return true;
(2)判断o是不是null
if (o == null) return false;
(3)判断是否为同一类对象
if (this.getClass() != o.getClass()) return false;
(4)强制类型转换
(5)根据自己需求写出判断条件

二、包装类(Integet,Character…)

1.为8种简单类型提供对象形式,方便让Object统一所有的数据类型

除了int —>Integer char—>Character这两种特殊外 其它六种基本数据类型直接首字母大写就是对应的包装类

2.对于数值类型的属性,区分0和null

比如某学校需要分别统计全校学生考了0分和没参考的同学人数的话 如果你直接定义了一个double score,那么,如果是没参考的学生对象
中的score属性就会被赋予默认值0.0,和考了0.0的学生分数一样,这样怎么分辨呢?那么就需要用到我们的包装类了,在Student对象里直接 定义一个Double d;的属性,这样如果是没有参加考试的学生,分数就是 默认值null,而考了0分的学生分数就是0.0,这样就能完美区分了~~~

//int <–> Integer
int i = 12;
Integer ii = new Integer(i);
int i2 = ii.intValue();

//int<–>String
String s = i +"";
int i3 = Integer.parseInt(s);

//Integer<–>String
String s2 = ii.toString();
Integer ii2 = Integer.valueOf(s2);

JDK5.0以后的版本编译器会自动进行包装类和基本数据类型之间的转换
比如Object o = 12; //编译通过 其原因是 编译器自动转换成了Object o = new Integer(12);

常用方法:

charAt(int index):根据下标获取字符
contains(String str):判断当前字符串中是否包含str
toCharArray(将字符串转换成char数组)
indexOf(Stringstr):在当前串中查找str出现的下标,如存在,返回第一次出现的下标,如不存在,返回-1
indexOf(String str,int fromindex):同上,从指定下标开始查找
lastIndexOf(String str):返回str在当前字符串中最后一次出现的下标
trim():去掉字符串前后的空格
split(String str):根据str做拆分
toUpperCase():小写转换成大写
toLowerCase():大写转换成小写
endWith(String str):判断字符串是否以str结尾
intern():从串池中获取和当前字符串内容相同的字符串

String str = “asjeji”;
System.out.println(str.charAt(4)); //j 获取当前字符串下标对象的字符
System.out.println(str.substring(2,5)); //jej 取两个参数的中间字符
System.out.println(str.replace(‘j’,‘x’)); //asjeji String为不可变长字符串，所以replace方法是先拷贝一个副文本，完成字符的
替换，如果获取替换后的结果，需要接收replace方法的返回值。

String和StringBuilder操作字符串时的区别。

(1) String是不可变长字符串，完成字符串拼接时效率相对较低
(2) StringBuilder是可变长字符串，完成字符串拼接时效率相对较高

getClass()的实例代码

package p1;

public class TestGetClass{
	public static void main(String []args){
		Animal a = new Dog();
		Dog d = new Dog();
		Animal m = new Cat();
		System.out.println(a.getClass() == d.getClass());  //true
		System.out.println(a.getClass() == m.getClass());  //false
	}
}

class Animal{}

class Dog extends Animal{}

class Cat extends Animal{}

运行结果

toString的实例代码

package p2;
public class TestToString{
	public static void main(String []args){
		Student s = new Student("zhangsan",18,'男');
		System.out.println(s); 
	}
}
class Student{
	String name;
	int age;
	char sex;
	public Student(){}
	public Student(String name,int age,char sex){
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	
	public String toString(){
		return "姓名:" + name + " 年龄:" + age + " 性别:" + sex;
	}
}

运行结果

equals的实例1 (比较对象的内容)

package p3;

public class TestEquals1{
	public static void main(String []args){
		String a = new String("abc");
		String b = new String("abc");
		Student s1 = new Student("zhangsan",18);
		Student s2 = new Student("xiaowang",19);
		Student s3 = s1;
		System.out.println(a == b);      //false
		System.out.println(a.equals(b));   // true
		System.out.println(s1.equals(s2));  //false
		System.out.println(s1.equals(s3));   // true
	}
}

class Student{
	String name;
	int age;
	public Student(){}
	public Student(String name,int age){
		this.name = name;
		this.age = age;
	}
}

运行结果

为什么String类型的equals()可以比较内容,但是Student类型的就不行呢?
因为Object中的equals默认是比较地址的
但是sum为了方便我们程序员默认把String类型的equals覆盖成了比较字符串的内容
那么,问题来了,怎么覆盖呢?
请看如下代码

package p3;

public class TestEquals2{
	public static void main(String []args){
		Student s = new Student("zhangsan",18,'男');
		Student s1 = s;
		Student s2 = new Student("zhangsan",18,'男');
		System.out.println(s.equals(s1));
		System.out.println(s1.equals(s2));
	}
}

class Student{
	String name;
	int age;
	char sex;
	public Student(){}
	public Student(String name,int age,char sex){
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	
	public boolean equals(Object o){
		//(1)判断自反性
		if (this == o) return true;
		//(2)判断是否为null
		if (o == null) return false;
		//(3)判断是否为同一类对象
		if (this.getClass() != o.getClass()) return false;
		//(4)强制类型转换
		Student s = (Student)o;
		//(5)判断所有属性值是否相等
		if(this.name.equals(s.name) && this.age == s.age && this.sex == s.sex) return true;
		else return false;
	}
}

覆盖后的运行结果

覆盖equals方法一般是按照这5个步骤来写的,其中第五步根据自己开发需求来写判断条件

包装类 Integer 的实例1

package p4;

public class TestInteger1{
	public static void main(String []args){
		/*
			实现原理--->   JDK5.0以后版本  虚拟机会默认进行包装类和基本数据类型直接的相互转换
						   在这里  虚拟机帮你添加的代码如下
							Object o = new Integer(11);    //Object o = 11;
						    k=new Integer(k.intValue()+1); //k++;
		*/
		Object o = 11;
		Integer k = (Integer)o;
		k++; 
		System.out.println("k=" + k);
	}
}

运行结果

int 和 String 之间的相互转换

package p4;

public class TestInteger2{
	public static void main(String []args){
		int i = 123;
		//int --> String
		String str = "" + i;
		System.out.println("str=" + str);
		//String --> int
		int k = Integer.parseInt(str);
		System.out.println("k=" + k);
	}
}

运行结果

String 和 Integer 直接的相互转换

package p4;

public class TestInteger3{
	public static void main(String []args){
		//String --> Integer
		String str = "1234";
		int i = Integer.valueOf(str);
		System.out.println("i=" + i);
		Integer ii = new Integer(i);
		//Integer --> String
		String str2 = ii.toString();
		System.out.println("str2=" + str2);
	}
}

运行结果

最后在这里总结一下,想偷懒,想少写代码,就得多记单词。。。。不然parse、character、valueOf都记不住。。Σ( ° △ °|||)︴说完,默默的打开了我的有道词典~~~