一?常用Object的方法
1.1 Object是什么?
????????Object 是java提供的根类,所有类有直接或者间接的继承Object,由于与java中继承是可以传递的所以Object中的所有方法是所有类都有的方法.
1.2 equals方法
1.2.1?设计目的
比较两个对象是否相等
1.2.2 和"=="的区别
?? ?使用==比较基本数据类型 可以比较值的大小,但是比较引用类型 只能比较内存地址,而 object中默认的equals方法是比较内存地址的,因为人家又不知道你要比较什么属性?需要根据自己的需求进行覆写即可
eg:
? ? ? ? ? ? ?public boolean equals(Object obj){
? ? ? ? ? ? ? ? return this ==obj;
? ? ? ? ? ? ?}
例子?
需求:规定id相同和名字相同,就是同一个学生
代码:
public class Equals_01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
String a1="asd";
String a2="asd";
System.out.println(a1.equals(a2));//true
Student s1=new Student(001, "张三");
Student s2=new Student(001, "张三");
System.out.println(s1==s2);//false,因为地址s1 和 s2的地址不同
System.out.println(s1.equals(s2));//名字和学号都相同,才返回true;
}
}
class Student {
private int id;
private String name;
public Student(int id,String name){
this.id=id;
this.name=name;
}
public String getName(){
return this.name;
}
@Override
public boolean equals(Object obj){
//需求:规定id相同,就是同一个学生
//1 先比较地址,地址一样说明是同一个对象,直接返回true;
if(this==obj){
return true;
}
//2 说明不是同一个对象,那么需要判断是否是同类,不同类没有可比性
if(obj instanceof Student){
//向下转型,否则会丢失子类特有的属性(多态的缺点)
Student s=(Student)obj;
if(this.id==s.id && this.name.equals(s.name)){
return true;
}
}
return false;
}
}
1.3?finalize方法
1.3.1设计目的
JVM四大特性:跨平台?? ? 面向对象 多线程 自动垃圾回收
????????垃圾:一个对象没有任何引用指向他,该对象就被当成垃圾数据,谁也找不到他.等于说是没有用的资源,浪费空间
1.3.1?finalize方法特点
1 是Object中的方法,也就意味着是所有类对象都有的
2 该方法不需要程序员调用,有系统自动调用
3 当一个对象被回收的时候,会自动调用该对象的finalize方法
4 如果我们手动调用该方法,那么只是一个方法调用而已,并不会被回收
例子
public class Finalize_01 {
public static void main(String[] args) {
Finalize_01 finalize_01=new Finalize_01();
finalize_01=null;
for(int i=1;i<10000000;i++){
System.gc();//程序员可以"建议"垃圾回收
}
//执行结果:day_05._02_Finalize.Finalize_01@7ad74083回收
//执行结果可能不会每次都出现,所以可以采用多次建议或者增加垃圾的数量
}
@Override
protected void finalize() {
System.out.println(this+"回收");
}
}
1.4 hashCode方法
1.4.1 设计目的
方法设计目的 返回该对象的字符串表示形式
1.4.2 哈希冲突:??
如果一个对象,取对此hash值,那么值一定相同,但是 不同对象,获取hash值也可能相同 又叫哈希冲突
hashCode 方法就是根据哈希方法得到的一个哈希值
hash算法:是一种安全的加密算法,把不定长的数据改为定长的数据,并不能保证其唯一性
1.4.3 既然有哈希冲突不能保证对象的唯一性,怎么办?
?用equals
1 先比较哈希值,如果不同 则不是同一个对象
2 如果不同,再用equals比较
1.5 toString方法
1.5.1 设计目的
方法设计目的 返回该对象的字符串表示形式
1.5.2 实现原理
????????输出一个引用类型的数据的时候 会自动调用该对象的toString方法?,Object中默认的toString方法是打印该对象的内存地址,如果输出一个对象的时候,不希望打印内存地址,而是打印指定格式的内容,就需要覆写toString方法
例子
public class toString_01 {
public static void main(String[] args) {
Person person=new Person(001,"张三",18);
Person person2=new Person(002, "李四", 19);
System.out.println(person);//运行结果:姓名: 张三 id:1 年龄 :18
System.out.println(person2);//运行结果:姓名: 李四 id:2 年龄 :19
}
}
class Person{
private int id ;
private String name;
private int age ;
public Person(int id, String name, int age) {
super();
this.id = id;
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "姓名: "+this.name+" id:"+this.id+" 年龄 :"+this.age;
}
}
二 内部类? ?
2.1 内部类概念
类体中还有其他的类,这个类就叫做内部类
????????当一个类的内部需要有一个完整的结构进行描述,而这个内部的完整结构有只是为了外部类提供服务,此时该类就可以定义成内部类
2.2 内部类优点
可以访问外部内的所有属性,包括私有属性
2.3 内部类的使用
1 .成员内部类 可以看做成员变量
成员内部类特点:
? ?1 成员内部类,没有static修饰
? ?2? 可以使用权限控制修饰符
? ?3 成员内部类中可以访问外部类的所有属性
? ?4?在成员内部类中不能有静态声明
? ?5 内部类编译之后的类名为 ?: 外部类类名$内部类类名
例子:
public class OuterClass_01 {
private static String s1="私有化静态";
private String s2="私有化成员态";
public static void main(String[] args) {
// TODO Auto-generated method stub
OuterClass_01 outerClass_01=new OuterClass_01();
InnerClass innerClass=outerClass_01.new InnerClass();
innerClass.m2();//输出结果:私有化静态 私有化成员态
}
class InnerClass{
// static int i=1;
// public static void m1(){}
public void m2(){
System.out.println(s1);
System.out.println(s2);
}
}
}
2. 静态内部类 可以看做静态变量
静态内部类特点:
? ? ? 1? 静态内部类使用static修饰
? ? ? 2? 可以使用权限控制修饰符
? ? ? 3? 内部类编译之后的类名为:外部类类名$内部类类名
? ? ? 4? 在静态内部类中 成员也能声明,静态也能声明
? ? ? 5? 在静态内部类中,无法直接访问外部类的成员属性,需要对象才可以
例子
public class OuterClass_02 {
private static String s1="私有化静态";
private String s2="私有化成员";
static class InnerClass{
public void m1() {
System.out.println(s1);
// System.out.println(s2);
// 创建外部类对象才能调用 外部类的成员属性
OuterClass_02 o = new OuterClass_02();
System.out.println(o.s2);
}
// static int i=1;
// public static void m1(){}
public static void m2(){
System.out.println(s1);
// System.out.println(s2);
OuterClass_02 o=new OuterClass_02();
System.out.println(o.s2);
}
}
public static void main(String[] args) {
OuterClass_02.InnerClass.m2();
InnerClass.m2();//在当前类中类名可以省略
//创建对象
InnerClass innerClass=new OuterClass_02.InnerClass();
//外部类类名可以完全省略
InnerClass innerClass2=new InnerClass();
innerClass2.m1();
}
}
3. 局部内部类 可以看做局部变量(方法中的类,不能写任何的修饰符(static,public等都不能写))
局部内部类特点:
1 局部内部类 : 方法中的类才是局部内部类
2? 局部内部类不能有静态声明,并且该类也不允许使用static修饰
3? 如果外部方法是成员方法,则该内部类可以直接访问外部类的所有属性
4 如果外部方法是静态方法,则该内部类不能直接访问外部类的成员属性,需要有对象
5 局部内部类也可以直接访问外部方法的局部变量,但是需要加fina修饰,从1.8开始final可以省略
? ?也就是说?,如果局部内部类使用了外部方法的局部变量,那么该局部变量也就等于加了final修饰了,? ? ?值就不能改了
?6 内部类类名:
?? ? ? ? 如果多个方法的内部类类名不一致, 那就这样:外部类类名$内部类类名,?
?? ? ? ? 如果多个方法的内部类类名一致, 就是这样:外部类类名$1内部类类名 , 外部类类名$2内部类? ? ? 类名 , 外部类类名$3内部类类名...
例子
public class OuterClass_03 {
private static String s1 = "私有化静态";
private String s2 = "私有化成员";
public void m1(){
final int i=100;
int i2=200;
class InnerClass {
//static int x=2;
public void m3(){
System.out.println(s1);
System.out.println(s2);
System.out.println(i);
System.out.println(i2);
// 不能在更改
// i=2;
// 局部内部类只能在方法内部使用
// 创建内部类对象
InnerClass innerClass = new InnerClass();
innerClass.m3();
}
}
}
public static void m2(){
final int a=100;
int a2=200;
class InnerClass{
public void m3(){
System.out.println(s1);
//静态方法中的内部类,不能直接访问外部类的成员属性,需要创建外部类对象才行
// System.out.println(s2);
OuterClass_03 outerClass_03=new OuterClass_03();
System.out.println(outerClass_03.s2);
}
}
// 不能在更改
// i=2;
// 局部内部类只能在方法内部使用
// 创建内部类对象
InnerClass innerClass = new InnerClass();
innerClass.m3();
System.out.println("111111");
}
public static void main(String[] args) {
OuterClass_03 outerClass_03 = new OuterClass_03();
outerClass_03.m1();
m2();
}
}
4. 匿名内部类 可以看做实参?? ?
? ? ? ? 下一篇文章见
? ??
|