java语言进阶篇8——final、内部类

最新推荐文章于 2022-11-30 08:19:24 发布
最新推荐文章于 2022-11-30 08:19:24 发布
阅读量253 收藏
点赞数 1
分类专栏： java语言进阶篇
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Saltyyy/article/details/105167116
版权

1、final关键字

  • 用于修饰不可改变内容。
  • final ： 不可改变。可以用于修饰类、方法和变量。
    类：被修饰的类，不能被继承。
    方法：被修饰的方法，不能被重写。
    变量：被修饰的变量，不能被重新赋值。
修饰类
  • final class 类名 { }
  • 查询 API发现像 public final class String 、 public final class Math 、 public final class Scanner等，很多我们学习过的类，都是被final修饰的，目的就是供我们使用，而不让我们所以改变其内容。
修饰方法

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

修饰变量
  1. 局部变量——基本类型
  • 基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改。代码如下：
public class FinalDemo1 {
    public static void main(String[] args) {
        // 声明变量，使用final修饰
        final int a;
        // 第一次赋值
        a = 10;
        // 第二次赋值
        a = 20; // 报错,不可重新赋值
        // 声明变量，直接赋值，使用final修饰
        final int b = 10;
        // 第二次赋值
        b = 20; // 报错,不可重新赋值
    }
}
//错误写法
final int c = 0;
for (int i = 0; i < 10; i++) {
    c = i;
    System.out.println(c);
}
//正确写法，因为每次循环，都是一次新的变量c。
for (int i = 0; i < 10; i++) {
    final int c = i;
    System.out.println(c);
}
  1. 局部变量——引用类型
  • 引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改。但是不影响对象内部的成员变量值的修改，代码如下：
public class FinalDemo2 {
    public static void main(String[] args) {
        // 创建 User 对象
        final   User u = new User();
        // 创建 另一个 User对象
        u = new User(); // 报错，指向了新的对象，地址值改变。
        // 调用setName方法
        u.setName("张三"); // 可以修改
    }
}
  1. 成员变量
  • 成员变量涉及到初始化的问题，初始化方式有两种，只能二选一：
//显式初始化
public class User {
    final String USERNAME = "张三";
    private int age;
}
//构造方法初始化
public class User {
    final String USERNAME ; //被final修饰的常量名称，一般都有书写规范，所有字母都大写
    private int age;
    public User(String username, int age) {
        this.USERNAME = username;
        this.age = age;
    }
}

2、 权限修饰符

  • 在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限，
    public ：公共的。
    protected ：受保护的
    default ：默认的
    private ：私有的
  • 不同权限的访问能力
    不同权限的访问能力
  • 编写代码时，如果没有特殊的考虑，建议这样使用权限：
    成员变量使用 private ，隐藏细节。
    构造方法使用 public ，方便创建对象。
    成员方法使用 public ，方便调用方法。
    小贴士：不加权限修饰符，其访问能力与default修饰符相同

3、内部类

  • 将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。
  • 定义格式：
    class 外部类 {
    class 内部类{
    }
    }
  • 在描述事物时，若一个事物内部还包含其他事物，就可以使用内部类这种结构。比如，汽车类 Car 中包含发动机类 Engine ，这时， Engine 就可以使用内部类来描述，定义在成员位置。
  • 访问特点
    内部类可以直接访问外部类的成员，包括私有成员。
    外部类要访问内部类的成员，必须要建立内部类的对象。
  • 创建内部类对象格式：
    外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；
public class Person {
    private  boolean live = true;
    class Heart {
        public void jump() {
            // 直接访问外部类成员
            if (live) {
                System.out.println("心脏在跳动");
            } else {
                System.out.println("心脏不跳了");
            }
        }
    }
    public boolean isLive() {
        return live;
    }
    public void setLive(boolean live) {
        this.live = live;
    }
}
public class InnerDemo {
	public static void main(String[] args) {
        // 创建外部类对象
        Person p  = new Person();
        // 创建内部类对象
        Heart heart = p.new Heart();
        // 调用内部类方法
        heart.jump();
        // 调用外部类方法
        p.setLive(false);
        // 调用内部类方法
        heart.jump();
    }
}
输出结果:
心脏在跳动
心脏不跳了
  • 内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的 .class文件，但是前面冠以外部类的类名
    和 $ 符号 。比如Person $ Heart.class

4、匿名内部类【重点】

  • 是内部类的简化写法。它的本质是一个 带具体实现的 父类或者父接口的 匿名的 子类对象。开发中，最常用到的内部类就是匿名内部类了。以接口举例，当你使用一个接口时，似乎得做如下几步操作，
  1. 定义子类
  2. 重写接口中的方法
  3. 创建子类对象
  4. 调用重写后的方法
  • 目的：最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类就是做这样的快捷方式。
  • 前提：匿名内部类必须继承一个父类或者实现一个父接口。
  • 格式
    new 父类名或者接口名(){
    // 方法重写
    @Override
    public void method() {
    // 执行语句
    }
    };
//定义接口
public abstract class FlyAble{
    public abstract void fly();
}
//创建匿名内部类，并调用
public class InnerDemo {
    public static void main(String[] args) {
        /*
        1.等号右边:是匿名内部类，定义并创建该接口的子类对象
        2.等号左边:是多态赋值,接口类型引用指向子类对象
        */
        FlyAble  f = new FlyAble(){
            public void fly() {
                System.out.println("我飞了~~~");
            }
        };
        //调用 fly方法,执行重写后的方法
        f.fly();
    }
}
public class InnerDemo2 {
    public static void main(String[] args) {
        /*
        1.等号右边:定义并创建该接口的子类对象
        2.等号左边:是多态,接口类型引用指向子类对象
       */
        FlyAble  f = new FlyAble(){
            public void fly() {
                System.out.println("我飞了~~~");
            }
        };
        // 将f传递给showFly方法中
        showFly(f);
    }
    public static void showFly(FlyAble f) {
        f.fly();
    }
}
//以上两步，也可以简化为一步
public class InnerDemo3 {
	 public static void main(String[] args) {           
        /*
       创建匿名内部类,直接传递给showFly(FlyAble f) 
        */
        showFly( new FlyAble(){
            public void fly() {
                System.out.println("我飞了~~~");
            }
        });
    }
    public static void showFly(FlyAble f) {
        f.fly();
    }
}

5、引用类型用法总结

  • 实际的开发中，引用类型的使用非常重要，也是非常普遍的。可以在理解基本类型的使用方式基础上，进一步去掌握引用类型的使用方式。基本类型可以作为成员变量、作为方法的参数、作为方法的返回值，那么当然引用类型也是可以的。
class 作为成员变量
class Weapon {
  String name； // 武器名称   
    int hurt； // 伤害值
}
class Armour {
   String name；// 装备名称  
    int protect；// 防御值 
}
class Role {
    int id；
    int blood；
    String name；
    // 添加武器属性
    Weapon wp；                  //class作为成员变量
    // 添加盔甲属性
    Armour ar；                 //class作为成员变量
    // 提供get/set方法
    public Weapon getWp() {
        return wp;
    }
    public void setWeapon(Weapon wp) {
        this.wp = wp;
    }
    public Armour getArmour() {
        return ar;
    }
    public void setArmour(Armour ar) {
        this.ar = ar;
    }
    // 攻击方法
    public void attack(){
        System.out.println("使用"+ wp.getName() +", 造成"+wp.getHurt()+"点伤害"); 
    }
    // 穿戴盔甲
    public void wear(){
        // 增加防御,就是增加blood值
        this.blood += ar.getProtect();
        System.out.println("穿上"+ar.getName()+", 生命值增加"+ar.getProtect());
    } 
}
public class Test {
   public static void main(String[] args) {  
     // 创建Weapon 对象     
       Weapon wp = new Weapon("屠龙刀" , 999999);        
       // 创建Armour 对象  
       Armour ar = new Armour("麒麟甲",10000);  
       // 创建Role 对象  
       Role r = new Role();        
       
       // 设置武器属性  
       r.setWeapon(wp);    //将类对象作为参数
       // 设置盔甲属性   
       r.setArmour(ar);    //将类对象作为参数
     
       // 攻击  
       r.attack();  
        // 穿戴盔甲
       r.wear();  
   }  
}
输出结果:
使用屠龙刀,造成999999点伤害
穿上麒麟甲 ,生命值增加10000
interface 作为成员变量
  • 接口是对方法的封装，对应游戏当中，可以看作是扩展游戏角色的技能。所以，如果想扩展更强大技能，在Role 中，可以增加接口作为成员变量，来设置不同的技能。
// 接口，法术攻击
public interface FaShuSkill {
    public abstract void faShuAttack();
}
public class Role {
    FaShuSkill fs;                         //接口作为成员变量
    public void setFaShuSkill(FaShuSkill fs) { 
        this.fs = fs;
    }
    // 法术攻击
    public void faShuSkillAttack(){
        System.out.print("发动法术攻击:");
        fs.faShuAttack();
        System.out.println("攻击完毕");
    }
}
public class Test {
    public static void main(String[] args) {
        // 创建游戏角色
        Role role = new Role();
        // 设置角色法术技能
        role.setFaShuSkill(new FaShuSkill() {     //匿名对象、匿名内部类写法
            @Override
            public void faShuAttack() {
                System.out.println("纵横天下");
            }
        });
        // 发动法术攻击
        role.faShuSkillAttack();
        // 更换技能
        role.setFaShuSkill(new FaShuSkill() {
            @Override
            public void faShuAttack() {
                System.out.println("逆转乾坤");
            }
        });
        // 发动法术攻击
        role.faShuSkillAttack();
}    
}
输出结果:
发动法术攻击:纵横天下
攻击完毕
发动法术攻击:逆转乾坤
攻击完毕
  • 使用一个接口，作为成员变量，以便随时更换技能，这样的设计更为灵活，增强了程序的扩展性。接口作为成员变量时，对它进行赋值的操作，实际上，是赋给它该接口的一个子类对象。
interface 作为方法参数和返回值类型
  • 当接口作为方法的参数时,需要传递什么呢？当接口作为方法的返回值类型时，需要返回什么呢？对，其实都是它的子类对象。 ArrayList 类是 java.util.List 接口的实现类。所以，当看见 List 接口作为参数或者返回值类型时，当然可以将 ArrayList 的对象进行传递或返回。
//获取某集合中所有的偶数。
public static List<Integer> getEvenNum(List<Integer> list) {
    // 创建保存偶数的集合
    ArrayList<Integer> evenList = new ArrayList<>();
    // 遍历集合list,判断元素为偶数,就添加到evenList中
    for (int i = 0; i < list.size(); i++) {
        Integer integer = list.get(i);
        if (integer % 2 == 0) {
            evenList.add(integer);
        }
    }
    /*
   返回偶数集合 
   因为getEvenNum方法的返回值类型是List,而ArrayList是List的子类, 
   所以evenList可以返回 
   */  
    return evenList;
}
public class Test {
    public static void main(String[] args) {
        // 创建ArrayList集合,并添加数字
        ArrayList<Integer> srcList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            srcList.add(i);
        }
        /*
       获取偶数集合  
       因为getEvenNum方法的参数是List,而ArrayList是List的子类,  
       所以srcList可以传递  
       */  
        List list = getEvenNum(srcList);
        System.out.println(list);
    }
}
  • 接口作为参数时，传递它的子类对象。
    接口作为返回值类型时，返回它的子类对象。

6、综合案例——发红包【界面版】

  • 红包类型：
  1. 普通红包：金额均分。不能整除的，余额添加到最后一份红包中。
  2. 手气红包：金额随机。各个红包金额累和与总金额相等。
  • 红包场景：
    案例是模拟群主给群成员发红包，群主自己打开最后一个红包的场景。
 //RedPacketFrame ：一个抽象类，包含了一些属性，是红包案例的页面（省略）。
 public abstract class RedPacketFrame extends JFrame {
    /*  ownerName : 群主名称 */
    public String ownerName = "谁谁谁谁";
    /* openMode : 红包的类型 [普通红包/手气红包]  */ 
    public OpenMode openMode = null;
    /**
 * 构造方法:生成红包界面.    
 * @param title 页面的标题.    
 */    
    public RedPacketFrame(String title) {
        super(title);
        init();// 页面相关的初始化操作
    }
    /* set方法 */
    public void setOwnerName(String ownerName) {
        this.ownerName = ownerName;
    }
    public void setOpenMode(OpenMode openMode) {
        this.openMode = openMode;
    }
}
//OpenMode ：一个接口，包含一个分配方法，用来指定红包类型。
public interface OpenMode {
    /**
 * @param totalMoney 总金额,单位是"分"。总金额为方便计算,已经转换为整数,单位为分。         
 * @param count 红包个数              
 * @return ArrayList<Integer> 元素为各个红包的金额值,所有元素的值累和等于总金额.        
 *     
 * 请将totalMoney,分成count分,保存到ArrayList<Integer>中,返回即可.    
 */    
    public abstract  ArrayList<Integer> divide(int totalMoney, int count);
}

// 定义 MyRed 类，继承 RedPacketFrame 
public class MyRed extends RedPacketFrame {
    /**
     * 构造方法：生成红包界面。
     *
     * @param title 界面的标题
     */
    public MyRed(String title) {
        super(title);
    }
}
}
//定义普通红包类实现OpenMode接口
import java.util.ArrayList;
public class NormalMode implements OpenMode {
    @Override
    public ArrayList<Integer> divide(final int totalMoney, final int totalCount) {
        ArrayList<Integer> list = new ArrayList<>();

        int avg = totalMoney / totalCount; // 平均值
        int mod = totalMoney % totalCount; // 余数，模，零头

        // 注意totalCount - 1代表，最后一个先留着
        for (int i = 0; i < totalCount - 1; i++) {
            list.add(avg);
        }

        // 有零头，需要放在最后一个红包当中
        list.add(avg + mod);

        return list;
    }
}
//定义手气红包类实现OpenMode接口
import java.util.ArrayList;
import java.util.Random;

public class RandomMode implements OpenMode {
    @Override
    public ArrayList<Integer> divide(final int totalMoney, final int totalCount) {
        ArrayList<Integer> list = new ArrayList<>();

        // 随机分配，有可能多，有可能少。
        // 最少1分钱，最多不超过“剩下金额平均数的2倍”
        // 第一次发红包，随机范围是0.01元~6.66元
        // 第一次发完之后，剩下的至少是3.34元。
        // 此时还需要再发2个红包
        // 此时的再发范围应该是0.01元~3.34元（取不到右边，剩下0.01）

        // 总结一下，范围的【公式】是：1 + random.nextInt(leftMoney / leftCount * 2);
        Random r = new Random(); // 首先创建一个随机数生成器
        // totalMoney是总金额，totalCount是总份数，不变
        // 额外定义两个变量，分别代表剩下多少钱，剩下多少份
        int leftMoney = totalMoney;
        int leftCount = totalCount;

        // 随机发前n-1个，最后一个不需要随机
        for (int i = 0; i < totalCount - 1; i++) {
            // 按照公式生成随机金额
            int money = r.nextInt(leftMoney / leftCount * 2) + 1;
            list.add(money); // 将一个随机红包放入集合
            leftMoney -= money; // 剩下的金额越发越少
            leftCount--; // 剩下还应该再发的红包个数，递减
        }

        // 最后一个红包不需要随机，直接放进去就得了
        list.add(leftMoney);
        return list;
    }
}//测试类
/*
场景说明：
    红包发出去之后，所有人都有红包，大家抢完了之后，最后一个红包给群主自己。
大多数代码都是现成的，我们需要做的就是填空题。
我们自己要做的事情有：
    1. 设置一下程序的标题，通过构造方法的字符串参数
    2. 设置群主名称
    3. 设置分发策略：平均，还是随机？

红包分发的策略：
    1. 普通红包（平均）：totalMoney / totalCount，余数放在最后一个红包当中。
    2. 手气红包（随机）：最少1分钱，最多不超过平均数的2倍。应该越发越少。
 */
public class Bootstrap {

    public static void main(String[] args) {
        MyRed red = new MyRed("传智播客双元课程");
        // 设置群主名称
        red.setOwnerName("王思聪");

        // 普通红包
//        OpenMode normal = new NormalMode();
//        red.setOpenWay(normal);

        // 手气红包
        OpenMode random = new RandomMode();
        red.setOpenWay(random);
    }

}
Saltyyy
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java进阶学习7—内部类、Lambda
m0_74270947的博客
11-17 199
I 内部类 一、内部类概述 1、定义：在一个类中定义一个类 2、分类：成员内部类、局部内部类、匿名内部类 3、内部类访问特点：(1)内部类可以直接访问外部类的成员，包括私有成员(2)外部类要通过创建对象访问内部类成员 二、内部类特点及使用 1、成员内部类：在类的成员位置 (i)属于类中的成员，可由修饰符修饰 (ii)private修饰：私有成员内部类访问需要在其所在外部类中创建对象使用 (iii)static修饰：(1)静态成员内部类访问格式：外部类名.内部类名.对象=new 外部类名.内
动力节点老杜Java基础入门视频教程——final修饰的类无法继承
09-22
010-JavaSE进阶-final修饰的类无法继承
JAVA小记：final，内部类
weixin_44489825的博客
08-20 405
小记：final，内部类一、 final关键字1、概述2、注意事项二、内部类1、概述定义分类2、成员内部类格式成员内部类的使用成员内部类的同名变量访问3、局部内部类定义格式局部内部类的使用4、关于类的权限修饰符外部类成员内部类局部内部类5、局部内部类访问所在方法的局部变量6、匿名内部类 一、 final关键字 1、概述   由继承关系可知，子类可以在父类的基础上改写父类内容，比如，方法重写。如果随意的继承API中提供的类，改写其内容，显然这是不合适的。为了避免这种随意改写的情况，Java提供了final 关
java 内部类
aiqing2015的博客
05-24 333
在Java中，可以将一个类定义在另一个类里面或者一个方法里边，这样的类称为内部类，广泛意义上的内部类一般包括四种：成员内部类，局部内部类，匿名内部类，静态内部类 。 1.成员内部类 （1）该类像是外部类的一个成员，可以无条件的访问外部类的所有成员属性和成员方法（包括private成员和静态成员）； （2）成员内部类拥有与外部类同名的成员变量时，会发生隐藏现象，即默认情况下访问的是成...
为什么局部内部类和匿名内部类只能访问final的局部变量?
sf_climber的博客
10-24 1万+
最近在看内部类的时候,有一个疑惑:局部内部类和匿名内部类只能访问final的局部变量,看了几篇博客,明白了很多,下面来分析一下:
内部类访问局部变量的时候，为什么变量必须加上final修饰
weixin_34148456的博客
05-07 194
这里的局部变量就是在类方法中的变量，能访问方法中变量的类当然也是局部内部类了。我们都知道，局部变量在所处的函数执行完之后就释放了，但是内部类对象如果还有引用指向的话它是还存在的。例如下面的代码： class Outer{ ...
java基础第九篇之final和内部类等
不一样的花朵的博客
06-16 174
final关键字:final:最终,终极 final:作用:修饰类,变量,方法、成员变量的访问 1.final修饰变量: final修饰局部变量: 把这个局部变量 变成一个厂里,这个厂里只能被赋值一次 final修饰成员变量: 要求这个成员变量 在创建对象之前必须初始化 所以final修饰的成员变量 第一直觉赋值 第二构造方法赋值 但是也只能赋值一次 2.fi...
动力节点老杜Java基础入门视频教程——final修饰引用
09-22
013-JavaSE进阶-final修饰引用
动力节点老杜Java基础入门视频教程——final修饰局部变量
09-22
012-JavaSE进阶-final修饰局部变量
动力节点老杜Java基础入门视频教程——final修饰的方法无法覆盖
09-22
011-JavaSE进阶-final修饰的方法无法覆盖
java学习进阶之路，如果从一个菜鸟进阶成大神（csdn）————程序.pdf
12-01
Java学习进阶是一个系统的过程，涉及多个层面的知识和技能。以下是一个详细的指南，帮助你从初学者逐步成长为Java开发的大神。 1. **编程基础** - **数据结构与算法**：这是所有程序员的基石。熟悉数组、链表、...
Java内部类与final关键字详解
Thinking_IN_Java
05-10 3001
详解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
8.java基础-final
最新发布
qq_30635523的博客
11-30 432
java基础-final关键字
为什么匿名内部类和局部内部类只能访问final变量
热门推荐
sala技术专栏
05-02 3万+
转:http://feiyeguohai.iteye.com/blog/1500108 为什么匿名内部类参数必须为final类型 1)  从程序设计语言的理论上:局部内部类(即:定义在方法中的内部类),由于本身就是在方法内部(可出现在形式参数定义处或者方法体处),因而访问方法中的局部变量(形式参数或局部变量)是天经地义的.是很自然的 2)  为什么JAVA中要加上一条限制:只能访
为什么必须是final的呢？
weixin_30772261的博客
06-23 279
一个谜团 如果你用过类似guava这种“伪函数式编程”风格的library的话，那下面这种风格的代码对你来说应该不陌生： 1 2 3 4 5 6 7 8 9 public void tryUsingGuava() { final int expectedLength = 4; Iterables.filter(Lists.n...
final常量为何常用于内部类？
qq_42320048的博客
02-16 471
1.final与static final： 在Java中，final指示常量。用final标记的变量只能被赋值一次，一旦被赋值就不能更改了。习惯上常量名用大写。final通常和static搭配使用，static final为类常量，类常量的定义位于main方法的外部，可以在一个类的多个方法中使用。 public class Test {     public static final dou...
匿名内部类为什么是 Final 的呢？
niexianglin_csdn的博客
10-30 4149
现在前面 匿名内部类来自外部闭包环境的自由变量必须是final的，除非自由变量来自类的成员变量。 什么是自由变量？ 一个函数的“自由变量”就是既不是函数参数也不是函数内部局部变量的变量。 什么是外部环境 外部环境如果持有内部函数所使用的自由变量，就会对内部函数形成“闭包”。 - 一个简单的列子public class AnonymousDemo1 { public st
内部类、final与垃圾回收，面试时你一说，面试官就知道
hsm_computer的博客
02-01 4408
内部类并不常用，而且使用起来有一定的定式，比如在下面的InnterDemoByTrhead.java里，我们通过内部类的形式创建线程。 1 public class InnerDemoByThread { 2 public static void main(String[] args) { 3 // 实现runnable接口，创建10个线程并启动 4 for(int ...
内部类 final变量的生命周期
天乙贵人
09-02 1460
(1).内部类是外部类的一个成员，就像外部类的成员方法一样，所以内部类有权限访问外部类的所有成员，包括private的。 (2).内部类不能访问外部类方法中的局部变量，除非变量是final的(一般发生在方法中定义的内部类)。这是因为局部变量的生命周期原因。 class Outer{ private int a; public class Inner{ private int a; public void method(int a){
Java SE进阶：理解final关键字与面向对象基础
"Java SE 进阶教程——面向对象篇深入解析" 在Java SE的进阶课程中，面向对象编程（Object-Oriented Programming, OOP）是核心内容之一。本章节主要讨论了几个关键的概念和技术，包括final关键字、抽象类、接口、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值