Java中的仅反对单继承，却神奇的是每个类都基本上间接或间接继承了Object类。Object类相当于祖宗类了。当然，对于曾n孙类来说，对于祖宗类的办法也的确有继承过去的。也就是说，Object类中的办法每个类外面都或多或少有，要么就是间接被继承过去，要么就是笼罩重写让我所用。那也就是说每个类都有继承 ? 对的。

 

1.上面我将以String字符串类举例，

如下代码:  给出两个字符串，输入两个字符串并且输入比拟的boolean值？可能就有人问了，这么简略你写什么?

public class StringTest {

public static void main(String[]args) {    String string1 = "csdn";    String string2 = "csdn";        System.out.println("stirng1 = "+string1); //等于string1.toString()    System.out.println("string2 = "+string2); //等于string2.toString()    System.out.println(string1.equals(string2));}

}
好像对于字符串的比拟equals办法进行比拟字面量的值十分理所应当呀，这不就是雷同的就返回true，否则返回false吗。对的，你想得没有错。

运行后果也是在情理之中:

2.那么上面我又定义一个Student类，外面蕴含属性有:姓名和年龄。

public class Student {

    private String name;    private int age;    Student(String name,int age){        this.name=name;        this.age = age;    }    Student(){            }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }

}
并且咱们用相似于上述的游戏应用String类的形式去实现Student类。

public class StudentTest {

public static void main(String[]args) {    Student student1 = new Student("xiaobai",18);    Student student2 = new Student("xiaobai",18);        System.out.println(student1); //等于student1.toStirng()    System.out.println(student2); //等于student2.toString()        System.out.println(student1.equals(student2));        }

}
难道他的后果跟String类相似吗?没有，它返回了一连串不晓得的货色和false。

那么，这到底是为什么呢?为什么String类间接输入字符串对象名能够输入对应的字符串，为什么equals做比拟就是true，而Student类也是一样的字面量却是false呢。

下面所应用的办法中并不是说凭空捏造的，先通知你 equals() , hashCode() 办法能够规定equals()办法的比拟形式，而toString()就能够只输入对象名就能够输入指定要输入的变量值，又恰好刚好，这几个办法都是Object类中的，他们都间接或间接继承了Object类，也刚好继承了这外面的办法。

然而，继承了这外面的办法并不能齐全为我所用，你必须要去笼罩重写办法后从新定义方法的内容能力让办法为我所用。这里的话，之所以编译器对于String类那么听话，就是因为String类依照本人的思路去笼罩重写了这几个办法，让其表白出了www.sangpi.comString类该有的特色。

String类中的几个办法的笼罩重写:

 

1.咱们对其Student类继承下来的toString办法笼罩重写

public class Student {

    private String name;    private int age;    Student(String name,int age){        this.name=name;        this.age = age;    }    Student(){            }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }        @Override    public String toString() {  //对toString笼罩重写        return "Student [name=" + name + ", age=" + age + "]";    }

}
而后再编译StudentTest类。这个时候就能够依照输入对象名来输入实例内容啦。

2.对其Student类继承下来的equals办法的笼罩重写。对其equals办法笼罩重写的同时，咱们也要对其hashCode办法笼罩重写，以保护 hashCode 办法的惯例协定，该协定申明相等对象必须具备相等的哈希码。对于这两个办法能够通过软件进行主动笼罩重写。上面是主动笼罩重写的代码。

public class Student {

    private String name;    private int age;    Student(String name,int age){        this.name=name;        this.age = age;    }    Student(){            }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }        @Override    public String toString() {        return "Student [name=" + name + ", age=" + age + "]";    }    @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;    }    @Override    public boolean equals(Object obj) {        if (this == obj)            return true;        if (obj == null)            return false;        if (getClass() != obj.getClass())            return false;        Student other = (Student) 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;    }

}
 

这样的话，上述的测试的代码就跟String类截然不同啦。如果你感觉这样太简单，你也能够设置本人的相等形式，前提是要让他人了解你的逻辑哦，并且也要使两个对象equals为true的同时，hashCode的值也要相等。

总结:java中如同继承无处不在，上述的例子只是其中的一粒尘埃。次要是用来更好的了解继承啦。当然Java外面还有接口和抽象类，持续在Java的陆地漫游吧。