final关键字概念及其四种用法、四种权限修饰符的优先级以及内部类的相关概念

最新推荐文章于 2022-08-14 14:40:53 发布
最新推荐文章于 2022-08-14 14:40:53 发布
阅读量403 收藏 2
点赞数
分类专栏： Java基础 文章标签： 多态 final关键字 内部类 匿名内部类 成员内部类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44096670/article/details/109964669
版权

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

  • 常见的四种用法：
    ①、可以用来修饰一个类。
    ②、可以用来修饰一个方法。
    ③、还可以用来修饰一个局部变量。
    ④、还可以用来修饰一个成员变量。

（1）、修饰一个类

当final关键字用来修饰一个类的时候，格式如下：

public final class 类名称 {
	//...
}

含义：当前这个类不能有任何的子类。 不能使用一个final类来作为父类。
注意：一个如果是final的，那么其中所有的成员方法都无法进行覆盖重写。

（2）、修饰一个方法

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

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

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

注意事项：
对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。
因为使用abstract关键字，子类必须覆盖重写；但是如果父类中的方法使用了final修饰，子类不能覆盖重写；这就出现了自相矛盾。

修饰一个局部变量

一旦使用final关键字用来修饰局部变量，那么这个变量就不能进行修改。
一次赋值，终身不变。

public class Demo01Final{
	public static void main(String[] args){
		final int num = 200;
	}
}

对于基本类型来说，不可变说的就是变量当中的数据不可改变，
对于引用类型来说，不可变说的就是变量当中的地址值不可以改变。

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

测试实例：

public class Main {
    public static void main(String[] args) {
        Student stu1 = new Student("路飞");
        System.out.println(stu1.getName());//路飞
        System.out.println(stu1);
        stu1 = new Student("索隆");
        System.out.println(stu1.getName());//索隆
        System.out.println(stu1);//stu1地址值前、后发生改变
        System.out.println("----------------");

        final Student stu2 = new Student("山治");
        System.out.println(stu2);
        System.out.println(stu2.getName());
        stu2.setName("乔巴巴巴巴");
        System.out.println(stu2);//stu2地址值前、后没有发生改变
        System.out.println(stu2.getName());//stu2的内容前、后发生改变
    }
}

运行结果：

路飞
com.zm.demo.Student@1540e19d
索隆
com.zm.demo.Student@677327b6
----------------
com.zm.demo.Student@14ae5a5
山治
com.zm.demo.Student@14ae5a5
乔巴巴巴巴

修饰一个成员变量

  • 对于成员变量来说，如果使用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 > protected > (default) > private
同一个类publicprotected(default)private
同一个类（我自己）YESYESYESYES
同一个包（我邻居）YESYESYESNO
不同包子类（我儿子）YESYESNONO
不同包非子类（陌生人）YESNONONO
  • 注意事项：（default）并不是关键字“default”，而是根本不写。

三、内部类的概念和分类

  • 如果一个事物的内部包含另外一个事物，那么这就是一个类内部包含另一个类。
  • 分类:
    ①、成员内部类。
    ②、局部内部类（包含匿名内部类）。

（一）、成员内部类：

1.定义格式：
修饰符 class 外部类名称 {
	修饰符 class 内部类名称{
		//...
	}
	//...
}
  • 注意:内用外，随意访问；外用内，需要内部类对象。
public class Body {//外部类
    public class Heart{//成员内部类
        //内部类的方法
        public void beat(){
            System.out.println("跳动...");
            System.out.println("我叫："+name);
        }
    }

    //外部类的成员方法
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    //外部类方法
    public void methodBody(){
        System.out.println("外部类的方法");
    }
}
2.成员内部类的使用
（1）间接方式：在外部类的方法当中，使用内部类；然后main只是调用外部类的方法
public class Body {//外部类
    public class Heart{//成员内部类
        //内部类的方法
        public void beat(){
            System.out.println("跳动...");
            System.out.println("我叫："+name);
        }
    }

    //外部类的成员方法
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

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

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

运行结果：

外部类的方法
跳动...
我叫：null
（2）直接方式：外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
class Test{
    public static void main(String[] args) {
        Body.Heart heart = new Body().new Heart();
        heart.beat();
    }
}

运行结果:

跳动...
我叫：null
3.内部类的同名变量访问
  • 如果出现重名现象，那么格式就是：外部类名称.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(Outer.this.num);//外部类的成员变量
        }
    }
}

class TestDemo{
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().new Inner();
        inner.methodInner();
    }
}

运行结果：

30
20
10

（二）、局部内部类：

1.局部内部类的定义
  • 如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。
  • “局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。
（1）定义格式
修饰符 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();//👈
    }
}

class TestDemo{
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.methodOuter();
    }
}

运行结果：

10
  • 注意：
    定义一个类的时候，权限修饰符规则:
    ①、外部类：public/（default）
    ②、成员内部类：public/protected/（default）/private
    ③、局部内部类：什么都不能写
2.局部内部类的final问题
  • 局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】
  • 备注：从Java 8+开始，只要局部变量实时不变，那么final关键字可以省略。
  • 原因：
    ①、new出来的对象在堆内存当中。
    ②、局部变量是跟着方法走的，在栈内存当中。
    ③、方法运行结束之后，立刻出栈，局部变量就会立刻消失。
    ④、但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。
public class MyOuter {
    public void methodOuter(){
        int num = 10;//所在方法的局部变量

        class MyInner{
            public void methodInner(){
                System.out.println(num);
            }
        }
    }
}

（三）、匿名内部类：

  • 如果接口的实现类（或者是父类的子类）只需要使用唯一的一次。
  • 那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】
1.匿名内部类的定义格式：
接口名称 对象名 = new 接口名称(){
	//覆盖重写所有的抽象方法
}

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

class TestDemo{
    public static void main(String[] args) {
        MyInterface obj = new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名内部类实现了方法！");
            }
        };
        obj.method();
    }
}

运行结果：

匿名内部类实现了方法！
2.匿名内部类的注意事项：

  • 对格式new 接口名称(){...}进行解析：
    ①、new代表创建对象的动作。
    ②、接口名称就是匿名内部类需要实现哪个接口。
    ③、{...}这才是匿名内部类的内容。

  • 另外还需要几点问题：
    ①、匿名内部类，在创建对象的时候，只能使用唯一一次。
    如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类了。
    ②、匿名对象，在【调用方法】的时候，只能调用唯一一次。
    如果希望同一个对象，调用多次方法，那么必须给对象起个名字。

public interface MyInterface{
    void method1();//抽象方法
    void method2();//抽象方法
}

class TestDemo{
    public static void main(String[] args) {
        //使用了匿名内部类，而且省略了对象名称，也是匿名对象
        new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法！111-B");
            }
            public void method2() {
                System.out.println("匿名内部类实现了方法！222-B");
            }
        }.method1();
        //因为匿名对象无法调用第二次方法，所以需要再创建一个匿名内部类的匿名对象
        new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法！111-B");
            }
            public void method2() {
                System.out.println("匿名内部类实现了方法！222-B");
            }
        }.method2();
    }
}
------------------------
运行结果：
匿名内部类实现了方法！111-B
匿名内部类实现了方法！222-B

③、匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
强调：匿名内部类和匿名对象不是一回事！！！

（四）、类作为成员变量类型

  • 类作为成员变量时，对它进行赋值的操作，实际上，是赋给它该类的一个对象。
//游戏当中的英雄角色类
public class Hero{
    private String name;//英雄名字
    private int age;//英雄的年龄
    private Weapon weapon;//武器

    public Hero() {
    }
    public Hero(String name, int age, Weapon weapon) {
        this.name = name;
        this.age = age;
        this.weapon = weapon;
    }

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

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    public Weapon getWeapon() {
        return weapon;
    }
    public void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }
}

public class Weapon {
    private String code;//武器的代号

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

    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
}

public class Main{
    public static void main(String[] args) {
        //创建英雄角色
        Hero hero = new Hero();
        //为英雄起一个名字，并且设置年龄
        hero.setName("盖伦");
        hero.setAge(20);

        //创建一个武器对象
        Weapon weapon = new Weapon("多兰剑");
        //为英雄配备武器
        hero.setWeapon(weapon);

        hero.attack();
    }
}

运行结果：

年龄为：20的盖伦用多兰剑攻击敌方。

（五）、接口作为成员变量类型

  • 我们使用一个接口，作为成员变量，以便随时更换技能，这样的设计更为灵活，增强了程序的扩展性。
  • 接口作为成员变量时，对它进行赋值的操作，实际上，是赋给它该接口的一个子类对象。
public interface Skill {
    void use();//释放技能的抽象方法
}

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

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

    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 SkillImpl implements Skill{
    @Override
    public void use() {
        System.out.println("Biu~biu~biu~");
    }
}

测试1：

public class Main{
    public static void main(String[] args) {
        Hero hero = new Hero();
        hero.setName("艾希");//设置英雄的名称

        //设置英雄技能
        hero.setSkill(new SkillImpl());//使用单独定义的实现类
        hero.attack();
    }
}
--------------------------
我叫艾希,开始施放技能：
Biu~biu~biu~
施放技能完成。

测试2：

public class Main{
    public static void main(String[] args) {
        Hero hero = new Hero();
        hero.setName("艾希");//设置英雄的名称

        //设置英雄技能
        //还可以使用匿名内部类
        Skill skill = new Skill() {
            @Override
            public void use() {
                System.out.println("Pia~pia~pia~");
            }
        };
        hero.setSkill(skill);
        hero.attack();
    }
}
-----------------------
我叫艾希,开始施放技能：
Pia~pia~pia~
施放技能完成。

测试3：

public class Main{
    public static void main(String[] args) {
        Hero hero = new Hero();
        hero.setName("艾希");//设置英雄的名称

        //设置英雄技能
        //进一步简化，同时使用匿名内部类和匿名对象
        hero.setSkill(new Skill() {
            @Override
            public void use() {
                System.out.println("Biu~pia~biu~pia~");
            }
        });
        hero.attack();
    }
}
------------------------
我叫艾希,开始施放技能：
Biu~pia~biu~pia~
施放技能完成。
bfhonor
关注
专栏目录
别翻了，这篇文章绝对让你深刻理解java类的加载以及ClassLoader源码分析【JVM篇二】
宜春
12-01 5万+
点进文章的盆友不如先来做一道非常常见的面试题，如果你能做出来，可能你早已掌握并理解了java的类加载机制，若结果出乎你的意料，那就很有必要来了解了解java的类加载机制了。代码如下嗯哼？其实上面程序并不是关键，可能真的难不倒各位，不妨做下面一道面试题可好？如果下面这道面试题都做对了，那没错了，这篇文章你就不用看了，真的。
java final关键字各种用途的总结
weixin_44577944的博客
04-03 149
引言： final在Java中并不常用，然而它却为我们提供了诸如在C语言中定义常量的功能，不仅如此，final还可以让你控制你的成员、方法或者是一个类是否可被覆写或继承等功能，这些特点使final在Java中拥有了一个不可或缺的地位，也是学习Java时必须要知道和掌握的关键字之一。 final修饰成员变量 　　当你在类中定义变量时，在其前面加上final关键字，那便是说，这个变量一旦被初始化便不可...
java基础——final关键字有哪些作用
tom和cat的博客
03-18 153
final关键字有哪些作用 用来修饰数据，包括成员变量和局部变量，该变量只能被赋值一次且它的值无法被改变。对于成员变量来讲，我们必须在声明时或者构造方法中对它赋值； 用来修饰方法参数，表示在变量的生存期中它的值不能被改变； 修饰方法，表示该方法无法被重写； 修饰类，表示该类无法被继承。 package basic; /** * @Classname finalTest * @Des...
final关键字概念与四种用法
一叶之秋的博客
12-14 234
Demo01Final /* final关键字代表最终、不可改变的。 常见四种用法： 1.可以用来修饰一个类 2.可以用来修饰一个方法 3.还可以用来修饰一个局部变量 4.还可以用来修饰一个成员变量 */ public class Demo01Final { public static void main(String[] args) { int num1 = 10; System.out.println(num1); num1 = 20;
final关键字作用详解
大屎蛋教程网
05-19 2258
final关键字作用详解目录1 final关键字常用应用场景  1.1 单例模式  1.2 静态配置文件解析后的初始化2 final关键字初始化3 在构造函数中参数用final关键字修饰的作用4 final在集合中的应用  4.1 将集合类对象定义为final  4.2 集合类中的对象设置为final5 final在数组中的应用在java中final关键字有第一无二的特性，就是只可以赋值一次，一旦...
Java学习之：final 关键字的用法总结
qq_42902997的博客
12-06 276
final关键字常用的4种用法 可以用来修饰一个类 可以用来修饰一个方法 可以用来修饰一个局部变量 可以用来修饰一个成员变量 对于类、方法来说：abstract 关键字和 final 关键字不能同时使用，因为 abstract 修饰的抽象类或者方法一定要通过覆盖重写才有意义，而 final 定义的东西都不能再被重写，所以矛盾 final 修饰一个类 格式： public final class 类名称 {方法体} 要把 final 放到 class 之前 final 修饰的类称为太
java基础笔记三（静态、继承与多态、抽象类、接口、权限修饰符、枚举、final关键字、Object&Math&Date&包装类等常见类、Collection集合、Map集合）
fuyaozhishangzzx的博客
08-14 310
java基础知识（三）：stastic、extend、implements、面向对象三大特性：封装、继承、多态，抽象类、接口与开发中常见类、集合的使用.
2.Java笔记:接口与多态，构造器，final类，内部类，Object类，数字与字符串，日期和时间类，代码块
qq_45134373的博客
12-14 250
JAVA初级学习部分总结2:主要包括接口与多态，构造器，final类，内部类，Object类，数字与字符串，日期和时间类。
Eclipse,静态,继承,封装,this,super,重写,重载,多态,final,冒泡排序,选择排序,抽象类,接口,内部类
liu_yan_hui的博客
10-16 317
文章目录Eclipse工具中java项目的工程结构静态代码块的书写格式静态代码块,构造代码块,构造方法的优先级static关键字的特点封装的概念private关键字的特点面向对象思想特点Eclipse中一些常用的快捷键继承的概念继承的好处继承的格式Java中的开发原则继承的特点继承中的注意事项继承中变量名相同的访问问题继承中子类构造方法访问父类构造方法的问题this和super的区别代码块的优先级问题有关方法重写和方法重载的区别多态的概念多态的前提条件:多态的成员访问特点:多态的好处:多态的弊端:多态的向下
【小结】成员变量与局部变量的区别、形式参数的问题、构造方法、static关键字、创建对象初始化的流程、代码块的优先级介绍、使用继承时所需要的注意事项、super和this、重写与重载的区别、final
qq_46563096的博客
01-19 191
【小结】成员变量与局部变量的区别、形式参数的问题、构造方法、static关键字、创建对象初始化的流程、代码块的优先级介绍、使用继承时所需要的注意事项、super和this、重写与重载的区别、final
final关键字
09-19 101
final的字面意思是指无法改变，但是不同的情况下使用，会有些许区别 final成员变量 当final修饰一个类的成员变量时，表示该成员变量是常量，这句话需要解释一下： 如果该成员变量的类型是预定义类型，说明该变量值不可修改；如果该成员变量的类型是自定义类型，则该变量只是引用，那么该引用不能再指向别的对象，而对象的值却是可以修改的。 注意： 1）当我们使...
Java关键字final
Qqidian的博客
08-28 86
final final 的概念 因为继承的出现提高了代码的复用性,并方便开发,但随之也有问题,比如有些类在描述完之后,不想被继承,或者类中的部分方法功能是固定的,不想让子类重写. 此时就要用到一个关键字final,final的意思就是为最终,不可变.,final是个修饰符,它可以用来修饰类,类的成员变量,以及局部变量. final 的特点 final修饰类不可以被继承,但是可以继承其他类 ...
Java(final、权限、内部类、引用类型)
Yzc_start的博客
09-08 261
final关键字 1.概述：方法重写。那么我们能不能随意的继承 API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了 final 关键字，用于修饰不可改变内容。 final： 不可改变。可以用于修饰类、方法和量。 类：被修饰的类，不能被继承。 方法：被修饰的方法，不能被重写。 变量：被修饰的变量，不能被重新赋值。 2.使用方式 a.修饰类 final cla...
Final关键字
itzhuzhu的博客
09-28 1955
目录： final关键字介绍 final修饰类 final修饰方法 final修饰变量 1. final关键字介绍 final关键字的意思： 是不能改变的意思，用来修饰类、方法、变量。 用法： Java提供了Final关键字主要用来修饰一些不可改变的内容。 2. final修饰类 注意： final修饰的类，不能被继承。 代码演示： final class 类名 { } // 代码...
final 关键字
不远远方
08-19 846
https://www.cnblogs.com/liun1994/p/6691094.html https://www.cnblogs.com/xiaoxi/p/6392154.html https://blog.csdn.net/hanghangde/article/details/50686565?locationNum=7 1. final关键字的含义 　　final表面意思就是不可...
final关键词的意义。
LiZhen314的博客
09-29 577
final作为java中的一个关键字，可以用来修饰类，变量，方法，表示其不可变的概念。 final修饰类的时候，表示该类不能被继承。 final修饰变量的时候，不允许改变变量（如果是对象，则不能改变其引用，里面的属性允许被修改。基本类型则不能改变其值）。 final修饰方法的时候，表示该方法将不能被重写。 以上是基本概念，老生常谈。下面将具体分析final关键字的意义： 讨论final修...
Java学习之关键词final
秋水惊鸿的博客
02-27 228
final关键词主要可以用来变量的声明、final方法以及final类，下面逐个介绍。 final变量 final定义的变量，一旦被设定，就不可以再改变变量的值，同时必须在申明的时对其进行赋值操作（有些情况申明后赋值也可以，但是为培养良好的编程习惯，声明的时候赋值最好）。 final可以修饰一般的常量，同时也可以修饰对象引用，由于数组也可以被看作对象来引用，所以final也可以修饰数组。...
Java中final关键字
热门推荐
JoyceBridge的博客
10-04 2万+
一，概述 final关键字代表最终、不可改变的。 常见四种用法： 1. 可以用来修饰一个类 2. 可以用来修饰一个方法 3. 还可以用来修饰一个局部变量 4. 还可以用来修饰一个成员变量 二，final修饰类：太监类，没有儿子 1）当final关键字用来修饰一个类的时候，格式： public final class 类名称 { // ... } 含义：当前这个类不能有任何的子类。（太监类） eg：定义一个final类pubilc final MyClass，继承报错！ 2）..
Java面向对象设计与UML表示：对象、类、变量、常量、方法及可见性修饰符详解
可见性修饰符可以控制类、变量和方法的访问权限，包括public、private、protected和default。 在面向过程设计和面向对象设计中，存在着不同的设计思想。面向过程设计强调的是程序的执行过程，通过函数来描述程序的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值