Java基础-面向对象第三大特性之多态（polymorphism ）

　　　　　　　　　　　　　　　　Java基础-面向对象第三大特性之多态（polymorphism）

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

一.多态概述

　　多态是继封装，继承之后，面向对象的第三大特性，多态的前提是继承。

　　从现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三即是学生也是人。即出现两种形态。Java作为面向对象的语言，同样可以描述一个事物的多种形态。如Student类继承了Person类，一个Student的对象便既是Student，又是Person。

　　最终多态体现为父类引用变量可以指向子类对象。多态的前提是必须有子父类关系或者类实现接口关系，否则无法完成多态。在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法。

二.多态调用的三种形式

　　多态调用方法，方法必须运行子类的重写！

1>.多态的定义格式：就是父类的引用变量指向子类对象。

 父类类型  变量名 = new 子类类型();
 变量名.方法名();

2>.普通类多态定义的格式

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 class Father{
     public void show(){
         System.out.println("父类的show方法！");
     }
 }

 class Son extends Father{
     public void show(){
         System.out.println("子类重写父类的show方法！");
     }
 }

 public class MyInterfaceDemo{
     public static void main(String[] args){
         //Java中，对象的多态性，调用公式：“父类类型或者接口类型  变量  =  new 子类对象();”
         Father f = new Son();
         f.show();
     }
 }

 /*
 以上代码执行结果如下：
 子类重写父类的show方法！
 */

3>.抽象类多态定义的格式

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 abstract class Father{
     public abstract void eat();
 }

 class Son extends Father{
     public void eat(){
         System.out.println("儿子喜欢吃米饭！");
     }
 }

 public class MyInterfaceDemo{
     public static void main(String[] args){
         //抽象类Father,子类是Son
         Father f = new Son();
         f.eat();
     }
 }

 /*
 以上代码执行结果如下：
 儿子喜欢吃米饭！
 */

4>.接口多态定义格式

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 interface  Father{
     public abstract void smoking();
 }

 class Son implements Father{
     public void smoking(){
         System.out.println("儿子会抽烟！");
     }
 }

 public class MyInterfaceDemo{
     public static void main(String[] args){
         //接口Father，实现类Son
         Father f = new Son();
         f.smoking();
     }
 }

 /*
 以上代码执行结果如下：
 儿子会抽烟！
 */

三.多态中成员变量的特点

1>.成员变量（编译运行全看父类）

　　a>.编译的时候，参考父类中有没有这个变量，如果有，编译成功，没有则编译失败；

　　b>.运行的时候，运行的是父类中的变量值；

2>.成员方法（编译看父类，运行看子类。）

　　a>.编译的时候，参考父类中有没有这个方法，如果有，编译成功，没有则编译失败

　　b>.运行的时候，运行的是子类的重写方法；

3>.静态成员方法

　　没有多态性。

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 class  Father{
     int age = 30;
     public void show(){
         System.out.println("Father的方法");
     }
 }

 class Son extends Father{
     int age = 8;
     public void show(){
         System.out.println("Son的方法");
     }
 }

 public class MyInterfaceDemo{
     public static void main(String[] args){
         Father f = new Son();
         System.out.println(f.age);
         f.show();
     }
 }

 /*
 以上代码执行结果如下：
 30
 Son的方法
 */

四.instanceof关键字

　　我们了解多态之后，会发现一个对象的数据类型不一定会保持不变。当我们想要确定一个对象是否是某个类时，就会用到比较运算符，只不过它很特殊，不能赢大于小于或是等于号直接进行判断，而是要用到关键字，即instanceof，它只能用作比较引用数据类型，用来比较一个引用类型的变量，是不是这个类型的对象。

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 abstract class Person{
     public abstract void sleep();
 }

 class Student extends Person{
     public void sleep(){
         System.out.println("学生在休息！");
     }
 }

 class Teacher extends Person{
     public void sleep(){
         System.out.println("老师在休息！");
     }
 }

 public class PersonDemo{
     public static void main(String[] args){

         Person p = new Student();

         p = new Teacher();

         boolean flag = p instanceof Student;

         System.out.println("引用数据类型'p'是否为Student类型:>>> " + flag);

         p.sleep();
     }
 }

 /*
 以上代码执行结果如下：
 引用数据类型'p'是否为Student类型:>>> false
 老师在休息！
 */

五.多态转型

1>.多态的向上转型

　　多态常见的就是自动类型提升，将取值范围小的，自动提升为取值范围大的。范围小的，看成是子类，范围大的看成父类。

优点：

　　这样做的好出就是可以调用子类父类的公共属性（方法）。

缺点：

　　无法调用子类特有的属性（方法）。

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 abstract class Person{
     public abstract void sleep();
 }

 class Student extends Person{
     public void sleep(){
         System.out.println("学生在休息！");
     }
 }

 class Teacher extends Person{
     public void sleep(){
         System.out.println("老师在休息！");
     }
 }

 public class PersonDemo{
     public static void main(String[] args){

         //从子类对象往父类变量赋值(自动类型提升,向上转型)
         Person p = new Student();

     }
 }

2>.多态的向下转型

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 abstract class Person{
     public abstract void sleep();
 }

 class Student extends Person{
     public void sleep(){
         System.out.println("学生在休息！");
     }
 }

 class Teacher extends Person{
     public void sleep(){
         System.out.println("老师在休息！");
     }
 }

 public class PersonDemo{
     public static void main(String[] args){

         //从子类对象往父类变量赋值(自动类型提升,向上转型)
         Person p = new Student();

         //从父类类型转向子类类型(向下转型)
         Student s  = (Student)p; 

     }
 }

3>.多态转型的案例

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 abstract class Animal{
     public abstract void eat();
 }

 class Cat extends Animal{
     public void eat(){
         System.out.println("猫吃猫粮！");
     }

     public void catchMouse(){
         System.out.println("猫抓老鼠！");
     }
 }

 class Dog extends Animal{
     public void eat(){
         System.out.println("狗吃狗粮！");
     }

     public void run(){
         System.out.println("狗能跑！");
     }
 }

 public class AnimalDemo{
     public static void main(String[] args){
         //两个子类，使用两次多态调用
         Animal a1 = new Cat();
         Animal a2 = new Dog();
         //a1,a2调用子类父类共有方法，运行走子类的重写方法
         a1.eat();
         a2.eat();
         /*类型向下转型，强制转换，调用子类的特有，防止发生异常，
         a1属于CatUI小，转成Cat类,a2属于Dog对象，转成Dog类，我们
         可以用关键字instanceof判断。
         */
         if(a1 instanceof Cat){
             Cat c = (Cat)a1;
             c.catchMouse();
         }

         if(a2 instanceof Dog){
             Dog d = (Dog)a2;
             d.run();
         }

     }
 }

 /*
 以上代码执行结果如下：
 猫吃猫粮！
 狗吃狗粮！
 猫抓老鼠！
 狗能跑！
 */

六.匿名对象

1>.匿名对象的概念 　　

　　匿名对象是指创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 class Person{
     public void eat(){
         System.out.println("人是铁，饭是钢，一顿不吃饿得慌！");
     }
 }

 public class PersonDemo{
     public static void main(String[] args){

         //有名字的对象，引用类型变量，可以反复使用eat方法。
         Person p = new Person();
         p.eat();

         //匿名对象，没有引用变量，只能使用一次，如果你再通过new调用eat方法的话实际上是又新生成了一个对象。
         new Person().eat();
         new Person().eat();

     }
 }

2>.匿名对象的特点

　　a>.创建匿名对象直接使用，没有变量名；

　　b>.匿名对象在没有指定其引用变量时，只能使用一次；

　　c>.匿名对象可以作为方法接受的参数，方法返回值使用；

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 class Person{
     public void eat(){
         System.out.println("人是铁，饭是钢，一顿不吃饿得慌！");
     }
 }
 public class PersonDemo{
     public static void main(String[] args){
         //有名字的对象，引用类型变量，可以反复使用eat方法。
         Person p = new Person();
         p.eat();
         //匿名对象，没有引用变量，只能使用一次，如果你再通过new调用eat方法的话实际上是又新生成了一个对象。
         new Person().eat();
         new Person().eat();
         method(p);

         //匿名方法当实参
         method(new Person());
         p = method();
         method(p);
     }
     //方法的返回值是Person类型，方法的return语句，返回的是这个类的对象。就可以用匿名对象来实现。
     public static Person method(){
         return new Person();
     }
     //调用方法method，传递Person类型对象
     public static void method(Person p){
         p.eat();
     }
 }

 /*
 以上代码执行结果如下：
 人是铁，饭是钢，一顿不吃饿得慌！
 人是铁，饭是钢，一顿不吃饿得慌！
 人是铁，饭是钢，一顿不吃饿得慌！
 人是铁，饭是钢，一顿不吃饿得慌！
 人是铁，饭是钢，一顿不吃饿得慌！
 人是铁，饭是钢，一顿不吃饿得慌！
 */

七.内部类

1>.内部类概念

　　a>.什么是内部类

　　　　将类写在其它类的内部，可以写在其它类的成员位置和局部位置，这时写在其它类内部的类成为内部类，其它类也称为外部类。

　　b>.什么时候使用内部类

　　　　在描述事物时，若一个事物内部还包含其它可能包含的事物，比如在描述汽车时，汽车中还包含这发动机，这时发动机就可以使用内部类来描述。

　　c>.内部类分类

　　　　内部类分为成员内部类和局部内部类。我们定义内部类时，就是一个正常定义类的过程，同样包含各种修饰符，继承与实现关系等。在内部类中可以直接访问外部类的所有成员。

2>.成员内部类的调用格式

　　内部类可以使用外部类成员，包括私有变量。外部类要使用内部类的成员，必须建立内部类对象。

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 class Outer{
     private int a = 100;
     class Inner{
         public void inner(){
             System.out.println("内部类方法inter " + a);
         }
     }
 }

 public class InnerClassDemo{
     public static void main(String[] args){
         //创建内部类对象in
         Outer.Inner  in = new Outer().new Inner();
         //调用内部类方法
         in.inner();
     }
 }

 /*
 以上代码执行结果如下：
 内部类方法inter 100
 */

3>.成员内部类的同名变量调用

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 class Outer{
     int a = 100;
     class Inner{
         int a = 200;
         public void inner(){
             int a = 300;
             System.out.println("内部类局部变量（内部类成员方法）访问:>>> "+ a);
             System.out.println("内部类成员变量访问:>>> "+ this.a);
             System.out.println("外部类成员变量访问:>>> "+ Outer.this.a);
         }
     }
 }

 public class InnerClassDemo{
     public static void main(String[] args){
         //创建内部类对象in
         Outer.Inner  in = new Outer().new Inner();
         //调用内部类方法
         in.inner();
     }
 }

 /*
 以上代码执行结果如下：
 内部类局部变量（内部类成员方法）访问:>>> 300
 内部类成员变量访问:>>> 200
 外部类成员变量访问:>>> 100
 */

3>.局部内部类

　　局部内部类，定义在外部类方法中的局部位置。与访问方法中的局部变量相似，可通过调用方法进行访问。

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 class Outer{
     public void out(){
         class Inner{
             public void inner(){
                 System.out.println("局部内部类方法！");
             }
         }
         //创建我们定义的Inner对象
         Inner in = new Inner();
         //调用创建好的对象的方法，这样不管谁只要能调用out方法就会触发调用Inner类中的inner()方法啦！
         in.inner();
     }
 }

 public class InnerClassDemo{
     public static void main(String[] args){
         new Outer().out();
     }
 }

 /*
 以上代码执行结果如下：
 局部内部类方法！
 */

4>.匿名内部类

　　a>.匿名内部类概念

　　　　内部类是为了应对更为复杂的类间关系。查看源代码中会涉及到，而在日常业务中很难遇到，这里不做赘述。最长用到的内部类就是匿名内部类，它是局部内部类的一种。定义的匿名内部类有两个含义：第一，临时定义某一指定类型的子类；第二，定义后即刻创建刚刚定义的这个子类的对象。

　　b>.定义匿名内部类的作用与格式

　　　　匿名内部类是创建某个子类对象的快捷方式。

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 interface  Smoking{
     public abstract void smoking();
 }

 public class  SmokingDemo{
     public static void main(String[] args){
         //这就是用匿名对象实现接口并调用接口中的方法，切记不要忘记调用smoking()了哟！
         new Smoking(){
             public void smoking(){
                 System.out.println("运维不喜欢吸烟！");
             }
         }.smoking();
     }
 }

 /*
 以上代码执行结果如下：
 运维不喜欢吸烟！
 */