final关键字 及 关键类

最新推荐文章于 2024-07-10 21:37:49 发布
最新推荐文章于 2024-07-10 21:37:49 发布
阅读量109 收藏
点赞数
分类专栏： JavaSE 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57331274/article/details/134117835
版权

1 final关键字

1.1 定义

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

1.2 用法

        常见四种用法：

1.可以用来修饰一个类

        public final class 类名称{

                //...

        }

        含义：当前这个类不能有任何子类，但是可以有父类。（太监类）

        注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写。（因为没儿子）

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

2.可用来修饰一个方法

        修饰符 final 返回值类型 方法名称（参数列表）{

                //方法体

        }

        含义：当final关键字用来修饰一个方法的时候，这个方法就是最终方法么也就是不能被覆盖重写。

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

public class Fu {
    public final void method(){
        System.out.println("父类方法执行");
    }
}

3.可以用来修饰一个局部变量

        注意事项：

  •         对于基本类型来说，不可变说的是变量当中的数据不可改变
  •         对于引用类型来说，不可变说的是变量当中的地址不可改变
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;
    }
}
public class Final {
    public static void main(String[] args) {
        int num=20;
        System.out.println(num);
        num=10;
        System.out.println(num);

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

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

        //正确写法，只要保证有唯一一次赋值即可
        final int num3;
        num3=90;

        //对于基本类型来说，不可变说的是变量当中的数据不可改变
        //对于引用类型来说，不可变说的是变量当中的地址值不可变
        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());

        final Student stu2=new Student("cici");
        System.out.println(stu2.getName());
        //错误写法，final的引用类型变量，其中的地址不可改变】
//        stu2=new Student("sdff");
    }
    
}

4.可以用来修饰一个成员变量

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

        1.由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了

        2.对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一

        3.必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值

public class Person {
    //直接赋值，删掉所有方法中的赋值语句
//    private final String name="sfdsg";
    //间接赋值，在无参构造中加入赋值，并删掉setter方法
    private final String name;

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

    public Person() {
        name="cici";
    }

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

    public String getName() {
        return name;
    }
}

Java中的四种权限修饰符：

                                                    public      >      protected      >     (default)      >      private

同一个类(我自己）                        yes                     yes                     yes                    yes

同一个包（我邻居）                      yes                     yes                     yes                    yes

不同包子类（我儿子）                   yes                     yes                     no                      no

不同包非子类（陌生人）               yes                       no                     no                      no

注意事项：(default)不是关键字，根本不用写

2 内部类

2.1 定义

如果一个事物的内部包含另一个事物，那么也就是一个类内部包含另一个类

例如：身体和心脏的关系，汽车和发动机的关系

2.2 分类

2.2.1 成员内部类

        修饰符 class 类名称{

                修饰符 class 类名称{

                        //...

                }

                //...

        }

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

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

        1.间接方式：在外部类的方法当中，使用内部类，然后main只是调用外部类的方法

        2.直接方式：

                外部类名称.内部类名称 对象名=new 外部类名称（）.new 内部类名称（）；


//外部类
public class Body {
    //成员内部类
    public class Heart{
        //内部类方法
        public void beat(){
            System.out.println("心脏跳动：蹦蹦蹦");
            System.out.println("我叫"+name);//正确写法
        }
    }
    //外部类成员变量
    private String name;

    public void methodBody(){
        System.out.println("外部类的方法");
        new Heart().beat();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
public class MyClass {
    public static void main(String[] args) {
        //间接调用
        Body body=new Body();//外部类的对象
        body.setName("vivi");
        //通过外部类的对象，调用外部类的方法，里面直接在使用内部类heart
        body.methodBody();

        //直接调用
        Body.Heart heart=new Body().new Heart();
        heart.beat();
    }

}

如何访问重名的成员内部类的方法：

          外部类名称.this.外部类成员变量名

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(super.num);//不对，没有继承关系
            System.out.println(Outer.this.num);//外部类的成员变量
        }
    }
}
public class MyClass2 {
    public static void main(String[] args) {
        Outer.Inner inner=new Outer().new Inner();
        inner.methodInner();
    }
}

2.2.2 局部内部类（包含匿名内部类）

        如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。

        “局部”只有当前所属的方法才能使用它，出了这个方法外面就不能用了

        修饰符 class 外部类名称{

                修饰符 返回值类型 外部类方法名称（参数列表）{

                        class 局部内部类名称{

                                //...

                        }

                }

        }

public class Outer {
    public void methodOuter(){
        class Inner{
            int num=10;
            public void methodInner(){
                System.out.println(num);//10
            }
        }
        Inner inner=new Inner();
        inner.methodInner();
    }
}
public class Main {
    public static void main(String[] args) {
        Outer outer=new Outer();
        outer.methodOuter();
    }
}

   

小结一下类的权限修饰符：

public > protected >  (default)  > private

定义一个类的时候，权限修饰符规则：

1.外部类：public / （default）

2.成员内部类：public / protected / （default）/ private

3.局部内部类：什么都不能写

注意事项：

        局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】

        备注：从Java8开始，只要局部变量事实不变，那么final关键字可以省略

        原因：

        1.new出来的对象在堆内存房中。

        2.局部变量是跟着方法走的，在栈内存当中

        3.方法运行结束之后，立刻出栈，局部变量就会立刻消失

        4.但是new出来的对象会在堆当中持续存在，直到垃圾回收消失

public class MyOuter {
    public void methodOutrer(){
        int num=10;
        class MyInner{
            public void methodInner(){
                System.out.println(num);
            }
        }
    }
}

2.2.3 匿名内部类

        如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】

        接口名称 对象名 = new 接口名称（）{

                //覆盖重写所有抽象方法

        }；

public interface MyInterface {
    void method();//抽象方法
}
public class MyInterfaceImpl implements MyInterface{

    @Override
    public void method() {
        System.out.println("实现类覆盖重写了方法");
    }
}
public class DemoMain {
    public static void main(String[] args) {
//        MyInterfaceImpl impl=new MyInterfaceImpl();
//        impl.method();

        //使用匿名内部类
        MyInterface myInterface=new MyInterface() {
            @Override
            public void method() {
                System.out.println("覆盖重写了method方法");
            }
        };
        myInterface.method();
    }
}

对“new 接口名称（）{...}”格式进行解析：

1.new代表创建对象的动作

2.接口名称就是匿名内部类需要实现哪个接口

3.{...}这才是匿名内部类的内容

注意事项：

1.匿名内部类，在【创建对象】的时候，只能使用唯一一次

        如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类了

2.匿名对象，在【调用方法】的时候，整你调用唯一一次

        如果希望同一个对象，调用多次方法，那么必须给对象起个名字

3.匿名内部类是省略了【实现类/子类】，但是匿名对象是省略了【对象名称】

        强调：匿名内部类和匿名对象不是一回事！

public interface MyInterface {
    void method1();//抽象方法
    void method2();//抽象方法
}
public class MyInterfaceImpl implements MyInterface{
    @Override
    public void method1() {
        System.out.println("实现类覆盖重写了方法1");
    }

    @Override
    public void method2() {
        System.out.println("实现类覆盖重写了方法2");
    }
}

public class DemoMain {
    public static void main(String[] args) {
//        MyInterfaceImpl impl=new MyInterfaceImpl();
//        impl.method();

        //使用匿名内部类,但不是匿名对象，对象名称就叫myInterface
        MyInterface myInterface = new MyInterface() {
            @Override
            public void method1() {
                System.out.println("覆盖重写了method方法1");
            }

            @Override
            public void method2() {
                System.out.println("覆盖重写了method方法2");

            }

        };
        myInterface.method1();

        //使用匿名内部类,而且省略了对象名称，也是匿名对象
        new MyInterface() {
            @Override
            public void method1() {
                System.out.println("覆盖重写了method方法1");
            }

            @Override
            public void method2() {
                System.out.println("覆盖重写了method方法2");

            }
        };
        myInterface.method1();
        //因为匿名对象无法调用第二次方法，所以需要在创建一个匿名内部类的匿名对象
    }
}

3 其他

3.1 类作为成员变量类型

public class Hero {
    private String name;//英雄姓名
    private Weapom weapom;//英雄的武器
    private int age;//英雄的年龄

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

    public Hero() {
    }

    public void attack(){
        System.out.println("年龄为"+age+"的"+name+"正在用"+weapom.getCode()+"攻击敌方");
    }

    public String getName() {
        return name;
    }

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

    public Weapom getWeapom() {
        return weapom;
    }

    public void setWeapom(Weapom weapom) {
        this.weapom = weapom;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
public class Weapom {
    private String code;//武器的代号

    public Weapom(String code) {
        this.code = code;
    }

    public Weapom() {
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }
}
public class DemoMain {
    public static void main(String[] args) {
        //创建一个英雄角色
        Hero hero=new Hero();
        //为英雄起一个名字，并设置年龄
        hero.setName("王五");
        hero.setAge(22);
        //为英雄配备武器
        Weapom weapom=new Weapom("刀");
        hero.setWeapom(weapom);
        hero.attack();
    }
}

3.2 接口作为成员变量类型

public interface Skill {
    void use();//释放技能的抽象方法
}
public class SkillImpl implements Skill{
    @Override
    public void use() {
        System.out.println("咻咻咻——");
    }
}

public class Hero {
    private String name;//英雄的名字
    private Skill skill;//英雄的法术技能

    public Hero(String name, Skill skill) {
        this.name = name;
        this.skill = skill;
    }

    public Hero() {
    }

    public void attack(){
        System.out.println("我叫"+name+",开始释放技能:");
        skill.use();
        System.out.println("释放技能完成");
    }

    public String getName() {
        return name;
    }

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

    public Skill getSkill() {
        return skill;
    }

    public void setSkill(Skill skill) {
        this.skill = skill;
    }
}
public class DemoGame {
    public static void main(String[] args) {
        Hero hero=new Hero();
        hero.setName("cici");//设置英雄的名称
        System.out.println(hero.getName());

        //设置英雄技能
//        hero.setSkill(new SkillImpl());//使用单独定义的实现类

        //还可以使用匿名内部类
//        Skill skill=new Skill() {
//            @Override
//            public void use() {
//                System.out.println("Xiuxiuxiu_");
//            }
//        };
//        hero.setSkill(skill);

        //进一步简化，同时使用匿名内部类和匿名对象
        hero.setSkill(new Skill() {
            @Override
            public void use() {
                System.out.println("hahaha_");
            }
        });

        hero.attack();
    }
}

3.3 接口作为方法的参数或返回值

/**
 * java.util.list正是ArrayList所实现的接口
 */
public class DemoInterface {
    public static void main(String[] args) {
        //左边是接口名称，右边是实现类名称，这就是多态写法
        List<String> list=new ArrayList<>();

        System.out.println(addNames(list));
    }

    public static List<String> addNames(List<String> list){
        list.add("cici");
        list.add("asjkf");
        list.add("sdkjha");
        return list;
    }
}

今天你改bug了吗？
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Android源码中final关键字的用法及final,finally,finalize的区别
09-03
Android的源码中很多地方对final关键字的用法很是“别出心裁”，之所以这么说是因为我从没看过是这么使用final关键字的，通过本文给大家分享Android源码中final关键字的用法及final,finally,finalize的区别，感兴趣的朋友一起学习吧
Android课程---final关键字
weixin_33726943的博客
04-04 107
final 在Java中声明属性、方法和类时，可使用关键字final来修饰。 final变量即为常量，只能赋值一次； final方法不能被子类重写； final类不能被继承。 1. final变量 声明 final 字段有助于优化器作出更好的优化决定，因为如果编译器知道字段的值不会更改，那么它能安全地在寄存器中高速缓存该值。fina...
[Android]【安卓】【Java】final关键字
Hy的博客
07-08 572
[Android]【安卓】【Java】final关键字 A、final修饰成员变量：获得初始值后不能再赋值。 　　a、类变量：必须在静态初始化块中指定初始值或声明该变量时指定初始值，且只能在两个地方中的一个指定。 　　b、实例变量：必须在非静态初始化块、声明实例变量时或构造器中指定初始值，且只能在三个地方中的一个指定。 B、final修饰局部变量：系统不会对局部变量初始化，既可以指定默...
10074---深入理解Java中的final关键字
xxxcyzyy的博客
08-15 217
原文 Java中的final关键字非常重要，它可以应用于类、方法以及变量。这篇文章中我将带你看看什么是final关键字？将变量，方法和类声明为final代表了什么？使用final的好处是什么？最后也有一些使用final关键字的实例。final经常和static一起使用来声明常量，你也会看到final是如何改善应用性能的。 final关键字的含义? final在Java中是一个保留
android final关键字用法简单总结
秦时明月
06-08 4757
final:final修饰的变量为常量，只能赋值一次，赋值后不可修改。 final方法不能被子类重写 final类不能被继承1、final变量必须初始化，初始化必须在声明时或者构造方法中直接赋值。不能通过函数赋值。2、final方法final方法不能被子类覆盖好处：1、防止子类修改，改变它本身的意义。 2、编译器执行final方法时效率更高（会使用inline机制）
Java中final关键字详解
12-18
谈到final关键字，想必很多人都不陌生，在使用匿名内部类的时候可能会经常用到final关键字。另外，Java中的String类就是一个final类，那么今天我们就来了解final这个关键字的用法。 主要介绍：一.final关键字的基本...
Java中的final关键字详解及实例
01-05
用final关键字修饰的方法是不能被该类的子类override（重写），因此，如果在想明确禁止 该方法在子类中被覆盖的情况下才将方法设置为final的。 注：类的private方法会隐式地被指定为final方法。 public class ...
关于final关键字的基础运用
12-22
关于final关键字的基础运用 首先明确final的含义：最终，不可改变的 final的四种基本用法 1.修饰一个类 格式： 权限修饰符 final 类名{ //*** } 此时final的含义是声明：当前这个类不能有任何的子类，也就是说该...
java中final关键字使用示例详解
09-04
4. **final关键字的好处** - 提高性能：JVM可以对`final`变量进行优化，因为它们的值是不可变的，这有助于提升程序执行速度。 - 多线程安全：`final`变量在多线程环境中可以直接共享，因为它们的值不会改变，从而...
举例讲解Java中final关键字的用法
09-02
下面我们将详细探讨`final`关键字在修饰变量、方法和类时的不同用法。 1. **final变量** - 常量定义：`final`变量一旦被初始化后，其值就不能再改变。例如，我们可以定义一个名为`PI`的`final`变量，表示圆周率，...
Android中的关键字
zenmela2011的专栏
09-09 790
1.volatile 要真正搞懂volatile关键字，需要从CPU高速缓存说起。 当一个程序运行的时候，数据是保存在内存当中的，但是执行程序这个工作却是由CPU完成的。那么当CPU正在执行着任务呢，突然需要用到某个数据，它就会从内存中去读取这个数据，得到了数据之后再继续向下执行任务。 这是理论上理想的工作方式，但是却存在着一个问题。我们知道，现在CPU的速度越来越快，但是光CPU快没有用呀，因为CPU再快还是要从内存去读取数据，而这个过程是非常缓慢的，所以就大大限制了CPU的发展。 为了解决这个问题，CP
final关键字的用法
yinzhijiezhan的专栏
03-18 6659
一、final修饰类： 被final修饰的类，是不可以被继承的，这样做的目的可以保证该类不被修改，Java的一些核心的API都是final类，例如String、Integer、Math等 代码举例： 二、final修饰方法： 子类不可以重写父类中被final修饰的方法 代码举例： 三、final修饰实例变量(类的属性，定义在类内，但是在类内的方法之外) final修饰
安卓开发——final的用法
萌鼠喝酸奶的博客
02-10 6413
final如果修饰类，该类不能被继承； final如果修饰变量，该变量不能被修改，不能再重新赋值，即变为常量； final如果修饰方法，该方法不能被重写； 此外，只有被final修饰的局部变量可以用在内联方法里。比如onClick里面如果调用button.setText(...)，就必须将button设置为final，即： public class MyActivity extends
深入理解Java中的final关键字
12-04 1449
本文由 ImportNew - 唐小娟 翻译自 Javarevisited。如需转载本文，请先参见文章末尾处的转载要求。 Java中的final关键字非常重要，它可以应用于类、方法以及变量。这篇文章中我将带你看看什么是final关键字？将变量，方法和类声明为final代表了什么？使用final的好处是什么？最后也有一些使用final关键字的实例。final经常和static一起使用来声明常量
Java关键字static、final使用小结
weixin_34210740的博客
08-29 296
static 1. static变量 按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是： 　 对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通...
配置Java开发环境
最新发布
Broken_x的博客
07-10 1440
Java开发环境配置
day10-final、接口、多态.pdf
11-02
在Java编程中，"day10-final、接口、多态.pdf"文档主要探讨了Java中的关键概念，包括final关键字、接口和多态。这些内容对于理解Java语言的封装和面向对象原则至关重要。 首先，final关键字被用来表示"不可变性"，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值