精华内容
下载资源
问答
  • Java父类继承的static和final

    千次阅读 2018-11-02 16:54:53
    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父类和子类

    2016-01-24 12:11:29
    JAVA父类与子类的方法调用package mobanfangfa; //1.父类是抽象类 public abstract class Father { //2.父类方法是普通方法,子类可以覆写,可以不覆写。 //如果子类覆写,则子类调用此方法时是子类的方法。如果...
    JAVA父类与子类的方法调用
    package mobanfangfa;
    
    1.父类是抽象类</span>
    public abstract class Father {
    
    	//2.父类方法是普通方法,子类可以覆写,可以不覆写。
    	//如果子类覆写,则子类调用此方法时是子类的方法。如果子类不覆写,则调用的该方法是父类的方法。</span>
    	public void test1() {
    		System.out.println("father");
    	}
    
          //3.父类方法是抽象类时,子类必须继承	public abstract void blew();
    	
    	
    	//4.不允许子类覆写该方法</span>
    	public final void test2(){
    		System.out.println("final father");
    	}
    }
    


    package mobanfangfa;
    
    public class Son extends Father {
    
    	
    	public void test1() {
    		System.out.println("son");
    	}
    	public static void main(String[] args) {
    		Son son = new Son();
    		son.test1();
    	}
    	@Override
    	public void blew() {
    
    	}
    	
    }
    

    展开全文
  • Java 父类子类的对象初始化过程摘要: Java基本的对象初始化过程,子类的初始化,以及涉及到父类和子类的转化时可能引起混乱的情况。1. 基本初始化过程:对于一个简单类的初始化过程是:&nbsp;&nbsp;&...

    转载自 Java 父类子类的对象初始化过程

    摘要: Java基本的对象初始化过程,子类的初始化,以及涉及到父类和子类的转化时可能引起混乱的情况。

    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,如何精炼,如此有趣。值得一看。

    1. class Parent{
    2. int x=10;
    3. public Parent(){
    4. add(2);
    5. }
    6. void add(int y){
    7. x+=y;
    8. }
    9. }
    10. class Child extends Parent{
    11. int x=9;
    12. void add(int y){
    13. x+=y;
    14. }
    15. public static void main(String[] args){
    16. Parent p=new Child();
    17. System.out.println(p.x);
    18. }
    19. }


    引用 1. 类加载机制:

    http://blog.csdn.net/kai_wei_zhang/article/details/8234146 

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

    http://www.cnblogs.com/binjoo/articles/1585342.html

    引用 3. 隐藏和覆盖

    http://renyanwei.iteye.com/blog/258304 

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

    http://www.cnblogs.com/miniwiki/archive/2011/03/25/1995615.html 


    展开全文
  • 在学习java中发现 方法覆盖,方法名,方法参数类型、个数,返回值,必须一样,不能比父类方法有更严格的访问权限控制  final方法为最终方法,不可修改,即子类不可以覆盖父类final方法  final变量 为常量 ...
    在学习java中发现  方法覆盖,方法名,方法参数类型、个数,返回值,必须一样,不能比父类方法有更严格的访问权限控制
      final方法为最终方法,不可修改,即子类不可以覆盖父类的final方法
      final变量 为常量 一旦声明,就不可修改
      final类为最终类,不可以扩展,即不可以被继承
     
      子类可以继承父类的中非私有的方法及变量
    展开全文
  • 父类和子类的同步方法是共用的同一个
  • 实例化子类时,父类与子类的静态代码块、实例代码块、静态变量、实例变量、构造函数的执行顺序是怎样的? 代码执行的优先级为: firest:静态部分 second:实例化过程 详细顺序为: 1.父类静态代码块...
  • 父类中的方法定义成private私有的,这样子类就不能看到父类方法了,也就无法重写了 父类方法定义成final,这样子类可以调用,但是不能重写 父类方法定义成static静态的,不过这样的话就没有意义了哈,静态的水都...
  • java父类调用被子类重写的方法

    千次阅读 2018-07-19 16:26:37
    1.如果父类构造器调用了被子类重写的方法,且通过子类构造函数创建子类对象,调用了这个父类构造器(无论显示还是隐式),就会导致父类在构造时实际上调用的是子类覆盖的方法(你需要了解java继承的初始化机制)。...
  • 1.如果父类构造器调用了被子类重写的方法,且通过子类构造函数创建子类对象,调用了这个父类构造器(无论显示还是隐式),就会导致父类在构造时实际上调用的是子类覆盖的方法(你需要了解java继承的初始化机制)。...
  • 1、父类中private的方法,可以被重写,但是不能被继承。如果被重写了,那么:父类 a=new 子类(),运行的时候,调用的是子类的private方法。测试代码如下: package static_; public class M {  public static ...
  • Java中final变量、final方法和final

    万次阅读 多人点赞 2018-12-13 17:39:24
    1、final变量 final关键字可用于变量声明,一旦该变量被设定,就不可以再改变该变量...在Java中定义全局常量,通常使用public static final修饰,这样的常量只能在定义是被赋值。 public static final double PI...
  • 子类 public class UserInfo implements Serializable { ... private static final long serialVersionUID = 5359479211352456087L; /** * 主键 */ @Id @Column(name = "user_id") priv...
  • java父类构造函数调用子类覆盖方法

    千次阅读 2017-07-17 16:54:48
    原文链接:... ... 1.如果父类构造器调用了被子类重写的方法,且通过子类构造函数创建子类对象,调用了这个父类构造器(无论显示还是隐式),就会导致父类在构造时实际上
  • 1、java 中父类引用指向子类对象时动态绑定针对的只是子类重写的成员方法; 2、父类引用指向子类对象时,子类如果重写了父类的可重写方法(非private、非 final 方法),那么这个对象调用该方法时默认调用的时子类重写...
  • 父类实现序列化接口,子类自动继承序列化接口,无需显示申明,即子类序列化时会自动序列化父类对象,反序列化没有问题 二.父类没有实现序列化接口,子类实现序列化接口 1.子类可以被序列化,但是父类无法被序列化.无论如何...
  • Java 父类和子类对象销毁实例

    千次阅读 2013-12-02 14:32:41
    1)定义一个共享类Shared ... public class Shared {  private int refcount=0;  private static long counter=0;... private final long id=counter++;    public Shared(){  System.out.printl
  • Java中final关键字详解

    千次阅读 2019-07-29 11:34:01
    Java中final关键字final关键字的基本用法1、修饰类2、修饰方法3、修饰成员变量 final关键字的基本用法 在 java final 关键字可以来 修饰类、方法和变量。下面就来详细的了解一下 final 关键字的一些基本用法...
  • (易混点)java中,关于子类继承父类的private方法与final方法 对于子类继承父类的方法,相信很多人都已经掌握得非常熟悉了,今天由于在做牛客网的一道关于这个知识点的面试题,忽略了一个非常重要的细节,导致入坑...
  • Java中父类和子类的代码执行顺序

    万次阅读 2018-05-02 14:12:13
    Java中(静态)代码块、(静态)变量的执行顺序 父类代码 public class Parent { static { System.out.println(&quot;Parent static block&quot;); } { System.out.println(&quot;Parent ...
  • Java的继承体系,子类可以在父类的基础上根据自己的需求来修改父类的内容来使子类更具个性,但是出于一些其他方面的考虑,我们不可能让子类随意的修改父类的内容,为了避免子类随意改写父类的内容,java提供了...
  • ②final 修饰方法:此方法不能重写,即父类某方法被final修饰,在子类中将不能定义一个与父类final 方法同名且有相同方法标识符(参数个数也相同,返回值类型相同)的方法 ③final 修饰类:此类不能再派生子类 ④...
  • java顶级父类object

    2021-05-18 23:04:48
    object是顶级父类,是所有java类的父类(除了object本身)。体现了java的继承特性 Object主要方法 public final native Class<?> getClass();获取.class对象方法 public boolean equals(Object obj){};对象...
  • Java中final关键字

    千次阅读 多人点赞 2018-07-16 23:18:21
    java中可以将实例域定义为final。在构建对象是必须初始化这样的值。必须确保在每个构造器执行之后,这个域的值被设置,并且在后面的操作不再对其修改。使用final声明变量之后,这个值就不能修改,一般final类型...
  • Java获取父类的类名

    千次阅读 2015-03-28 22:55:40
    Java获取父类的类名
  • 浅谈java中final用法

    千次阅读 2019-04-10 09:43:57
    另外,Java中的String类就是一个final类,那么今天我们就来了解final这个关键字的用法。 一、final关键字的基本用法 在Java中final关键字可以用来修饰类、方法和变量(包括成员变量和局部变量)。下面就从这三个...
  • java中父类与接口的区别

    千次阅读 2018-08-02 23:44:24
    接口实现的注意点: a)实现一个接口就是要实现该接口的所有的...extends 是继承父类,只要那个类不是声明为final或者那个类定义为abstract的就能继承,JAVA中不支持多重继承,但是可以用接口来实现,这样就用到了...
  • java中父类和子类的关系

    千次阅读 2014-06-30 22:15:48
    子类继承父类,子类jiu

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 203,892
精华内容 81,556
关键字:

java父类中的final

java 订阅