final关键字、权限、内部类

最新推荐文章于 2022-11-22 18:42:54 发布
最新推荐文章于 2022-11-22 18:42:54 发布
阅读量308 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Addccchhhhh/article/details/107434444
版权

final

final关键字概念与四种用法

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

常见四种用法：

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

final用来修饰类

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

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

public final class MyClass /*extends Object*/ {

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

}

final用来修饰成员方法

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

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

public abstract class Fu {

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

    public abstract /*final*/ void methodAbs() ;

}

final修饰局部变量

  // 一旦使用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()); // 高圆圆圆圆圆圆

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

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;
//    }
}

四种权限修饰符

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

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

内部类的概念与分类

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

分类：

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

成员内部类的定义和使用

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

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

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

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

}

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;
    }
}

内部类的同名变量访问

如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名

public class Outer {

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

    public class Inner /*extends Object*/ {

        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 外部类名称 {
修饰符 返回值类型 外部类方法名称(参数列表) {
class 局部内部类名称 {
// …
}
}
}

小节一下类的权限修饰符：
public > protected > (default) > private
定义一个类的时候，权限修饰符规则：

  1. 外部类：public / (default)
  2. 成员内部类：public / protected / (default) / private
  3. 局部内部类：什么都不能写
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 DemoMain {

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

}

局部内部类的final的问题

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

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

原因：

  1. new出来的对象在堆内存当中。
  2. 局部变量是跟着方法走的，在栈内存当中。
  3. 方法运行结束之后，立刻出栈，局部变量就会立刻消失。
  4. 但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。
public class MyOuter {

    public void methodOuter() {
        int num = 10; // 所在方法的局部变量

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

}

匿名内部类

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

匿名内部类的定义格式：
接口名称 对象名 = new 接口名称() {
// 覆盖重写所有抽象方法
};

对格式“new 接口名称() {…}”进行解析：

  1. new代表创建对象的动作
  2. 接口名称就是匿名内部类需要实现哪个接口
  3. {…}这才是匿名内部类的内容

另外还要注意几点问题：

  1. 匿名内部类，在【创建对象】的时候，只能使用唯一一次。
    如果希望多次创建对象，而且类的内容一样的话，那么就需要使用单独定义的实现类了。
  2. 匿名对象，在【调用方法】的时候，只能调用唯一一次。
    如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
  3. 匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
    强调：匿名内部类和匿名对象不是一回事！！！
public class DemoMain {

    public static void main(String[] args) {
//        MyInterface obj = new MyInterfaceImpl();
//        obj.method();

//        MyInterface some = new MyInterface(); // 错误写法！

        // 使用匿名内部类，但不是匿名对象，对象名称就叫objA
        MyInterface objA = new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法！111-A");
            }

            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法！222-A");
            }
        };
        objA.method1();
        objA.method2();
        System.out.println("=================");

        // 使用了匿名内部类，而且省略了对象名称，也是匿名对象
        new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法！111-B");
            }

            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法！222-B");
            }
        }.method1();
        // 因为匿名对象无法调用第二次方法，所以需要再创建一个匿名内部类的匿名对象
        new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法！111-B");
            }

            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法！222-B");
            }
        }.method2();
    }

}

接口

public interface MyInterface {

    void method1(); // 抽象方法

    void method2();

}

类作为成员变量类型

// 游戏当中的英雄角色类
public class Hero {

    private String name; // 英雄的名字
    private int age; // 英雄的年龄
    private Weapon 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 DemoMain {

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

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

        // 年龄为20的盖伦用多兰剑攻击敌方。
        hero.attack();
    }

}

接口作为成员变量类型

public class DemoGame {

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

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

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

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

        hero.attack();
    }

}

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


import java.util.ArrayList;
import java.util.List;

/*
java.util.List正是ArrayList所实现的接口。
 */
public class DemoInterface {

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

        List<String> result = addNames(list);
        for (int i = 0; i < result.size(); i++) {
            System.out.println(result.get(i));
        }
    }

    public static List<String> addNames(List<String> list) {//这里的接口作为返回值，又做参数类型
        list.add("迪丽热巴");
        list.add("古力娜扎");
        list.add("玛尔扎哈");
        list.add("沙扬娜拉");
        return list;
    }

}
RYYYUUU
关注
final关键字、权限修饰符、内部类、引用类型的介绍
Su3253067688的博客
11-27 602
一、final关键字一、final关键字1.1final关键字定义：Final用于修饰类、成员变量和成员方法。（String、StringBuilder、StringBuffer、Math，不可变类），其中所有的方法都不能被重写(需要注意的是不能被重写，但是可以被重载)，所以不能同时用abstract和final修饰类（abstract修饰的类是抽象类，抽象类是用于被子类继承的，和final起相反的作用）；，但是子类可以用父类中final修饰的方法；
初识Java--final关键字、内部类
weixin_52895875的博客
03-19 280
一、final关键字 final关键字代表最终，不可改变。 常见四种用法： 可以用来修饰一个类。 可以用来修饰一个方法。 可以用来修饰一个局部变量。 可以用来修饰一个成员变量。 当final关键字用来修饰一个类时 格式： public final class 类名称 { // … } 含义：当前这个类不能有任何的子类。（太监类） 注意：一个类如果是final类，那其中的所有成员方法都无法进行覆盖重写（没有子类）。 备注：不能用一个final类来当作父类。 当final关键字用来修饰一个方法时 这个方法时
美好(fanzao)的一天又开始了今天研究SpringBoot
明天是个好天气
02-17 9418
爱情来的太快就像龙卷风
热门推荐
qq_45717538的博客
10-19 8万+
题解 uuuu yyy uuu uuu ooo rrr rr w iii ee ww yyy ooo eee uuu rrr ee yy e 首先再26个键盘上找到u所对应一行u是第几个字母u对应第7个所以对应九宫格第7个格u有四个所以是第七个格里第四个字母s，以此类推
【2019年第十届蓝桥杯】 C++ 省赛B组 （题解 + 刷题链接）
黑桃
08-08 5595
刷题网站： 刷题网站 < — 这里可以刷题 第一题 组队： 题目链接 题目描述 作为篮球队教练，你需要从以下名单中选出1 号位至5 号位各一名球员，组成球队的首发阵容。 每位球员担任1号位至5号位时的评分如下表所示。请你计算首发阵容1号位至5号位的评分之和最大可能是多少？ 第一题答案：490 （比如1 10 17 11 15） 第二题 年号字串： 题目链接 题目描述 小明用字母A 对应数字1，B 对应2，以此类推，用Z 对应26。对于27以上的数字 小明用两位或更长位的字符串来对应，例如A
WebSocket
MorningDuGe
07-31 4万+
ajax轮询 每隔一段时间发送一次请求询问服务器有消息发送不（需要服务器有很快的处理速度） 长轮询 发送一次请求然后一直等待直到服务器有消息发送，服务器发完消息后连接中断，客户端重新建立连接请求，周而复始重复。（需要服务器有很高的并发性，即同时处理） 以上两种都需要重复建立连接，且容易使服务器崩溃。websocket 是HTML5的新协议，实现了浏览器和服务器的全双工通信，节省带宽实时通
Moving On 第 44 届 ACM/ICPC 亚洲区域赛（银川）网络赛
Up Panda
09-03 7万+
Firdaws and Fatinah are living in a country with nnn cities, numbered from 111 to nnn. Each city has a risk of kidnapping or robbery. Firdaws's home locates in the city uuu, and Fatinah's home locate...
孙Cloud的Java学习博客-10.5-final关键字与内部类
weixin_44719191的博客
09-21 232
- final概念及四种用法 final关键字有四种用法，即可以修饰一个类，一个方法，一个局部变量，一个成员变量 1.当他用于修饰一个类时，public final 类名称{//......} 含义为：这个类不能有任何子类（太监类） 注意：一个类如果是final的，那么其中所有成员方法都无法覆盖重写 2.用于修饰成员方法，那么这个方法就是最终方法，也就是不能覆盖重写 注意：对于类，方法来说abstract关键字与final关键字不能同时使用，因为矛盾 3.用于修饰局部变量，一旦赋值，终生不变（唯一一次
【3-4】《Java面向对象高级知识》——继承、重写和重载、final关键字、抽象类、接口、多态、Object类、内部类、包装类、可变参数、递归
程序媛乐园
09-27 972
文章目录一、继承格式二、子类实例化内存分析三、super详解四、重写1、重写的概念2、重写和重载的区别五、final关键字六、抽象类1、抽象类的概念2、抽象类常见问题3、抽象类和普通类的区别七、接口1、面向接口编程思想2、接口的编写3、接口和抽象类的区别八、多态1、多态的体现2、instanceof九、Object类概述1、toString2、equals十、内部类概述1、成员内部类（了解）2、局部内部类3、匿名内部类4、静态内部类 一、继承格式 非常重要的部分！！！ 格式：先描述父类，再描述子类，子类通
final关键字、访问修饰符、内部类
最新发布
weixin_67224308的博客
11-22 296
学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承API中提供的类，改写其内容呢?显然这是不合适的。为了避免这种随意改写的情况，Java提供了 fina] 关键字用于修饰不可改变内容。final:不可改变。可以用于修饰类、方法和变量。类:被修饰的类，不能被继承。方法:被修饰的方法，不能被重写。变量:被修饰的变量，不能被重新赋值。在lava中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限。
php中的SERVER变量
刘阳龙Herman的专栏
09-10 976
<br /><br />，$_SERVER["QUERY_STRING"]<br />说明：查询(query)的字符串<br />2，$_SERVER["REQUEST_URI"]<br />说明：访问此页面所需的URI<br />3，$_SERVER["SCRIPT_NAME"]<br />说明：包含当前脚本的路径<br />4，$_SERVER["PHP_SELF"]<br />说明：当前正在执行脚本的文件名<br />实例：<br />1，http://www.biuuu.com/ (直接打开主页)<
字母(letter)
ENESAMA的博客
12-10 6072
字母(letter) 【题目描述】 给定一个字符串。取出的所有子串，并按字典序从小到大排序，然后将这些排完序的字符串首尾相接，记为字符串。有次询问，每次询问中的第个字符。 是被加密的，每次询问给出两个正整数，设为之前所有询问答案的ASCII码之和。初始时为。则该次询问的。   【输入格式】 输入第一行包含一个字符串，第二行包含一个正整数。 接下来行，每行两个正整数P,M。   【...
迷宫
weixin_46443427的博客
10-21 2万+
标题：迷宫 X星球的一处迷宫游乐场建在某个小山坡上。 它是由10x10相互连通的小房间组成的。 房间的地板上写着一个很大的字母。 我们假设玩家是面朝上坡的方向站立，则： L表示走到左边的房间， R表示走到右边的房间， U表示走到上坡方向的房间， D表示走到下坡方向的房间。 X星球的居民有点懒，不愿意费力思考。 他们更喜欢玩运气类的游戏。这个游戏也是如此！ 开始的时候，直升机把100名玩家放入一个个小房间内。 玩家一定要按照地上的字母移动。 迷宫地图如下： UDDLUULRUL UURLLLRRRU RRU.
＜Zhuuu_ZZ＞实时流之Apache Flink
Zhuuu_ZZ的博客
01-06 1万+
Apache Flink
聚类
weixin_43799419的博客
01-20 1万+
目录 相关概念 性能度量（外部指标、内部指标） 距离计算 原型聚类 层次聚类 密度聚类 优缺点 sklearn参数详解 1.相关概念 无监督学习： 无监督学习是机器学习的一种方法，没有给定事先标记过的训练示例，自动对输入的数据进行分类或分群。无监督学习的主要运用包含：聚类分析、关系规则、维度缩减。它是监督式学习和强化学习等策略之外的一种选择。 一个常见的无监督学习是数据聚类。在人工神经网络中...
yuv图解（YUV444,YUV422,YUV420,YV12,NV12,NV21）
weixin_42097108的博客
08-02 1万+
图解YUV
字符集编码相关
LayzerAr的专栏
06-08 1万+
BOM(byte-order mark)字节序标记，BOM的作用有两个，一是标记文本的编码类型，二是标记文本编码的字节序，文本文件的最开头都会有BOM标记（windows默认编码是ANSI，不带BOM）。以下是各种编码相关的BOM：UTF-8(3Byte): EF BB BFUTF-16(BE)(2Byte): FE FFUTF-16(LE)(2Byte): FF FE
uuuuuu
xjjavaeye
09-11 1万+
uuuuuuuuuuuuuuuuuuuuu
一些经典问题，大家学习讨论--摘自uuussseeennn
lijunuuxxx的专栏
11-07 1万+
1. 在类的普通成员函数中调用虚函数，情况是怎么样的？（对象、引用、指针） 多态， 事实上，这是 Template Method模式的关键 2. 关于成员变量初始化顺序，几个有依赖关系的成员变量要初始化，让写出构造函数。 在初始化列表中，成员变量的初始化顺序是其在类中声明顺序，而非列表中的顺序。 4. 写个is-a和has-a。 Class Pet{};
Java基础：final、权限、内部类与引用类型详解
在Java基础课程中，"final"关键字是关键的概念之一，它在章节一得到了深入探讨。final是一个静态类型的关键字，具有...后续章节会进一步探讨权限修饰符、内部类和引用类型的用法，这些都是Java编程中不可或缺的部分。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值