11-final；权限；内部类；引用类型

最新推荐文章于 2024-02-29 12:19:31 发布
最新推荐文章于 2024-02-29 12:19:31 发布
阅读量466 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42375099/article/details/106300479
版权

文章目录

1. final关键字

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

常见四种用法：

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

1.1. final修饰类

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

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

含义：当前这个类不能有任何的子类！（“太监类”—不能有任何子孙）

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

1.2. final修饰成员方法

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

格式：

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

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

1.3. final修饰局部变量

一旦使用final来修饰局部变量，那么这个局部变量就不可变。

什么叫“不可变”：

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

1.4. final修饰成员变量

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

  1. 由于成员变量具有默认值，所以用了final修饰之后，必须手动赋值。
  2. 对于final修饰的成员变量，要么使用直接赋值，或者使用构造方法进行赋值。
  3. 必须保证类当中所有的构造方法，都最终会对final的成员变量进行赋值。

2. 四种权限修饰符

Java中有四种权限修饰符：public > protected > (default) > private

publicprotected(default)private
同一个类(我自己)yesyesyesyes
同一个包(我邻居)yesyesyesno
不同包但是是子类(我儿子)yesyesnono
不同包且非子类(陌生人)yesnonono

注意事项：(default)并不是关键字，是可以省略不写的。

3. 内部类

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

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

分类：

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

3.1. 成员内部类

格式：

修饰符 class 类名称 {
    修饰符 class 类名称 {
        // 方法体
    }
    // 方法体
}

注意：内用外：可以随意访问；外用内：需要借助内部类对象。

使用成员内部类：

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

创建Body类：

package cn.itcast.demo03;

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

创建主方法：

package cn.itcast.demo03;

public class Demo01InnerClass {
    public static void main(String[] args) {
        // 1. 间接访问：
        Body body = new Body(); // 外部类的对象
        // 通过外部类的对象，调用外部类的方法，里面间接使用内部类Heart：
        body.methodBody();
        System.out.println("=================");

        // 2. 直接访问：
        Body.Heart heart = new Body().new Heart();
        heart.beat();
    }
}
/* 输出结果：
外部类的方法
心脏跳动，蹦蹦蹦
我叫：null
=================
心脏跳动，蹦蹦蹦
我叫：null
*/

以下两张图：创建完内部类，点击Recomplie Body.java，在项目中目录就可以看到文件Body $ Heart.class，$代表内部类的意思。

在这里插入图片描述

在这里插入图片描述

3.2. 内部类的同名变量访问

如果出现了重名现象，格式：

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

定义Outer类：

package cn.itcast.demo03;

public class Outer {

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

    public class Inner {

        int mum = 20; // 内部类的成员变量

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

主方法：

package cn.itcast.demo03;

public class Demo02InnerClass {
    public static void main(String[] args) {
        Outer.Inner obj = new Outer().new Inner();
        obj.methodInner();
    }
}
/* 输出结果：
30
20
10
*/

3.3. 局部内部类

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

什么叫局部：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。

格式：

修饰符 class 外部类名称 {
    修饰符 返回值类型 外部类方法名称(参数列表) {
        class 局部类名称 {
            // ......
        }
    }
}

总结一下类的修饰符：public > protected > (default) > private；定义一个类的时候，权限修饰符的使用规则：

  1. 外部类：public / (default)
  2. 成员内部类：public / protected / (default) / private
  3. 局部外部类：什么都不写

定义Outer类：

package cn.itcast.demo04;

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

主方法：

package cn.itcast.demo04;

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

3.4. 局部内部类的final问题

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

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

原因：

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

定义MyOuter类：

package cn.itcast.demo04;

public class MyOuter {

    public void methodOuter() {
        int num = 10; // 所在方法的局部变量
//        final int num = 10; // 只要局部变量事实不变，那么final关键字可以省略

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

3.5. 匿名内部类【今天最重要！】

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

匿名内部类定义格式：

接口名称 对象名 = new 几口名称() {
    // 覆盖重写所有的抽象方法
};

好处：不需要单独定义实现类了！

注意事项：

  1. 对格式"new 接口名() {…}"进行解析：

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

  2. 匿名内部类再创建对象时候只能使用唯一一次。如果希望多次创建对象，而且类的内容一样，那么就必须使用单独定义的实现类了。

  3. 匿名对象，【在调用方法】的时候只能调用唯一一次，如果希望同一个对象，调用多次方法，那么必须给对象起名字。

  4. 匿名内部类是省略了【实现类或者是子类】，但是匿名对象是省略了【对象名称】。

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

定义接口MyInterface：

package cn.itcast.demo05;

public interface MyInterface {

    void method1(); // 抽象方法

    void method2();
}

主方法：

package cn.itcast.demo05;

public class DemoMain {
    public static void main(String[] args) {
        // 1. 使用普通方法：
//        MyInterface impl = new MyInterfaceImpl();
//        impl.method1();

        // 2. 使用匿名内部类：这样就不需要定义MyInterfaceImpl实现类了！
        // 使用的是匿名内部类，但不是匿名对象，对象名称就叫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();
    }
}
/* 输出结果：
匿名内部类实现了方法！111-A
匿名内部类实现了方法！222-A
================
匿名内部类实现了方法！111-B
匿名内部类实现了方法！222-B
*/

3.6. 类作为成员变量类型

定义Hero类：

package cn.itcast.demo06;

// 游戏中的英雄角色类：
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() {
        // 注意这里weapon是对象
        System.out.println("年龄为" + age + "的" + name + "用" + weapon.getCode() + "攻击敌人");
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public Weapon getWeapon() {
        return weapon;
    }

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

    public void setAge(int age) {
        this.age = age;
    }

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

定义Weapon类：

package cn.itcast.demo06;

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

主方法：

package cn.itcast.demo06;

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

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

        hero.attack();
    }
}

3.7. 几口作为成员变量类型

定义Hero类：

package cn.itcast.demo07;

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(); // 调用接口中的抽象方法
    }

    public String getName() {
        return name;
    }

    public Skill getSkill() {
        return skill;
    }

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

    public void setSkill(Skill skill) {
        this.skill = skill;
    }
}

定义Skill接口：

package cn.itcast.demo07;

public interface Skill {
    void use(); // 释放技能的抽象方法
}

定义SkillImpl实现类：

package cn.itcast.demo07;

public class SkillImpl implements Skill{

    @Override
    public void use() {
        System.out.println("Biu-Biu-Biu");
    }
}

主方法：

package cn.itcast.demo07;

public class DemoMain {
    public static void main(String[] args) {
        Hero hero = new Hero();
        hero.setName("艾希射手");

        // 1. 使用当单独定义的实现类：
//        hero.setSkill(new SkillImpl());

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

        // 3. 进一步简化，同时使用匿名内部类和匿名对象：
        hero.setSkill(new Skill() {
            @Override
            public void use() {
                System.out.println("Biu-Pia-Biu-Pia");
            }
        });
        hero.attack();
    }
}
/* 输出结果：
我叫艾希射手开始施放技能：
Biu-Pia-Biu-Pia
*/

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

java.util.List正式ArrayList所实现的接口。

package cn.itcast.demo07;

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

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

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

    // 讲接口List作为返回值：
    public static List<String> addName(List<String> list) {
        list.add("迪丽热巴");
        list.add("古力娜扎");
        list.add("马儿扎哈");
        list.add("沙扬娜拉");
        return list;
    }
}
/* 输出结果：
迪丽热巴
古力娜扎
马儿扎哈
沙扬娜拉
*/

4. 发红包案例

package cn.itcast.demo14;

public class User {
    private String name; //姓名
    private int money; //余额

    public User() {
    }

    public User(String name, int money) {
        this.name = name;
        this.money = money;
    }

    // 展示一下当前用户有多少钱：
    public void show() {
        System.out.println("我叫：" + name + "，我有多少钱" + money);
    }

    public String getName() {
        return name;
    }

    public int getMoney() {
        return money;
    }

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

    public void setMoney(int money) {
        this.money = money;
    }
}

package cn.itcast.demo14;

import java.util.ArrayList;
import java.util.Random;

// 普通成员
public class Member extends User{
    public Member() {
    }

    public Member(String name, int money) {
        super(name, money);
    }

    public void receive(ArrayList<Integer> list) {
        // 从多个红包中随机抽取一个，给我自己
        // 随机获取一个集合中的索引编号：
        int index = new Random().nextInt(list.size());
        // 根据索引，从集合当中删除，并且得到被删除的红包，给我自己
        int delta = list.remove(index);
        // 当前成员自己本来有多少钱：
        int money = super.getMoney();
        // 加法，并且重新设置回去
        super.setMoney(money + delta);

    }
}

package cn.itcast.demo14;

import java.util.ArrayList;

// 群主的类：
public class Manager extends User{

    public Manager() {
    }

    public Manager(String name, int money) {
        super(name, money);
    }

    public ArrayList<Integer> send(int totalMonry, int count) {
        // 首先，需要一个集合，用来存储若干个红包的金额：
        ArrayList<Integer> redList = new ArrayList<>();

        // 看一下群主有多少钱：
        int leftMoney = super.getMoney(); // 群主当前余额
        if (totalMonry > leftMoney) {
            System.out.println("余额不足！");
            return redList; //返回空集合
        }

        // 扣钱，其实就是重新设置余额
        super.setMoney(leftMoney - totalMonry);

        // 发红包需要评价拆分为count份：
        int avg = totalMonry / count;
        int mod = totalMonry % count; // 余数，也就是剩下的零头
        // 剩下得零头包在最后一个红包里
        // 下面把红包一个一个放到集合中
        for (int i = 0; i < count - 1; i++) {
            redList.add(avg);
        }

        // 最后一个红包：
        int last = avg + mod;
        redList.add(last);

        return redList;
    }
}
  • 主方法：
package cn.itcast.demo14;

import java.util.ArrayList;

public class MainRedPocket {
    public static void main(String[] args) {
        Manager manager = new Manager("群主",100);

        Member one = new Member("成员A",0);
        Member two = new Member("成员A",0);
        Member three = new Member("成员A",0);

        manager.show(); // 100
        one.show(); // 0
        two.show(); // 0
        three.show(); // 0
        System.out.println("============");

        // 群主一个发20块钱，分成3个红包：
        ArrayList<Integer> redList = manager.send(20,3);
        // 三个普通成员收红包：
        one.receive(redList);
        two.receive(redList);
        three.receive(redList);

        manager.show(); // 100-20=80
        // 6、6、8随机分给三个人：
        one.show();
        two.show();
        three.show();
    }
}
亚呦u椰
关注
专栏目录
重新认识java（九） ---- 内部类
mystery的博客
02-11 5184
注意注意！！！前排提示！！！本篇文章过长，最好收藏下来慢慢看，如果你之前对内部类不是很熟悉，一次性看完，大概你会懵逼。。。
12 final、权限、内部类
weixin_43353418的博客
02-03 1798
第一章 final关键字 1.1 概述   学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承 API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了 final 关键字， 用于修饰不可改变内容。 final： 不可改变。可以用于修饰类、方法和变量。 类：被修饰的类，不能被继承。 方法：被修饰的方法，不能被...
11.【Java基础之final、权限、内部类、引用类型】
芒果爱柠檬
10-11 137
一、final关键字 二、权限修饰符 三、内部类 四、引用类型用法总结 备注： 只为分享和自用。 来源：源自文档、截图。
Java——static、final、内部类
qq_41649869的博客
05-15 2030
Static 其实知识点就那么些 但是涉及类加载、初始化、变量的 具体见PPT，不再总结 static修饰内容有 ： 属性、方法、初始化块、内部类 与static 相关的设计模式 单例设计模式 final修饰符 final修饰的变量 final修饰的变量就是不可变的量（并不等于常量） final修饰的变量值不可以改变，如果修饰的简单变量（int 、double），那么就是常量 final修饰的属...
Java -- 成员内部类不能含有static成员（汇总）
Syntactic Sugar
11-15 5033
文章目录1、为什么内部类中有static成员时内部类也必须声明为static2、JVM的类加载规则 ：3、成员内部类中为什么不能有静态方法和属性4、静态内部类(public static class)和普通内部类(public class)的区别5、Java中普通内部类为何不能有static属性 却可以有常量6、java内部类有什么好处？为什么需要内部类？静态内部类局部内部类匿名内部类7、Java静态内部类(static class) 1、为什么内部类中有static成员时内部类也必须声明为static &
Java 访问权限 内部类总结
夏沐的博客
09-23 5214
    在Java中，可以将一个类定义在另一个类里面或者一个方法里边，这样的类称为内部类，广泛意义上的内部类一般包括四种：成员内部类，局部内部类，匿名内部类，静态内部类 。 1.成员内部类     （1）该类像是外部类的一个成员，可以无条件的访问外部类的所有成员属性和成员方法（包括private成员和静态成员）；     （2）成员内部类拥有与外部类同名的成员变量时，会发生隐藏现象，即默认情...
7-关键字（final，static）内部类
forget_start的博客
02-29 1075
看王争专栏关键字与内部类总结。
Java--内部类学习笔记
记录并分享学习编程时的知识点...
05-21 2399
本文介绍了什么是内部类,Java中的内部类:实例内部类. 静态内部类.局部内部类.匿名内部类的语法和注意事项,以及每个内部类的运用场景,以及简单介绍了匿名内部类更简洁更特殊的语法->lambda表达式
详解 Java 内部类
热门推荐
指点
09-04 6万+
前言 内部类在 Java 里面算是非常常见的一个功能了，在日常开发中我们肯定多多少少都用过，这里总结一下关于 Java 中内部类的相关知识点和一些使用内部类时需要注意的点。 从种类上说，内部类可以分为四类：普通内部类、静态内部类、匿名内部类、局部内部类。我们来一个个看： 普通内部类 这个是最常见的内部类之一了，其定义也很简单，在一个类里面作为类的一个字段直接定义就可以了，例： pub...
细说final的的四种用法-----修饰类，修饰方法，常量，修饰参数 及内部类与final
liuerchong的博客
12-04 7267
final关键字用于修饰类 public final class 类名称 { … } 一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写,java中典型的final修饰的类 String类 作用：使当前这个类不能有任何子类 说明：当用final修饰一个类时，表明这个类不能被继承。 final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。 在使用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
引用类型在Java中指所有非基本类型的类型，包括类类型、接口类型、数组类型等。它们是类或接口的实例。引用类型用作成员变量、方法参数或方法返回值类型时，允许类与类之间进行更灵活的交互。 - **作为成员变量**：...
day11【final、权限、内部类】1
08-04
Java 中的 final 关键字、权限修饰符和内部类 final 关键字是 Java 中的一个重要概念，它用于修饰类、方法和变量，以确保它们不可被改变。下面我们将详细介绍 final 关键字的概念、使用方式和特点。 final 关键字...
11【final、权限、内部类】1
08-04
对于引用类型的变量，`final`保证变量只能引用一个对象，但不阻止对象内部的属性修改。例如，你可以改变对象的状态，但不能让变量指向不同的对象。 以下是一些使用`final`关键字的例子： ```java public class ...
基于java的共享汽车管理系统的开题报告2.docx
09-25
基于java的共享汽车管理系统的开题报告2.docx
基于SpringBoot的ChongyouLostandfound失物招领网站设计源码
09-25
该源码是一款基于SpringBoot框架构建的重邮失物招领网站，包含了250个文件，涵盖101个XML配置文件、44个Java源代码文件、26个HTML页面文件、20个JavaScript脚本文件、12个CSS样式文件、12个图片文件（JPG格式）、10个属性文件、5个ICO图标文件、5个PNG图片文件、4个SVG矢量图形文件。项目采用Java、HTML、JavaScript和CSS等多种语言实现，功能完善，界面友好。
小白学JavaScript的第六天
最新发布
09-25
小白学JavaScript的第六天
源享科技STM32学习开发板芯片资料74HC595
09-25
源享科技STM32学习开发板芯片资料74HC595
基于C++和C语言的邻居Toyota日落追逐故事设计源码
09-25
本项目是一款以C++和C语言为基础开发的“Toyota日落追逐故事”游戏源码，包含68个文件，其中包括30个可执行文件、29个C++源文件、6个文档文件、2个C源文件以及1个文本文件。游戏讲述了一个主人公驾驶邻居家的Toyota汽车追逐日落的冒险故事，其中充满了惊险与刺激。
Java基础：final、权限、内部类与引用类型详解
在Java基础课程中，"final"关键字是关键的概念之一，它在章节一得到了深入探讨。final是一个静态类型的关键字，具有...后续章节会进一步探讨权限修饰符、内部类和引用类型的用法，这些都是Java编程中不可或缺的部分。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值