精华内容
下载资源
问答
  • final关键字;使用final定义的类能够再有子类即任何类都能够继承以final声明的父类;使用final定义的方法不能被子类所覆写;使用final定义的变量就成为了常量常量必须在定义的时候设置好内容并且不能修改;谢谢大家...
  • 面试题  以下关于final关键字说法错误的是(A,C)(两项) A) final是java中的修饰符,可以修饰类、接口、抽象类、方法和...一、final关键字可以用来修饰类、方法、变量。各有不同。 A、修饰类(class)。   1、

    面试题 

    以下关于final关键字说法错误的是(A,C)(两项)

    A) final是java中的修饰符,可以修饰类、接口、抽象类、方法和属性
    B) final修饰的类肯定不能被继承
    C) final修饰的方法不能被重载
    D) final修饰的变量不允许被再次赋值

    一、final关键字可以用来修饰类、方法、变量。各有不同。

    A、修饰类(class)。 
         1、该类不能被继承。 
         2、类中的方法不会被覆盖,因此默认都是final的。 
         3、用途:设计类时,如果该类不需要有子类,不必要被扩展,类的实现细节不允许被改变,那么就设计成final类

    B、修饰方法(method) 
         1、该方法可以被继承,但是不能被覆盖。 
         2、用途:一个类不允许子类覆盖该方法,则用final来修饰 
         3、好处:可以防止继承它的子类修改该方法的意义和实现;更为高效,编译器在遇到调用fianal方法转入内嵌机制,提高了执行效率。 
         4、注意:父类中的private成员方法不能被子类覆盖,因此,private方法默认是final型的(可以查看编译后的class文件)

    C、修饰变量(variable) 
         1、用final修饰后变为常量。包括静态变量、实例变量和局部变量这三种。 
         2、特点:可以先声明,不给初值,这种叫做final空白。但是使用前必须被初始化。一旦被赋值,将不能再被改变。

    D、修饰参数(arguments) 
         1、用final修饰参数时,可以读取该参数,但是不能对其作出修改

    二、final关键字不能用来抽象类和接口。
    展开全文
  • 15、final关键字和权限修饰符01_final关键字概念与四种用法02_final关键字用于修饰类03_final关键字用于修饰成员方法04_final关键字用于修饰局部变量05_final关键字用于修饰成员变量06_四种权限修饰符 01_final...

    01_final关键字概念与四种用法

    final关键字代表最终、不可改变的。

    常见四种用法:

    1. 可以用来修饰一个类
    2. 可以用来修饰一个方法
    3. 还可以用来修饰一个局部变量
    4. 还可以用来修饰一个成员变量

    02_final关键字用于修饰类

    当final关键字用来修饰一个类的时候,格式:
    public final class 类名称 {
    // …
    }

    含义:当前这个类不能有任何的子类。(太监类)
    注意:一个类如果是final的,那么其中所有的成员方法都无法进行覆盖重写(因为没儿子。)
    但可以对他以上的父类进行覆盖重写,只是他不能有子类了

    public final class MyClass /*extends Object*/ {
    
        public void method() {
            System.out.println("方法执行!");
        }
    
    }
    
    // 不能使用一个final类来作为父类
    public class MySubClass /*extends MyClass*/ {
    }
    

    03_final关键字用于修饰成员方法

    当final关键字用来修饰一个方法的时候,这个方法就是最终方法,也就是不能被覆盖重写。
    格式:
    修饰符 final 返回值类型 方法名称(参数列表) {
    // 方法体
    }

    注意事项:
    对于类、方法来说,abstract关键字和final关键字不能同时使用,因为矛盾。

    public abstract class Fu {
    
        public final void method() {
            System.out.println("父类方法执行!");
        }
    
        public abstract /*final*/ void methodAbs() ;
    
    }
    
    
    public class Zi extends Fu {
        @Override
        public void methodAbs() {
    
        }
    
        // 错误写法!不能覆盖重写父类当中final的方法
    //    @Override
    //    public void method() {
    //        System.out.println("子类覆盖重写父类的方法!");
    //    }
    }
    

    04_final关键字用于修饰局部变量

    public class Demo01Final {
    
        public static void main(String[] args) {
            int num1 = 10;
            System.out.println(num1); // 10
            num1 = 20;
            System.out.println(num1); // 20
    
            // 一旦使用final用来修饰局部变量,那么这个变量就不能进行更改。
            // “一次赋值,终生不变”
            final int num2 = 200;
            System.out.println(num2); // 200
    
    //        num2 = 250; // 错误写法!不能改变!
    //        num2 = 200; // 错误写法!
    
            // 正确写法!只要保证有唯一一次赋值即可
            final int num3;
            num3 = 30;
    
            // 对于基本类型来说,不可变说的是变量当中的数据不可改变
            // 对于引用类型来说,不可变说的是变量当中的地址值不可改变
            Student stu1 = new Student("赵丽颖");
            System.out.println(stu1);
            System.out.println(stu1.getName()); // 赵丽颖
            stu1 = new Student("霍建华");
            System.out.println(stu1);
            System.out.println(stu1.getName()); // 霍建华
            System.out.println("===============");
    
            final Student stu2 = new Student("高圆圆");
            // 错误写法!final的引用类型变量,其中的地址不可改变
    //        stu2 = new Student("赵又廷");
            System.out.println(stu2.getName()); // 高圆圆
            stu2.setName("高圆圆圆圆圆圆");
            System.out.println(stu2.getName()); // 高圆圆圆圆圆圆
        }
    
    }
    
    public class Student {
    
        private String name;
    
        public Student() {
        }
    
        public Student(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }
    
    

    05_final关键字用于修饰成员变量

    对于成员变量来说,如果使用final关键字修饰,那么这个变量也照样是不可变。

    1. 由于成员变量具有默认值,所以用了final之后必须手动赋值,不会再给默认值了。
    2. 对于final的成员变量,要么使用直接赋值,要么通过构造方法赋值。二者选其一。
    3. 必须保证类当中所有重载的构造方法,都最终会对final的成员变量进行赋值。
    public class Person {
    
        private final String name/* = "鹿晗"*/;
    
        public Person() {
            name = "关晓彤";
        }
    
        public Person(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    
    //    public void setName(String name) {
    //        this.name = name;
    //    }
    }
    

    06_四种权限修饰符

    Java中有四种权限修饰符:
    public > protected > (default) > private
    同一个类(我自己) YES YES YES YES
    同一个包(我邻居) YES YES YES NO
    不同包子类(我儿子) YES YES NO NO
    不同包非子类(陌生人) YES NO NO NO

    注意事项:(default)并不是关键字“default”,而是根本不写。

    public class Demo01Main {
    }
    
    public class MyClass {
    
        public int num = 10;
    
        public void method() {
            System.out.println(num);
        }
    
    }
    
    public class MyAnother {
    
        public void anotherMethod() {
    //        System.out.println(new MyClass().num);
        }
    
    }
    
    package cn.itcast.day11.demo02.sub;
    
    import cn.itcast.day11.demo02.MyClass;
    
    public class MySon extends MyClass {
    
    
        public void methodSon() {
    //        System.out.println(super.num);
        }
    
    }
    
    package cn.itcast.day11.demo02.sub;
    
    import cn.itcast.day11.demo02.MyClass;
    
    public class Stranger {
    
        public void methodStrange() {
            System.out.println(new MyClass().num);
        }
    
    }
    
    展开全文
  • 文章目录final关键字、权限修饰符final关键字概念与四种用法final关键字用于修饰类final关键字用于修饰成员方法注意事项final关键字用于修饰局部变量演示一final关键字修饰成员演示一(构造方法)演示二(直接定义时...


    这里是一段防爬虫文本,请读者忽略。
    本文原创首发于CSDN,作者IDYS
    博客首页:https://blog.csdn.net/weixin_41633902/
    本文链接:https://blog.csdn.net/weixin_41633902/article/details/115741592
    未经授权,禁止转载!恶意转载,后果自负!尊重原创,远离剽窃!
    

    final关键字、权限修饰符

    final关键字概念与四种用法

    • final关键字代表最终、不可改变的意思

    • final关键字常见的四种用法
    1. 用来修饰类
    2. 用来修饰方法
    3. 用来修饰局部变量
    4. 用来修饰成员变量

    final关键字用于修饰类

    • final关键字用于修饰一个类的时候,格式:
    public final class 类名称 {
    }
    

    • 含义:用final关键字修饰的这个类不能有任何的子类(太监类)

    final关键字用于修饰成员方法

    • final关键字用来修饰一个方法的时候,这个方法就是最终方法,也就意味着不能被覆盖重写

    • 格式:

        修饰符 final 返回值类型 方法名称(参数列表){
        		方法体
        }
    

    注意事项

    • 对于类、方法来说,abstract关键字和final关键字不能同时使用,因为矛盾
      • 因为abstract意味着必须要被覆盖重写,而final意味着不能被覆盖重写

    final关键字用于修饰局部变量

    • 一旦使用final用来修饰局部变量,那么这个变量就不能进行更改
      • 只保证有唯一 一次赋值即可
      • 对于基本类型来说,不可变意味着变量当中的数据不可改变
      • 对于引用类型来说,不可变意味着变量当中的地址值不可改变

    演示一

    • 其他类
    package com.idayuanshuai.www.Demo1;
    
    public class OperateSystem {
        String name;
    
        public OperateSystem(String name) {
            this.name = name;
        }
    
        public OperateSystem() {
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }
    
    • 主类
    package com.idayuanshuai.www.Demo1;
    
    public  class Myclass {
        public static void main(String[] args) {
            System.out.println("this is idys's program ");
            // 基本类型定义方法一
            final int num1 =20;
            System.out.println(num1);
            // 基本类型定义方法二
            final int num2;
            num2 = 30;
            System.out.println(num2);
            final OperateSystem syName = new OperateSystem("linux");
            System.out.println(syName.getName());
            syName.setName("Windows");
            System.out.println(syName.getName());
            //  syName = new OperateSystem("Unix"); 因为syname已经用final修饰了,
            //  所以不能再将 syName 指向新的对象
        }
    
    }
    
    • 输出结果
    this is idys's program 
    20
    30
    linux
    Windows
    

    final关键字修饰成员

    1. final关键字修饰的成员变量,必须手动赋值
    2. 对于final的成员变量,要么直接赋值,要么通过构造方法赋值,二者必选其一
    3. 必须保证类当中所有重载的构造方法,都最终会对final的成员变量进行赋值

    演示一(构造方法)

    package com.idayuanshuai.www.Demo1;
    
    public class StudentTest {
        private final String name;
    
        public StudentTest(String name) {
            this.name = name;
        }
        // 必须保证所有的构造方法都能对name赋值
        public String getName() {
            return name;
        }
        // 这个时候就不要去用setName方法了,因为name是用final修饰的,
        // 而构造方法里面已经有对其进行赋值
    }
    

    演示二(直接定义时对成员变量赋值)

    package com.idayuanshuai.www.Demo1;
    
    public class StudentTest1 {
        private final String name = "idys";
    
        public StudentTest1() {
        }
    
        public String getName() {
            return name;
        }
    }
    

    四种权限修饰符

    • Java有四种权限修饰符,分别为:
    1. public
    2. protected
    3. (default)
    4. private
    • 它们的权限大小关系为:

      • public>protected>(default)>private
    • 注意事项:(default)并不是关键字default,而是根本不写

    • 关于在各种情况下不同关键字的访问权限

    publicprotected(default)private
    同一个类(我自己)YESYESYESYES
    同一个包(我邻居)YESYESYESNO
    不同包子类(我儿子)YESYESNONO
    不同包非子类(陌生人)YESNONONO

    写在最后的话:

    • 无论每个知识点的难易程度如何,我都会尽力将它描绘得足够细致
    • 欢迎关注我的CSDN博客,IDYS’BLOG
    • 持续更新内容
      linux基础 | 数据通信(路由交换,WLAN) | Python全栈 | 云计算
    • 如果你有什么疑问,或者是难题。欢迎评论或者私信我。你若留言,我必回复!
    • 虽然我现在还很渺小,但我会做好每一篇内容。谢谢关注!

    展开全文
  • finalfinal可以修饰:属性,方法,类,局部变量(方法中的变量) final修饰的属性的初始化可以在编译期,也可以在运行...final修饰的方法表示该方法在子类中不能被重写,final修饰的类表示该类不能被继承。 ...

    final:

    • final可以修饰:属性,方法,类,局部变量(方法中的变量)
    • final修饰的属性的初始化可以在编译期,也可以在运行期,初始化后不能被改变。
    • final修饰的属性跟具体对象有关,在运行期初始化的final属性,不同对象可以有不同的值。
    • final修饰的属性表明是一个常数(创建后不能被修改)。
    • final修饰的方法表示该方法在子类中不能被重写,final修饰的类表示该类不能被继承。
    • 对于基本类型数据,final会将值变为一个常数(创建后不能被修改);但是对于对象句柄(亦可称作引用或者指针),final会将句柄变为一个常数(进行声明时,必须将句柄初始化到一个具体的对象。而且不能再将句柄指向另一个对象。但是,对象的本身是可以修改的。这一限制也适用于数组,数组也属于对象,数组本身也是可以修改的。方法参数中的final句柄,意味着在该方法内部,我们不能改变参数句柄指向的实际东西,也就是说在方法内部不能给形参句柄再另外赋值)。

    static:

    • static可以修饰:属性,方法,代码段,内部类(静态内部类或嵌套内部类)
    • static修饰的属性的初始化在编译期(类加载的时候),初始化后能改变。
    • static修饰的属性所有对象都只有一个值。
    • static修饰的属性强调它们只有一个。
    • static修饰的属性、方法、代码段跟该类的具体对象无关,不创建对象也能调用static修饰的属性、方法等
    • static和“this、super”势不两立,static跟具体对象无关,而this、super正好跟具体对象有关。
    • static不可以修饰局部变量。
    • import static方式导入的包,调用静态方法时不需要使用 对象.方法(Math.random)可以直接使用方法(random())

    static final:

    • static修饰的属性强调它们只有一个,final修饰的属性表明是一个常数(创建后不能被修改)。static final修饰的属性表示一旦给值,就不可修改,并且可以通过类名访问。

    • static final也可以修饰方法,表示该方法不能重写,可以在不new对象的情况下调用

    • 对于变量,表示一旦赋值就不可以修改,并且通过类名可以访问;

    • 对于方法,表示不可覆盖,并且可以通过类名直接访问。

    展开全文
  • final修饰类 格式 public final class 类名称{ } 含义 这个类不能有子类,所有...abstract关键字和final关键字不能同时使用,因为矛盾 final修饰局部变量 一旦被final修饰,那么这个变量可更改 对于基本类型...
  • final关键字也是一个修饰符,能修饰类、方法、属性、局部变量(参数) ​ final 是最终的意思 2)final 修饰类 ​ final 修饰类,这个类不能被继承 ​ final class XXX{} 含义为允许这个类被继承 ​ ...
  • 在项目学习过程中,接触到了一种传参的方式:用final关键字修饰方法的参数。 一、在方法中,用final修饰参数的好处如下: 1、确保,不会也不能对于参数进行修改,保证了调用发起方数据的安全; 2、避免在方法体中...
  • JavaSE面向对象之final关键字及权限修饰符11 第一章 fifinal关键字 1.1 概述 学习了继承后,我们知道,子类可以在父类的基础上改写父类内容,比如,方法重写。那么我们能不能随意的继承 API中提供的类,改写...
  • 三、修饰参数 用来表示这个参数在这个函数内部允许被修改。 class C{ public int cInt = 4; public void setInt(final int cInt){ this.cInt = cInt; cInt = 4;//编译错误:在这个函数内部允许修改这个参数....
  • 概述 final关键字代表最终的,可改变的; 常见四种用法:    1) 可以用来修饰一个类    2)可以用来修饰一个方法 ...final关键字修饰类 格式:public final class 类名称...
  • final关键字修饰类的时候,格式: public final class 类名称{ // ... } 含义:当前这个类不能有任何子类。 注意:一个类如果是final类,那么其中的所有成员方法都无法进行覆盖重写 当final...
  • final关键字 :代表最终,可改变的。 可以用来修饰一个类: public final 类名{}; 修饰的类不能有子类也就是可以被继承 注意:一个类如果是final,那么其中所有的成员方法都无法进行覆盖重写 可以用来修饰...
  • final关键字代表最终、可改变的 final常见的四种用法 修饰类 final修饰类的格式: public final class MyClass { // ... } 含义:当前这个类不能有任何子类(太监类)意思就是说不能作为父类 一个类如果...
  • 在方法参数前面加final关键字就是为了防止数据在方法体中被修改。 主要分两种情况:第一,用final修饰基本数据类型;第二,用final修饰引用类型。 第一种情况,修饰基本类型(非引用类型)。这时参数的值在方法...
  • (1) 修饰类:被fianl关键字修饰的类不能有任何子类 public final class 类名称{ 类内容; } (2)修饰方法:被fianl关键字修饰的方法不能被覆盖重写 public final 返回值类型 方法名称(参数列表){ 方法体; } ...
  • final关键字 代表最终、可改变的 常见四种用法: 可以用来修饰一个类 不能使用一个final类来作为父类 格式: public final class 类名称{ ...注意:对于类、方法来说,abstract关键字和final关键字不能
  • java复习第3天---3.1---final关键字、权限修饰符 目录 文章目录1、final 关键字1.1、修饰类1.2、修饰成员方法1.3、修饰成员变量1.4、修饰局部变量2、权限修饰符***后记*** : 内容 1、final 关键字   final -...
  • final关键字 权限修饰符 内部类final关键字使用方法修饰修饰方法修饰变量局部变量----基本类型局部变量---引用类型成员变量权限修饰符内部类成员内部类访问特点:匿名内部类: final关键字使用方法 学习了继承以后...
  • Final关键字

    2019-09-28 14:06:50
    目录: final关键字介绍 final修饰类 ...Java提供了Final关键字主要用来修饰一些可改变的内容。 2. final修饰类 注意: final修饰的类,不能被继承。 代码演示: final class 类名 { } // 代码...
  • final修饰一个变量时,引用不能变,引用变量所指向的对象中的内容可以变。 final StringBuffer a = new StringBuffer("abc"); a = new StringBuffer("");//编译错误 a.append("ddd");//编译成功 因此定义...
  • 首先我们来看下 final关键字的用法,然后再来回答这道题! 1.final 关键字可以用来修饰 类,方法和变量(成员变量和局部变量) 那么我们来讨论下,final关键字集中用法 修饰类 final修饰类时,说明该类你想被...
  • 首先我们来看下 final关键字的用法,然后再来回答这道题! 1.final 关键字可以用来修饰 类,方法和变量(成员变量和局部变量) 那么我们来讨论下,final关键字几种用法 修饰类 final修饰类时,说明该类你想被别人...
  • 使用final关键字修饰一个变量时,是指引用变量不能变,引用变量所指向的对象中的内容还是可以改变的。例如,对于如下语句: finalStringBuffera=newStringBuffer("immutable");执行如下语句将报告编译期错误: a=...
  • final关键字

    千次阅读 2019-07-20 19:48:29
    谈到final关键字,想必很多人都陌生,在使用匿名内部类的时候可能会经常用到final关键字。另外,Java中的String类就是一个final类,那么今天我们就来了解final这个关键字的用法。 一、final关键字的基本用法 在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 92,313
精华内容 36,925
关键字:

final关键字不能修饰的参数是