精华内容
下载资源
问答
  • 其实是HttpServletRequest这个接口的上转型实例对象,因此,只是隐藏了子类中的方法,所以我们拿到这个对象之后,把他向下转型之后,只是还原了这个对象应有的方法不存在安全问题,也不会在调用getSession方法...

    转:https://www.cnblogs.com/gwyy/p/9078135.html
    前情提要:学习servlet的时候,学到了用令牌机制防止用户恶意登录的时候(即:只在网站的index.html或者是网站的登录界面),给用户发令牌(即是用户账号密码验证无误登陆成功后request.getSession()),其他所有的servlet中,如果要操作该用户session,则都使用request.getSession(false);这样就能保证用户只有通过合法的登录渠道才能访问除了登录页外的动态资源。
    但是这样做,需要在网站内的每一个servlet,都对用户的令牌进行一个判断,操作复杂,并且无法防止用户直接访问网站的静态资源文件,因此,想到了用过滤器,对所有的请求进行一次身份验证再放行。
    但是在javax.servlet这个包下的Filter接口中,doFilter(ServletRequest reques, ServletResponse respinse)方法中的两个参数,他们是HttpServletRequest和HTTPServletResponse的父类,而ServletRequest接口中,并没有提供getSession()方法,无法获取到用户令牌获取身份。于是在这个地方考虑到了把这两个参数强转为他的子类HttpServletRequest,来调用getSession()方法,问题解决,此时,问题就产生了,众所周知,java中的向下转型是不安全的,此处,却通过强转,调用了request对象中的getSession方法,却没有报错,是为什么呢?
    转载的这篇文章完美的回答了这个问题,因此转载记录,给作者点赞!
    简单描述一下:作者通过instanceof关键词,验证了这个方法上的参数request并不是有tomcat通过ServletRequest request = new ServletRequest(); 这种方法得来,而应该是由ServletRequest request = (ServletRequest)new HttpServletRequest();这种方法得来,也就是说,这个参数中的request对象,其实是HttpServletRequest这个接口的上转型实例对象,因此,只是隐藏了子类中的方法,所以我们拿到这个对象之后,把他向下转型之后,只是还原了这个对象应有的方法,并不存在安全问题,也不会在调用getSession方法时报错。详见转载文章。

    展开全文
  • 从 2 个名词开始说起:向上转型(upcasting)、向下转型(downcasting)。 举个例子:有2个类,Father 是父类,Son 类继承自 Father。 第 1 个例子: Father f1 = new Son(); // 这就叫 upcasting (向上转型) // ...

    Java 转型问题其实并不复杂,只要记住一句话:父类引用指向子类对象。

    什么叫父类引用指向子类对象?

    从 2 个名词开始说起:向上转型(upcasting) 、向下转型(downcasting)

    举个例子:有2个类,Father 是父类,Son 类继承自 Father。

    第 1 个例子:

    Father f1 = new Son();   // 这就叫 upcasting (向上转型)
    // 现在 f1 引用指向一个Son对象
    
    Son s1 = (Son)f1;   // 这就叫 downcasting (向下转型),其实向下转型就是赋值而已,将父类引用赋值给子类引用,因此需要强制转换。
    // 现在f1 还是指向 Son对象

    第 2 个例子:

    Father f2 = new Father();
    Son s2 = (Son)f2;       // 出错,子类引用不能指向父类对象

    你或许会问,第1个例子中:Son s1 = (Son)f1; 问为什么是正确的呢。

    很简单因为 f1 指向一个子类对象,Father f1 = new Son(); 子类 s1 引用当然可以指向子类对象了。

    而 f2 被传给了一个 Father 对象,Father f2 = new Father(); 子类 s2 引用不能指向父类对象。

    总结:

    1、父类引用指向子类对象,而子类引用不能指向父类对象。实例化子类对象,调用子类重写后的方法。向上转型并不能调用子类特有属性和方法;

    • 我们在学习向上转型可能会很难理解,向上转型并不能调用子类特有属性和方法;
    • 我们必须先生成子类实例再赋值给父类引用(向上转型),然后将父类引用向下强制转换给子类引用(向下转型),这样才能调用子类中的所有成员。这看起来像是多次一举,还不如直接创建子类实例。

     

    父类若想调用子类的方法参考:通过模板方法父类调用子类的方法(实例化子类,向上转型为父类引用,调用父类中的模板方法,模板方法中的基本方法已经被子类实现)。

    【Java面试】父类能调用子类的方法吗? - 简书

    Java设计模式—模板方法模式_冷血之心的博客-CSDN博客_java的模板设计模式

    2、把子类对象直接赋给父类引用叫upcasting向上转型,向上转型不用强制转换,如:

    Father f1 = new Son();

    3、把指向子类对象的父类引用赋给子类引用叫向下转型(downcasting),要强制转换,如:

    f1 就是一个指向子类对象的父类引用。把f1赋给子类引用 s1 即 Son s1 = (Son)f1;

    其中 f1 前面的(Son)必须加上,进行强制转换。

    展开全文
  • 什么是继承 继承其实听名字大概就知道是什么意思了,我们想象一下,现在有一个动物类。他包括名称,年龄的属性,吃饭,睡觉的方法,当然好的大家能想到的肯定有猫和狗,我们现在有了新的要求...使用者是子类,被使用者

    什么是继承

    继承其实听名字大概就知道是什么意思了,我们想象一下,现在有一个动物类。他包括名称,年龄的属性,吃饭,睡觉的方法,当然好的大家能想到的肯定有猫和狗,我们现在有了新的要求,我们想要这类有一个新的方法,我们想要听他们的叫声。
    可是很明显猫,狗的叫声不一样啊,我们此时又不想重新定义猫类或者狗类,因为这样做太麻烦了。这个时候继承的作用就来了,我们可以定义一个猫类,可以继承他的父类也就是动物类的属性方法,也可以再为子类定义的新方法。
    我们把这种可以使用别的类的属性和方法的方式叫做继承。使用者是子类,被使用者是父类。
    那么我们总不能直接拿着人家的东西用啊,最起码要喊一声爸爸,而喊爸爸的方式需要extends 关键字如下:

    class Dog extends Animal{
    	void call() {
    		System.out.println("汪汪汪");
    	}
    }
    

    为了便于理解我把动物类也粘贴出来:

    class Animal{
    	String name;
    	private int age;
    	public Animal() {
    	}
    	public Animal(String name, int age) {
    		// TODO Auto-generated constructor stub
    		this.name=name;
    		this.age=age;
    	}
    	private void eat() {
    		System.out.println(name+"吃饭了");
    	}
    	void sleep() {
    		System.out.println(name+"睡觉了");
    	}
    }
    

    我们的dog继承与动物类也就是说他有动物类的属性和方法。但是!我们不能继承原本的私有属性和方法。你怎么可以继承你爸爸的年龄呢?
    这个时候有的小伙伴要问了“啊,博主,那我可以调用父类的构造函数吗,他应该是公有的!”答案自然是可以的。

    在JAVA中子类调用父类的构造函数

    我们要知道没有父亲怎么会有儿子,更别提你还用了人家的属性和方法,所以当我们去new一个子类对象的时候,我们首先是去调用它的父类的构造函数,去创建父对象,随后我们在去调用它的构造函数去创建它。但是这个创建父对象的工作不是由我们而是由程序自主完成的,而创建出来的父类对象的位置位于子类对象里边(内存中)。所以子类所占的内存比父类要大。
    那么口说无凭我们写个代码看看:

    class Anmail{
    	String name;
    	private int age;
    
    	public Animal() {
    		System.out.println("我是爸爸");
    	}
    	public Animal(String name, int age) {
    		this.name=name;
    		this.age=age;
    	}
    	private void eat() {
    		System.out.println(name+"吃饭了");
    	}
    	void sleep() {
    		System.out.println(name+"睡觉了");
    	}
    }
    class Dog extends Animal{
    
    	void call() {
    		System.out.println("汪汪汪");
    	}
    }
    public class oopjc {
    	public static void main(String[] args) {
    		Dog dog = new Dog();
    		System.out.println(dog.name);
    	}
    }
    

    他的输出是这样的
    在这里插入图片描述
    大家可以看到当我创建子类对象的时候,他先调用了父类的构造方法。
    注意
    1、我们在创建子类对象的时候调用了父类的对象,这个是必须的,如果我们不写父类的构造方法,那么编译器会帮我们加上一个默认的构造方法,所谓默认的构造方法,就是没有参数的构造方法,但是如果你自己写了构造方法,那么编译器就不会给你添加了,所以有时候当你new一个子类对象的时候,肯定调用了子类的构造方法,但是在子类构造方法中我们并没有显示的调用基类的构造方法,就是没写,如:super(); 并没有这样写,但是这样就会调用父类没有参数的构造方法,如果父类中没有没有参数的构造方法就会出错。
    2、为了解决上述的事情,通常我们需要显示:super(参数列表),来调用父类有参数的构造函数。
    代码例子:

    class Animal{
    	String name;
    	private int age;
    
    	public Animal(String name, int age) {
    		this.name=name;
    		this.age=age;
    	}
    }
    class Dog extends Animal{
    	
    }
    public class oopjc {
    	public static void main(String[] args) {
    		Dog dog = new Dog();
    		System.out.println(dog.name);
    	}
    }
    

    这种情况下,程序是会报错的,因为你定义了父类的构造函数却没有定义没有参数的父类构造函数,这就导致了我们无法创建子类。
    解决办法呢其实很简单:1、在父类加入无参构造函数2、删除父类的有参构造函数3、用关键字super
    前两个我感觉应该不会看不懂,那么我们来看看第三个办法的实现方式:

    	public Dog() {
    		super("花花",1);
    	}
    

    在Dog类中加入这个,我们就可以实现赋值了,当然这个初始值可以随意,他就来自与父类(其实就相当于给了父类对象赋值,父类对象再把值初始化给子类对象)。

    向上转型

    我们一直在说的是一个狗是动物的一种,所以我们把动物作为一个通用或者叫普遍类型,狗作为一个特定类型。
    我们现在把这句话反着说 动物是狗。这句话的说法有些片面但是我们在局限性的看法中发现他的说法并不完全错误,因为狗确实有动物的所有特征。这种由特定类型转化为普遍类型的方式就是向上转型。从我们的编程角度看理解为通过子类实例化父类去使用。这种转换其实属于自动转换。

    class Animal{
    	void call() {
    		System.out.println("叫");
    	}
    	void print() {
    		System.out.println("Animal");
    	}
    }
    class Dog extends Animal{ 
    	void eat() {
    		
    	}
    	void print() {
    		System.out.println("Dog");
    	}
    }
    public class oopjc {
    	public static void main(String[] args) {
    		Animal animal = new Dog();
    		animal.print();
    		animal.eat();
    	}
    }
    

    我们从上边代码,我们其实会发现他出错了,原因在于你无法调用eat()这个方法,但是很明显print();方法输出的是Dog;
    这就是向上转型的特点:
    1.向上转型,可以调用父类的对象但不能调用子类的对象。
    2.向上转型,如果遇到父类的方法被子类重写了,那么就去调用子类也就是被重写后的方法。
    那么向上转型的作用是什么呢?
    当我们需要多个由同一个父类创建的对象调用某个方法时,通过向上转换后,则可以确定参数的统一,方便程序设计。

    向下转型

    向下转型和向上刚好相反,当父对象需要用到子对象的某些功能的时候,我们就可以采取向下转型。但是这个其实并不长用,因为我们知道一个特别的人可以是人,但是不是人人都可以做特别的人。因此 通过父类对象(大范围)实例化子类对象(小范围),这种属于强制转换。

    		Animal animal = new Animal();
    		Dog dog = (Dog)animal;
    		//dog.print();
    		dog.eat();
    

    强制转换的方式就是这样。
    特点:
    1、向下转型可以调用子类的特定功能。
    这个我的编译器一直报错,因为才学的时间比较短留个坑…我个人感觉这个向下转型还是不用为好。

    一些小问题

    1.如果子类和父类的方法名相同调用那个?
    这里我们采用的是就近原则,子类对象调子类的,父类对象调父类的,大家可以自行尝试。其实这个地方牵扯到函数的重写与重载也就是多态,这个多态本次我们先不多做了解。

    注意继承有什么特征呢?
    1.喊爸爸必须要通过extends关键字
    2.java只支持单继承(只能有一个爸爸)
    3.但是一个类可以有多个子类(爸爸的快乐)
    4.继承可以传递(爸爸也有爸爸啊,爸爸的爸爸也是有一部分东西可以传给自己的嘛)
    5、 不能继承父类的私有成员
    6、 继承多用于功能的修改,子类可以拥有父类的功能的同时,进行功能拓展

    展开全文
  • 上转型对象 上转型对象只能访问父类中...下转型对象 恢复子类原有的成员变量和成员方法,即继承关系的调用顺序。 继承链中对象方法调用的优先级: this.show(O)、super.show(O)、this.show((super)O)、super.show

    上转型对象

    上转型对象只能访问父类中声明的成员变量和成员方法,不可以访问子类新增的特有的成员变量和成员方法。

    如果子类重写了父类的方法,则上转型对象调用该方法时,必定是调用重写的方法。

    如果子类重新定义了父类的同名变量,则上转型对象应用该变量时是父类中的定义的变量,而不是子类中定义的变量

    下转型对象

    恢复子类原有的成员变量和成员方法,即继承关系的调用顺序。

    • 继承链中对象方法的调用的优先级:
      this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。
    展开全文
  • 以下Animal为父类,Dog,Cat作为子类,分别继承AnimalclassAnimal{public voidshout(){System.out.println("叫了一声");}}class Dog extendsAnimal{public voidshout() {System.out.println("旺旺旺");}public ...
  • Java多态之父类调用子类方法//多态的体现import javax.print.attribute.standard.RequestingUserName;import java.util.Scanner;public class testfather {public static void main(String[] args){Animal a = new...
  • 在java继承体系中,认为父类(超类)在上层,子类在下层(派生类) ,向上转型就是把子类对象转成父类对象向下转型就是把父类对象转成子类对象Person.classpublic class Person {public void work(){System.out.println...
  • 子类对象调用子类特有的方法(Java多态) 在使用多态时,可以让我们把具有共同特性的多个类更加方便地使用,但是简单的多态使用会导致一个很严重的问题,就是子类对象只能调用子类中重写的父类方法,而不能调用子类...
  • 向上转型和向下转型

    2021-05-08 05:05:34
    简单使用声明一个父类Father,子类Son继承FatherFather a = new Son() // 父类引用、子类对象(向上转型)Son b = (Son)a // 向下转型,强制转换// 父类引用转成子类引用向上转型实例public class Animal {public void ...
  • java向下转型的作用

    2021-03-22 13:55:10
    这些属性在操作时所有的属性名称都使用 String 进行接收, 所有的属性内容使用 Object 进行接收,可以保存任意的对 象,在取得属性时要根据取得的类型进行向下转型操作......equals()——作用,对象的比较 ? 多态(难点) ...
  • 在讨论向上转型和向下转型之前,先复习下多态。如果有错误的地方,希望能够指出,大家共同进步!什么是多态?多态(Polymorphism)即同一操作作用于不同的对象,可以有不同的解释,产生不同的结果。多态的分类多态一般...
  • Java 中对象类型之间的类型转换(前提是两个类是父子关系) 1.向上转型:把子类对象直接赋给父类引用,自动进行类型转换。 静态方法/成员变量(包括静态...2.向下转型:将一个指向子类对象的父类引用赋给一个子类
  • 在实际的应用中,还有两种特殊情形:向上转型和向下转型。所谓向上转型即是声明父类变量后却在实例化时创建一个子类的实例。首先先创建父类User与子类Student如下。其中子类中覆盖了父类的name变量与重...
  • 一、向上转型和向下转型 向上转型和向下转型是在JAVA继承操作中用到的东西,在讲到转型之前我们需要认识到继承过程中的对象类型转换,这种转换有两个特点: 1.这是继承过程中发生的操作 2.新类是现有类的一种...
  • 这个和上面的快捷键补全意思是一样的,但是我起码明白了是怎么一回事,这个叫做向下转型。 同理,肯定还有向上转型,子类强制转型成父类。 ((Person)s1).action(); //拆开 Person p1=(Person)s1; p1.action(); 其实...
  • 那么我们在运用的时候根据不同的场景会出现向上转型和向下转型的情况。 一、向上转型 1、Animal a1 = new Cat(); 2、Cat cat = new Cat();  Animal a2 = cat; 这两种情况都是向上转型:一个父类引用指向一个子类...
  • 子类静态方法调用

    2021-09-02 11:14:14
    若在父类中添加静态方法say,则子类不能重写父类的静态方法: 在父类和子类中都添加say方法: 父类Animal: public static void say(){ System.out.println("动物间打招呼"); } 子类Cat: public static void say...
  • 向下转型) g() in the MoreUseful2 class // 又x[2].g()这一句中调用g()方法实际的对象类型是子 // 类Moreuseful类型,故将调用子类Moreuseful中 // 覆盖父类的g()方法。(向上转型) u() in the ...
  • 向下转型:向下转型是与向上转型相对的概念,他是用子类引用指向父类实例.如:Animal animal = new Dog();Dog d = animal;// 报错这时就告诉我们向下转型不能自动转换,我们需要强转,所以向下转型又叫做强制类型转换....
  • Java向上转型和向下转型(附具体样例)熬夜整理的关于Java向上和向下转型的样例,很的通俗易懂哦~~~~一.向上转型package com.sheepmu;class Animal{public void eat(){System.out.println("父类的 eating...");}}class...
  • Java对象类型转换:向上转型和向下转型 将一个类型强制转换成另一个类型的过程被称为类型转换。本节所说的对象类型转换,是指存在继承关系的对象,不是任意类型的对象。当对不存在继承关系的对象进行强制类型转换时...
  • 简单理解Java中转型问题(向上转型和向下转型) —————————————————————————— 本文内容仅仅为个人的理解,仅供大家参考。如果本文中存在一些错误的地方还请大佬们指出,感激不尽。 ————...
  • java向上向下转型

    2021-03-09 04:56:21
    转型是在继承的基础上而言的,继承是面向对象语言中,代码复用的一种机制,通过继承...此处父类对象可以是接口向下转型:父类引用的对象转换为子类类型称为向下转型。前者是一个向上转型,Animal dog 引用指向new Do...
  • 父类子类对象之间的转换分为向上转型和向下转型 向上转型:通过子类对象(小范围)实例化父类对象(大范围),这种属于自动转换。(将一个子类类型的对象赋值给一个父类类型的变量) 语法:父类类型 变量 = new 子类...
  • 重写/重载重写指的是根据运行时对象的类型来决定调用哪个方法,而不是根据编译时的类型。所以静态方法不能被覆盖。(如果从重写方法会有什么特点来看,我们是不能重写静态方法的。虽然就算你重写静态方法,编译器也...
  • 向下转型:Cat cat = (Cat) a,必须要先经过向上转型的变量–再向下转型,此时cat就拥有子类自己定义的特有方法cat.sleep() instanceof用法:a instanceof Cat 这里a必须是经过向上转型后的父类对
  • Java多态之向下转型

    2021-02-28 11:46:46
    Java多态之向下转型往期回顾:我们学习了向上转型和动态绑定的概念,可以知道在继承关系中,将一个子类...那么,如何在这时调用子类中的方法呢,这时就需要与向上转型相对应的方法,就是所谓的:向下转型。向上转型...
  • 目的:当父类中的方法无法满足子类时,子类可以在此基础上进行功能的扩展 定义:子类重写父类中的方法要和父类中方法名、返回值类型、参数列表完全一致。而且访问修饰符的范围不能被缩小。 public class Demo6{ ...
  • 学习向上转型和向下转型怎么用没多难,但是为什么那样用,我搞了很多次没弄明白。没弄明白的原因是平时学习时之看例子,而例子一般都比较简单,没有对象之间的调用,一般就是一个对象调用自己的方法。首先看下怎么用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 31,533
精华内容 12,613
关键字:

向下转型并调用子类方法