精华内容
下载资源
问答
  • 具体规定如下:final 修饰的类不能被继承。final 修饰的方法不能被子类重写。final 修饰的变量(成员变量或局部变量)即成为常量,只能赋值一次。final 修饰的成员变量必须在声明的同时赋值,如果在声明的时候没有赋值...

    在 Java 中,声明类、变量和方法时,可使用关键字 final 来修饰。final 所修饰的数据具有“终态”的特征,表示“最终的”意思。具体规定如下:

    • final 修饰的类不能被继承。
    • final 修饰的方法不能被子类重写。
    • final 修饰的变量(成员变量或局部变量)即成为常量,只能赋值一次。
    • final 修饰的成员变量必须在声明的同时赋值,如果在声明的时候没有赋值,那么只有 一次赋值的机会,而且只能在构造方法中显式赋值,然后才能使用。
    • final 修饰的局部变量可以只声明不赋值,然后再进行一次性的赋值。
    83ed2059f334a31969517eea5fdf78d5.png

    final 一般用于修饰那些通用性的功能、实现方式或取值不能随意被改变的数据,以避免被误用,例如实现数学三角方法、幂运算等功能的方法,以及数学常量π=3.141593、e=2.71828 等。
    事实上,为确保终态性,提供了上述方法和常量的 java.lang.Math 类也已被定义为final 的。
    需要注意的是,如果将引用类型(任何类的类型)的变量标记为 final,那么该变量不能指向任何其它对象。但可以改变对象的内容,因为只有引用本身是 final 的。
    如果变量被标记为 final,其结果是使它成为常数。想改变 final 变量的值会导致一个编译错误。下面是一个正确定义 final 变量的例子:

    public final int MAX_ARRAY_SIZE = 25; // 常量名一般大写

    常量因为有 final 修饰,所以不能被继承。
    请看下面的代码:

    2fdafe6107ecb398174ca74133423b7b.png

    final 也可以用来修饰类(放在 class 关键字前面),阻止该类再派生出子类,例如 Java.lang.String 就是一个 final 类。这样做是出于安全原因,因为要保证一旦有字符串的引用,就必须是类 String 的字符串,而不是某个其它类的字符串(String 类可能被恶意继承并篡改)。
    方法也可以被 final 修饰,被 final 修饰的方法不能被覆盖;变量也可以被 final 修饰,被 final 修饰的变量在创建对象以后就不允许改变它们的值了。一旦将一个类声明为 final,那么该类包含的方法也将被隐式地声明为 final,但是变量不是。

    被 final 修饰的方法为静态绑定,不会产生多态(动态绑定),程序在运行时不需要再检索方法表,能够提高代码的执行效率。在Java中,被 static 或 private 修饰的方法会被隐式的声明为 final,因为动态绑定没有意义。
    由于动态绑定会消耗资源并且很多时候没有必要,所以有一些程序员认为:除非有足够的理由使用多态性,否则应该将所有的方法都用 final 修饰。
    这样的认识未免有些偏激,因为 JVM 中的即时编译器能够实时监控程序的运行信息,可以准确的知道类之间的继承关系。如果一个方法没有被覆盖并且很短,编译器就能够对它进行优化处理,这个过程为称为内联(inlining)。例如,内联调用 e.getName() 将被替换为访问 e.name 变量。这是一项很有意义的改进,这是由于CPU在处理调用方法的指令时,使用的分支转移会扰乱预取指令的策略,所以,这被视为不受欢迎的。然而,如果 getName() 在另外一个类中被覆盖,那么编译器就无法知道覆盖的代码将会做什么操作,因此也就不能对它进行内联处理了。

    最后,我自己是一名从事了多年开发的JAVA老程序员,今年年初我花了一个月整理了一份最适合零基础学习的java学习干货,可以送给每一位喜欢java的小伙伴,想要获取的可以关注我的头条号并在后台私信我:交流,即可免费获取。

    49e35e5375e579cd2155baff074a5fbf.png
    展开全文
  • String类能被继承吗,为什么。

    千次阅读 2019-07-15 15:01:37
    在Java中,只要是被定义为final的类,也可以说是被final修饰的类,就是不能被继承的。 final是java中的一个关键字,可以用来修饰变量、方法和类。用关键词final修饰的域成为最终域。用关键词final修饰的变量一旦...

    不可以

    在Java中,只要是被定义为final的类,也可以说是被final修饰的类,就是不能被继承的。
    final是java中的一个关键字,可以用来修饰变量、方法和类。用关键词final修饰的域成为最终域。用关键词final修饰的变量一旦赋值,就不能改变,也称为修饰的标识为常量。如果一个类的域被关键字final所修饰,它的取值在程序的整个执行过程中将不会改变。

    展开全文
  • final修饰基本数据类型的变量时,必须赋予初始值且不能被改变。 static final修饰的是常量常量分为编译时常量与运行时常量,定义为static,强调只有一份。 比如static final int a = 10;就是编译时常量,只要是该...

    final可以用来修饰数据、方法、类。

    final数据

    1、final修饰变量
    final修饰基本数据类型的变量时,必须赋予初始值且不能被改变。
    static final修饰的是常量,常量分为编译时常量与运行时常量,定义为static,强调只有一份。
    比如static final int a = 10;就是编译时常量,只要是该常量带入的语句,在编译过后都会替换。
    这段代码
    在这里插入图片描述
    在反编译后变成
    在这里插入图片描述
    而且只要这种常量在的算式,在编译时期就会被计算。(只有基本数据类型和String)
    在这里插入图片描述
    反编译后
    在这里插入图片描述
    很明显了。
    关于运行时常量:static final int a = “123”.length();就是一个运行时常量,它的赋值会引起类的初始化。
    编译器常量有一个风险。就比如A类定义了常量,B类使用了常量。但现在需要修改A类源码的常量值,对A类重新编译,但没对B类重新编译,这就导致A类与B类的常量值不一样。
    2、final修饰引用
    对于对象引用,final使引用恒定不变。就是一旦引用指向一个对象,就无法把他再指向另一个对象,但对象是可以修改的。数组也一样,毕竟数组也是对象。
    3、空白final
    所谓空白final就是被声明为final但未赋初值的域,但在使用前,必须保证赋初值,这样就可以灵活的为其进行赋值,但是又保持了其不可更改的特性 。
    必须在域定义处(final修饰局部变量)或每个构造器里(final修饰成员变量)用表达式对final进行赋值。

    public class Tests {
    	private final int j;
    	public Tests(){
    		j = 0;
    	}
    	public Tests(int x){
    		j = x;
    	}
    	public static void main(String[] args) {
    		new Tests(12);
    		final int k;
    		k = 2;
    		System.out.println(k);
        }
    }
    

    3、final参数
    被final修饰的参数称位final参数。意思是你无法更改参数引用所指向的变量,可以读参数,但不可修改参数。主要用于向内部类传递数据。
    4、final方法
    被final修饰的方法,只能被继承,不能被覆盖
    final与private关键字:类中所有private方法都被隐式指定是final的,但如果在子类定义一个与父类方法名、参数列表、返回值都相同的private方法也可以,但调用的时候,还是按照private的法则,private方法只在本类中使用,而且用@Override也会报错,也就是说父类与子类的相同的private方法没有任何关系。
    5、final类
    当类被final修饰时,表示类是不可被继承的。final类中的所有方法都是隐式的指定为final的,无法被覆盖。但成员变量不是final,你可以人为指定某个成员变量是final。



    继承与初始化

    如下代码:

    public class Battle extends Insect {
    	private int k = printInit("Battle.k initialized");
    	public Battle(){
    		System.out.println("k = " + k);
    		System.out.println("j = " + j);
    	}
    	private static int x2 = printInit("static Battle.x2 initialized");
    	public static void main(String[] args) {
    		System.out.println("Battle constructor");
    		Battle t = new Battle();
        }
    }
    class Insect{
    	private int i = 9;
    	protected int j;
    	Insect(){
    		System.out.println("i = " + i + ", j = " + j);
    		j = 39;
    	}
    	private static int x1 = printInit("static Insect.x1 initialized");
    	static int printInit(String s){
    		System.out.println(s);
    		return 47;
    	}
    }
    

    输出
    在这里插入图片描述
    在Battle上运行Java时,程序想要访问Battle类的main方法,这时加载器就要找出Battle的.class文件,对它进行加载。加载过程中,发现它有一个父类,于是就要对父类进行加载,如果发现父类还有父类,那就要加载“爷爷类”,不要认为加载父类是由于本类调用了父类的静态方法,实际上去掉调用父类的成员变量,父类还是先加载。
    父类的static初始化完后,就轮到自己的static执行,执行完后,也就输出了前两行。
    执行到这,说明必要的类已经加载完毕了。进入main方法,输出Battle constructor。开始创建对象。先把对象内所有的基本类型设置为默认值,引用类型设置为null(通过将对象内存设为二进制零值一举生成的),然后,构造器开始调用,我们知道,子类构造器会默认在第一行添加super(),先调用父类构造器,输出i = 9, j = 0;,然后子类构造器执行。

    展开全文
  • final修饰的类,为最终类,该类不能被继承。如String 类 2. 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方法)

    展开全文
  • * 由于SIZE常量是获取到位,而8位算一个字节 * 依次向下,依次递增。小的可以直接转换为大的,大的需要强制转换为小的。 */ public void characterSize(){ int bytelen = Byte.SIZE; int shortlen = Short....
  • final的类,不能被继承 父类中如果有final的方法,子类中不能改写此方法 final的变量,不能再次赋值 –如果是基本类型的变量,不能修改其值 –如果是对象实例,不能修改其指针(但是可以修改对象内部的值) 常量 ...
  • 不可以,因为String类有final修饰符,而final修饰的类是不能被继承的,实现细节不允许改变。 关于final修饰符,介绍如下: 根据程序上下文环境,Java关键字final有“这是无法改变的”或者“终态的”含义,它可以修饰...
  • 解释:接口中的属性都是静态常量,不能被继承;方法均为抽象方法,没有具体实现的方法体,所以在多继承的情况下,即使方法同名,也不会出现类多继承那样的矛盾。 类与接口之间可以多实现 解释:与接口之间可多继承...
  • 常量模式

    2016-06-12 18:03:00
    public class Constants{ public static final String CONSTANT_PATHS=""; } 如 java.io.ObjectStreamConstans,...1. 接口是不阻止实现或继承的,也就是说子接口或实现中是能够覆盖掉常量的定义,这样通过...
  • 初学 Java 的人很不经意间就会把常量定义在接口中,大概唯一的理由是接口不实例化,而使用接口中定义的常量也是不用附着在实例上的。... 接口是不阻止实现或继承的,也就是说子接口或实现中是能够覆...
  • Java常量final

    2020-01-26 00:01:12
    1. 被final修饰的类不可以被继承 2. 被final修饰的方法不可以被重写 3. 被final修饰的变量不可以被改变.如果修饰引用,那么表示引用不可变,引用指向的内容可变. 4. 被final修饰的方法,JVM会尝试将其内联,以提高...
  • 能被重写的代码: 1,static 属于类,它不属于实例 2,final 常量 3,private 私有的 父类引用指向子类对象 注意:多态是方法的多态,属性没有多态性 类型转换异常 ClassCastException instanceof 1,子类转换为...
  • 初学 Java 的人很不经意间就会把常量定义在接口中,大概唯一的理由是接口不实例化,而使用接口中定义的常量也是不用附着在实例上的。这主要还是 JDK 本身给我们做了很... 接口是不阻止实现或继承的,也就是说...
  • 继承

    2015-07-07 20:08:54
    继承:在面向对象编程中可以通过一个扩展一个已有类病继承该类的属性和行为。来创建一个新的类这种方式叫继承。 super():调用指定的父类构造方式。能且只能写在构造方式的第一...类前面这个类不能被继承。方法前面不
  • JAVA 常量修饰符 final

    2020-10-22 10:13:49
    1.被 final 修饰的称之为常量,被修饰的变量或对象或方法不能被改变,比如被 final 修饰的变量就不允许改变 2.final 修饰的对象的命名规则要求大写 比如 NAME 当使用多个单词拼接时,使用下划线“_”拼接 比如 MY_...
  • HotSpot String常量

    2020-11-06 20:00:12
    在Java语言中String类被final关键字修饰,意味着String类不能被继承,并且它的成员方法都默认为final方法;字符串一旦创建就不能再修改。String实例的值是通过字符数组实现字符串存储的。使用字符串池的优点就是避免...
  • 字符串常量

    2020-02-29 20:01:25
    1.字符串是常量的,他们一旦被创建是不能被改变的 左为栈,右为堆 2.如果对字符串多次拼接,不建议用String类,而是用StringBuffer类 public final class string //final 不可继承 public final char value [];...
  • java变量是不可修改变量,也不能被继承 一、字符串常量常量池的设计意图 jvm为提高性能和减少内存开销 1、创建了字符串常量池,类似于缓冲区,使用 string s1 = “xxxxx”时,如果常量池存在该字符串,那么将...
  • C#中的常量与结构

    2011-06-22 09:59:00
    不能继承,也不能被继承,但可以实现接口。字段值不能在声明时直接赋值。 常量只跟类名直接联系,不能被实例化的对象调用。 常量跟结构? 常量跟结构也是直接关系,用结构名直接调用,结构名.常量名;在结构中,...
  • //private关键字和final关键字修饰的常量无法被继承重写 val id: Int = 1 var name: String = "zhangsan" def sayHello = println("hello") } // 子类可以使用extends继承父类,这么做可以提高代码...
  • final关键字 常量

    2018-08-02 23:08:47
    (1)修饰类:final修饰的类不可以被继承。 (2)修饰成员变量:可以直接初始化,也可以在构造器中初始化,除了以上两种情况不在其他任何地方再次赋值,只可赋值一次。 (3)修饰局部变量:只能初始化一次。  ...
  • final的意思是最终,修饰类的时候不能被继承,类的成员不能被修改,类的成员方法不能被修改,局部变量就成了常量。final修饰的变量:一次赋值,终身不变。(包括成员变量和局部变量) Final修饰成员变量必须定义就...
  • 多重继承中同名方法就出现了竞争关系,需要明确到底是继承的哪个方法。 方法调用阶段确定调用方法的版本。所有方法调用中的目标方法在Class文件中都是一个常量池中的符号引用。要调用方法首先要知道其直接引用...
  • 1.String类是final类,也即意味着String类不能被继承,并且它的成员方法都默认为final方法。在Java中,被final修饰的类是不允许被继承的,并且该类中的成员方法都默认为final方法。 2.String类底层是char数组来保存...
  • 预定义符号常量

    2009-07-20 17:47:00
    C++继承了ANSI C的预定义常量,预处理器在处理代码时将它们替换为确定的字面常量。这些符号不用#define重新定义,也不用#undef取消该宏。__LINE__ 引用语句的代码行号__FILE__ 引用语句所在的文件名__DATE__ ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,300
精华内容 1,320
关键字:

常量能被继承