精华内容
下载资源
问答
  • Java向上转型方法调用
    2020-10-24 19:05:08

    向上转型方法与作用

    父类名 引用变量名= new 子类名()

    向上转型的作用在于让代码复用,提高代码简洁性,同个继承链的类可以用同个顶层类型表示参数。

    如将子类对象作为实参,传进父类为形参的函数,即可不必为每一个子类都写一个子类形参的函数。

    向上转型后方法调用

    向上转型后,引用变量调用方法,调用的是子类覆盖或继承的方法,并非原先父类的方法。

    但向上转型后,无法通过引用变量调用子类特有的方法,即便是父类中有同名抽象方法也不行。

    测试代码

    public class MainClass {
    
    	public abstract class Parent
    	{
    		public void f1(){System.out.println("调用父类方法1");}
    		public abstract void f2();
    	}
    	
    	public class Child extends Parent
    	{
    		public void f1(){System.out.println("调用子类方法1");}
    		public void f2(){System.out.println("调用子类方法2");}
    	}
    	
    	public static void main(String[] args) {
    		
    		MainClass ms=new MainClass();
    		Parent p=ms.new Child();
    		p.f1();//p.f1()输出结果是"调用子类方法1"
    		//无法调用p.f2();
    		
    	}
    
    }
    
    更多相关内容
  • 这个时候继承的作用就来了,我们可以定义一个猫类,可以继承他的父类也就是动物类的属性方法,也可以再为子类定义的新方法。 我们把这种可以使用别的类的属性和方法的方式叫做继承。使用者是子类,被使用者

    什么是继承

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

    展开全文
  • java通过反射调用父类中的方法

    千次阅读 2021-02-12 13:26:59
    } } 首先用到反射的话 针对的对象是class不能是接口 假设现在我有一个Person父类 里面有一个方法 getUserName() 后面有一个Man类来继承Person类 然后我想通过反射Man类来调用Person里面的getUserName()方法 Object ...

    下面是工具类

    package com.ninemax.utils;

    import java.lang.reflect.Field;

    import java.lang.reflect.InvocationTargetException;

    import java.lang.reflect.Method;

    import java.lang.reflect.Modifier;

    import java.lang.reflect.ParameterizedType;

    import java.lang.reflect.Type;

    import java.util.ArrayList;

    import java.util.Collection;

    import java.util.Date;

    import java.util.List;

    import org.apache.commons.beanutils.ConvertUtils;

    import org.apache.commons.beanutils.PropertyUtils;

    // import org.apache.commons.beanutils.converters.DateConverter;

    import org.apache.commons.lang.StringUtils;

    /**

    *

    * 反射的 Utils 函数集合

    * 提供访问私有变量, 获取泛型类型 Class, 提取集合中元素属性等 Utils 函数

    *

    */

    public class ReflectionUtils {

    /**

    * 将反射时的 "检查异常" 转换为 "运行时异常"

    * @return

    */

    public static IllegalArgumentException convertToUncheckedException(Exception ex){

    if(ex instanceof IllegalAccessException || ex instanceof IllegalArgumentException

    || ex instanceof NoSuchMethodException){

    throw new IllegalArgumentException("反射异常", ex);

    }else{

    throw new IllegalArgumentException(ex);

    }

    }

    /**

    * 转换字符串类型到 toType 类型, 或 toType 转为字符串

    * @param value:  待转换的字符串

    * @param toType: 提供类型信息的 Class, 可以是基本数据类型的包装类或指定格式日期型

    * @return

    */

    //    public static Object convertValue(Object value, Class> toType){

    //        try {

    //            DateConverter dc = new DateConverter();

    //

    //            dc.setUseLocaleFormat(true);

    //            dc.setPatterns(new String[]{"yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss"});

    //

    //            ConvertUtils.register(dc, Date.class);

    //

    //            return ConvertUtils.convert(value, toType);

    //        } catch (Exception e) {

    //            e.printStackTrace();

    //            throw convertToUncheckedException(e);

    //        }

    //    }

    /**

    * 提取集合中的对象的属性(通过 getter 方法), 组成 List

    * @param collection: 来源集合

    * @param propertyName: 要提取的属性名

    * @return

    */

    @SuppressWarnings("unchecked")

    public static List fetchElementPropertyToList(Collection collection, String propertyName){

    List list = new ArrayList();

    try {

    for(Object obj: collection){

    list.add(PropertyUtils.getProperty(obj, propertyName));

    }

    } catch (Exception e) {

    e.printStackTrace();

    convertToUncheckedException(e);

    }

    return list;

    }

    /**

    * 提取集合中的对象属性(通过 getter 函数), 组合成由分隔符分隔的字符串

    * @param collection: 来源集合

    * @param propertyName: 要提取的属性名

    * @param seperator: 分隔符

    * @return

    */

    @SuppressWarnings("unchecked")

    public static String fetchElementPropertyToString(Collection collection, String propertyName,

    String seperator){

    List list = fetchElementPropertyToList(collection, propertyName);

    return StringUtils.join(list, seperator);

    }

    /**

    * 通过反射, 获得定义 Class 时声明的父类的泛型参数的类型

    * 如: public EmployeeDao extends BaseDao

    * @param clazz

    * @param index

    * @return

    */

    @SuppressWarnings("unchecked")

    public static Class getSuperClassGenricType(Class clazz, int index){

    Type genType = clazz.getGenericSuperclass();

    if(!(genType instanceof ParameterizedType)){

    return Object.class;

    }

    Type [] params = ((ParameterizedType)genType).getActualTypeArguments();

    if(index >= params.length || index < 0){

    return Object.class;

    }

    if(!(params[index] instanceof Class)){

    return Object.class;

    }

    return (Class) params[index];

    }

    /**

    * 通过反射, 获得 Class 定义中声明的父类的泛型参数类型

    * 如: public EmployeeDao extends BaseDao

    * @param

    * @param clazz

    * @return

    */

    @SuppressWarnings("unchecked")

    public static Class getSuperGenericType(Class clazz){

    return getSuperClassGenricType(clazz, 0);

    }

    /**

    * 循环向上转型, 获取对象的 DeclaredMethod

    * @param object

    * @param methodName

    * @param parameterTypes

    * @return

    */

    public static Method getDeclaredMethod(Object object, String methodName, Class>[] parameterTypes){

    for(Class> superClass = object.getClass(); superClass != Object.class; superClass = superClass.getSuperclass()){

    try {

    //superClass.getMethod(methodName, parameterTypes);

    return superClass.getDeclaredMethod(methodName, parameterTypes);

    } catch (NoSuchMethodException e) {

    //Method 不在当前类定义, 继续向上转型

    }

    //..

    }

    return null;

    }

    /**

    * 使 filed 变为可访问

    * @param field

    */

    public static void makeAccessible(Field field){

    if(!Modifier.isPublic(field.getModifiers())){

    field.setAccessible(true);

    }

    }

    /**

    * 循环向上转型, 获取对象的 DeclaredField

    * @param object

    * @param filedName

    * @return

    */

    public static Field getDeclaredField(Object object, String filedName){

    for(Class> superClass = object.getClass(); superClass != Object.class; superClass = superClass.getSuperclass()){

    try {

    return superClass.getDeclaredField(filedName);

    } catch (NoSuchFieldException e) {

    //Field 不在当前类定义, 继续向上转型

    }

    }

    return null;

    }

    /**

    * 直接调用对象方法, 而忽略修饰符(private, protected)

    * @param object

    * @param methodName

    * @param parameterTypes

    * @param parameters

    * @return

    * @throws InvocationTargetException

    * @throws IllegalArgumentException

    */

    public static Object invokeMethod(Object object, String methodName, Class[] parameterTypes,

    Object [] parameters) throws InvocationTargetException{

    Method method = getDeclaredMethod(object, methodName, parameterTypes);

    if(method == null){

    throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + object + "]");

    }

    method.setAccessible(true);

    try {

    return method.invoke(object, parameters);

    } catch(IllegalAccessException e) {

    }

    return null;

    }

    /**

    * 直接设置对象属性值, 忽略 private/protected 修饰符, 也不经过 setter

    * @param object

    * @param fieldName

    * @param value

    */

    public static void setFieldValue(Object object, String fieldName, Object value){

    Field field = getDeclaredField(object, fieldName);

    if (field == null)

    throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");

    makeAccessible(field);

    try {

    field.set(object, value);

    } catch (IllegalAccessException e) {

    }

    }

    /**

    * 直接读取对象的属性值, 忽略 private/protected 修饰符, 也不经过 getter

    * @param object

    * @param fieldName

    * @return

    */

    public static Object getFieldValue(Object object, String fieldName){

    Field field = getDeclaredField(object, fieldName);

    if (field == null)

    throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");

    makeAccessible(field);

    Object result = null;

    try {

    result = field.get(object);

    } catch (IllegalAccessException e) {

    }

    return result;

    }

    }

    首先用到反射的话 针对的对象是class不能是接口

    假设现在我有一个Person父类 里面有一个方法 getUserName()

    后面有一个Man类来继承Person类

    然后我想通过反射Man类来调用Person里面的getUserName()方法

    Object o=Class.forName("com.ninemax.test.Man");

    ReflectionUtils.invokeMethod(o, "getUserName", new Class[]{String.class},

    new String[]{"张三"});

    展开全文
  • 子类使用super调用的父类方法里,再调用父类方法 先来看一段代码(该段代码只是作为测试用,正常编码时类名一定要规范编写) package supertetst; /** * @Author: x1aolone * @Date: 2019/11/8 22:11 */ ...

    最近在看代码的时候遇到一个天坑,由于习惯性思维,可能大部分人都会掉近这个坑,所以拿出来记录一下

    子类使用super调用的父类方法里,再调用父类的方法

    先来看一段代码(该段代码只是作为测试用,正常编码时类名一定要规范编写)

    package supertetst;
    
    /**
     * @Author: x1aolone
     * @Date: 2019/11/8 22:11
     */
    
    class father {
        public void invoke () {
            say();
        }
    
        public void say () {
            System.out.println("father say");
        }
    }
    
    class child extends father{
        @Override
        public void invoke () { 
        	super.invoke(); 
        }
    
        @Override
        public void say () { 
        	System.out.println("child say"); 
        }
    }
    
    
    public class test {
        public static void main(String[] args) {
            child c = new child();
            c.invoke();
        }
    }
    
    

    猜猜上面的代码运行结果是什么?
    "child say"

    你没有看错,答案不是想象之中的"father say",实际上调用的是子类中的say方法。

    在刚看到代码时,你可能想当然地以为代码的执行顺序是:子类invoke() => 父类invoke() => 父类invoke()

    但是,通过debug断点发现,上面这段代码的执行顺序是:子类invoke() => 父类invoke() => 子类invoke()

    OK,虽然上面的例子有点“毁三观”,但是你可能以为你已经明白super的使用方法了,那么再看看下面这个粒子

    子类使用super调用的父类方法里,再调用父类的变量

    package supertetst;
    
    /**
     * @Author: x1aolone
     * @Date: 2019/11/8 22:11
     */
    
    class father {
        public String a = "father";
    
        public void invoke () {
            System.out.println(a);
        }
    }
    
    class child extends father{
    
        public String a = "child";
    
        @Override
        public void invoke () { super.invoke(); }
    }
    
    
    public class test {
        public static void main(String[] args) {
            child c = new child();
            c.invoke();
        }
    }
    
    

    在这一段例子中,变量a是公共变量,可以由子类继承,于是父类的变量a会被子类的变量a隐藏,类似@Override

    按照我们上一个例子得出的教训,子类通过super调用的父类invoke方法,在父类Invoke方法里再调用say方法,实际上调用的是子类的invoke方法,那么此时父类的invoke方法使用的变量a应该也是子类覆盖过的变量a,也就是输出"child"

    很遗憾!结果是输出“father”,也就是父类自己的变量a

    那么经过以上两个例子,我们可以发现:

    子类通过super调用父类的invoke方法,在父类的invoke方法中,如果调用方法,则优先选择子类重写的方法,如果使用变量,则选择父类自己的变量(这里可没有优先二字)

    对于不关心原理的人来说,你只需要看到这个坑,记住上面那句话,不要再想当然采坑就好了,对于喜欢问“为什么”的同学,我们下面就来聊聊它到底是为什么

    成员变量的隐藏和方法重写

    如果父类中存在一个可继承的变量,并且子类中存在同类型、同名的变量,那么父类的变量会被隐藏,称为成员变量的隐藏
    如果父类中存在一个可继承的方法,并且子类中存在同名、同参数类型、同参数个数、同返回值的方法,那么父类的方法会被隐藏,成为方法重写

    无论是变量还是方法,其实都只是被隐藏了而已,在《JAVA程序设计精编教程》中是这么说的:“如果子类想使用被隐藏的方法或成员变量,必须使用关键字super”

    super关键字

    在JAVA中,super关键字用来操作被隐藏的成员变量和方法,对于变量,使用方式如super.x,对于方法啊,使用方式如super.x()

    到这里,JAVA的基础知识就复习得差不多了,需要注意的是,例子1和例子中在父类和子类中同时出现的变量、方法,其实只是在子类中被隐藏了而已,在访问时是需要通过super关键字才能访问的。

    回到我们的例子,先看例子1,为了方便你们阅读,再贴一遍代码

    package supertetst;
    
    /**
     * @Author: x1aolone
     * @Date: 2019/11/8 22:11
     */
    
    class father {
        public void invoke () {
            say();
        }
    
        public void say () {
            System.out.println("father say");
        }
    }
    
    class child extends father{
        @Override
        public void invoke () { 
        	super.invoke(); 
        }
    
        @Override
        public void say () { 
        	System.out.println("child say"); 
        }
    }
    
    
    public class test {
        public static void main(String[] args) {
            child c = new child();
            c.invoke();
        }
    }
    
    

    在例子1中,主函数调用child.invoke(),代码继续往下执行,super.invoke(),这个时候就要注意了,子类通过super关键字访问子类中被隐藏invoke方法,说到底还是在子类中,此时执行被隐藏的invoke()方法,内容为say(),自然就会调用子类中重写的say(),因为子类中被隐藏的say()是需要使用super才能调用的

    再来看例子2,为什么变量就不会用子类的变量了呢?

    package supertetst;
    
    /**
    * @Author: x1aolone
    * @Date: 2019/11/8 22:11
    */
    
    class father {
       public String a = "father";
    
       public void invoke () {
           System.out.println(a);
       }
    }
    
    class child extends father{
    
       public String a = "child";
    
       @Override
       public void invoke () { super.invoke(); }
    }
    
    
    public class test {
       public static void main(String[] args) {
           child c = new child();
           c.invoke();
       }
    }
    
    

    在《JAVA程序设计精编教程》中讲述成员变量的隐藏时,有这么一句话:“需要注意的是,子类对象仍然可以调用从父类继承的方法操作隐藏的成员变量”

    子类隐藏掉的invoke()方法,是从父类继承的,从上面这句话可以看出,从父类继承的方法所操作的变量仍然是从父类的继承变量。

    于是乎,子类调用super.invoke()来使用那个从父类中继承的、被隐藏的invoke()方法,这个方法中操作的变量仍然是从父类中继承的、被隐藏的变量,所以输出的答案是"father"

    当然了,这个机制看起来跟我上面例子1提到的原理有点冲突,既然是调用隐藏的方法,访问变量就应该访问子类的变量不是?

    所以个人觉得例子2出现的问题可能是个机制问题,由于面向对象编程时常常需要封装,变量设为private后子类无法继承,于是使用继承getter、setter的方法来访问父类私有变量,由于这种情况遇见得多,我们会下意识地认为父类方法调用某个方法时调用的是自己的方法,但实际上无论例子1的子类invoke()是否存在,输出都是"child",通过子类对象调用的父类方法invoke()在实际执行时调用的是子类已经重写的say()方法,即使把子类对象上转型成父类对象以后,再调用invoke(),结果仍然是调用子类的say(),父类的say()根本不会被调用

    上面这个问题可能跟jvm有关,先埋个坑,等以后了解到jvm的相关知识,再回来填

    ====================================

    对这个问题有疑惑的同学可以看一下《深入理解Java虚拟机》第三版的 8.3.2 分派 里面的 2.动态分派 ,在那一小节的结尾有一段代码,讲的就是这个问题,与虚拟机的静态分派和动态分派有关(其实严格来说静态分派发生在编译阶段,不是由虚拟机执行)

    展开全文
  • 目录1、方法一:子类调用父类的同名方法和属性2、方法二:super()方法3、总结: 1、方法一:子类调用父类的同名方法和属性 注意: 设Prentice()类继承了School()类、而School()类又继承了Master类。对Prentice()类...
  • 父类 FatherClasspackage 父类与子类方法调用顺序;/*** 父类* @author shundong**/public class FatherClass {private int i =0;private String name;/*** 父类无参构造*/FatherClass(){System.out.println("--父类...
  • Java中的上转型对象

    千次阅读 2020-03-27 11:37:20
    java中的上转型变量 引言: 当学习到java的多态时,提到了上转型变量的概念,由于java中的多态十分重要,在本文中将介绍本人在学习过程中的疑惑和寻找到的解答并进行总结。 1.定义 如果B类是A类的子类或间接子类,...
  • 1. SuperClassReflectionUtils.javapackage zmx.reflect.test;import java.lang.reflect.Field;import java.lang.reflect.InvocationTargetException;.../*** 获取父类中的所有属性和方法 工具类* @aut...
  • 反射工具类(调用父类方法和字段)

    千次阅读 2017-06-05 21:48:28
    使用这个工具类,可以完成父类,基类,方法,字段,无论什么权限都可以调用.package com.reflect; /** * 基类 * @author jianghui */ public class GrandParent { public String publicField = "1"; String ...
  • Java 子类构造函数默认调用父类构造函数super

    千次阅读 多人点赞 2020-11-25 22:32:08
    创建对象时,会先自动调用父类的构造函数,再自动调用子类的构造函数。 解释:super()表示父类的构造函数并会调用于参数相对应的父类中的构造函数。子类中,它在调用父类中空参数的构造函数。因为子类继承父类,会...
  • Java 向上转型中属性和方法调用规则: 调用属性看父类调用方法先看子类,子类没有,再看父类
  • 父类,子类中方法调用

    千次阅读 2020-10-24 17:01:13
    父类中有一个public void ...=父类),此时再用子类的对象调public void printDetail方法,输出的就是子类重写后的同名方法执行的结果,此时若子类的对象想要调用父类的该方法,则要再写一个不同名p2方法:用super调用
  • 在学习方法重载时想到如果声明了一个上转型对象,那么当超类与子类作为方法参数重载时会如何调用呢? 于是编写了一个玩具代码来验证了一下,发现编译器会调用声明时的参数父类方法。 代码如下: public class ...
  • ,如此就可调用父类类的方法,而不可以调用自身的方法,但如果父类的方法被子类重写, 那就调用子类的方法 。好处:减少重复代码*/ public class Human {  public void sleep() {  System.out.println("...
  • 封装的目的是增强安全性和简化编程,使用者不必在意具体实现细节,而只是通过外部接口(此处的接口可以理解为某些访问私有属性的方法如JavaBean中的属性以及对应的getter和setter方法)即可访问类的成员。此时如果类中...
  • 什么是上转型对象及其基本特征

    千次阅读 2020-12-15 18:44:38
    上转型对象---子类对象赋值给父类变量。 例如: package com.wangxing.test1; //父类 public class Person { public void testPerson() { System.out.println("父类Person的实例方法"); } } package ...
  • 重写时可以修改访问权限修饰符和返回值,方法名和参数类型及个数都不可以修改;仅当返回值为类类型时,重写的方法才可以修改返回值类型,且必须是父类方法返回值的子类;要么就不修改,与父类返回值类型相同。那么,...
  • 1、里氏替换原则:任何基类(父类)可以出现的地方,子类一定可以出现(子类对象可以替换父类对象) 2、即父类类型的变量可以引用子类对象 如:Person st = new Student(); 3、extends关键字不翻译为继承,是指的正确...
  •   向上转型之后,父类引用变量只能调用父类中的属性和方法,不能访问子类独有的属性和方法。如果父类访问的方法是子类重写的方法,则访问重写之后的方法。   要求:在发生直接(间接)的继承(实现关系)的时候,才...
  • publicclassAthlete{privateShoesshoes;publicAthlete(Shoesshoes){this.shoes=shoes;}publicstaticvoidmain(String[]args){Shoesshoes=newSneaker();Athleteathlete1=newAthlete(sho...public class Athlete {priva...
  • 前文:C++之继承探究(四):继承的使用 把子类对象当作父类对象使用 ...   ——将子类对象传递给参数父类引用的函数;函数原型返回值类型为父类引用,而实际返回的是子类对象父类引用指向子类对象时,当通过父
  • Java继承中的转型及其内存分配看书的时候被一段代码能凌乱啦,代码是这样的:package 继承; abstract class People { public String tag = "疯狂Java讲义"; //① public String name = "Parent&...
  • 方法的多态
  • 首先是方法参数父类对象,传入子类对象是否可行然后引出Parentp=newChildren();这句代码不是很理解,google的过程中引出向上转型要理解向上转型又引出了动态绑定从动态绑定又引出了静态绑定程序绑定的概念:绑定...
  • 向上转型:子类对象转为父类父类可以是接口。公式:Father f = new Son();Father是父类或接口,son是子类。向下转型父类对象转为子类。公式:Son s = (Son)f;我们将形参设为父类Animal类型,当执行test.f(c)时,...
  • 在head first 设计模式中 用到了很多很多接口对象 首先澄清一个问题,就是接口不仅可以声明对象,...实际,当接口变量调用被类实现的接口中的方法时,就是通知相应的对象调用接口方法 直接代码 using System; usin
  • 对象的上转型对象有怎样的特点

    千次阅读 2019-12-24 14:46:49
    一、问答题 1.子类可以有多个父类吗? 答案:不可以 2.java.lang包中的Object类是所有其他类的祖先类吗? 答案:是 3.如果子类和父类不在同...答案:子类重写的方法类型和父类方法的类型一致或者是父类方法的...
  • 面向对象——上转型

    2018-02-19 21:23:36
    面向对象——转型 定义 父类声明,子类实例化的对象称为转型对象。...如果子类重写了父类的某个方法后,当对象的上转型对象调用这个方法时一定是调用了子类重写的方法。因为程序在运行时知道,这个转对象的...
  • JAVA中上转型对象的详细解释首先是方法参数父类对象,传入子类对象是否可行 然后引出Parentp=newChildren(); 这句代码不是很理解,google的过程中引出向上转型 要理解向上转型又引出了动态绑定 从动态绑定又引出...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,704
精华内容 13,481
关键字:

上转型对象调用父类的方法参数