精华内容
下载资源
问答
  • Java中实现常量和常量方法是通过关键字final实现。通常分为两种情况 编译时一种不可变的常量 运行时初始化,但不希望被改变的变量 编译时的常量,编译器可以将它的值代入用到它的任何地方,也就是说在编译时就...

    Java常量、常量类和常量方法

    Java中实现常量类和常量方法是通过关键字final实现。通常分为两种情况

    1. 编译时一种不可变的常量
    2. 运行时初始化,但不希望被改变的变量

    编译时的常量,编译器可以将它的值代入用到它的任何地方,也就是说在编译时就已经执行了计算式,减少了运行时的负担,优化了性能。在Java这些常量必须为基本类型,并且必须赋值。

    final关键字修饰的特点

    • 静态常量一般以大写字母和下划线命名。
    • 当final关键字修饰类时,标明该类为常量类,常量类不能被继承。
    • 当final关键字修饰方法时,标明该方法为常量方法,常量方法不能被重写。
    • 常量类里面的成员方法隐式为常量方法,因为常量类无法被继承,成员方法也无法被重写。
    • 当final关键字修饰基本类型的成员属性时,标明该成员属性为常量,属性的值不能被改变,而且只能赋值一次。
    • 当final关键字修饰引用类型的成员属性时,标明该成员属性为常量,属性的引用不能被改变,只能指向一次引用,但该属性指向的对象里面的值可以被改变。
    • 常量属性必须要赋值,可以在初始化时赋值,也可以在类的构造方法里面赋值。
    • 类的构造方法不能被final修饰为常量方法,包括常量类。
    • 一个既被static关键字修饰 又被final修饰的域,是一个不可改变的内存空间。

    代码示例如下:

    //常量类 不能被继承
    public final class FinalPerson{
    
     //编译时常量,基本类型,初始化时赋值
     private final int eyes=2;
     
     //静态常量,以大写字母加下划线命名,一般对外可见
     public static final int MAX_VALUE=200;
    
     //常量,在构造方法里面赋值
     public final int watches;
     
     //引用类型的常量,包括类、数组、集合。
     private final Worker worker=new Worker("david");
     private final int[] intarray={1,2,3,4,5};
     private final ArrayList<String> lists=new ArrayList();
     
     //构造方法,不能被final修饰,常量可在构造方法中赋值
     public FinalPerson(int watches){
     	//常量赋值
        this.watches=watches;
        //引用常量,对象添加值。
        lists.add("a");
        lists.add("b");
     }
    
     //常量方法,不能被重写
     public final void change(){
     	//错误用法
      	//引用常量不能再次指向新的引用
       	//woker=new Worker();
       	//intArray=new int[1];
       	//lists=new ArrayList();
    
    	//如下使用是正确的
       	//可以改变引用常量里面的属性值,如
       	worker.setName("Jack");
       	//数组操作 变为{1,3,3,4,5}
       	intarray[1]=3;
       	//list下标值改变
       	list.set(0,"b");
     }
    
     
    }
    
    //普通类
    public class Worker{
       private String name;
       
       public Worker(String name){
       		this.name=name;
       }
    
       public void setName(String name){
       		this.name=name;
       }
    }
    
    
    展开全文
  • * 1.final修饰变量,变量变成了一个常量,所有字母大写. * 2.方法final修饰,方法不允许重写. * 3.类被final修饰,类不允许继承,也就不存在方法重写的问题了. * 4.final public都是修饰符,顺序无要求. * 5...

    /**
    * 1.final修饰变量,变量变成了一个常量,所有字母大写.
    * 2.方法被final修饰,方法不允许重写.
    * 3.类被final修饰,类不允许继承,也就不存在方法重写的问题了.
    * 4.final 和 public都是修饰符,顺序无要求.
    * 5.
    * */

    public final class Mathematics { //类被final修饰,不能继承
        final double PI=3.14; //常量,不能再改变
    
        //求周长
        public final void c(double r){
            System.out.println("周长为:"+2*PI*r);
        }
        //求面积
        public final void s(double r){
            System.out.println("面积为:"+PI*r*r);
        }
    
    }
    
    
    
    class Test{
        public static void main(String[] args) { 
            //main方法要是没在public修饰的类中的时候,要用run as===》run configurations配置
             Mathematics m=new  Mathematics(); //创建对象
             m.c(3);
             m.s(3);
        }
    }
    
    展开全文
  • Java核心技术学习笔记——入门——第六章 static 、 final 和常量设计——6.4 常量设计和常量池.pdf
  • final本身的含义是“最终的,不可改变的”,它可以修饰抽象类,非抽象方法和变量。 注意:构造方法不能使用final修饰,因为构造方法不能被继承,肯定是最终的。final修饰的类:表示最终类,该类不能在有子类。 ...

    为什么得需要使用final修饰符

    继承关系最大的弊端是破坏封装:子类能访问父类的实现细节,而且可以通过方法覆盖的形式修改实现细节。

    final本身的含义是“最终的,不可改变的”,它可以修饰抽象类,非抽象方法和变量。
    注意:构造方法不能使用final修饰,因为构造方法不能被继承,肯定是最终的。

    final修饰的类:表示最终类,该类不能在有子类。
    只要满足以下条件就可以把一个类设计成final类
    1、某个类不是专门为继承而设计的
    2、处于安全考虑,类的实现细节不许改动
    3、确信该类不会再被扩展
    java里final修饰的类有很多,比如八大基本数据类型保证类和String等。

    final修饰的方法:最终的方法,该方法不能被子类覆盖
    注意:子类可以调用,但是不能覆盖

    1、final修饰的变量:表示常量,只能赋值一次,不能再次赋值。
    2、final变量必须显示的指定初始值,系统不会为final字段初始化。

    常量名规范:常量名符合标识符,单词全部大写,单词之间使用下划线隔开。

    final修饰基本类型变量:表示该变量的值不能改变,即不能重新赋值。
    final修饰引用类型:表示该变量的引用地址不能改变,而不是引用地址里的内容不能变。

    final是唯一可以修饰局部变量的修饰符,局部内部类只能访问final修饰的局部变量。

    什么时候用常量

    当在程序中多个地方使用到共同的数据,且该数据不会改变,此时我们专门定义全局的常量。

    展开全文
  • 50 Java final 常量final方法

    千次阅读 2014-02-09 07:27:38
    * java 会使用常量池来管理曾经用过的字符串直接量,例如,只想能够string a="java";语句之后 * 系统的字符串池中就会缓存一个字符串“java”;如果程序再次执行 String b=“java”,系统将会让 * b直接指向字符...
    /*
     * java 会使用常量池来管理曾经用过的字符串直接量,例如,只想能够string a="java";语句之后
     * 系统的字符串池中就会缓存一个字符串“java”;如果程序再次执行 String b=“java”,系统将会让
     * b直接指向字符串池中的“java” 字符串,因此a==b将会返回true
     */
    public class FinalReplaceTest {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		//下面定义了4个final “宏变量”
    		final int a=5+2;
    		final double b=1.2/3;
    		final String str="科技"+"Java";
    		final String book="科技"+"Java:"+99.9;
    		//下面的book2变量的值因为调用了方法,所以无法在编译时被确认下来
    		final String book2="科技Java:"+String.valueOf(99.9);
    		System.out.println(book=="科技Java:99.9");//true
    		System.out.println(book2=="科技Java:99.9");//false
    		
    	}
    
    }
    


    final方法

    /*
     * final 修饰的方法不可被重写,如果处于某些原因,不希望自乐ichognxie弗雷的某个方法
     * 可以用final修饰该方法
     * 例如:Object类里就有个final方法:getClass(),
     */
    //下面程序师徒重写final方法,将会引发编译错误
    public class FinalMethod {
    	//用final修饰的方法
    	public final void test(){};
    
    }
    class Sub extends FinalMethod{
    	//下面方法定义将出现编译错误,不能重写final方法
    	public void text();//编译错误
    }
    

    /*
     * 对于一个private 方法,因为它仅 在当前类中可见,其子类无法访问该类方法,所以
     * 子类无法重写该方法——如果子类中定义一个鱼弗雷private方法有相同方法名、相同
     * 形参列表、相同返回值类型的方法,也不是方法重写,知识重新定义了一个新方法。
     * 因此即使使用能够final修饰一个private访问权限的方法,依然可以在其子类中
     * 定义与给方法具有相同方法名、相同形参列表、相同返回值类型的方法
     */
    /**
     * “重写”父类 private fianl 方法
     * @author Administrator
     *
     */
    public class PrivateFinalMethod {
    
    	private final void  test(){};
    }
    class Sub2 extends PrivateFinalMethod{
    	//下面的方法定义不会出现问题
    	public void test(){};
    }
    /**
     * final 修饰的方法知识不能被重写,完全可以被重载
     * @author Administrator
     *
     */
    class FinalOverload{
    	public final void test(){};
    	public final void test(String arg){
    		
    	}
    }


    fianl 类

    /**
     * fianl 修饰的类不可以有子类 例如java.lang.Math 就是一个final类,他不可以有子类
     * 为了保证某个类不可被继承,则可以使用final修饰这个类
     * @author Administrator
     *
     */
    public final class FinalExtends {
    
    }
    //下面的类定义将出现编译错误
    class Sub3 extends FinalExtends{
    	
    }
    


    展开全文
  • Java核心技术学习笔记——入门——第六章 static 、 final 和常量设计——6.3 final.pdf
  • final---用于类、方法前。final类---不可被继承。final方法---不可被覆盖。final类不能被继承。如果我们不希望一个类被继承,我们使用final来修饰这个类。于是这个类将无法被继承。 比如我们设定的Math类,涉及了...
  • (Java代码执行顺序,先编译为class文件,在用虚拟机加载class文件执行)放于方法区中的静态常量池。在编译阶段存入调用类的常量池中如果调用此常量的类不是定义常量的类,那么不会初始化定义常量的类,因为在编译...
  • java当中的接口的变量都是final修饰的常量,那么方法方法final修饰的吗 final能不能修饰类呢
  • Java核心技术学习笔记——入门——第六章 static 、 final 和常量设计——6.2 static.pdf
  • Java核心技术学习笔记——入门——第六章 static 、 final 和常量设计——6.1 static.pdf
  • Java常量final

    2020-01-26 00:01:12
    1 final在java中的作用,有哪些用法? 2 常量 1 final在java中的作用,有哪些用法? fifinal也是很多面试喜欢问的地方,但我觉得这个问题很无聊,通常能回答下以下5点就不错了: 1. 被final修饰的类不可以被继承 ...
  • 返回string对象在常量池中的引用(即字符串对象在常量池中的地址); ==比较的是对象的地址是否相同;(即是否是同一个对象) equals比较的是对象的内容是否一样; 对象的引用存的是对象实际位置的首地址; final从...
  • Java中static final常量”的坑

    千次阅读 2018-11-29 10:50:44
    但是我们根据常量的特点(不可修改),经常会使用“static final”关键字,一个变量进行修饰,以达到不创建类就可直接使用,并且该变量不允许修改的目的,看起来就跟“常量”一样。无论是教科书,还是上网查资料,...
  • 4、被final修饰后的变量(属性)不允许被再次赋值,final变量进行修饰时一定要赋值,被final修饰后的变量,我们称之为常量 定义常量final 类型 大写常量名 = 常量常量命名规范:字母全部要...
  • final修饰的常量不能修改:当调用f1(final修饰的)方法的时候,将i重新赋值这样会报错(例i=i+1),当调用f2(非final修饰),将i重新定值就不会把报错,结论:final修饰的是常量。static修饰和final的修饰public: ...
  • final的概述和作用

    2019-04-18 10:20:11
    final的概述和作用 final: 修饰符,可以用于修饰类、成员方法和成员变量 final所修饰的类:不能被继承,不能有子类 final所修饰的方法:不能被重写 final所修饰的变量:是不可以修改的,是常量 注意:...
  • Java中的final变量、final方法和final

    万次阅读 多人点赞 2018-12-13 17:39:24
    1、final变量 final关键字可用于变量声明,一旦该变量被设定,就不可以再改变该变量...在Java中定义全局常量,通常使用public static final修饰,这样的常量只能在定义是被赋值。 public static final double PI...
  • http://blog.csdn.net/qq_27093465/article/details/52180865 (侵删) enum适合用于多属性常量 final static 适合用于单属性常量
  • Integer i = 0; String s = "0"; 上述两个代码都会保存在运行时常量池中 ...而 final Integer i = 200; 只会保存在堆内存或栈内存中, final只代表这是个常量, 不允许修改, 而不代表其存储区域
  • final实例域 将实例域定义为final。...例如在Employee类中的name域声明为final,因为在对象构建之后,这个值不会再被修改,即没有setName方法。 class Employee {  private final String name;...
  • java kotlin 混合编码已经一段时间了,java中经常在类(或者interface)里写 public final static 常量来代替枚举。 java 的final static 常量转换为kotlin 时,直接用IDE 自动转转的是不够好的。特此记录下 ...
  • final可用来修饰类,变量,方法final修饰的类不能有子类,也不能被继承。 final修饰的变量是一个常量,不能重新赋值。 final修饰的方法不能重写 final修饰的常量① 与static final 修饰的常量② 的区别。 ...
  • 1、首先properties文件一般是配置型...2、通过public static final在类中定义的常量是属于永不可变的东西(当然要变化的话会非常麻烦,要修改改常量值,要把整个项目重新编译打包,如果不重新编译的话值是不会变的)
  • 关于final常量的一个题目.pdf
  • JAVA final关键字,常量的定义

    千次阅读 2019-06-17 16:58:14
    final(最终)是一个修饰符 ...4、被final修饰后的变量(属性)不允许被再次赋值,final变量进行修饰时一定要赋值,被final修饰后的变量,我们称之为常量 定义常量final 类型 大写常量名 = 常量常量命名规范...
  • const也是JavaScript中新加的关键字,JavaScript允许使用关键字定义常量,与var、let不同的是,使用const定义的常量只能在定义时指定...在Java中,利用关键字final指示常量; 关键字final 表示这个变量只是被赋值一...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 241,065
精华内容 96,426
关键字:

final对常量和方法的作用