《疯狂java讲义》学习（13）：处理对象

版权声明：本文为博主原创文章，如若转载请注明出处 https://blog.csdn.net/tonydz0523/article/details/86479361

处理对象

Java对象都是Object类的实例，都可直接调用该类中定义的方法，这些方法提供了处理Java对象的通用方法。

打印对象和toString方法

这里有一个程序：

class Person{
    private String name;
    public Person(String name){this.name=name;}
    public void info(){
        System.out.println("此人名字为："+ name);
    }
}
public class PrintObject {
    public static void main(String[] args){
        //创建一个Person对象，将其赋值给p
        Person p = new Person("孙悟空");
        //打印出p
        System.out.println(p);
    }
}

当运行上面程序是，看到的结果类似Person@1b6d3586,@后的是6位十六进制数字。System.out.println方法只能在控制台输出字符串，而Person实例是一个内存中的对象，当使用该方法输出Person对象时，实际上输出的是Person对象的toString()方法的返回值。也就是说，下面两行代码的效果完全一样

System.out.println(p);
System.out.println(p.toString());

所有的Java对象都具有toString()方法,所有的Java对象都可以和字符串进行连接运算，当Java对象和字符串进行连接运算时，系统自动调用Java对象toString方法的返回值和字符串进行连接运算，即下面两行代码的结果也完全相同。

String pStr=p + "";
String pStr=p.toString() + "";

toString方法是一个非常特殊的方法，它是一个“自我描述”方法，如果用户需要自定义类能实现“自我描述”的功能，就必须重写Object类的toString方法。例如下面程序：

class Apple{
    private String color;
    private double weight;
    public Apple(){}
    public Apple(String color, double weight){   //提供有参数的构造器
        this.color = color;
        this.weight = weight;
    }
    //此处省略setter和getter方法
    //重写toString方法，用于实现Apple对象的“自我描述”
    public String toString(){
        return "一个苹果，颜色是：" + color
                + ",重量是：" + weight;
    }
}
public class ToStringTest {
    public static void main(String[] args){
        Apple a=new Apple("红色",5.68);
        //打印Apple对象
        System.out.println(a);
    }
}

大部分时候，重写toString方法总是返回该对象的所有令人感兴趣的信息所组成的字符串：

public String toString()
{
    return "Apple[color=" + color + ",weight=" + weight + "]";
}

这个toString方法提供了足够的有效信息来描述Apple对象，也就实现了toString方法的功能。

==和equals方法

当使用==来判断两个变量是否相等时，如果两个变量是基本类型变量，且都是数值类型（不一定要求数据类型严格相同），则只要两个变量的值相等，就将返回true。
但对于两个引用类型变量，它们必须指向同一个对象时，==判断才会返回true。==不可用于比较类型上没有父子关系的两个对象。下面程序示范了使用==来判断两种类型变量是否相等的结果：

public class EqualTest
{
    public static void main(String[] args)
    {
        int it=65;
        float fl=65.0f;
        //将输出true
        System.out.println("65和65.0f是否相等？" + (it==fl));
        char ch='A';
        //将输出true
        System.out.println("65和'A'是否相等？" + (it==ch));
        String str1=new String("hello");
        String str2=new String("hello");
        //将输出false
        System.out.println("str1和str2是否相等？"+ (str1==str2));
        //将输出true
        System.out.println("str1是否equals str2？"+ (str1.equals(str2)));
        // 由于java.lang.String与EqualTest类没有继承关系
        //所以下面语句导致编译错误
        // System.out.println("hello"==new EqualTest());
    }
}

运行上面程序，可以看到65、65.0f和’A’相等。但对于str1和str2，因为它们都是引用类型变量，它们分别指向两个通过new关键字创建的String对象，因此str1和str2两个变量不相等。
"hello"直接量和new String(“hello”)有什么区别呢？当Java程序直接使用形如"hello"的字符串直接量（包括可以在编译时就计算出来的字符串值）时，JVM将会使用常量池来管理这些字符串；当使用new String(“hello”)时，JVM会先使用常量池来管理"hello"直接量，再调用String类的构造器来创建一个新的String对象，新创建的String对象被保存在堆内存中。换句话说，new String(“hello”)一共产生了两个对象。
下面程序示范了JVM使用常量池管理字符串直接量的情形:

public class StringCompareTest
{
    public static void main(String[] args)
    {
        //s1直接引用常量池中的"疯狂Java"
        String s1="疯狂Java";
        String s2="疯狂";
        String s3="Java";
        //s4后面的字符串值可以在编译期就确定下来
        //s4直接引用常量池中的"疯狂Java"
        String s4="疯狂" + "Java";
        // s5后面的字符串值可以在编译期就确定下来
        //s5直接引用常量池中的"疯狂Java"
        String s5="疯" + "狂" + "Java";
        // s6后面的字符串值不能在编译期就确定下来
        //不能引用常量池中的字符串
        String s6=s2 + s3;
        // 使用new调用构造器将会创建一个新的String对象
        //s7引用堆内存中新创建的String对象
        String s7=new String("疯狂Java");
        // 输出true
        System.out.println(s1==s4);
        //输出true
        System.out.println(s1==s5);
        //输出false
        System.out.println(s1==s6);
        //输出false
        System.out.println(s1==s7);
    }
}

equals方法是Object类提供的一个实例方法，因此所有引用变量都可调用该方法来判断是否与其他引用变量相等。但使用这个方法判断两个对象相等的标准与使用==运算符没有区别，同样要求两个引用变量指向同一个对象才会返回true。因此这个Object类提供的equals方法没有太大的实际意义，如果希望采用自定义的相等标准，则可采用重写equals方法来实现。
String已经重写了Object的equals()方法，String的equals()方法判断两个字符串相等的标准是：只要两个字符串所包含的字符序列相同，通过equals()比较将返回true，否则将返回false。
下面程序示范了重写equals方法产生Person对象和Dog对象相等的情形:

class Person{
    //重写equals方法，提供自定义的相等标准
    public boolean equals(Object obj){
        //不加判断，总是返回true，即Person对象与任何对象都相等
        return true;
    }
}
//定义一个Dog空类
class Dog{}

public class OverrideEqualsError {
    public static void main(String[] args){
        Person p=new Person();
        Dog d=new Dog();
        System.out.println("Person对象是否equals Dog对象：" + p.equals(d));
        System.out.println("Person对象是否equals String对象：" + p.equals(new String("hello")));
    }
}

当然大部分时候，我们不希望看到Person对象和Dog对象相等的“荒唐局面”，我们还是希望两个类型相同的对象才可能相等，而且必须关键的Field相等才能相等。看下面重写Person类的equals方法，更符合实际情况:

class Person
{
    private String name;
    private String idStr;
    public Person(){}
    public Person(String name , String idStr)
    {
        this.name=name;
        this.idStr=idStr;
    }
    //此处省略name的setter和getter方法
    public String getIdStr(){
        return this.idStr;
    }
    public void setIdStr(String idStr){
        this.idStr = idStr;
    }
    //重写equals方法，提供自定义的相等标准
     public boolean equals(Object obj){
    // 如果两个对象为同一个对象
        if (this==obj)return true;
    // 当obj不为null，且它是Person类的实例时
        if (obj !=null && obj.getClass()==Person.class){
        Person personObj=(Person)obj;
    // 并且当前对象的idStr与obj对象的idStr相等才可判断两个对象相等
        if (this.getIdStr().equals(personObj.getIdStr())){return true;}
        }
        return false;
    }
}
    public class OverrideEqualsRight
    {
        public static void main(String[] args)
        {
            Person p1=new Person("孙悟空" , "12343433433");
            Person p2=new Person("孙行者" , "12343433433");
            Person p3=new Person("孙悟饭" , "99933433");
            //p1和p2的idStr相等，所以输出true
            System.out.println("p1和p2是否相等？"
                    + p1.equals(p2));
            //p2和p3的idStr不相等，所以输出false
            System.out.println("p2和p3是否相等？"
                    + p2.equals(p3));
        }
}

通常而言，正确地重写equals方法应该满足下列条件。

• 自反性：对任意x，x.equals(x)一定返回true。
• 对称性：对任意x和y，如果y.equals(x)返回true，则x.equals(y)也返回true。
• 传递性：对任意x, y, z，如果x.equals(y)返回ture，y.equals(z)返回true，则x.equals(z)一定返回true。
• 一致性：对任意x和y，如果对象中用于等价比较的信息没有改变，那么无论调用x.equals(y)多少次，返回的结果应该保持一致，要么一直是true，要么一直是false。
• 对任何不是null的x，x.equals(null)一定返回false。

Object默认提供的equals()只是比较对象的地址，即Object类的equals方法比较的结果与==运算符比较的结果完全相同。因此，在实际应用中常常需要重写equals方法，重写equals方法时，相等条件是由系统要求决定的，因此equals方法的实现也是由系统要求决定的。
对于instanceof运算符而言，当前面对象是后面类的实例或其子类的实例时都将返回true，所以实际上重写equals()方法判断两个对象是否为同一个类的实例时使用instanceof是有问题的。比如有一个Teacher类型的变量t，如果判断t instanceof Person，这也将返回true。但对于重写equals()方法的要求而言，通常要求两个对象是同一个类的实例，因此使用instanceof运算符不太合适。改为使用t.getClass()==Person.class比较合适。

Java实例练习

1,2,3,4能组成多少个会不相同的三位数

在数学运算中，我们经常会遇到给定数字，要求这几个数字能组成多少个互不相同且不重复的几位数的情况。较少位数我们可以按规律写出，当位数较大时，就只能依靠计算机来输出了

1.

在数学运算中，我们经常会遇到给定数字，要求这几个数字能组成多少个互不相同且不重复的几位数的情况。较少位数我们可以按规律写出，当位数较大时，就只能依靠计算机来输出了：

public class ThreeDig {
    public static void main(String[] args){
        int[] a={1,2,3,4};
        for (int i=0;i<a.length;i++){
            for (int j=0;j<a.length;j++){
                if(i==j)continue;
                for (int k=0;k<a.length;k++){
                    if(k==i||k==j)continue;
                    System.out.println(a[i]*100+a[j]*10+a[k]+"");
                }
            }
        }
    }
}