精华内容
下载资源
问答
  • 2018-11-02 16:54:53

    1、父类中staitic修饰的静态方法,不能覆盖、不能继承。

    2、父类中staitic修饰的变量或常量,能覆盖、不能继承。

            static修饰的变量和方法,只属于类本身,不属于对象;当声明一个对象时,并不产生static变量和方法的拷贝。也就是说,用static修饰的变量和方法在类加载的时候,会分配一块存储空间,所有此类的对象都可以操控此块存储空间;

            注意:当子类没有与父类同名的static变量(或方法时),子类的对象也可操控这块内存空间。但是,子类并没有继承父类中static修饰的变量和方法。这是因为static修饰的变量和方法是属于父类本身的。

    3、父类中final修饰的方法,不能覆盖,但可继承。

    代码示例:

    package com.jdk;
    
    /**
     * Created by Liuxd on 2018-11-02.
     */
    public class TestExtendsClass {
        public static void main(String[] args) {
            ParentClass parentClass = new ChildClass();
            System.out.println();
    
            int pFResult = ParentClass.plus(3,2);
            int pResult = ParentClass.add(3,2);
            int cResult = ChildClass.add(3,2);
    
            int pMResult = parentClass.minus(2,3);
    
            System.out.println("父类静final方法计算结果:" + pFResult);
            System.out.println("父类静方法计算结果:" + pResult);
            System.out.println("子类静方法计算结果:" + cResult);
            System.out.println("父类final方法计算结果:" + pMResult);
    
            System.out.println("父类静态变量num:" + ParentClass.num);
            System.out.println("子类静态变量num:" + ChildClass.num);
    
        }
    }
    
    class ParentClass {
        public static final int num = 1;
        ParentClass() {
            System.out.println("执行父类无参数构造方法");
        }
    
        static int add(int i, int j) {
            return i + j;
        }
    
        static final int plus(int i, int j) {
            return i + j;
        }
    
        final int minus(int i, int j) {
            return i - j;
        }
    
    }
    
    class ChildClass extends ParentClass {
        public static  final int num = 2;
        ChildClass() {
            System.out.println("执行子类无参数构造方法");
        }
    
    //    @Override 无法继承,编译时出错
        static int add(int i, int j) {
            return i * j;
        }
    
    //    无法继承,编译时出错
    //    int plus(int i, int j) {
    //        return i + j;
    //    }
    
    //    无法继承,编译时出错
    //    int minus(int i, int j) {
    //        return i - j;
    //    }
    
    }
    

    输出结果:

    执行父类无参数构造方法
    执行子类无参数构造方法

    父类静final方法计算结果:5
    父类静方法计算结果:5
    子类静方法计算结果:6
    父类final方法计算结果:-1
    父类静态变量num:1
    子类静态变量num:2

    更多相关内容
  • 1、父类中staitic修饰的静态方法,不能覆盖、不能继承。2、父类中staitic修饰的变量或常量,能覆盖、不能继承。static修饰的变量和方法,只属于类本身,不属于对象;当声明一个对象时,并不产生static变量和方法的...

    1、父类中staitic修饰的静态方法,不能覆盖、不能继承。

    2、父类中staitic修饰的变量或常量,能覆盖、不能继承。

    static修饰的变量和方法,只属于类本身,不属于对象;当声明一个对象时,并不产生static变量和方法的拷贝。也就是说,用static修饰的变量和方法在类加载的时候,会分配一块存储空间,所有此类的对象都可以操控此块存储空间;

    注意:当子类没有与父类同名的static变量(或方法时),子类的对象也可操控这块内存空间。但是,子类并没有继承父类中static修饰的变量和方法。这是因为static修饰的变量和方法是属于父类本身的。

    3、父类中final修饰的方法,不能覆盖,但可继承。

    代码示例:

    package com.jdk;

    /**

    * Created by Liuxd on 2018-11-02.

    */

    public class TestExtendsClass {

    public static void main(String[] args) {

    ParentClass parentClass = new ChildClass();

    System.out.println();

    int pFResult = ParentClass.plus(3,2);

    int pResult = ParentClass.add(3,2);

    int cResult = ChildClass.add(3,2);

    int pMResult = parentClass.minus(2,3);

    System.out.println("父类静final方法计算结果:" + pFResult);

    System.out.println("父类静方法计算结果:" + pResult);

    System.out.println("子类静方法计算结果:" + cResult);

    System.out.println("父类final方法计算结果:" + pMResult);

    System.out.println("父类静态变量num:" + ParentClass.num);

    System.out.println("子类静态变量num:" + ChildClass.num);

    }

    }

    class ParentClass {

    public static final int num = 1;

    ParentClass() {

    System.out.println("执行父类无参数构造方法");

    }

    static int add(int i, int j) {

    return i + j;

    }

    static final int plus(int i, int j) {

    return i + j;

    }

    final int minus(int i, int j) {

    return i - j;

    }

    }

    class ChildClass extends ParentClass {

    public static final int num = 2;

    ChildClass() {

    System.out.println("执行子类无参数构造方法");

    }

    // @Override 无法继承,编译时出错

    static int add(int i, int j) {

    return i * j;

    }

    // 无法继承,编译时出错

    // int plus(int i, int j) {

    // return i + j;

    // }

    // 无法继承,编译时出错

    // int minus(int i, int j) {

    // return i - j;

    // }

    }

    输出结果:

    执行父类无参数构造方法

    执行子类无参数构造方法

    父类静final方法计算结果:5

    父类静方法计算结果:5

    子类静方法计算结果:6

    父类final方法计算结果:-1

    父类静态变量num:1

    子类静态变量num:2

    补充知识:java中static、final 和 static final之间的区别

    static可以修饰:全局属性,方法,代码块,内部类(静态内部类或嵌套内部类)

    由于静态属性和方法是属于该类的所有对象的,所以可以用类名.静态属性/方法名来访问。用static修饰的代码块表示静态代码块,当Java虚拟机(JVM)加载类时,就会执行该代码块。

    1.被static修饰的变量,叫静态变量或类变量(不能是局部变量),直接可以用类名调用;被static修饰的变量,叫实例变量,必须实例化对象以后调用;static修饰的变量可以被修改.

    2.静态方法可以直接通过类名调用,任何的实例也都可以调用,因此静态方法中不能用this和super关键字,也不能直接访问所属类的实例变量和实例方法(非static的成员变量和成员成员方法),只能访问所属类的静态成员变量和成员方法。

    3.父子类中,静态方法只能被静态方法覆盖,父子类中,非静态方法只能被非静态方法覆盖。

    常见的java中的main方法必须有static修饰,因为在类加载时无法创建对象,静态方法可以不通过对象调用,所以在类的main方法所在在类加载时就可以通过main方法入口来运行程序。

    4.static代码块也叫静态代码块,是在类中独立于类成员的static语句块,可以有多个,位置可以随便放,它不在任何的方法体内,JVM加载类时会执行这些静态的代码块,如果static代码块有多个,JVM将按照它们在类中出现的先后顺序依次执行它们,每个代码块只会被执行一次。

    final可以修饰:方法,类,局部变量

    对于基本类型数据,final会将值变为一个常量,创建后不能被修改;但是对于对象句柄(亦可称作引用或者指针),final会将句柄变为一个常数(进行声明时,必须将句柄初始化到一个具体的对象。而且不能再将句柄指向另一个对象。

    但是,对象的本身是可以修改的。这一限制也适用于数组,数组也属于对象,数组本身也是可以修改的。

    方法参数中的final句柄,意味着在该方法内部,我们不能改变参数句柄指向的实际东西,也就是说在方法内部不能给形参句柄再另外赋值)。

    1.final修饰的变量就会变成常量,而且应当大写,一旦赋值不能改变,final的常量不会有默认初始值,对于直接在初始化赋值时final修饰符常和static修饰符一起使用。

    2.final修饰的方法将不能被其子类覆盖重写。

    3.final修饰的类类将不能被继承,且final类中的方法也都是final的, final不能用来修饰构造方法,在父类中如果有常量属性,在子类中使用常量属性时是不会进行父类的类加载。

    static final和final static

    没什么区别,一般static写在前面,既具有static属性又具有final属性的类/方法/变量。

    以上这篇Java父类继承中的static和final用法就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持脚本之家。

    展开全文
  • 1. 基本初始化过程:对于一个简单类的初始化过程是:static 修饰的模块(static变量和static 块) --->...父类static修饰的模块|子类static修饰模块|父类实例变量和非static块|父类对应构造函数。当...

    1. 基本初始化过程:

    对于一个简单类的初始化过程是:

    static 修饰的模块(static变量和static 块)  ---> 按照代码顺序依次执行。

    |

    实例变量  及非static模块---> 按照代码顺序依次执行。

    |

    构造函数 ---> 执行对应的构造函数。

    子类的初始化过程。

    父类static修饰的模块

    |

    子类static修饰模块

    |

    父类实例变量和非static块

    |

    父类对应构造函数。当子类对应构造函数中没有显示调用时调用的是父类默认的构造函数。

    |

    子类实例变量和非static块

    |

    子类构造函数

    Class的static模块是唯一的,所以只初始化一次。所有类的实例公用Class的static模块。

    static模块的初始化条件: ( From: 引用1 )

    (1)遇到new、getstatic、putstatic 或 invokestatic这4条字节码指令时,如果类还没初始化,则触发初始化。对应场景是:new实例化对象时、读或设置一个静态字段时(被final修饰,已在编译器把结果放入常量池的静态字段除外),以及调用一个类的静态方法时

    (2)对类进行反射调用时

    (3)初始化子类。但父类还没有初始化时,先触发父类初始化

    (4)当虚拟机启动时,需指定一个需要执行的主类(包含main方法),虚拟机会先初始化该类

    2. 关于覆盖和隐藏

    覆盖:被覆盖的方法相当于被擦除了,不可恢复(即使类型强制转换也无法调用)。

    隐藏:一直保存的某个位置,等需要的时候可以继续使用(类型强制转换后可以调用)。

    关于父类子类之间的覆盖和隐藏关系: (From :引用2)

    1. 父类的实例变量和类变量能被子类的同名变量隐藏。

    2. 父类的静态方法被子类的同名静态方法隐藏,父类的实例方法被子类的同名实例方法覆盖。

    3. 不能用子类的静态方法隐藏父类的实例方法,也不能用子类的实例方法覆盖父类的静态方法,否则编译器会异常。

    4. 用final关键字修饰的最终方法不能被覆盖。

    5. 变量只能被隐藏不会被覆盖,子类的实例变量可以隐藏父类的类变量,子类的类变量也可以隐藏父类的实例变量。

    涉及的典型情况:

    前提:

    -----------------------------------------

    class B extends A{……}

    -----------------------------------------

    (1) B instanceB = new B();

    instanceB的初始化过程如第一部分中:子类的初始化过程。

    此时instanceB中实际上有一个super的全部信息(除了父类中被覆盖的实例方法),但是当前的引用是子类的信息(如果子类中没有的变量和方法则是从父类继承来)。

    (2)A instanceA = new B();

    此时父类A的变量和静态方法会将子类的变量和静态方法隐藏。instanceA此时唯一可能调用的子类B的地方就是子类B中覆盖了父类A中的实例方法。

    执行 B instanceB = (B) instanceA; 后

    此时instanceB相当于 B instanceB = new B();

    注意:

    (1) 这里唯一的覆盖的情况:父类的实例方法被子类的同名实例方法覆盖。

    这里方法调用变量时,实际上是带有一个默认的this的。也就是此实例方法中调用的是当前Class的值。涉及到继承的情况时,要十分注意super,this的情况。

    (2) 在初始化的时候,有两个阶段。第一步是申请空间,第二步是赋值。

    具体见:

    static的值和final static值在初始化时的区别。(引用1)

    子类覆盖父类实例方法时,调用子类的实例方法,而此时子类的实例方法调用了子类中的变量(此时static变量已经初始化,但是实例变量并没有初始化)。(引用2)

    这段代码来自引用2,如何精炼,如此有趣。值得一看。

    classParent{

    int x=10;

    publicParent(){

    add(2);

    }

    voidadd(inty){

    x+=y;

    }

    }

    classChildextendsParent{

    int x=9;

    voidadd(inty){

    x+=y;

    }

    publicstaticvoidmain(String[] args){

    Parent p=new Child();

    System.out.println(p.x);

    }

    }

    引用 1. 类加载机制:

    引用 2. 隐藏和覆盖,以及一个好例子:

    引用 3. 隐藏和覆盖

    引用 4. 基本的初始化过程

    展开全文
  • (易混点)java中,关于子类继承父类的private方法与final方法 对于子类继承父类的方法,相信很多人都已经掌握得非常熟悉了,今天由于在做牛客网的一道关于这个知识点的面试题,忽略了一个非常重要的细节,导致入坑...

    (易混点)java中,关于子类继承父类的private方法与final方法

    对于子类继承父类的方法,相信很多人都已经掌握得非常熟悉了,今天由于在做牛客网的一道关于这个知识点的面试题,忽略了一个非常重要的细节,导致入坑了。因此,在这里分享自己的总结:一来是希望可以加深自己的理解,防止再次掉坑,二来也是希望跟大家一起分享,一起学习,有写的不对的地方欢迎大家指正。

    以下附上牛客网上的原题

    在这里插入图片描述
    正确的答案是A

    下面我从三个方面进行分析

    1.父类中的方法被private修饰,子类中也定义了一个跟父类一样的方法

    在这里插入图片描述
    这种情况编译和运行都没有问题,运行的结果是输出“son”

    2.父类中的方法被final修饰,子类中重写了这个方法
    在这里插入图片描述
    这种情况编译不通过

    3.父类中的方法同时被private和final修饰,子类中也定义了一个跟父类一样的方法
    在这里插入图片描述
    这种情况编译和运行同样都没有问题,运行的结果也是输出“son”

    针对于上面三种不同的情况,所产生不同的结果,在此进行总结:
    ①父类中被private修饰的方法表示仅在该类可见,所以子类没有继承到父类的private方法,因此,若子类定义了一个与父类的private方法相同的方法名和参数列表也是没问题的,相当于子类自己定义了一个新的方法;

    ②而父类中被final修饰的方法表示不可以被子类重写,如果没有被private修饰则表示该方法是有被子类继承但是不可以被覆盖,若子类定义了相同的方法则编译无法通过。

    ③需要注意的点:若父类中的方法是既被private修饰也被final修饰了,那么说明该方法是不会被子类继承,此时子类定义相同的方法也没有问题,不再产生重写与final的矛盾,而是在子类中定义了新的方法。

    展开全文
  • Java 父类调用被子类重写的方法

    千次阅读 2021-03-08 04:17:20
    1.若是父类构造器调用了被子类重写的方法,且经过子类构造函数建立子类对象,调用了这个父类构造器(不管显示仍是隐式),就会致使父类在构造时实际上调用的是子类覆盖的方法(你须要了解java继承的初始化机制)。java...
  • Java中final的使用

    千次阅读 2021-03-14 11:45:17
    概念final 具有“不可改变的”的含义,可以修饰 非抽象类、非...注:final 不能用来修饰构造方法,因为“方法覆盖”这一概念仅适用于类的成员方法,而不适用于类的构造方法,父类的构造方法和子类的构造方法之间不...
  • 主要介绍了Java反射如何修改private final成员变量值,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Java中父类的静态方法能否被子类重写前言一、final关键字和static关键字介绍二、问题产生及解决1.错误结论2.正确结论及验证总结 前言 今天在复习final关键字的时候突发奇想,在考虑static和final关键字既然可以修饰...
  • java学习-继承和final方法

    千次阅读 2021-02-27 20:03:26
    1.继承1.1继承的概述继承面向对象的一大特征继承 : 让类与类之间发生关系(关联), 子父类关系 ; 使用extends关键字,让类与类之间具有子父类继承关系举例 :class A{}class B extends A{}上述代码:A类被继承的类 : ...
  • Java中使用static、final、private修饰的方法能被子类继承,但不会重写。此外,属性也能继承,但不能重写。 属性和static修饰的方法。在子类如果又定义了一份,那么从父类继承来的这些结构会被隐藏,存在2份。此时...
  • Java中父类的构造方法能不能被重写? 2. 题目剖析 其实上面这个题目,考察的还是我们对方法重写的掌握情况,只要我们把上一篇文章的内容熟悉的记下来,这个问题就可以得出很明确的答案。 二. 参考答案 1. 方法...
  • 如果父类构造器调用了被子类重写的方法,且通过子类构造函数创建子类对象,调用了这个父类构造器(无论显示还是隐式),就会导致父类在构造时实际上调用的是子类覆盖的方法(你需要了解java继承的初始化机制)。...
  • 子类 public class UserInfo implements Serializable { ... private static final long serialVersionUID = 5359479211352456087L; /** * 主键 */ @Id @Column(name = "user_id") priv...
  • Java中父类能调用子类的方法吗? 如果不可以,原因?如果可以,如何做? 每种实现方式,在实际项目被允许吗? 不被允许的原因有哪些? 如果在实际项目,的确有这样的特殊业务场景,应如何“正确的” - “变相”的...
  • 1、父类中private的方法,可以被重写,但是不能被继承。如果被重写了,那么:父类 a=new 子类(),运行的时候,调用的是子类的private方法。测试代码如下:package static_;public class M {public static void test...
  • Java中final变量、final方法和final

    万次阅读 多人点赞 2018-12-13 17:39:24
    1、final变量 final关键字可用于变量声明,一旦该变量被设定,就不可以再改变该变量...在Java中定义全局常量,通常使用public static final修饰,这样的常量只能在定义是被赋值。 public static final double PI...
  • java中父类对象引用指向子类对象

    千次阅读 2021-02-12 12:58:11
    62616964757a686964616fe4b893e5b19e31333238656637Java的多态性面向对象编程有三个特征,即封装、继承和多态。封装隐藏了类的内部实现机制,从而可以在不影响使用者的前提下改变类的内部结构,同时保护了数据。继承...
  • 父类的引用指向子类的对象,要调用的就是父类的方法而不是子类的方法,比如说定义一个父类animal类,一个子类 鸟类,鸟类有个独有的方法飞行。现在的情况是 Animal animal = new Bird (); 你要调用 animal.fly();...
  • 看以下代码:父类使用private定义的方法,子类使用public覆写: class Father{ public void fun(){ this.print(); } //如果现在父类使用了private定义,那么就表示该方法只能被父类使用,子类无法使用,换句话说...
  • 继承是为了重用父类代码,同时为实现多态性作准备。那么什么是多态呢?方法的重写、重载与动态连接构成多态性。Java之所以引入多态的概念,原因之一是它在类的继承问题上和C++不同,后者允许多继承,这确实给其带来...
  • (1)子类和父类如果在同一个包内,则子类可以继承父类的除private以外的所有成员变量和方法,并且权限不变;(2)子类和父类如果不在同一个包内,则子类可以继承父类的public和protected权限的成员变量和方法,不能继承...
  • 在学习java中发现 方法覆盖,方法名,方法参数类型、个数,返回值,必须一样,不能比父类方法有更严格的访问权限控制  final方法为最终方法,不可修改,即子类不可以覆盖父类final方法  final变量 为常量 ...
  • 父类中的方法定义成private私有的,这样子类就不能看到父类方法了,也就无法重写了 父类方法定义成final,这样子类可以调用,但是不能重写 父类方法定义成static静态的,不过这样的话就没有意义了哈,静态的水都...
  • Java子类父类属性的覆盖

    千次阅读 2021-02-13 01:43:09
    Java codeclass ParentClass {public int i = 10;}public class SubClass extends ParentClass {public int i = 30;public static void main(String[] args) {ParentClass parentClass = new SubClass();SubClass su...
  • Java不支持多重继承(子类只有一个父类(超类))。 格式:class 子类名 extends 父类名{...} 继承性:1.在同一包中:除private方法和成员、构造方法 2.不同包中,只继承父类的protected和public 成员变量的...
  • 首先我们先看下finaljava中的作用 finalJava中可以用来修饰类、修饰方法和修饰变量 1. final修饰的类,为最终类,该类不能被继承。如String 类 2. final修饰的方法可以被继承和重载,但不能被重写 3. ...
  • 作用: 子类一旦继承父类,有权使用父类中的成员,可以在子类定义子类独有的内容 定义: 子类 extends 父类 实体类|子类 : 根据一系列对象抽取共性所定义的实体类 父类 : 子类的共性 子类| 派生类 父类 | 基类...
  • Java中final关键字

    千次阅读 多人点赞 2021-10-04 12:40:47
    一,概述 final关键字代表最终、不可改变的。 常见四种用法: 1. 可以用来修饰一个类 2. 可以用来修饰一个方法 3. 还可以用来修饰一个局部变量 ...eg:定义一个final类pubilc final MyClass,继承报错! 2)..
  • java 获取类和父类的属性和方法

    千次阅读 2021-02-12 15:49:57
    问题在日常开发,经常需要获取当前类和父类的所有属性,没办法只能查API了。getDeclaredFields VS getFields查阅API得知,class.getDeclaredFields()能获取所有属性(public、protected、default、private),但不...
  • 一,final修饰类 fianl修饰符如果修饰类的话就代表该类不可以被继承,即不允许被继承;...类似的比如Java中的String类也是final修饰的,也即String类不允许被继承不允许扩展其方法或属性。 二,final修饰成员变

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 242,090
精华内容 96,836
关键字:

java父类中的final

java 订阅