常用类
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
}
}
未完待续...
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
