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();
}
} /*
以上代码执行结果如下：
运维不喜欢吸烟！
*/
