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 的陆地漫游吧。