Java面向对象（七）：Object类 & 内部类 & 单例模式

一、Object类

如果一个类没有继承任何类的话，默认继承Object 类，所以Object类为所有类的超类。

Object类常用的方法：

1、toString()：返回该对象的字符串表示；

　　重写toString的意义：Object类中默认返回该对象的地址值字符串表示，没有太大的实际意义，若要知道类的成员信息或其他信息，则需要重写toString()方法,获取需要知道的信息；

2、equals()：判断对象是否相等(重点能够手动重写)；

重写equal()方法的意义：

Object类equals()默认根据比较两个对象的地址值相等（引用？）来判别对象是否相等；但是更多时候我们需要根据自己定义的条件来判定两个对象是否相等，一般情况下若两个同类对象的成员变量相等即判断两个对象是相等的，此时就需要重写equal()方法。

重写方式：

（1）自动（eclipse等IDE)；

（2）手动

备注：

1、== 与equals区别：都是比较地址值，==数值型数据的共享性，equals直接比较地址值。

2、重写equals必须重写hashCode();

　　参考：http://www.cnblogs.com/111testing/p/7062310.html

3、getClass():  获取字节码，反射知识。

4、hashCode():

哈希值,以一定算法将其他类型数据换算成十进制数据；

思考：

为什么重写equals()必须得重写hashCode:

因为在Object类中,若两个对象equal()比较后相同，则hashCode必定相同,但当重写完equal()方法后,会出现两个对象equal相同但是hashCode却不一定相同，所以也需要重写hashCode使得两个对象equal()比较相同时hashCode也相同。

5、finalize():

              当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

例程：studyObject包：Student.java

package studyObject;
//默认继承Object类
public class Student {       
    String name;
    int age;
    
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    /*
     * 重写toString意义：
     * 若重写Object类中打印的是类的所属位置和类地址，没有太大意义
     * 重写可打印出我们想要的东西
     */
    @Override    //注解，验证下面的方法是否是重写方法
    public String toString() {
        return " [姓名=" + name + ", 年龄=" + age + "]";
    }
    
    //重写hashCode使得成员变量相等的同类对象哈希值也相同
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    
    /*
     * @ Mark：重写equal()方法的步骤
     */
    @Override
    public boolean equals(Object obj) {
        // 1、判断是否为同一对象
        if (obj==this) {
            return true;
        }
        
        // 2、判断比较对象是否为空值
        if (obj==null) {
            return false;
        }
        
        // 3、判断比较对象是否为同类对象，再判断是否满足两对象相等的条件，一般比较成员变量即可；
        if (obj instanceof Student) {
            // 若为同类对象向下转型
            Student objStu = (Student) obj;
            
            // 判断相等的条件
            if ( (objStu.age == age) && (objStu.name.equals(name)) ) {    
                return true;
            }
        }
        
        return false;
    }
    
/**自动重写
    //重写equals
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        ObjectDemo1 other = (ObjectDemo1) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    ***/
    
}

 

package studyObject;

public class TextStudent {
    public static void main(String[] args) {
        
        Student OD1 = new Student("鲁班七号",3);
        Student OD2 = new Student("鲁班七号",3);

        //调用重写的toString方法
        System.out.println("toString测试"+OD1);        
        
        System.out.println("OD1哈希值："+OD1.hashCode());
        System.out.println("OD2哈希值："+OD2.hashCode());

        //调用重写的equals方法
        System.out.println("equals测试变量值：" +( OD1.equals(OD2) ? "OD1与OD2相等": "OD1与OD2不相等") );
        
        //比较地址值
        System.out.println("OD1、OD2引用地址值：" +( OD1 == OD2  ? "OD1与OD2相等": "OD1与OD2不相等") );

        
    }

}

二、内部类

2.1 内部类：

在一个类中再定义一个类，外层类称为外部类，内层了称为内部类，内部类能够调用外部类的一切包括私有变量方法，

内部类只能够被外部类调用。

例程：

public class Outer {
    private int time;
    private Inner inner;
    public Outer(int time) {
        this.time=time;
        inner=new Inner();//对象中会有一个隐式的引用指向创建它的Outer类对象。
        inner.innerTime();

    }
    public void printTime(){
        System.out.println(time);//101
    }
    //内部类
    class Inner{
        //Inner类可以访问Outer类中的一切
        public int innerTime(){
            return time++;//可以访问Outer的私有属性
        }
     }
    public static void main(String[] args) {
        Outer outer=new Outer(100);
        outer.printTime();
    }
}

2.2 匿名内部类（掌握）

　　创建对象之执行依次

1、语法：

SuperType obj = new SuperType() {

　　匿名类的成员变量方法。

}

2、例程：

package interClass;

import java.util.Timer;
import java.util.TimerTask;

/****
 * 匿名内部类
 * 
 * @author 89869
 *
 */
public interface  NiMingNeiBuLei {
    public static void main(String[] args) {
        Timer  timer =  new Timer();
        // 创建匿名内部类
        TimerTask task= new TimerTask() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                System.out.println("支付宝到账100000万");
            }
        };
        timer.schedule(task, 1, 3);         
    }

}

三、单例模式Singleton

Singleton：一个类只能创建一个对象

创建单例模式的两种方式

1  懒汉式（常用的）：

package studySingleton;
/**
 * 单例模式：类只有一个实例对象，其他类只能调用这个类的唯一对象不能再创建对象
 * @author 89869
 *
 */

public class SingletonDemo {
    //懒汉式
    private static SingletonDemo singleton =null;
    
    //将构造函数设为私有使得其不能再其他地方创建对象
    private SingletonDemo() {

    }
    public SingletonDemo getSingleton() {
        if (singleton ==null ) {
            singleton = new SingletonDemo();
        }
        return singleton;
    } 
    
    
}

2、饿汉式：

package studySingleton;
/***
 * 单例模式：饿汉式
 * @author 89869
 *
 */
public class SingletonDemo2 {
    private SingletonDemo2 singleton = new SingletonDemo2();

    private SingletonDemo2() {
        super();
        // TODO Auto-generated constructor stub
    }
    
    public SingletonDemo2 getSingleton() {
        
        return singleton;
    }
}