面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

什么是继承

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

继承的特点

  • 关于继承的注意事项：

    只支持单继承，即一个子类只允许有一个父类，但是可以实现多级继承，及子类拥有唯一的父类，而父类还可以再继承。
    子类可以拥有父类的属性和方法。
    子类可以拥有自己的属性和方法。
    子类可以重写覆盖父类的方法。

  • 继承的特点：

    1. 提高代码复用性。
    2.  父类的属性方法可以用于子类。
    3.  可以轻松的定义子类。
    4.  使设计应用程序变得简单。

    继承的使用

  • 在父子类关系继承中，如果成员变量重名，则创建子类对象时，访问有两种方式。

    • 直接通过子类对象访问成员变量

    等号左边是谁，就优先使用谁，如果没有就向上找。

    • 间接通过成员方法访问成员变量

该方法属于谁，谁就优先使用，如果没有就向上找。

  1. public class FU {
  2.     int numFU = 10;
  3.     int num = 100;
  4.     public void method(){
  5.         System.out.println("父类成员变量："+numFU);
  6.     }
  7.     public void methodFU(){
  8.         System.out.println("父类成员方法!");
  9.     }
  10. }
  1. public class Zi extends FU{
  2.     int numZi = 20;
  3.     int num = 200;
  4.     public void method(){
  5.         System.out.println("子类成员变量："+numFU);
  6.     }
  7.     public void methodZi(){
  8.         System.out.println("子类方法！");
  9.     }
  10. }
  1. public class ExtendDemo {
  2.     public static void main(String[] args) {
  3.         FU fu = new FU();
  4.         // 父类的实体对象只能调用父类的成员变量
  5.         System.out.println("父类：" + fu.numFU);   // 结果：10
  7.         Zi zi = new Zi();
  8.         System.out.println("调用父类：" + zi.numFU); // 结果：10
  9.         System.out.println("子类：" + zi.numZi);   // 结果：20
  10.         /** 输出结果为200，证明在重名情况下，如果子类中存在则优先使用，
  11.          *  如果不存在则去父类查找，但如果父类也没有那么编译期就会报错。
  12.          */
  13.         System.out.println(zi.num); // 结果：200
  14.         /**
  15.          * 通过成员方法调用成员变量
  16.          */
  17.         zi.method();    // 结果：10
  18.     }
  19. }
  • 同理：
    成员方法也是一样的，创建的对象是谁，就优先使用谁，如果没有则直接向上找。
    注意事项：
    无论是成员变量还是成员方法，如果没有都是向上父类中查找，绝对不会向下查找子类的。
    在继承关系中，关于成员变量的使用：
    局部成员变量：直接使用
    本类成员变量：this.成员变量
    父类成员变量：super.父类成员变量
    1. int numZi = 10;
    2. public void method() {
    3.  int numMethod = 20;
    4.  System.out.println(numMethod);  // 访问局部变量
    5.  System.out.println(this.numZi); // 访问本类成员变量
    6.  System.out.println(super.numFu); // 访问本类成员变量
    7. }

    重写，重载

    重写(override)
    是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！ ``` class Animal{ public void move(){
    1. System.out.println("动物行走！");
    } }

class Dog extends Animal{ public void move(){ System.out.println(“狗可以跑和走”); } }

public class TestDog{ public static void main(String args[]){ Animal a = new Animal(); // Animal 对象 Animal b = new Dog(); // Dog 对象 a.move();// 执行 Animal 类的方法 b.move();//执行 Dog 类的方法 } }

  2. -  重写的规则：<br /> 1，参数列表必须与被重写方法相同。<br /> 2，访问权限不能比父类中被重写的方法的访问权限更低（public>protected>(default)>private）。<br /> 3，父类成员的方法只能被它的子类重写。<br /> 4，被final修饰的方法不能被重写。<br /> 5，构造方法不能<br />**重载(overload)**<br /> 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。<br /> 最常用的地方就是构造器的重载。

public class Overloading { public int test(){ System.out.println(“test1”); return 1; } public void test(int a){ System.out.println(“test2”); }
//以下两个参数类型顺序不同 public String test(int a,String s){ System.out.println(“test3”); return “returntest3”; }
public String test(String s,int a){ System.out.println(“test4”); return “returntest4”; }
public static void main(String[] args){ Overloading o = new Overloading(); System.out.println(o.test()); o.test(1); System.out.println(o.test(1,”test3”)); System.out.println(o.test(“test4”,1)); } } ``` 重载规则：
1，被重载的方法必须改变参数列表（参数个数或者类型不一样）。
2，被重载的方法可以改变返回类型。
3，被重载的方法可以改变访问修饰符。

this，super关键字

super()关键字的用法
1，子类的成员方法中，访问父类的成员变量。
2，子类的成员方法中，访问父类的成员方法。
3，子类的构造方法中，访问父类的构造方法。
this关键字用法：
1，本类成员方法中，访问本类的成员变量。
2，本类成员方法中，访问本类的另一个成员方法。
3，本类的构造方法中，访问本类的另一个构造方法。
注意：

  • this关键字同super一样，必须在构造方法的第一个语句，且是唯一的。
  • this与super不能同时存在。

    构造器

    继承关系中，父子类构造方法的访问特点：
    1，在子类构造方法中有一个默认隐含的super();调用，因此一定是先调用父类构造方法，再调用子类构造方法。
    2，子类构造可以通过super();调用父类的重载构造。(重载)
    3，super();的父类调用构造方法，必须在子类构造中的第一行，就是第一个;号结束的元素，并且只能调用一次。

    关于继承的注意事项：

    1，Java语言是单继承的，一个子类只能有唯一一个父类
    2，Java语言可以是多级继承，一个子类有一个父类，一个父类还可以有一个父类。
    3，一个子类只有一个父类，但是一个父类可以有多个子类。
    继承 - 图1