继承、多态

继承：继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。当我们定义很多部分具有相同属性和行为的类时，如果使用之前我们所讲类的定义方式进行定义，那么是不是发现有大量的代码重复书写，为了允许使用现有的类的功能，并在无须改写原来的类的情况下，引入了继承的概念。继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。我们把允许重用现有类称为基类（或超类，父类），由基类派生出来的类称为派生类(子类)。
生活中，继承的表示是这样的：

牛和羊属于食草动物类，老虎和狮子属于食肉动物类。食草动物和食肉动物又是属于动物类。父类更通用，子类更具体。虽然食草动物和食肉动物都是属于动物，但是两者的属性和行为上有差别，所以子类会具有父类的一般特性也会具有自身的特性。
类的继承格式：
在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：
class 父类 {}
class 子类 extends 父类 {}
继承的特性：
1）子类拥有父类非private的属性，方法。
2）子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
3）子类可以用自己的方式实现父类的方法。
4）Java的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如A类继承B类，B类继承C类，所以按照关系就是C类是B类的父类，B类是A类的父类，这是java继承区别于C++继承的一个特性。
5）提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系）。
继承关键字：继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在java.lang包中，所以不需要import）祖先类。
1）extends关键字在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

public class Animal {     
     private String name;     
     private int id;     
     public Animal(String myName, String myid) {         //初始化属性值     
     }     
     public void eat() {         
        //吃东西方法的具体实现     
     }    
      public void sleep() {         
        //睡觉方法的具体实现     
      }
}
 public class Penguin extends Animal{
 //
 }

2）super 与 this 关键字
super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
this关键字：指向自己的引用。

class Animal {     
   void eat(){         
        System.out.println("animal : eat");    
   }
} 
class Dog extends Animal {     
          void eat() {         
                 System.out.println("dog : eat");     
          }    
          void eatTest() {        
                 this.eat();// this 调用自己的方法         
                 super.eat(); // super 调用父类方法     
          }
}
 public class Test {     
        public static void main(String[] args) {         
                  Animal a = new Animal();         
                  a.eat();        
                  Dog d = new Dog();        
                  d.eatTest();    
        
       }
}

输出结果：

animal : eat 
dog : eat 
animal : eat

final关键字
final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写：
声明类：Final class 类名{//类体}
声明方法：修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}
注:实例变量也可以被定义为 final，被定义为 final 的变量不能被修改。被声明为 final 类的方法自动地声明为 final，但是实例变量并不是 final。
多态：
多态分两种：
(1) 编译时多态（设计时多态）：也称编译时的多态、静多态，就是我们所说的方法重载。相同的函数名，根据形参类型个数的不同调用不同的方法。在编译期间就已经确定要调用的方法。
(2) 运行时多态： 动多态（运行时多态）运行期JAVA运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态。（我们平时说得多的是运行时多态，所以多态主要也是指运行时多态）
注意：发生运行时多态的三个条件。
多态：父类型的引用可以指向子类型的对象。 　　
比如 Parent p = new Child(); 　　
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；
如果有，再去调用子类的该同名方法。 　　
（注意此处，静态static方法属于特殊情况，静态方法只能继承，不能重写Override，如果子类中定义了同名同形式的静态方法，它对父类方法只起到隐藏的作用。调用的时候用谁的引用，则调用谁的版本。）简单点理解就是，现实中的东西具有相同的行为，但行为的内部实现逻辑却不相同。举个例子，就如汽车会跑，但是有的汽车是前轮驱动，有的是后轮驱动。再譬如，足球场上的进球，可以抽射进球，也可以任意球，还可以点球。
发生多态的三个条件：
1 继承
2 方法的重写
3 父类引用引用派生类对象（向上造型）

abstract class Shape{
     protected int wide;
     protected int length;
     protected int high;
     
     public Shape(int wide, int length, int high) {
          super();
          this.wide = wide;
          this.length = length;
          this.high = high;
     }
      public abstract double Circumference();//周长
}
class Rectangle extends Shape{
       public Rectangle(int wide, int length, int high) {
                   super(wide, length, high);// TODO Auto-generated constructor stub
        }
        @Override
        public double Circumference() {//方法的重写
                   // TODO Auto-generated method stub
                   return 2*(high+length+wide);
        }
}
class Square extends Shape{
        public Square(int wide, int length, int high) {
                   super(wide, length, high);
                   // TODO Auto-generated constructor stub
        }
@Override
public double Circumference() {//方法的重写
        // TODO Auto-generated method stub
        return 4*wide;
        }
}
public class TestDemo{
      public static void main(String[] args){
                 Shape s=new Rectangle(10, 20, 30);
                 //父类的引用引用派生类对象（向上造型：长方形也是一种形状）      
                 System.out.println(s.Circumference());//通过父类的引用调用派生类对象的方法
                 Shape s1=new Square(10,10,10);System.out.println(s1.Circumference());
      }
}

多态的好处：
1.可替换性。多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。
2.可扩充性。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。
3.接口性。多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。
4.灵活性。它在应用中体现了灵活多样的操作，提高了使用效率。
5.简化性。多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。