1.问题描述
向下转型的应用场景是面向接口编程的时候，经常需要向下转型。但是向上转型的应用场景是什么呢？
我看到网上有的说是为了获取父类的方法，子类也可以访问父类的方法啊，就算是覆盖的方法，也可以通过super.方法()来访问父类的方法啊。
2.代码
代码来源是《深入剖析Tomcat》第二章的代码。
package ex02.pyrmont;
import java.net.URL;
import java.net.URLClassLoader;
import java.net.URLStreamHandler;
import java.io.File;
import java.io.IOException;
import javax.servlet.Servlet;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
public class ServletProcessor1 {
public void process(Request request, Response response) {
String uri = request.getUri();
String servletName = uri.substring(uri.lastIndexOf("/") + 1);
URLClassLoader loader = null;
try {
// create a URLClassLoader
URL[] urls = new URL[1];
URLStreamHandler streamHandler = null;
File classPath = new File(Constants.WEB_ROOT);
// the forming of repository is taken from the createClassLoader
// method in
// org.apache.catalina.startup.ClassLoaderFactory
String repository = (new URL("file", null,
classPath.getCanonicalPath() + File.separator)).toString();
// the code for forming the URL is taken from the addRepository
// method in
// org.apache.catalina.loader.StandardClassLoader class.
urls[0] = new URL(null, repository, streamHandler);
loader = new URLClassLoader(urls);
} catch (IOException e) {
System.out.println(e.toString());
}
Class myClass = null;
try {
myClass = loader.loadClass(servletName);
} catch (ClassNotFoundException e) {
System.out.println(e.toString());
}
Servlet servlet = null;
try {
servlet = (Servlet) myClass.newInstance();
servlet.service((ServletRequest) request,
(ServletResponse) response); //注：Request实现了ServletRequest接口，这里为什么要向上转型呢？
} catch (Exception e) {
System.out.println(e.toString());
} catch (Throwable e) {
System.out.println(e.toString());
}
}
}
SO相同问题
Java不太懂, 之前学过一点.
我认为是这样的:
// 为了方便理解, 用的汉子
class 鸟{
public void 吃(){}
}
class 鹦鹉 extends 鸟{
public void 吃(){
System.out.println("鹦鹉 吃");
}
}
class 鸽子 extends 鸟{
public void 吃(){
System.out.println("鸽子 吃");
}
}
class test{
public static void main (String[] args){
鸟 Niao = new 鸽子();
喂食(Niao);
}
public static void 喂食(鸟 Niao){
Niao.吃();
}
}
这行代码将 Request 和 Response 类型的参数强制转换为 ServletRequest 和 ServletResponse，这不是向上，仍然是向下。强制类型转换与变量本身的类型有关，而与变量所指向的对象的实际类型无关。
这个不叫向上转型，只是一个显式的类型转换吧
向上转型基本上都是画蛇添足，脱裤子放屁，只有个别时候才需要

1.问题描述
向下转型的应用场景是面向接口编程的时候，经常需要向下转型。但是向上转型的应用场景是什么呢？
我看到网上有的说是为了获取父类的方法，子类也可以访问父类的方法啊，就算是覆盖的方法，也可以通过super.方法()来访问父类的方法啊。
2.代码
代码来源是《深入剖析Tomcat》第二章的代码。
package ex02.pyrmont;
import java.net.URL;
import java.net.URLClassLoader;
import java.net.URLStreamHandler;
import java.io.File;
import java.io.IOException;
import javax.servlet.Servlet;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
public class ServletProcessor1 {
public void process(Request request, Response response) {
String uri = request.getUri();
String servletName = uri.substring(uri.lastIndexOf("/") + 1);
URLClassLoader loader = null;
try {
// create a URLClassLoader
URL[] urls = new URL[1];
URLStreamHandler streamHandler = null;
File classPath = new File(Constants.WEB_ROOT);
// the forming of repository is taken from the createClassLoader
// method in
// org.apache.catalina.startup.ClassLoaderFactory
String repository = (new URL("file", null,
classPath.getCanonicalPath() + File.separator)).toString();
// the code for forming the URL is taken from the addRepository
// method in
// org.apache.catalina.loader.StandardClassLoader class.
urls[0] = new URL(null, repository, streamHandler);
loader = new URLClassLoader(urls);
} catch (IOException e) {
System.out.println(e.toString());
}
Class myClass = null;
try {
myClass = loader.loadClass(servletName);
} catch (ClassNotFoundException e) {
System.out.println(e.toString());
}

 List<String> lists = new ArrayList();
ArrayList<String> lists = new ArrayList(); 
到底有什么区别？这是上转型。
上转型对象不是父类创建的对象，而是子类对象的“简化”状态，它不关心子类新增的功能，只关心子类继承和重写的功能。
当一个类有很多子类时，并且这些子类都重写了父类中的某个方法。
当使用上转型对象在调用这个方法时就可能具有多种形态。因为不同的子类在重写父类的方法时可能产生不同的行为。也就是说，不同对象的上转型对象调用同一方法可能产生不同的行为。

例如下面的程序你测试一下就可以理解这样的用法。以下的程序输出为
Wang!Wang!......
miao~~miao~~...
package com.vince.testJava;

class Animal {
	void cry() {
	}
}

class Dog extends Animal {
	void cry() {
		System.out.println("Wang!Wang!......");
	}
}

class Cat extends Animal {
	void cry() {
		System.out.println("miao~~miao~~...");
	}
}

public class Test01 {
	public static void main(String args[]) {
		Animal animal;
		animal = new Dog(); // animal是Dog对象的上转型对象
		animal.cry();
		animal = new Cat(); // animal是Cat对象的上转型对象
		animal.cry();
	}
}

一、多态的概念
多态是继封装，继承之后，面向对象的三大特性。
现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的张三同学既是学生也是人，即出现两种形态。
java作为面向对象的语言，同样可以描述一个事物的多种形态，java中多态的代码体现在一个子类对象(实现类对象)既可以给这个子类(实现类对象)引用变量赋值，又可以给这个子类(实现类对象)的父类(接口) 变量赋值。
父类的引用变量指向子类对象。多态的前提需要有继承关系或者是实现关系，否则没法完成多态。在使用多态后的父类引用变量调用方法时，会调用子类重写的;
二、多态的定义与使用
多态的定义格式：就是父类的引用变量指向子类的对象;
父类类型变量名 = new 子类对象();
变量名.方法名();
1.普通类的多态定义格式：
父类类型变量名 = new 子类();
2.抽象类多态的定义：
抽象类变量名 =new 抽象类子类();
3.接口多态定义的格式：
接口变量名 =new 接口实现类();
注意：虽然变量指向子类的对象，但表现的是一个父类的形态，可以调用一切父类的方法，子类特有的方法将不能调用
三、多态调用的注意事项：
编译：成员变量，成员方法都需要看父类;父类没有编译报错;
运行：成员变量运行父类的成员变量，成员方法运行父类重写的方法
四、多态的好处与弊端
好处：多态配合继承子类重写，提高了代码的复用性与扩展性
弊端：不能调用子类特有的方法
五、向上向下类型转换
多态本身是子类类型向父类类型向上转型的过程;
1.向上转型：
当子类的对象赋值给一个父类的引用时，便是向上转型，多态本身就是向上转型的过程
使用格式：父类类型 变量名= new 子类类型();
2.向下转型：
一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类的引用转换为子类引用，这个过程是向下转型。直接创建父类对象的无法使用向下转型;
使用格式：
子类类型 变量名= (子类类型) 父类类型的变量;
六、instanceof 关键字
可以通过instanceof关键字来判断某个对象是否属于某种数据类型;
使用格式：
boolean b= 对象(new ) instanceof 数据类型;