精华内容
下载资源
问答
  • 主要介绍了Java父类调用子类的方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 子类: public class User implements Serializable { private String name; private Integer age; private String address; private BigDecimal balance; private Date createTime; public String ...

    子类:

    public class User implements Serializable {
    
        private String name;
    
        private Integer age;
    
        private String address;
    
        private BigDecimal balance;
    
        private Date createTime;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        public BigDecimal getBalance() {
            return balance;
        }
    
        public void setBalance(BigDecimal balance) {
            this.balance = balance;
        }
    
        public Date getCreateTime() {
            return createTime;
        }
    
        public void setCreateTime(Date createTime) {
            this.createTime = createTime;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", address='" + address + '\'' +
                    ", balance=" + balance +
                    ", createTime=" + createTime +
                    '}';
        }
    }

    父类:

    public class UserVO extends User implements Serializable {
        /**
         * 电话号码
         */
        private String phone;
    
        public String getPhone() {
            return phone;
        }
    
        public void setPhone(String phone) {
            this.phone = phone;
        }
        
    }

    深克隆案例:

    public class CopyUtils {
        public static void main(String[] args) throws IOException, ClassNotFoundException {
            UserVO userVO = new UserVO();
            userVO.setPhone("110");
            userVO.setAddress("中国");
            userVO.setAge(5000);
            userVO.setName("上海");
            User user = (User) clone2(userVO);
            System.out.println(user.toString());
        }
        public static Object clone2(Object o) throws ClassNotFoundException, IOException {
            //将对象写入流中
            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(outputStream);
            oos.writeObject(o);
    
            //将对象从流中去取
            ByteArrayInputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(inputStream);
            return ois.readObject();
        }
    }

     

    展开全文
  • 主要介绍了Java父类子类之间的转换操作,结合实例形式分析了Java父类子类之间的转换相关原理、操作技巧与使用注意事项,需要的朋友可以参考下
  • java 父类对象赋值给子类

    千次阅读 2019-12-14 16:36:56
    方式一: private void fatherToChild(Object father, Object child) { if (!(child.getClass().getSuperclass() == father.getClass())) { ... throw new Exception(child + "不是" + father + "的子类"); ...

    方式一:

    private void fatherToChild(Object father, Object child) {
    	if (!(child.getClass().getSuperclass() == father.getClass())) {
        	try {
            	throw new Exception(child + "不是" + father + "的子类");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        Class fatherClass = father.getClass();
        Field[] fatherClassDeclaredFields = fatherClass.getDeclaredFields();
        for (Field tmpField : fatherClassDeclaredFields) {
        	Method method = null;
            try {
            	method = fatherClass.getMethod("get" + upperHeadChar(tmpField.getName()));
                Object invoke = method.invoke(father);
                tmpField.set(child, invoke);
            } catch (Exception e) {
                e.printStackTrace();
            }
    	}
    }
    
     /**
      * 首字母大写
      *
      * @param name
      * @return
      */
    private String upperHeadChar(String name) {
    	String head = name.substring(0, 1);
        return head.toUpperCase() + name.substring(1, name.length());
    }
    

    方式二:

    setter 方式一个一个进行赋值

    展开全文
  • 子类 public class UserInfo implements Serializable { private static final long serialVersionUID = 5359479211352456087L; /** * 主键 */ @Id @Column(name = "user_id") priv...

     子类

    public class UserInfo  implements Serializable {
    
        private static final long serialVersionUID = 5359479211352456087L;
    
        /**
         * 主键
         */
        @Id
        @Column(name = "user_id")
        private String userId;
    
        /**
         * 用户名
         */
        @Column(name = "user_name")
        private String userName;
    
        /**
         * 手机号
         */
        @Column(name = "user_phone")
        private String userPhone;
    
        /**
         * 角色
         */
        @Column(name = "user_role")
        private String userRole;
    
        /**
         * 性别
         */
        @Column(name = "user_sex")
        private String userSex;
    
        /**
         * 头像
         */
        @Column(name = "user_face")
        private String userFace;
    
    省略GETER/SETER
    }

    父类

    public class User implements Serializable {
    
        private static final long serialVersionUID = 5359479211352400087L;
    
        /**
         * 主键
         */
        @Id
        @Column(name = "user_id")
        private String userId;
    
        /**
         * 用户名
         */
        @Column(name = "user_name")
        private String userName;
    
        /**
         * 手机号
         */
        @Column(name = "user_phone")
        private String userPhone;
    
        /**
         * 密码
         */
        @Column(name = "user_password")
        private String userPassword;
    
        /**
         * 角色
         */
        @Column(name = "user_role")
        private String userRole;
    
        /**
         * 性别
         */
        @Column(name = "user_sex")
        private String userSex;
    
        /**
         * 头像
         */
        @Column(name = "user_face")
        private String userFace;
    
        /**
         * 密保问题
         */
        private String question;
    
        /**
         * 答案
         */
        private String answer;
    
        /**
         * 是否被锁
         */
        @Column(name = "bol_lock")
        private Short bolLock;
    
        /**
         * 是否被删除
         */
        @Column(name = "bol_delete")
        private Short bolDelete;
    
        /**
         * 是否别禁言
         */
        @Column(name = "bol_banned_speak")
        private Short bolBannedSpeak;
    
        /**
         * 最后登录时间
         */
        @Column(name = "last_login_time")
        private Date lastLoginTime;
    
        /**
         * 新建日期
         */
        @Column(name = "create_data")
        private Date createData;
    
        /**
         * 修改日期
         */
        @Column(name = "modify_data")
        private Date modifyData;
    }

     

     复制属性方法

    import cn.hutool.core.bean.BeanUtil;
    import com.example.bise.system.model.user.User;
    import com.example.bise.system.model.user.UserInfo;
    import java.beans.PropertyDescriptor;
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationTargetException;
    
      /**
         * 父类属性传值到子类上
         * @param out 输出目标子类
         * @param oClazz 子类Class类型
         * @param in 输入父类
         * @param iClass 父类Class类型
         * @return 返回Object子类
         */
        public static  <T1,T2> T1 copy(T1 out, Class<?> oClazz, T2 in, Class<?> iClass) {
            // 获取子类成员变量描述
            PropertyDescriptor[] propertyOut = BeanUtil.getPropertyDescriptors(oClazz);
            // 获取父类属成员变量描述
            PropertyDescriptor[] propertyIn = BeanUtil.getPropertyDescriptors(iClass);
            try {
                // 遍历子类属性名
                for (int i = 0; i < propertyOut.length; i++) {
                    String name = propertyOut[i].getName();
                    // 遍历父类属性名
                    for (int j = 0; j < propertyIn.length; j++) {
                        // 对比父子属性名,相同就进入
                        if (name.equals(propertyIn[j].getName())) {
                            // 获取父类该字段类型
                            Field field = in.getClass().getDeclaredField(name);
                            // 开启私有成员可读取
                            field.setAccessible(true);
                            // 获取属性值
                            Object o = field.get(in);
                            if (o != null) {
                                // 赋值给子类
                                Field field2 = out.getClass().getDeclaredField(name);
                                field2.setAccessible(true);
                                field2.set(out, o);
                            }
                        }
                    }
                }
            } catch (Exception e) {
                e.fillInStackTrace();
            }
            return out;
        }

    这里用到了【Hutool】的bean工具集。 maven坐标如下,官网Hutool文档

    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
        <version>5.1.2</version>
    </dependency>

    就这样调用

        public static void main(String[] args) {
            User user = new User();
            user.setUserId("234234");
            user.setUserName("asd");
            user.setUserPassword("13423432432");
            user.setUserPhone("131654848464");
    
            UserInfo info1 = copy(new UserInfo(), UserInfo.class, user, User.class);
            System.out.println(info1.toString());
        }

    输出结果如下

    UserInfo{userId='234234', userName='asd', userPhone='131654848464', userRole='null', userSex='null', userFace='null'} 

    java小白自己想的代码,如有改进请大家提出!

     

    展开全文
  • 父类获取子类属性

    2019-04-05 01:17:00
    NULL 博文链接:https://2528.iteye.com/blog/1523901
  • Java父类怎么调用子类的方法?

    万次阅读 多人点赞 2019-04-09 18:06:53
    把子类传递到父类的有参构造中,然后调用。● 使用反射的方式调用,你使用了反射还有谁不能调用的?! ● 父类调用子类的静态方法。 案例展示: package com.ywq; public class Test2{ public static ...

    父类能调用子类的方法吗?

    答:能。

    怎么做?

    ● 把子类传递到父类的有参构造中,然后调用。
    ● 使用反射的方式调用,你使用了反射还有谁不能调用的?!
    ● 父类调用子类的静态方法。

    案例展示:

    package com.ywq;
     
     
     
    public class Test2{	
    	public static void main(String[] args)
    	{
    		Son son = new Son();
    		Father father=new Father(son);
    		father.fun1();
    		father.fun4();
    	}	
    }
    class Father{
    	public Son son;
    	public Father(Son son){		
    		this.son=son;
    	}	
    	public Father() {
    		
    	}
     
    	public void fun4(){
    		//方法3:使用反射的方式调用子类方法
    		try {
    			Class cls=Class.forName("com.ywq.Son");
    			Son son=(Son) cls.newInstance();
    			son.fun2();
    		} catch (Exception e) {
    		
    			e.printStackTrace();
    		}
    	}
    	public void fun1(){
    		//方法1:把子类传递到父类的有参构造函数中,然后调用。
    		System.out.println("我是父类的方法");
    		son.fun2();
    		
    		//方法2:父类调用子类的静态方法。
    		Son.fun3();
    	}		
    }
     
    class Son extends Father{
    	
    	public static void fun3(){
    		System.out.println("我是子类的静态方法");
    	}
    	public void fun2(){
    		System.out.println("我是子类的方法");
    		
    	}
    	
    }

    这三种都是父类直接调用子类的方法,

          好用不?好用!

          解决问题了吗?解决了!

          项目中允许使用不?不允许!

    我就一直没有搞懂为什么要用父类调用子类的方法。如果一定要调用子类,那为什么要继承它呢?搞不懂。其实这个问题可以换个角度去理解,父类建立框架,子类在重写了父类部分的方法后,再调用从父类继承的方法,产生不同的结果(而这正是模板方法模式)。这是不是也可以理解为父类调用了子类的方法呢?你修改了子类,影响了父类行为的结果,曲线救国的方式实现了父类依赖子类的场景,模板方法模式就是这种效果。

    ---------------------
    作者:温柔狠角色
    原文:https://blog.csdn.net/qq_25827845/article/details/52916513

    展开全文
  • 父类对象属性赋值给子类对象 org.springframework.beans.BeanUtils.copyProperties(父类对象,子类对象);
  • 把父类的属性赋值给子类

    千次阅读 2020-03-25 11:28:40
    package ... import java.lang.reflect.Field; import java.lang.reflect.Method; /** * @Author: lc * @Date: 2020/3/25 9:53 */ public class Subclas...
  • java 子类对象赋值给父类对象的使用,包括代码及详解,个人笔记
  • Java父类引用指向子类实例对象

    千次阅读 2019-01-14 19:57:06
    版权声明:欢迎转载,交流共享,转载请注明出处!如若转载请贴上此链接(山里...知识点: 1、java父类引用指向子类对象时动态绑定针对的只是子类重写的成员方法; 2、父类引用指向子类对象时,子类如果重写了父...
  • Java之所以引入多态的概念:原因之一是它在类的继承问题上和C++不同,后者允许多继承,这确实其带来的非常强大的功能,但是同时复杂的继承关系也C++开发者带来了更大的麻烦,为了规避风险, 在Java中只允许单继承...
  • Java多态 父类引用指向子类对象

    万次阅读 多人点赞 2018-04-23 00:26:28
    Java多态的三个必要条件: ...2、 子类重写父类方法 3、 父类引用指向子类对象 然后看一个例子 输出结果为: 出结论:Father c = new Child() 在c的眼里只能看到 child
  • 在本篇文章里小编大家整理了关于java子类调用父类的方法中包含子类重写的实例方法以及相关知识点,需要的朋友们可以学习下。
  • 不贴代码,纯理论,读不懂的多读几遍,实在不理解我也没办法 平时我们的接口调用,其实就是...实现步骤:我们把子类的setName方法用接口定义。​​ 然后定义一个抽象的父类父类 Implement 接口,但不给予具体的实现
  • 父类能调用子类的方法吗?...● 把子类传递到父类的有参构造中,然后调用。 ● 使用反射的方式调用,你使用了反射还有谁不能调用的?! ● 父类调用子类的静态方法。 package study; /** * Cr
  • Java父类引用指向子类对象

    千次阅读 2018-07-12 17:06:54
    JAVA 通过父类对象new 子类对象,这个对象的声明的类型就是父类的类型,调用这个对象的方法也只能是父类型的方法,子类独有的方法是不能够被使用的。例如 List alist =new ArrayList&lt;&gt;();//只能用...
  • JAVA父类引用指向子类对象

    万次阅读 多人点赞 2018-07-24 21:07:31
    Java之所以引入多态的概念,原因之一就它在类的继承上的问题和C++不同,后者允许多继承,这确实其带来了非常强大的功能,但是复杂的继承关系也C++开发者带来了更大的麻烦,为了规避风险,Java只允许单继承,势必在功能...
  • java父类声明new子类对象 和子类声明new子类对象

    千次阅读 多人点赞 2018-04-28 16:26:01
    父类名 a = new 子类名()子类名 b = new 子类名()a只能调用父类的函数,不能调用子类的函数,因为它没有继承b可以调用父类的函数也可以调用子类的函数但是对构造函数的执行上二者是没有区别的。...
  • java父类声明子类实例化

    千次阅读 多人点赞 2020-11-01 19:31:25
    父类:Father ,子类 Child extends Father。在使用时候,这样写: Father child==new Child(); 这样看来,声明的时候,是父类,而在产生对象的时候,实际的对象是子类。怎么理解??? 知识点: Java的多态性 ...
  • Java父子对象属性赋值问题:现有父类Father类,子类Son类继承于Father类,现要求将父类对象的属性全部赋予给子类,如果通过子类对象.set(父类对象.get属性),那势必相当麻烦。 那么,有没有更加方便的API呢?...
  • 主要介绍了Java编程关于子类重写父类方法问题的理解,分享了有关子类重写父类的实例,具有一定参考价值,需要的朋友可以了解下。
  • java父类获取子类对象、调用子类方法

    万次阅读 多人点赞 2020-01-17 14:24:39
    1.Java父类能调用子类的方法吗? 答案:能 1.1 实现方式描述 (1)父类中的抽象方法让子类实现并返回 (2)通过注册监听,然后通过回调接口调用子类相关方法 (3)在父类中通过反射调用子类的相关方法 (4)在...
  • java父类子类的关系以及使用

    万次阅读 多人点赞 2018-03-15 20:45:25
    java中规定:一个父类可以有多个子类,但是一个子类只能有一个父类子类可以通过extends关键字来继承父类。做个比较通俗的比喻,就像一个父亲可以有多个亲孩子,但是一个孩子只能有一个亲生父亲。1.继承以及重写...
  • 本篇文章是对Java父类子类的加载顺序进行了详细的分析介绍,需要的朋友参考下
  • Java父类引用指向子类对象好处

    千次阅读 2019-09-09 04:22:45
    父类引用指向子类对象的好处: 好处一:降低代码耦合度,让程序员关注业务的时候,更加关注父类能做什么,而不去关心若干个子类具体是怎么做的 如果我需要实现两个方法:喂猫和喂狗  feed(Cat cat){ ....
  • 多态 父类的引用可以调用子类中重写的父类的方法,但不能调用子类中独有的方法,即不能调用父类中不存在,子类中存在的方法。
  • 在做网站开发的时候我们都会写一个控制器,控制器的作用就是接收客户端的请求,有时候为了控制访问入口的唯一性,方便我们监控用户访问的数据;...1.定义一个抽象类作为所有控制器的父类 package thread; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 374,541
精华内容 149,816
关键字:

java把父类值给子类

java 订阅