上次我为大家写出啦“封装性”，封装性是面向对象三大特性之一是Java学习必备的知识，如没有了解透彻的话请打开下方文章在进行观看一下哦！！今天我们来说一下面向对象三大特性之“继承性”。
继承（Inheritance）是面向对象编程的三大特征之一，它让我们更加容易实现对于已有类的扩展、更加容易实现对于现实世界的建模。嘿~嘿~我们今天该来啃~啃它~
继承让我们更加容易实现类的扩展。 比如，我们定义了人类，再定义Boy类就只需要扩展人类即可。实现了代码的重用，不用再重新发明轮子(don’t reinvent wheels)。
从英文字面意思理解，extends的意思是“扩展”。子类是父类的扩展。现实世界中的继承无处不在。比如：
上图中，哺乳动物继承了动物。意味着，动物的特性，哺乳动物都有；
在我们编程中，如果新定义一个Student类，发现已经有Person类包含了我们需要的属性和方法，那么Student类只需要继承Person类即可拥有Person类的属性和方法。
public class Animal {//extends Object
private String color;//颜色
private int age;//年龄
public Animal() {
super();
}
public Animal(String color, int age) { //alt+insert
this.color = color;
this.age = age;
}
public void eat(){
System.out.println("eating ..........");
}
public void sleep(){
System.out.println("sleeping............");
}
public void introduce(){
System.out.println(color+" "+age);
}
}
public class Dog extends Animal{
private String nickName;//昵称
public Dog() {
}
public Dog(String color,int age){
}
public Dog(String color,int age,String nickName){
// this.color = color;
// this.age = age;
super(color,age);
this.nickName = nickName;
}
public void guard(){
System.out.println("Dog guarding......");
}
}
public class Cat extends Animal {
private int eysSight;//视力
public Cat() {
super();//默认调用父类的无参数构造方法
}
public Cat(String color, int age, int eysSight) {
super(color,age);
this.eysSight = eysSight;
}
public void grabMouse(){
System.out.println("Cat grab mouse..........");
}
}
public class Test {
public static void main(String[] args) {
Dog dog = new Dog("黑色",3,"旺财");
dog.eat();//从父类继承的方法
dog.sleep();//从父类继承的方法
dog.introduce();//从父类继承的方法
dog.guard();//子类特有的方法
Cat cat = new Cat("花色",3,5);//alt+enter
cat.eat();
cat.sleep();
cat.introduce();
cat.grabMouse();
}
}
1. 父类也称作超类、基类。子类：派生类等。
2. Java中只有单继承，没有像C++那样的多继承。多继承会引起混乱，使得继承链过于复杂，系统难于维护。
3. 子类继承父类，可以得到父类的全部属性和方法 (除了父类的构造方法)，但不见得可以直接访问(比如，父类私有的属性和方法)。
4. 如果定义一个类时，没有调用extends，则它的父类是：java.lang.Object。
父类的方法introduce()已经无法满足子类的需求，怎么办？同理，Object类的toString()已经无法满足Animal类、Dog类的需求，怎么办？？？ 其实可通过方法重写（override）解决，或者称为方法覆盖
public class Animal {//extends Object
protected String color;//颜色
private int age;//年龄
public Animal() {
super();
}
public Animal(String color, int age) {
this.color = color;
this.age = age;
}
public void introduce(){
System.out.println(color+" "+age);
}
@Override
public String toString() {
//return super.toString();
return "Animal[color="+color+",age="+age+"]";
}
}
public class Dog extends Animal{
private String nickName;//昵称
public Dog() {
}
public Dog(String color, int age){
}
public Dog(String color, int age, String nickName){
// this.color = color;
// this.age = age;
super(color,age);
this.nickName = nickName;
}
public void introduce(){
//this.introduce();
//super.introduce();
System.out.println(color+" "+this.getAge()+" "+nickName);
}
public void guard(){
//this.guard();
//super.guard();
System.out.println("Dog guarding......");
}
@Override
public String toString() {
//return super.toString()+" "+nickName;
return "Dog[name="+color+",age="+getAge()+
",nickName="+this.nickName+"]";
}
}
如果没有看懂的小伙伴：我再来总分总展示一下，去更清晰的了解
总：方法重载和方法重写（覆盖）是面向对象中两个重要概念，其实这两个概念之间没有什么关系，但是毕竟都是关于方法的，毕竟容易引起混淆。对此我也做了一些归纳，感觉能够把这两个概念很好的区分开。我打算从总体区别、细节区别两个方面来说明。
分：总体的区别：最主要的区别，是解决的问题不同，即作用不同。
重载：overload
同一个类中，在一个类里面为一种行为提供多种实现方式并提高可读性
重写：override
子类和父类间，父类方法无法满足子类的要求，子类通过方法重写满足要求
细节的区别：一个方法的声明自左向右包括权限修饰符、方法返回值、方法名、参数列表、抛出的异常类型等。下面从这几方面说明区别：
总：重载实例：构造方法重载、println()方法重载
重写实例：Object类的toString()、equals()、hashCode()等都可以被子类重写
不知道这样下来能够让你们看懂不
原文：https://www.cnblogs.com/VlogCode/p/15200628.html