JAVA 多态

                                **JAVA多态**

多态实现的必要条件：
1.继承
2.重写
3.向上造型（父类引用派生类对象）
继承：
基本语法: class 类名 extends 父类名 { }
如果没有指定的父类，那么 java 编译器默认 Object 就是该类的父类。
*（1） extends(扩展)

• 父类/超类/基类 子类/派生类
• 继承不仅可以继承父类所有属性和方法,
• 同时我们还可以添加自己特有的属性和方法
• （2） super关键字
• a. 用于从派生类访问基类的成员
• b. 派生类要调用基类的构造方法 super（），super（）只能在派生类的构造方法中调用，位于方法首行。
• c. 调用基类已被其他方法重写的方法
• d. 访问基类的数据成员：super.成员变量、super.成员方法
• （3）继承的特性
• a.不可以访问私有的属性或者方法
• b.子类相比父类功能会更强大
• c.单继承
  重写：
  类方法的重写应满足的条件：

1. 派生类中该方法的返回值和基类同名方法的返回值相同，参数列表相同。
2. 派生类中的重写方法的访问权限不能比基类小。权限的顺序为：public,protected,private。
3. 基类的 abstract 方法必须被派生类重写，否则派生类也必须是 abstract
4. 基类的 final 方法不能被派生类重写。
   例：

public class TestDemo {
	public static void main(String[] args) {
		Animal a = new dog();
		a.call();
	}
}
 
class Animal {
	void call() {
		eat();
		
	}
	void eat() {
		System.out.println("a");
	}
}
 
class dog extends Animal {
	@Override
	void call() {
		// TODO Auto-generated method stub
		super.call();
	}
 
	@Override
	void eat() {
		// TODO Auto-generated method stub
		System.out.println("d");
		sleep();
	}
 
	void sleep() {
		System.out.println("sleep");
	}
}

当a调用call这个方法的时候同时实现了eat这个方法，但是子类已经重写了这个方法所以就备覆盖了，这里实现多态是因为子类比父类有更多的实现，范围更大，更可以实现多样化。

向上造型：
向上造型就是定义父类的引用，引用派生类的对象。
Animal animal=new Cat();
animal 引用.出来的方法是父类的方法接口，但是方法的实现却是子类的实现方式。

多态的分类：
1.静多态：编译期就知道应该调用哪个方法，即方法的重载；相同的函数名，根据形参类型个数的不同调用不同的方法，在编译期间就已经确定要调用的方法。
2.动多态（运行时多态）：编译期不知道调用哪种方法，运行期才知道

例：

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.重载可以在同一个类，也可以在不同类，重写必须在不同类。

• 函数名相同、参数列表不同的称之为重载;
  2.重写是返回值、参数列表、函数名都是一样的

多态机制的底层实现原理：