精华内容
下载资源
问答
  • 这是一次阿里面试里问到的题目,在我的印象中,final修饰的方法是不能被子类重写的。如果在子类中重写final修饰的方法,在编译阶段就会提示Error。但是回答的时候还是有点心虚的,因为final变量就可以用反射的方法...

    这是一次阿里面试里被问到的题目,在我的印象中,final修饰的方法是不能被子类重写的。如果在子类中重写final修饰的方法,在编译阶段就会提示Error。但是回答的时候还是有点心虚的,因为final变量就可以用反射的方法进行修改,我也不太确定是否有类似的机制可以绕过编译器的限制。于是面试之后特地上网搜了下这个问题,这里简单记录一下。

    首先说一下结论:没有办法能够做到重写一个final修饰的方法,但是有其他的方法可以接近在子类中重新实现final方法并在运行时的动态绑定的效果。
    这里需要用到一个aop框架叫aspectj,它和spring aop都是比较常用的aop框架。区别是spring aop是基于动态代理的,而aspectj有独立的编译器可以实现静态代理。关于aspectj的安装配置网上有很多文章了,这里就不再赘述,直接快进到例子。

    首先定义一个SuperClass并在其中定义一个final方法。
    SuperClass.java

    public class SuperClass {
    
        public final void doSomething() {
            System.out.println("super class do something");
        }
    
        public static void main(String[] args) {
            SuperClass instance = new SubClass(); //此处是父类引用和子类对象
            instance.doSomething();
        }
    
    }
    

    SubClass.java

    public class SubClass extends SuperClass {
    
        //doSomething是final方法,无法被重写
    
    }
    

    super class do something

    Process finished with exit code 0

    运行main方法,SubClass继承了doSomething方法,但是不能重写,所以通常情况下调用的一定是SuperClass的doSomething方法。

    在SubClass中实现“重写”的doSomething方法
    SubClass.java

    public class SubClass extends SuperClass {
    
        //doSomething是final方法,无法被重写
        //子类只能在另一个函数中实现重写的逻辑
        protected void overrideDoSomething() {
            System.out.println("sub class do something");
        }
    
    }
    

    利用环绕通知修改实际调用的方法
    DoSomethingAspect.aj

    public aspect DoSomethingAsepct {
        //   环绕通知               匹配SuperClass类的doSomething方法
        void around() : execution(* SuperClass.doSomething()) {
            if (thisJoinPoint.getThis() instanceof SubClass) {
                //调用子类方法
                ((SubClass)thisJoinPoint.getThis()).overrideDoSomething();
            } else {
                //调用原方法
                proceed();
            }
        }
    
    }
    

    运行结果

    sub class do something

    Process finished with exit code 0

    可以看到,调用SubClass的doSomething方法时实际调用的是SubClass类的overrideDoSomething方法,而如果是SuperClass对象的话调用的又是SuperClass里的doSomething方法。根据实际的类型决定调用的方法,就比较接近动态绑定的机制了。而仅从调用的代码来看和子类重写方法(虽然实际是final)的效果是一样的。

    展开全文
  • 首先我们先看下final在java中的作用 final在Java中可以用来修饰类、... final修饰的方法可以被继承和重载,但不能被重写 3. final修饰的变量不能修改,是个常量 举例说明: public class Person { private S...

    首先我们先看下final在java中的作用

    final在Java中可以用来修饰类、修饰方法和修饰变量

     1. final修饰的类,为最终类,该类不能被继承。如String 类
        
     2. final修饰的方法可以被继承和重载,但不能被重写
            
     3. final修饰的变量不能被修改,是个常量
    

    举例说明:

    public class Person {
    
        private String name;
        private int age;
        private String sex;
    
        final public void work(){ //final 修饰的最终方法 可以被子类继承,但不能被重写
            System.out.println("a person can do work");
        }
    
        final public void work(int age){ //重载一个final类
            System.out.println("a person can do another work");
        }
    
        public void eat(){   //普通方法  可以被子类继承、重写
            System.out.println("a person need to eat");
        }
    
        public static void sleep(){  //静态方法  可以被继承
            System.out.println("a person need to sleep");
        }
    }
    

    子类继承了父类Person 重写了父类普通方法eat() ,但不能重写父类final修饰的方法和静态方法

    public class Man extends Person{
        
        public void eat(){
            System.out.println("the man also need do eat");
        }
    
        public static void sleep(){
            System.out.println("the man also need to sleep");
        }
    
    }
    

    注意:
    在Java中静态方法可以被继承,但是不能被覆盖,即不能重写。
    如果子类中也含有一个返回类型、方法名、参数列表均与之相同的静态方法,那么该子类实际上只是将父类中的该同名方法进行了隐藏,而非重写。(比如子类Man 中的sleep方法)

    展开全文
  • 这是一次阿里面试里问到的题目,在我的印象中,final修饰的方法是不能被子类重写的。如果在子类中重写final修饰的方法,在编译阶段就会提示Error。但是回答的时候还是有点心虚的,因为final变量就可以用反射的方法...

    这是一次阿里面试里被问到的题目,在我的印象中,final修饰的方法是不能被子类重写的。如果在子类中重写final修饰的方法,在编译阶段就会提示Error。但是回答的时候还是有点心虚的,因为final变量就可以用反射的方法进行修改,我也不太确定是否有类似的机制可以绕过编译器的限制。于是面试之后特地上网搜了下这个问题,这里简单记录一下。

    首先说一下结论:没有办法能够做到重写一个final修饰的方法,但是有其他的方法可以接近在子类中重新实现final方法并在运行时的动态绑定的效果。
    这里需要用到一个aop框架叫aspectj,它和spring aop都是比较常用的aop框架。区别是spring aop是基于动态代理的,而aspectj有独立的编译器可以实现静态代理。关于aspectj的安装配置网上有很多文章了,这里就不再赘述,直接快进到例子。

    首先定义一个SuperClass并在其中定义一个final方法。
    SuperClass.java

    public class SuperClass {
    
        public final void doSomething() {
            System.out.println("super class do something");
        }
    
        public static void main(String[] args) {
            SuperClass instance = new SubClass(); //此处是父类引用和子类对象
            instance.doSomething();
        }
    
    }
    

    SubClass.java

    public class SubClass extends SuperClass {
    
        //doSomething是final方法,无法被重写
    
    }
    

    super class do something

    Process finished with exit code 0

    运行main方法,SubClass继承了doSomething方法,但是不能重写,所以通常情况下调用的一定是SuperClass的doSomething方法。

    在SubClass中实现“重写”的doSomething方法
    SubClass.java

    public class SubClass extends SuperClass {
    
        //doSomething是final方法,无法被重写
        //子类只能在另一个函数中实现重写的逻辑
        protected void overrideDoSomething() {
            System.out.println("sub class do something");
        }
    
    }
    

    利用环绕通知修改实际调用的方法
    DoSomethingAspect.aj

    public aspect DoSomethingAsepct {
        //   环绕通知               匹配SuperClass类的doSomething方法
        void around() : execution(* SuperClass.doSomething()) {
            if (thisJoinPoint.getThis() instanceof SubClass) {
                //调用子类方法
                ((SubClass)thisJoinPoint.getThis()).overrideDoSomething();
            } else {
                //调用原方法
                proceed();
            }
        }
    
    }
    

    运行结果

    sub class do something

    Process finished with exit code 0

    可以看到,调用SubClass的doSomething方法时实际调用的是SubClass类的overrideDoSomething方法,而如果是SuperClass对象的话调用的又是SuperClass里的doSomething方法。根据实际的类型决定调用的方法,就比较接近动态绑定的机制了。而仅从调用的代码来看和子类重写方法(虽然实际是final)的效果是一样的。

    展开全文
  • 1、父类中的静态方法可以被继承、但不能被子类重写。 2、如果在子类中写一个和父类中一样的静态方法,那么该静态方法由该子类特有,两者不构成重写关系。 final修饰: 1、修饰类表示不允许继承。 2、修饰方法...

    static修饰的方法:
    1、父类中的静态方法可以被继承、但不能被子类重写。

    2、如果在子类中写一个和父类中一样的静态方法,那么该静态方法由该子类特有,两者不构成重写关系。

    final修饰:
    1、修饰类表示不允许被继承。

    2、修饰方法表示不允许被子类重写,但是可以被子类继承,不能修饰构造方法。

    3、修饰变量表示不允许被修改
    a)方法内部的局部变量,使用前被赋值即可(只能赋值一次),没有必要非得初始化。
    b)类中的成员变量(如果没有在定义时候初始化,那么只能在构造代码块中或者构造方法中赋值)
    c)基本数据类型的变量(初始化赋值之后不能更改)
    d)引用数据类型的变量(初始化之后不能再指向另外一个对象,但对象的内容是可以变的)

        final Animal animal = new Animal("老子""吃火锅");
                    animal = new Animal();//这个是错误的
                    animal.gaiName = "重庆老子";
                    animal.gaiEat = "吃重庆火锅";//这两句是没问题的
    展开全文
  • 1.final修饰变量,则等同于常量 2.final修饰方法中的参数,称为最终参数。 3.final修饰类,则类不能继承 4.final修饰方法,则方法不能被重写。 ... final 不能修饰抽象类...final修饰的方法可以被重载 但不能被重写
  • 本来想试试final能不能重载,后来想想还是都整理一下吧。 final修饰的类不能继承验证 public class FinalTest { public static void main(String[] args){ Parent parent = new Son(); System.out.println...
  • 在animal类中重载了shout方法,但子类dog和cat中重写shout方法报错
  • 首先明确一点,在子类中重写父类的static方法,是不会报错的,编译也可以通过,但是在通过一个声明为父类,实际类型为子类的引用变量调用该方法时,发现调用的仍是父类中原本以为会覆盖的方法,不具有“多态”...
  • static方法能否被重写

    万次阅读 多人点赞 2016-09-11 15:51:54
    在Java中,子类可继承父类中的方法,而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法,而是想作一定的修改,这就需要采用方法重写(Override)。... 那么,我们便可以据此来对static方法
  • java,方法重写final

    2016-06-28 19:21:42
    弊端:会不小心把父类中不能改变的方法也给改变了。 如何解决弊端呢? 也就是说,我们现在需要一种方案,告诉子类,我这个方法你是不能重写的。 这个时候,java就提供了一个关键字:finalfinal: 是...
  • 虽然static修饰的父类方法,子类也可以取相同的方法名、相同的修饰符、相同的返回值类型,但实际上已经不是同一个方法了。例如: class Father{ public static void father(){ System.out.println("father"); } } ...
  • 如果一个方法被设置为private 那个这个方法就无法被子类调用,自然无法重写,所以定义为private的方法 被隐式的定义为final 因为无需将一个final的方法再修饰为private,否则还会有其他情况发生 实例: 这里:...
  • 可以被重写方法

    2020-11-01 16:49:55
    final修饰的方法:父类中final修饰的方法可以被重写可以被继承; 构造函数:父类的构造函数不可以被重写; private修饰的:因为父类中private修饰的方法子类不可见; 挎包中修饰符缺省的方法:因为缺省的方法...
  • 又由于构造器不能继承,所以就不能被重写。但是,在同一个类中,构造器是可以被重载的。 其实,在之前的一篇博客中,我已经记录了重载和重写的区别 这里我们再重复一下。 2. 方法重载(Overloading) 重载遵循 两...
  • java 的重写final关键字

    千次阅读 2018-03-04 22:51:32
    1、方法重写: 子类根据需求对从父类继承来的方法进行改写,是多态机制的前奏,重写方法必须和被重写方法方法... 在重写方法中,可以通过super.函数名来调用被重写的父类方法。 2、final 关键字的特点: ...
  • 先给出答案:可以被子类继承,不能被子类重写。 关于父类和子类关系还不太了解的看一去看一下链接https://blog.csdn.net/qq_34826261/article/details/97635047,里面详细解释了父类和子类不同情况下成员方法和成员...
  • final关键字在大多数的编程语言中都存在,表示不允许对其修饰的内容进行继承或者重新操作。下面通过实例代码给大家介绍swift用final关键字来防止重写
  • 方法重写,abstract,final总结

    千次阅读 2016-12-16 08:55:39
    方法重写的规定: 有继承;方法名与父类名一样;形参与父类中的方法一致;返回值类型 -----------------------------------------------------------------------------------------------------------------...
  • 此代码执行结果?或者编译会报错么 结果:Dog move 很多人觉得Dog重写了Animal的move方法,Animal和Dog都是private和final修饰的, 划重点:private和final修饰的方法是不能被重写的 ...
  • 子类是否可以重写父类的final方法,答案是:不可以! 父类Person: 子类SubPerson: Question 2: 子类是否可以重载父类的final方法,答案是可以的! 父类Add  子类 SubAdd: ...
  • 父类方法定义成final,这样子类可以调用,但是不能重写 父类方法定义成static静态的,不过这样的话就没有意义了哈,静态的水都可以直接使用了 本文纯粹是为了记录一下,犹如误导的或者有问题的地方,欢迎指导...
  • Java中private方法重写吗?

    万次阅读 2014-03-15 17:19:22
    问题:Java中private方法重写吗? 下面是测试代码 public class A { private void print() { System.out.println("A"); } public static void main(String[] args) { A a = new B(); a.
  • 问题描述Java中为什么静态方法不能被重写?为什么静态方法不能隐藏实例方法?诸如此类。前期准备首先理解重写的意思,重写就是子类中对父类的实例方法进行重新定义功能,且返回类型、方法名以及参数列表保持一致,且...
  • 我有某个类的属性或者方法不想被重写, 只要在基类定义的时候在前面加一个final关键字就可以防止被重写, 下面让我们来看看例子 class MyClass {    final var han: String = ""    final func hanwanjie...
  • 静态方法不能被重写

    千次阅读 2019-03-07 16:32:38
    重写”只能适用于可观察的实例方法.不能用于静态方法final、private.对于静态方法,只能隐藏。一方面这是Java的规定,另一方面其实也有一定的道道这里边。 首先谈谈java方法是何时绑定的 我们大家平时使用一个对象...
  • “覆盖”只有在某方法是基类的接口的一部分时才会出现。即,必须能将一个对象向上转型为它的基本类型并调用相同的方法。 class StaticSuper{ public static void staticGet() { System.out.println(...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 287,889
精华内容 115,155
关键字:

final方法可以被重写吗