java的final，权限、内部类的用法（一）

最新推荐文章于 2021-10-01 17:33:03 发布
最新推荐文章于 2021-10-01 17:33:03 发布
阅读量242 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cy_believ/article/details/111873424
版权

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

常见四种用法：

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

一旦使用final用来修饰局部变量，那么这个变量就不能进行更改。
“一次赋值，终生不变”
对于基本类型来说，不可变说的是变量当中的数据不可改变
对于引用类型来说，不可变说的是变量当中的地址值不可改变
例子：

package cn.itcast.day11.demo01;

public class Student {

    private String name;

    public Student() {
    }

    public Student(String name) {
        this.name = name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

main函数：

package cn.itcast.day11.demo01;

public class Demo01Final {

    public static void main(String[] args) {

        int num1 = 10;

        System.out.println(num1);

        num1 = 20;
        System.out.println(num1);

        //一旦使用final用来修饰局部变量，那么这个变量就不能进行更改
        // "一次赋值，终生不变"
        final int num2 = 200;
        System.out.println(num2);

        // num2 = 250 // 错误写法，不能改变

        // 正确写法！只要保证唯一一次赋值即可
        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());
    }

}
package cn.itcast.day11.demo01;

public class Demo01Final {

    public static void main(String[] args) {

        int num1 = 10;

        System.out.println(num1);

        num1 = 20;
        System.out.println(num1);

        //一旦使用final用来修饰局部变量，那么这个变量就不能进行更改
        // "一次赋值，终生不变"
        final int num2 = 200;
        System.out.println(num2);

        // num2 = 250 // 错误写法，不能改变

        // 正确写法！只要保证唯一一次赋值即可
        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());
    }
}

运行结果：
在这里插入图片描述

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

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

package cn.itcast.day11.demo01;

public class Student {

    private String name;

    public Student() {
    }

    public Student(String name) {
        this.name = name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

子类方法

package cn.itcast.day11.demo01;

public class Zi extends Fu{
    @Override
    public void methodAbs() {

    }

    // 错误写法！不能覆盖重写父类当中final的方法
//    @Override
//    public void method() {
//        System.out.println("子类覆盖重写父类的方法！");
//    }
}

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

  1. 由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
  2. 对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。
  3. 必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。
    例子：
package cn.itcast.day11.demo01;

public class Person {

   private final String name /*= "鹿晗"*/;
   public Person(){
       name = "关晓彤";
   }

   public Person(String name){
       this.name = name;
   }

   public String getName(){
       return name;
   }
}

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

含义：当前这个类不能有任何的子类。（太监类）
注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写（因为没儿子。）
例子：

package cn.itcast.day11.demo01;

public final class MyClass {

    public void method(){
        System.out.println("方法执行！");
    }
}

二、Java中有四种权限修饰符：

public > protected > (default) > private
同一个类（我自己） YES YES YES YES
同一个包（我邻居） YES YES YES NO
不同包子类（我儿子） YES YES NO NO
不同包非子类（陌生人） YES NO NO NO

注意事项：(default)并不是关键字“default”，而是根本不写。
不同包的子类或者陌生人，public修饰的成员变量也可以访问

public修饰符的用法：

同一个包中的public成员变量可以相互访问
MyClass类

package cn.itcast.day11.demo02;

public class MyClass {

    public int num = 10;

    public void methhod(){
        System.out.println(num);
    }
}

MyAnother类

package cn.itcast.day11.demo02;

public class MyAnother {

    public void anotherMethod() {
//        System.out.println(new MyClass().num);
    }

}

内部类

如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。
例如：身体和心脏的关系。又如：汽车和发动机的关系。

分类：

  1. 成员内部类
  2. 局部内部类（包含匿名内部类）

成员内部类的定义格式：
修饰符 class 外部类名称 {
修饰符 class 内部类名称 {
// …
}
// …
}

注意：内用外，随意访问；外用内，需要内部类对象。

==========================
如何使用成员内部类？有两种方式：

  1. 间接方式：在外部类的方法当中，使用内部类；然后main只是调用外部类的方法。
  2. 直接方式，公式：
    类名称 对象名 = new 类名称();
    【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();】

例子：

package cn.itcast.day11.demo03;

public class Body { // 外部类

    public class Heart{// 成员内部类

        // 内部类的方法
        public void beat(){
            System.out.println("心脏跳动：蹦蹦蹦");
            System.out.println("我叫:" + name);


        }

    }

    // 外部类的成员变量
    public String name;

    // 外部类的方法
    public void methodBody(){
        System.out.println("外部类的方法");

        new Heart().beat();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

main函数：

package cn.itcast.day11.demo03;

public class Demo01InnerClass {

    public static void main(String[] args) {
        Body body = new Body();

        // 通过外部类的对象，调用外部类的方法，里面间接在使用内部类Heart
        body.methodBody();
        System.out.println("===========");

        // 按照公式写
        Body.Heart heart = new Body().new Heart();
        heart.beat();
    }
}

结果：
在这里插入图片描述
如变量出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名

package cn.itcast.day11.demo03;

public class Outer {


    int num = 10;// 外部类的成员变量

    public class Inner{
        int num = 20;

        public void methodInner(){
            int num = 30;// 内部类方法的局部变量
            System.out.println(num); // 局部变量，就近原则
            System.out.println(this.num); // 内部类的成员变量
            System.out.println(Outer.this.num); // 外部类的成员变量

        }
    }
}

main函数

package cn.itcast.day11.demo03;

public class Demo02InnerClass {

    public static void main(String[] args) {
        // 外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
        Outer.Inner obj = new Outer().new Inner();
        obj.methodInner();
    }

}

结果
在这里插入图片描述

circle_yy
关注
专栏目录
java重点！Final+内部类+四种权限关键字详解
Gfeiyv的博客
11-13 212
final基本都可以修饰自己定义的东西 第一点关于类，public final class P这个类他可有父类（Object），但是绝不能有子类，当然依然不能重写自己的方法，但他本身可以重写它父类的方法，类似太监，没有儿子，但有父亲 关于方法，abstract抽象方法表示必须被重写，而与final意义向矛盾，两者不可同时用在同一个方法中 对于基本类型变量值是不可以改变的，但是对于引用类型，f的地址不可以改变，但是它指向对象的值是可以变的 对于成员变量，final后必须直接赋值，默认值会来搅和的，对于fin.
Java基础权限控制与final，内部类
03-31
Java是一种广泛使用的面向对象的编程语言，它提供了丰富的功能来帮助开发者构建各种应用程序...在实际开发中，合理地使用final和权限控制可以提高代码的安全性，而内部类的恰当应用则可以提升代码的表达力和组织结构。
Java-final、权限、内部类-第11节
zuefeng的博客
09-14 122
学习目标： 学会使用final关键字； 了解权限修饰符； 学会使用内部类。 学习内容： 一、final关键字 1、修饰类 a、修饰的类不能有任何子类，即太监类 b、final修饰的类中的抽象方法不能被重写 2、修饰方法 a、修饰的方法不能被覆盖重写 b、abstract和final关键字冲突，不能同时存在 3、修饰局部变量 a、修饰的局部变量不能进行更改，只能赋值一次 b、final修饰变量不可变： - 基本类型变量的数据不可以变 - 引用类型变量的地址不可变 4、修饰成员变量
Java内部类与final关键字详解
Thinking_IN_Java
05-10 3092
详解Java内部类与final关键字 内部类的几种创建方法： 1、成员内部类 class Outer{ private int i = 1; class Inner{ public void fun() {System.out.println("Outer I=" + i)} } } 2、方法内部类 class Outer{ public void fu
java基础——final接口内部类
上邪的博客
10-01 432
java基础 笔记的都是需要背诵的零散知识点，以顺序的方式组织 文章目录java基础1.单例模式2.饿汉式VS懒汉式3.final关键字4.final小细节5.抽象类 1.单例模式 静态方法和属性的经典实用 设计模式的理解：设计模式是在大量的实践中总结和理论化之后优选的代码结构，编程风格，以及解决问题的思考方式。设计模式就像是经典的棋谱，不同的棋局，我们用不同的棋谱，免去我们自己再思考和摸索 单例模式： 单例模式：就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类
JAVA小记：final，内部类
weixin_44489825的博客
08-20 418
小记：final，内部类一、 final关键字1、概述2、注意事项二、内部类1、概述定义分类2、成员内部类格式成员内部类的使用成员内部类的同名变量访问3、局部内部类定义格式局部内部类的使用4、关于类的权限修饰符外部类成员内部类局部内部类5、局部内部类访问所在方法的局部变量6、匿名内部类 一、 final关键字 1、概述   由继承关系可知，子类可以在父类的基础上改写父类内容，比如，方法重写。如果随意的继承API中提供的类，改写其内容，显然这是不合适的。为了避免这种随意改写的情况，Java提供了final 关
Java基础【final、权限、内部类、引用类型】
12-21
day11【final、权限、内部类、引用类型】第一章 final关键字1.1 概述1.2 使用方式修饰类修饰方法修饰变量第二章 权限修饰符2.1 概述2.2 不同权限的访问能力第三章 内部类3.1 概述什么是内部类成员内部类访问特点3.2 ...
day11【final、权限、内部类】.pdf
02-20
通过文件内容的描述，我们可以看出`final`关键字的使用、权限修饰符的定义和作用、内部类的概念及其优势、以及引用类型在Java编程中的重要性和应用场景。这些知识点对于理解Java编程的基本概念和提高编程技能至关...
java中的内部类详细总结
09-04
- 当一个类需要访问另一个类的私有成员，而又不希望暴露这个访问权限时，可以使用内部类。 - 在事件处理中，如Swing或Android开发，经常使用匿名内部类创建事件监听器。 - 用于实现回调机制，内部类可以作为接口...
11.【final、权限、内部类】.zip
01-31
在Java编程语言中，`final`关键字、权限控制和内部类是三个重要的概念，它们各自在不同的场景下发挥着关键作用。接下来，我们将详细探讨这三个主题。 首先，`final`关键字在Java中扮演着不可变性的角色。它可以用于...
final java类_深入理解 JAVA 内部类 - final 问题
weixin_35705523的博客
02-20 423
前言：对于 JAVA 基础的内容，其实网上资料挺多的，本打算只写 Android 相关技术文章，但对于内部类这个基础点，在春招的准备过程中，发现里面有些门道而且很少人深入研究，特此贡献给大家深入理解 JAVA 内部类系列文章如下：本文主要讨论是内部类的 final 问题阅读本文大概需要 8 分钟，大家耐心点看下去，会有不一样的收获哈~使用到 final 的地方因为使用内部类而出现需要使用 fina...
Java基础之final、内部类
weixin_46278125的博客
06-02 314
final: 为了避免子类随意更改父类的内容，Java提供了final关键字，用于修饰不可改变的内容。 当final修饰： 类：不可以被继承 方法：不可以被重写 变量：值不可以被更改 注意事项： 引用类型的局部变量，被final修饰后，只能指向一个对象，后续不可以再更改指向，但是不影响对象内部的成员变量值的修改。 成员变量，成员变量有两种初始化的方式： // 显式初始化 public class User { final String USERNAME = "张三"; private int a
修饰符，内部类，参数传递
shkstart的博客
10-13 154
第一章 final关键字 1.1 概述 学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了final 关键字，用于修饰不可改变内容。 final： 不可改变。可以用于修饰类、方法和变量。 类：被修饰的类，不能被继承。 方法：被修饰的方法，不能被重写。 变量：被修饰的变量，不能被重新赋值。 1.2 使用方式
Java：final、权限、内部类
qq_38353993的博客
08-27 228
1.final关键字 final代表最后的，最终的 可以用来修饰，类、方法、变量 2、final修饰类 被final修饰的类，不能被继承，太监了（不能有子类） final不能和abstract共用 3、fianl修饰方法 不能被子类覆盖重写，但是可以重载 4、final修饰局部变量 局部变量（定义参数的位置，方法中的变量，静态代码块） 一旦赋值就不能再赋值，即使赋值...
【2018-8-19】【day11】
方慕珩
08-19 179
【2018/8/19】   Final关键字代表最终、不可改变的。 常见的四种用法： 可以用来修饰一个类。Public final class 类名称{ // }【当前类不能有任何子类，其中所有的成员方法都不能进行覆盖重写。】 可以用来修饰一个方法。这个方法就是最终方法，不能被覆盖重写。修饰符 final  返回值类型 类名（参数列表）{}【对于类、方法来说，abstract关键字和fin...
java 内部类 final_Java内部类与final关键字详解
weixin_29172201的博客
02-21 205
一、内部类的几种创建方法：1、成员内部类2、方法内部类3、匿名内部类4、静态内部类5、接口内部类二、神马是内部类？乍一看，好些创建方式，挺复杂的吧？首先内部类是个啥东西？定义：创建在一个类内部的类型。根据创建位置的不同，分为成员的、方法的、匿名的。接口中的内部类叫做接口内部类。理解：在类的内部创建，那就是类的一部分，跟属性、方法同级。这也就解释了为何能访问外部私有成员，我是你的一部分，我当然可以访...
java-final关键字,内部类
weixin_45154559的博客
03-21 891
final关键字概念与四种用法 final关键字的概念 final关键字代表最终的,不可改变的 常见四种用法: 1.可以用来修饰一个类 2.可以用来修饰一个方法 3.还可以用来修饰一个局部变量 4.还可以用来修饰一个成员变量 final关键字用于修饰类 当final关键字用来修饰一个类的时候,格式: public final class 类名称{ // … } 含义: 当前这个类不能有任何子类(太...
java语言进阶篇8——final、内部类
Saltyyy的博客
03-28 269
1、final关键字 用于修饰不可改变内容。 final ： 不可改变。可以用于修饰类、方法和变量。 类：被修饰的类，不能被继承。 方法：被修饰的方法，不能被重写。 变量：被修饰的变量，不能被重新赋值。 修饰类 final class 类名 { } 查询 API发现像 public final class String 、 public final class Math 、 public...
Java 第11天 final、权限、内部类、引用类型学习
weixin_44354035的博客
08-11 782
final、权限、内部类、引用类型第一章 final关键字1.1 概述1.2 使用方式修饰类修饰方法1. 局部变量——基本类型2. 局部变量——引用类型3. 成员变量第二章 权限修饰符2.1 概述2.2 不同权限的访问能力第三章 内部类1.1 概述什么是内部类成员内部类访问特点1.2 匿名内部类【重点】前提格式使用方式第四章 引用类型用法总结4.1 class作为成员变量4.2 interface作为成员变量4.3 interface作为方法参数和返回值类型第五章 综合案例——发红包【界面版】案例需求案例分
Java基础：final、权限、内部类与引用类型详解
在Java基础课程中，"final"关键字是关键的概念之一，它在章节一得到了深入探讨。final是一个静态类型的关键字，具有...后续章节会进一步探讨权限修饰符、内部类和引用类型的用法，这些都是Java编程中不可或缺的部分。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值