精华内容
下载资源
问答
  • 反射之获得子类及其超类定义的属性和方法开心一笑快速成长 我大学刚毕业来这家公司面试的时候,老板语重心长的对我说:虽然薪水不多,但是你可以在这里获得快速的成长,这对年轻人来说是最重要的。现在,两年过去了...

    开心一笑

    快速成长
    我大学刚毕业来这家公司面试的时候,老板语重心长的对我说:虽然薪水不多,但是你可以在这里获得快速的成长,这对年轻人来说是最重要的。现在,两年过去了,老板没有骗我,我看起来已经像是40岁的人了

    视频教程

    大家好,我录制的视频《Java之优雅编程之道》已经在CSDN学院发布了,有兴趣的同学可以购买观看,相信大家一定会收获到很多知识的。谢谢大家的支持……

    视频地址:http://edu.csdn.net/lecturer/994

    自我介绍

    之所以写这篇文章,是因为今天在工作中确实碰到这个问题,才明白,要获得如果一个类继承其他类,要获得该类及其所有的超类的属性和方法,需要下面这么做:哈哈,语言太朴素…

    我的特长

    定义一个祖父类,有姓名和性别个属性:或许有些人到现在,也只能记住离开的祖父的姓名和性别吧!

    `` public class GrandFather {
    
        //姓名
        private String name;
        //性别
        private String sex;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        //干农活
        public void doFarmWork(){
            System.out.println("do do do ...simple life!");
        }
    }
    

    定义一个父亲类继承祖父

    /**
     * 描述:父亲
     * Created by Ay on 2016/3/17.
     */
    class Father extends GrandFather {
    
        private String age;
        private String address;
        private String phone;
    
        public String getAge() {
            return age;
        }
    
        public void setAge(String age) {
            this.age = age;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        public String getPhone() {
            return phone;
        }
    
        public void setPhone(String phone) {
            this.phone = phone;
        }
    }
    

    最后定义一个儿子类:

    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    import java.util.*;
    
    /**
     * 描述:儿子
     * Created by Ay on 2016/3/17.
     */
    public class Son extends Father {
    
    //身高
    private float height;
    //体重
    private float weight;
    
    public void play(){
        System.out.println("play play......");
    }
    
    public float getHeight() {
        return height;
    }
    
    public void setHeight(float height) {
        this.height = height;
    }
    
    public float getWeight() {
        return weight;
    }
    
    public void setWeight(float weight) {
        this.weight = weight;
    }
    
    /**
     * 测试
     * @param args
     */
    public static void main(String[] args){
        Son student = new Son( );
        // 获取属性
        Map<String,Field> map = getClassFields (student.getClass ( ),true );
        for ( Object key : map.keySet ( ) ){
            System.out.println ( "<field=" + key.toString ( ) + "> <Type=" + map.get ( key ) + ">" );
        }
        // 获取方法
        List< Method > methods = getMothds ( student.getClass ( ), true );
        for ( Method method : methods ){
            System.out.println ( method.getName ( ) );
        }
        System.out.println ( "方法总数:" + methods.size ( ) );
    }
    
    /**
     * 获取类实例的属性值
     * @param clazz
     *            类名
     * @param includeParentClass
     *            是否包括父类的属性值
     * @return 类名.属性名=属性类型
     */
    public static Map<String,Field> getClassFields(Class clazz,boolean includeParentClass ){
        Map<String,Field> map = new HashMap<String,Field>();
        //返回Class 对象所表示的类或接口的指定已声明字段
        Field[] fields = clazz.getDeclaredFields();
        for(Field field:fields){
            //将字段名作为key,field作为value
            map.put(field.getName(),field);
        }
        if (includeParentClass){
            //clazz.getSuperclass()
            // 返回表示此 Class 所表示的实体(类、接口、基本类型或 void)的超类的 Class
            getParentClassFields(map,clazz.getSuperclass());
        }
        return map;
    }
    
    /**
     * 获取类实例的父类的属性值
     * @param map
     *            类实例的属性值Map
     * @param clazz
     *            类名
     * @return 类名.属性名=属性类型
     */
    private static Map<String,Field> getParentClassFields(Map<String,Field> map, Class clazz){
        Field[] fields = clazz.getDeclaredFields ();
        for(Field field:fields){
            map.put (field.getName(),field);
        }
        if(clazz.getSuperclass() == null){
            return map;
        }
        //不断调用getParentClassFields(),知道没有父类为止
        getParentClassFields(map,clazz.getSuperclass());
        return map;
    }
    
    /**
     * 获取类实例的方法
     * @param clazz
     *            类名
     * @param includeParentClass
     *            是否包括父类的方法
     * @return List
     */
    public static List<Method>getMothds (Class clazz, boolean includeParentClass )
    {
        List<Method> list = new ArrayList< Method >();
        Method[] methods = clazz.getDeclaredMethods ();
        for (Method method : methods){
            list.add (method);
        }
        if (includeParentClass){
            getParentClassMothds (list,clazz.getSuperclass());
        }
        return list;
    }
    
    /**
     * 获取类实例的父类的方法
     * @param list
     *            类实例的方法List
     * @param clazz
     *            类名
     * @return List
     */
    private static List<Method> getParentClassMothds(List<Method> list, Class clazz){
        Method[] methods = clazz.getDeclaredMethods();
        for(Method method : methods){
            list.add(method);
        }
        if(clazz.getSuperclass() == Object.class){
            return list;
        }
        getParentClassMothds(list,clazz.getSuperclass());
        return list;
    }
    
    }
    

    感悟

    • 最近太忙,说好的要坚持写博客,可就是因其他琐事给占用了,但会坚持写下去,自己说过的承诺,就应该去履行
    • 最近发生太多事,渐渐的才明白自己太弱了,但是时刻提醒自己,坚强点,懦弱给谁看……
    • 成长需要慢慢积累,我只是一个还未入门的程序员,很多内容都有借鉴高手的,人生就是这样,先模仿别人,慢慢的有自己的想法,就可以创造出新的事物…..

    晚安

    展开全文
  • Java中,当子类超类继承时,称为“扩展”超类。 我的子类可以继承许多超类吗? ( Can My Subclass Inherit From Many Superclasses? ) No. In Java, a subclass can only extend one superclass. 不可以。在...

    java父类子类继承

    An important concept in object-oriented programming is inheritance. It provides a way for objects to define relationships with each other. As the name suggests, an object is able to inherit characteristics from another object.

    面向对象编程中的一个重要概念是继承。 它为对象提供了一种定义彼此之间关系的方法。 顾名思义,一个对象能够从另一个对象继承特征。

    In more concrete terms, an object is able to pass on its state and behaviors to its children. For inheritance to work, the objects need to have characteristics in common with each other.

    更具体而言,对象能够将其状态和行为传递给子对象。 为了使继承起作用,对象需要具有彼此相同的特征。

    In Java, classes can be taken from other classes, which can be taken from others, and so on. This is because they can inherit features from the class above it, all the way up to the topmost Object class.

    Java中 ,可以从其他类中获取类,而从其他类中获取类,依此类推。 这是因为它们可以从其上方的类继承功能,一直到最顶层的Object类。

    Java继承的示例 ( An Example of Java Inheritance )

    Let's say we make a class called Human that represents our physical characteristics. It's a generic class that could represent you, me, or anyone in the world. Its state keeps track of things like the number of legs, number of arms, and blood type. It has behaviors like eat, sleep, and walk.

    假设我们制作了一个名为Human的类,它代表了我们的身体特征。 这是一个通用类,可以代表您,我或世界上任何人。 它的状态跟踪腿数,臂数和血型等信息。 它具有饮食,睡眠和散步等行为。

    Human is good for getting an overall sense of what makes us all the same but it can't, for instance, tell me about gender differences. For that, we'd need to make two new class types called Man and Woman. The state and behaviors of these two classes will differ from each other in a lot of ways except for the ones that they inherit from Human.

    人类有利于全面了解使我们保持一致的原因,但是例如,它不能告诉我性别差异。 为此,我们需要创建两个新的类类型,分别称为Man和Woman。 这两个类的状态和行为将在很多方面彼此不同,除了它们是从人类继承的。

    Therefore, inheritance allows us to encompass the parent class' state and behaviors into its child. The child class can then extend the state and behaviors to reflect the differences it represents. The most important aspect of this concept to remember is that the child class is a more specialized version of the parent.

    因此,继承使我们能够将父类的状态和行为包含在其子类中。 然后,子类可以扩展状态和行为以反映其表示的差异。 要记住的这一概念的最重要方面是,子类是父类的更专门的版本。

    什么是超类? ( What's a Superclass? )

    In the relationship between two objects, a superclass is the name given to the class that is being inherited from. It sounds like a super duper class, but remember that it's the more generic version. Better names to use might be base class or simply parent class.

    在两个对象之间的关系中,超类是给继承自该类的名称。 听起来像是超级duper类,但请记住,它是更通用的版本。 使用更好的名称可能是基类或简单的父类。

    To take a more real-world example this time, we could have a superclass called Person. Its state holds the person's name, address, height, and weight, and has behaviors like go shopping, make the bed, and watch TV.

    这次以更真实的示例为例,我们可以有一个称为Person的超类。 它的状态包含该人的姓名,地址,身高和体重,并且具有诸如逛街,铺床和看电视的行为。

    We could make two new classes that inherit from Person called Student and Worker. They are more specialized versions because although they have names, addresses, watch TV, and go shopping, they also have characteristics that are different from each other.

    我们可以创建两个继承自Person的新类,称为Student和Worker。 它们是更专业的版本,因为尽管它们具有名称,地址,看电视和购物,但它们也具有彼此不同的特征。

    Worker could have a state that holds a job title and place of employment whereas Student might hold data on an area of study and an institution of learning.

    工人可能拥有一个拥有职务和工作地点的州,而学生可能拥有一个研究领域和一个学习机构的数据。

    超类示例: ( Superclass Example: )

    Imagine you define a Person class:

    假设您定义了一个Person类:

    public class Person
    {
    }

    A new class can be created by extending this class:

    可以通过扩展此类来创建一个新类:

    public class Employee extends Person
    {
    }

    The Person class is said to be the superclass of the Employee class.

    据说Person类是Employee类的超类。

    什么是子类? ( What's a Subclass? )

    In the relationship between two objects, a subclass is the name given to the class that is inheriting from the superclass. Although it sounds a little drabber, remember that it's a more specialized version of the superclass.

    在两个对象之间的关系中,子类是赋予从超类继承的类的名称。 尽管听起来有些傻瓜,但请记住,它是超类的一个更专业的版本。

    In the previous example, Student and Worker are the subclasses.

    在前面的示例中,Student和Worker是子类。

    Subclasses can also be known as derived classes, child classes, or extended classes.

    子类也可以称为派生类,子类或扩展类。

    我可以拥有几个子类? ( How Many Subclasses Can I Have? )

    You can have as many subclasses as you want. There is no limitation to how many subclasses a superclass can have. Likewise, there isn't a limitation on the number of levels of inheritance. A hierarchy of classes can be built upon a certain area of commonality.

    您可以根据需要拥有任意多个子类。 对于超类可以具有多少个子类没有限制。 同样,继承级别的数量也没有限制。 类的层次结构可以建立在特定的公共领域上。

    In fact, if you look at the Java API libraries you will see many examples of inheritance. Every class in the APIs is inherited from a class called java.lang.Object. For example, any time you use a JFrame object, you're at the end of a long line of inheritance:

    实际上,如果您查看Java API库,将会看到许多继承示例。 API中的每个类均继承自名为java.lang.Object的类。 例如,每当您使用JFrame对象时,您就处于一长串继承的末尾:

    java.lang.Object
    extended by java.awt.Component
    extended by java.awt.Container
    extended by java.awt.Window
    extended by java.awt.Frame
    extended by javax.swing.JFrame

    In Java, when a subclass inherits from a superclass, it's known as "extending" the superclass.

    在Java中,当子类从超类继承时,称为“扩展”超类。

    我的子类可以继承许多超类吗? ( Can My Subclass Inherit From Many Superclasses? )

    No. In Java, a subclass can only extend one superclass.

    不可以。在Java中,子类只能扩展一个超类。

    为什么要使用继承? ( Why Use Inheritance? )

    Inheritance allows programmers to reuse code they've already written. In the Human class example, we don't need to create new fields in the Man and Woman class to hold the blood type because we can use the one inherited from the Human class.

    继承允许程序员重用他们已经编写的代码。 在“人类”类示例中,我们不需要在“男人”和“女人”类中创建新字段来保存血液类型,因为我们可以使用从“人类”类继承的字段。

    Another benefit of using inheritance is that it lets us treat a subclass as if it was a superclass. For example, let's say a program has created multiple instances of the Man and Woman objects. The program might need to call the sleep behavior for all these objects. Because the sleep behavior is a behavior of the Human superclass, we can group all the Man and Woman objects together and treat them as if they were Human objects.

    使用继承的另一个好处是,它使我们可以将子类视为超类。 例如,假设一个程序创建了Man和Woman对象的多个实例。 该程序可能需要调用所有这些对象的睡眠行为。 因为睡眠行为是人类超类的行为,所以我们可以将所有“男人”和“女人”对象组合在一起,并将它们视为“人类”对象。

    翻译自: https://www.thoughtco.com/what-is-inheritance-2034264

    java父类子类继承

    展开全文
  • 在真实的世界里,员工也可能会成为经理,所以你建模时可能希望经理也是员工,而不是员工的一个子类。不过,在例子中,假设公司只有两类人:一些人永远是员工,另一些人一直是经理。 Employee 类: import java.time....

    “is-a” 关系是继承的一个明显特征。

    注释: 我们使用员工和经理的例子,不过这个例子要有所保留。在真实的世界里,员工也可能会成为经理,所以你建模时可能希望经理也是员工,而不是员工的一个子类。不过,在例子中,假设公司只有两类人:一些人永远是员工,另一些人一直是经理。

    Employee 类:

    import java.time.LocalDate;
    import java.util.Objects;
    
    public class Employee {
        private String name;
        private double salary;
        private LocalDate hireDay;
    
        public Employee(String name, double salary, int year, int month, int day) {
            this.name = name;
            this.salary = salary;
            hireDay = LocalDate.of(year, month, day);
        }
    
        public String getName() {return name;}
    
        public double getSalary() {return salary;}
    
        public LocalDate getHireDay() {return hireDay;}
    
        public void raiseSalary(double byPercent) {
            double raise = salary * byPercent / 100;
            salary += raise;
        }
    
        @Override
        public String toString() {
            String str = "%s[name=%s, salary=%.2f, hireDay=%s]";
            return String.format(str, getClass(), name, this.getSalary(), hireDay);
        }
    }
    
    

    Manager 类:

    public class Manager extends Employee {
    
        private double bonus;
    
        public Manager(String name, double salary, int year, int month, int day) {
            super(name, salary, year, month, day);
            this.bonus = 0;
        }
    
        public void setBonus(double bonus) {
            this.bonus = bonus;
        }
    
        @Override
        public double getSalary() {
            double baseSalary = super.getSalary(); 
            return baseSalary + bonus;
        }
    }
    

    1. 定义子类

    继承 Employee 类来定义 Manager 类,使用关键字 extends 表示继承。

    public class Manager extends Employee {
        // added methods and fields
    }
    

    在 Java 中,所有的继承都是公共继承。

    关键字 extends 表明正在构造的新类派生于一个已存在的类。已存在的类称为超类(superclass)、基类(base class)或父类(parent class);新类称为子类(subclass)、派生类(derived class)或孩子类(child class)。超类和子类是 Java 程序员最常用的两个术语,而了解其他语言的程序员可能更加偏爱使用父类和孩子类,这可能很贴切地体现了“继承”。

    尽管 Employee 类是一个超类,但并不是因为它优于子类或者拥有比子类更多的功能。实际上恰恰相反,子类比超类拥有的功能更多。例如,读过 Manager 类的源代码之后就会发现,Manager 类比超类 Employee 封装了更多的数据,拥有更多的功能。

    注释: 前缀 “超”(super) 和 “子”(sub) 来源于计算机科学与数学理论中集合语言的术语。所有员工组成的集合包含所有经理组成的集合。可以这样说,员工集合是经理集合的超集,也可以说,经理集合是员工集合的子集。

    在 Manager 类中,增加了一个用于存储奖金信息的字段,以及一个用于设置这个字段的新方法 :

    public class Manager extends Employee
    {
        // 奖金
        private double bonus;
        ...
        public void setBonus(double bonus)
        {
            this.bonus = bonus;
        }
    }
    

    这里定义的方法和字段并没有什么特别之处。如果有一个 Manager 对象,就可以使用 setBonus 方法。

    Manager boss = ...;
    boss.setBonus(5000);
    

    由于 setBonus 方法不是在 Employee 类中定义的,所有属于 Employee 类的对象不能使用它。

    然而,尽管在 Manager 类中没有显式地定义 getName 和 getHireDay 等方法,但是可以对 Manager 对象使用这些方法,这是因为 Manager 类自动地继承了超类 Employee 中的这些方法。

    类似地,从超类中还继承了 name、salary 和 hireDay 这 3 个字段。这样一来,每个 Manager 对象就包含了 4 个字段:name、salary、hireDay 和 bonus。

    通过扩招超类定义子类的时候,只需要指出子类与超类的不同之处。因此在设计类的时候,应当将最一般的方法放在超类中,而将更特殊的方法放在子类中,这种将通用功能抽取到超类的做法在面向对象设计中十分普遍。

    2. 覆盖方法

    超类中的有些方法对子类 Manager 并不一定适用。具体来说,Manager 类中的 getSalary 方法应该返回薪水和奖金的总和。为此,需要提供一个新的方法覆盖(override)超类中的这个方法:

    public class Manager extends Employee {
        ...
        public dobule getSalary() {
            ...
        }    
    }
    

    应该如何实现这个方法呢?乍看起来似乎很简单,只要返回 salary 和 bonus 字段的总和就可以了:

    public double getSalary() {
        return salary + bonus; // 不能运行
    }
    

    不过,这样做是不行的。回想一下,只有 Employee 方法能直接访问 Employee 类的私有字段。这意味着,Manager 类的 getSalary 方法不能直接访问 salary 字段。如果 Manager 类的方法想要访问那些私有字段,就要像所有其他方法一样使用公共接口,在这里就是要使用 Employee 类中的公共方法 getSalary。

    现在,再试一下。你需要调用 getSalary 方法而不是直接访问 salary 字段:

    public double getSalary() {
        double baseSalary = getSalary(); // 仍然不能运行
        return baseSalary + bonus;
    }
    

    这段代码有问题。问题出现在调用 getSalary 的语句上,它只是在调用自身,这是因为 Manager 类也有一个 getSalary 方法,所以这条语句将会导致无限次调用自己,直到整个程序最终崩溃。

    这里需要指出:我们希望调用超类 Employee 中的 getSalary 方法,而不是当前类的这个方法。为此,可以使用特殊的关键字 super 解决这个问题:
    super.getSalary()
    这个语句调用的是 Employee 类中的 getSalary 方法。下面是 Manager 类中 getSalary 方法的正确版本:

    public double getSalary() {
        double baseSalary = super.getSalary();
        return baseSalary + bonus;
    }
    

    注释: 有些人认为 super 与 this 引用是类似的概念,实际上,这样比较并不太恰当。这是因为 super 不是一个对象的引用,例如,不能将值 super 赋给另一个对象变量,它只是一个指示编译器调用超类方法的特殊关键字。

    在子类中可以增加字段、增加方法或覆盖超类的方法,不过,继承绝对不会删除父类任何字段或方法。

    3. 子类构造器

    public Manager(String name, double salary, int year, int month, int day)
    {
        super(name, salary, year, month, day);
        bonus = 0;
    }
    

    这里的关键字 super 具有不同的含义。语句
    super(name, salary, year, month, day);
    是 “调用超类中含有 name、 salary、year、month 和 day 参数的构造器” 的简写形式。

    由于 Manager 类的构造器不能访问 Employee 类的私有字段,所以必须通过一个构造器来初始化这些私有字段。可以利用特殊的 super 语法调用这个构造器。使用 super 调用构造器的语句必须是子类构造器的第一条语句。

    如果子类的构造器没有显式地调用超类的构造器,将自动地调用超类的无参数构造器。如果超类没有无参数构造器,并且在子类的构造器中又没有显式地调用超类的其他构造器,则 Java 编译器将报告错误。

    this 关键字有两个含义:

    • 指示隐式参数的引用。
    • 调用该类的其他构造器。

    super 关键字有两个含义:

    • 调用超类的方法。
    • 调用超类的构造器。

    在调用构造器的时候,this 和 super 这两个关键字紧密相关。调用构造器的语句只能作为另一个构造器的第一条语句出现。构造器参数可以传递给当前类(this)的另一个构造器,也可以传递给超类(super)的构造器。

    重新定义 Manager 对象的 getSalary 方法之后,奖金将会自动添加到经理的薪水中。
    下面给出一个例子说明这个类的使用。我们要创建一个新经理,并设置他的奖金:

    Manager boss = new Manager("Carl Cracker", 75000, 1987, 12, 15);
    boss.setBonus(500000);
    

    下面定义一个包含 3 个员工的数组:
    Employee[] staff = new Employee[3];
    在数组中混合填入经理和员工:

    staff[0] = boss;
    staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
    staff[2] = new Employee("Tommy Tester", 40000, 1990, 3, 15);
    

    输出每个人的信息:

    for (Employee e : staff) {
        System.out.println(e);
    }
    

    运行这条循环语句将会输出下列数据:

    Carl Cracker 575000.0
    Harry Hacker 50000.0
    Tommy Tester 40000.0
    

    这里的 staff[1] 和 staff[2] 仅输出了基本薪水,这是因为它们是 Employee 对象,而 staff[0] 是一个 Manager 对象,它的 getSalary 方法会将奖金和基本薪水相加。
    需要提醒大家的是,以下调用
    e.getSalay()
    能够选出应该执行的正确 getSalary 方法。请注意,尽管这里将 e 声明为 Employee 类型,但实际上 e 即可以引用 Employee 类型的对象,也可以引用 Manager 类型的对象。

    当 e 应用 Employee 对象时,e.getSalary() 调用的是 Employee 类中的 getSalary 方法;当 e 引用 Manager 对象时,e.getSalary() 调用的是 Manager 类中的 getSalary 方法。虚拟机知道 e 实际引用的对象类型,因此能够正确地调用相应的方法。

    一个对象变量可以指示多种实际类型的现象被称为多态(polymorphism)。在运行时能够自动地选择调用哪个方法的现象称为动态绑定(dynamic binding)

    在 Java 中,动态绑定是默认的行为。如果不希望让一个方法虚拟的,可以将它标记为 final。

    4. 继承层次

    继承并不仅限于一个层次。例如,可以由 Manager 类派生 Executive 类。

    Employee 继承层次

    由一个公共超类派生出来的所有类的集合被称为***继承层次(inheritance hierarchy)***,在继承层次中,从某个特定的类到其祖先的路径称为该类的***继承链(inheritance chain)***。

    通常,一个祖先类可以拥有多个子孙继承链。例如,可以由 Employee 类派生出子类 Programmer 和 Secretary,它们与 Manager 类没有任何关系(它们彼此之间也没有任何关系)。必要的话,可以将这个过程一直延续下去。

    Java 不支持多重继承,但提供了一些类似多重继承的功能——接口。

    展开全文
  • java子类和基类中的字段相同时产生的问题

    千次阅读 热门讨论 2018-10-30 17:09:53
    *前言   最近重构代码时,总是遇到这样...  后来发现是因为子类中的有些字段在父类中已经有了,父类中有的字段子类再出现时,在idea中生成set和get方法就会自动加上@Override,刚开始小菜的猜想是子类和父类...

      最近重构代码时,总是遇到这样的问题:把之前的程序上的代码原模原样的复制到另一边的服务器上,唯一区别的就是多加了一层Dubbo,但是有些字段从service传回来的值在Controler总却获取不到。为什么呢?

      后来发现是因为子类中的有些字段在父类中已经有了,父类中有的字段在子类再出现时,在idea中生成set和get方法就会自动加上@Override,刚开始猜想是子类和父类都有的字段程序不知道获取哪个,所以是空的,直到今天在网上查了一些资料也发现了一些别的回答。下文就分享一下java子类和基类中的字段相同时产生的问题

      Controler里获取不到值就是因为子类和父类中出现了相同的字段,我觉得此时程序不知道获取哪个字段,如何解决呢?

      我们目前的办法是:父类里有的字段,子类就不要了,要不就把这个字段重新命名,以免出现不必要的异常。

    展开全文
  • 类、超类子类 在之前的Employee类中都是普通员工的工资,并没有经理工资。这里定义一个新的类Manager,并增加一些新的功能。但是可以重用Employee类中已经编写的部分代码,并保留Employee类中的所有字段子类 ...
  • Java基础知识查漏补缺(Java核心技术)----继承知识点1 子类访问父类字段。知识点2 子类构造器 知识点1 子类访问父类字段。 尽管子类拥有父类的所有字段和方法,但是子类中的方法不能直接访问父类中的私有字段,...
  • 文章目录1、父类与子类2、覆盖方法3、子类构造器4、this和super5、多态6、方法调用的过程7、阻止继承:final类和方法8、强制类型转换9、抽象类10、受保护访问11、四种访问控制符参考 1、父类与子类 一个简单规则...
  • 一个子类只能继承其父类的可访问的成员,并且该子类没有覆盖或者说隐藏父类中的那些可访问成员。 所以,一个类的成员就是指在这个类中所声明的属性和方法,再加上从其父类继承而来的属性和方法。也就是说,*子类是...
  • public class Manager extends Employee(){ //奖金 private double bouns; ....... public void setBouns(double bouns){ ...代码表示Manager类继承Employee类,Manager类称为子类,Employee称为父类。 .
  • * 获取类型的所有字段属性,能够获取到类型的超类字段属性 * * @param classOwner 类型 * @param containJavaClass 是否检索Java类型 * @param errcode [out]错误信息返回 * @return 类型及其超类的...
  • Java中protected字段可以被同包的类访问子类通过继承,可以在自己类中访问自己的protected字段,但是不能访问异包类的protected字段。 示例说明如下: Person是被用来继承的超类;WPerson是与Person同包、继承...
  • Java所有类的超类Object

    2020-02-25 00:21:38
    Object类是Java中所有类的始祖,在Java中每个类都是由它扩展而来的。 如果没有明确指出超类,Object被默认是这个类的超类。 Object的用途 可以使用Object类型的变量引用任何类型的变量 public void demo() { Object...
  • 子类的构造器不能访问超类的私有字段,故必须通过一个构造器来初始化这些私有片段 使用super调用构造器的语句必须是子类构造器的第一条语句 若子类构造器未显式调用超类的构造器,将自动调用超类的无参数构造
  • 5.1 类,超类,以及子类 让我们回到上一章讨论的Employee类。假设你在一家公司工作,在那里经理的待遇不同于其他员工。当然,经理在很多方面都和员工一样。员工和经理都有薪水。然而,虽然员工被期望完成他们分配的...
  • 子类继承父类 当我们在父类和子类中创建一个具有相同名称的变量,并尝试使用持有子类对象的父类引用访问它时,我们会得到什么? 为了理解这一点,让我们考虑下面的示例,其中在Parent和Child类中声明一个具有相同...
  • 有时候可能希望限制超类中的某个方法只允许子类访问,或者允许子类的方法访问超类的某个字段。需要将这些类方法或字段声明为受保护(protected)。例如,如果将超类 Employee 中的 hireDay 字段声明为 protected,而...
  • 当我们在父类和子类中创建一个具有相同名称的变量,并尝试使用持有子类对象的父类引用访问它时,我们会得到什么? 为了理解这一点,让我们考虑下面的示例,在该示例中,我们在Parent和Child类中都声明了一个具有...
  • JAVA覆盖和隐藏超类中的方法

    千次阅读 2013-07-07 21:48:56
     当一个子类中的一个实例方法具有与其超类中的一个实例方式相同的签名(即方法名、参数个数和类型)和返回值时,称子类中的方法"重写"或"覆盖"了超类的方法.  示例:   // 父类A class A{ //表示问
  • 5.1 类、超类子类

    2021-04-24 09:29:15
    文章目录5.1 类、超类子类5.1.1 定义子类5.1.2 覆盖方法5.1.3 子类构造器5.1.4 继承层次5.1.5 多态5.1.6 理解方法调用 5.1 类、超类子类 现在让我们回忆一下在前一章讨论过的Employee类。假设你在某个公司工作,...
  • Object类是Java中所有类的始祖,在Java中每个类都扩展了Object。 Object类型的变量 可以使用Object类型的变量引用任何类型的对象: Object obj = new Employee("Q",35000); 当然,Object类型的变量只能用于作为各种...
  • 当我们在父类和子类中创建一个具有相同名称的变量,并尝试使用持有子类对象的父类引用访问它时,我们会得到什么? 为了理解这一点,让我们考虑下面的示例,其中在Parent和Child类中声明一个具有相同名称的变量x 。...
  • Java中的继承和子类

    2020-04-14 16:53:10
    java中子类的定义是在继承中提到的:...子类从其超类继承所有成员(字段、方法和嵌套类)。构造函数不是成员,不能够被继承,但可以从子类中调用超类的构造函数(eg. super(…))。 子类的调试不需要再调试超类中...
  • JAVA继承

    2017-04-05 18:21:21
    继承 ...子类拥有超类字段和方法,同时子类也可以添加自己的字段和方法,因此子类比超类会更加具体,表示更加专门化的对象组。子类能够体现出超类的行为,同时子类可以改变这些行为,使得他们能够适
  • 如果子类与父类有相同的字段,则子类中的字段会代替或隐藏父类的字段子类方法中访问的是子类中的字段(而不是父类中的字段)。如果子类方法确实想访问父类中被隐藏的同名字段,可以用super关...
  • java对象序列化去掉字段 假设您正在开发一个将对象自动保存到数据库中的框架。 您需要检测两次保存之间所做的更改,以便仅保存已修改的字段。 如何检测脏场。 最简单的方法是遍历原始数据和当前数据,并分别比较每...
  • 本小节详细介绍了 Java 访问修饰符。...这意味着一个类、它的函数、字段只能被同一模块中的其他类访问。 顺便说一下,Java 中主要有四种类型的访问修饰符。让我们在示例的帮助下详细讨论它们中的每一个。
  • 一个子类只能继承其父类的可访问的成员,并且该子类没有覆盖或者说隐藏父类中的那些可访问成员。所以,一个类的成员就是指在这个类中所声明的属性和方法,再加上从其父类继承而来的属性和方法。也就是说,*子类是不...
  • 子类重写超类的方法时,子类该方法的被访问权限不能低于超类方法。如果超类方法为 public,则相应的被重写的子类方法也要为 public。即子类重写方法的访问权限不能缩小。 当子类重写超类的方法时,子类该方法中...
  • 文章目录前言特性中的继承访问控制符成员访问控制符private默认protectedpublic类的访问控制符非访问控制符static静态域静态方法finalfinal类final方法final字段和局部变量main()方法 你好,我是goldsun。 你有想法...
  • Java访问控制修饰符的作用范围详解和示例——Java学习 1. public —— 对外部完全可见 2. protected —— 对本包和所有子类可见 3. 默认(不需要修饰符)—— 对本包可见 4. private —— 仅对本类可见

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,786
精华内容 5,914
关键字:

java子类访问超类字段

java 订阅