Java基础语法(十)之final关键字，权限修饰符，内部类（匿名内部类），成员变量（接口，类）

最新推荐文章于 2022-11-27 17:59:12 发布
最新推荐文章于 2022-11-27 17:59:12 发布
阅读量199 收藏
点赞数
分类专栏： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32719221/article/details/100049749
版权

final关键字概念与四种用法

final关键字概念

代表最终、不可改变的。

常见四种用法：

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

final 关键字用于修饰类

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

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

final关键字用于修饰成员方法

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

注意事项：
对于类、方法来说**，abstract关键字和final关键字不能同时使用**，因为矛盾，abstract要求方法必须重写，final不让重写，报错

final关键字用于修饰局部变量

一旦使用final用来修饰局部变量，那么这个变量就不能进行更改。
“一次赋值，终生不变”
对于基本类型来说，不可变说的是变量当中的数据不可改变
对于引用类型来说，不可变说的是变量当中的地址值不可改变，但可以修改指向的对象里的内容

final int num2 = 200;
num2 = 250; // 错误写法！不能改变！
num2 = 200; // 错误写法！

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

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/* = "鹿晗"*/;   //不会给默认值，方式1直接赋值，其他的赋值方式报错

public Person() {   //方式2 构造方法赋值
    name = "关晓彤";
}

public Person(String name) {  //方式2 保证每个构造方法都要赋值
    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. 局部内部类（包含匿名内部类）

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

}

成员内部类的使用

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

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

外用内，创建内部类对象
public class Body { // 外部类

public class Heart { // 成员内部类

    // 内部类的方法
    public void beat() {
        System.out.println("心脏跳动：蹦蹦蹦！");
    }

}

// 外部类的方法
public void methodBody() {
    System.out.println("外部类的方法");     
    new Heart().beat();    //外访问内，通过创建内部类对象
}

}

public class Demo01InnerClass {

public static void main(String[] args) {
    Body body = new Body(); // 外部类的对象
    // 方式一: 通过外部类的对象，调用外部类的方法，里面间接在使用内部类Heart
    body.methodBody();
    
    //方式二: 按照公式写：
    Body.Heart heart = new Body().new Heart();
    heart.beat();
}

}

内部类的同名变量访问

如果出现了重名现象，那么格式是：外部类名称.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); // 外部类的成员变量 外部类名称.this.外部成员变量
    }

}

}

2 局部内部类的定义

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。
“局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。

定义格式：

修饰符 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的】，可以不写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. {…}这才是匿名内部类的内容，没有名字，class只有{}
另外还要注意几点问题：
  1. 匿名内部类，在【创建对象】的时候，只能使用唯一一次。
    如果希望多次创建对象，而且类的内容一样的话，那么就需要使用单独定义的实现类了。
  2. 匿名对象，在【调用方法】的时候，只能调用唯一一次。
    如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
  3. 匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
    强调：匿名内部类和匿名对象不是一回事！！！

原来的使用方式：

定义接口 ，接口方法，省略public abstract
public interface MyInterface {

void method1(); // 抽象方法

void method2();

}

接口的实现类：
public class MyInterfaceImpl implements MyInterface {

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

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

}

使用多态的形式接受新创建的接口实现类对象，调用对象的方法
public class DemoMain {

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

}

如果以匿名类的形式的话，实现类没有必要再定义

public class DemoMain {

public static void main(String[] args) {
    // MyInterface some = new MyInterface(); // 错误写法！

    // 使用匿名内部类，但不是匿名对象，对象名称就叫objA
    // 使用匿名内部类，new 接口 相当于实现接口覆盖重写，{}里相当于接口的实现类，是一个局部内部类，这个类没有名字是匿名内部类
    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();

  // 使用了匿名内部类，而且省略了对象名称，也是匿名对象
    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();

}

快速创建匿名内部类技巧；

new 接口名称 回车

类作为成员变量的类型

String 就是类常被我们当作成员变量的类型

设置一个武器类
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 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 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();
}

}

接口作为成员变量的类型

创建类的时候如何设置接口类型成员变量的值
1通过创建接口实现类，创建实现类对象设置接口成员变量的值
2通过匿名内部类（不创建接口实现类），将匿名内部类对象设置为接口成员变量的值
3使用匿名内部类和匿名对象直接传递值进去（不创建接口实现类，和产生对象名称）

创建一个Skill接口，作为英雄技能接口
public interface Skill {

void use(); // 释放技能的抽象方法

}

Skill接口实现类

public class SkillImpl implements Skill {

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

}

用接口作为英雄Hero类的成员变量
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 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();
}

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

java.util.List正是ArrayList所实现的接口。
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));
    }
}

//接口List作为函数的参数值和返回值，添加元素后，返回List

        public static List<String> addNames(List<String> list) {
            list.add("迪丽热巴");
            list.add("古力娜扎");
            list.add("玛尔扎哈");
            list.add("沙扬娜拉");
            return list;
        }

}

快速导包技巧

ALT+回车

菜菜的程序猿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java为什么匿名内部类的参数引用时final？final局部变量的生命周期
01-20
在知乎上看到了一篇帖子 在这个问题下面大家已经吵得不可开交了，看了很多篇文章，被误导进了很多的坑，发现只有下面两篇文章是写的最好的，解释的很清楚，我把两篇文章简单的总结了一下： ...1.问题的引出 ...
匿名内部类访问局部变量是否需要 final 修饰（Java Kotlin 对比）
qq_39438055的博客
02-07 593
匿名内部类访问局部变量是否需要 final 修饰（Java Kotlin 对比）
java不能用final修饰_问：JAVA中，final不能修饰下面( )。
weixin_39929646的博客
03-02 1305
问：JAVA中，final不能修饰下面( )。A:成员变量,B:类 ,C:构造方法 ,D:一般方法正确答案:绛旓細鎴挎€ф棭鎼?/p >解析：问：JAVA中，final不能修饰下面( )。 A:成员变量,B:类 ,C:构造方法 ,D:一般方法相关问题：在各种异步通信方式中，______速度最快A:全互锁B:以上都不...
Java中final关键字，权限修饰符，内部类
m0_70648941的博客
11-27 231
1.不能修饰构造方法,不能修饰成员变量,可以修饰类（接口）,成员方法2.被修饰的类（接口）不能被实例化，只能被继承，被修饰的成员方法在子类中必须被重写。
java类成员变量常量_Java中的final关键字1、修饰类的成员变量 这是final的主要用途之一，和C/C++的const，即该成员被修饰为常量，意味着不可修改。 上...
weixin_35227213的博客
02-25 299
Java中的final关键字1、修饰类的成员变量这是final的主要用途之一，和C/C++的const，即该成员被修饰为常量，意味着不可修改。上面的代码对age进行初始化后就不可再次赋值，否则编译时会报类似上图的错误。如果修饰的是引用类型的变量，那么初始化后就不能让他指向另一个对象，如下图所示2.修饰方法用final关键字修饰的方法是不能被该类的子类override(重写)，因此，如果在想明确禁止...
java接口，private，final，static组合（课堂）
501846585_QQAndroid_java
01-14 1042
package com.qianfeng.day10.demo5;   //private final static组合修饰接口中的属性   //运用场景：工具类  public class SingleInstance {               //3、一个可以缓存唯一实例的对象        privatefinal
Java学习笔记——Java语言基础（十）（package（包）、import关键字、修饰符、内部类、匿名内部类）
GXlbj23的博客
12-25 300
一、包 1.1 package关键字 1.包是用来解决同一个路径下不能存在同名文件的问题 二、内部类 1.分类： 成员位置：在成员位置定义的类，被称为成员内部类 局部位置：在局部位置定义的类，被称为局部内部类 2.特点：内部类，可以直接访问外部类的成员，包括私有的成员 外部类想要范围内部类的成员必须创建内部类的对象 2.1成员内部类 成员内部类的修饰符： private 为了保证数据的安全性 ...
Java基础_Static，静态代码块，final，包权限修饰符,内部类
平塘大鱼儿
04-18 277
staticstatic 表示静态的作用修饰成员变量（静态变量，只有一个储存空间，被所有的对象共享，可以通过类名调用使用方便！）修饰成员方法（静态方法。只有一个储存空间，可以通过类名调用使用方便）修饰内部类注意：不能修饰顶层类，构造方法，局部变量，抽象类，接口。 静态方法只能访问“静态成员”。 普通方法都可以访问。特点1、只有一个储存空间，被所有对象共享可以节省储存空间。2、成员方法：静态方法和普...
Java为什么匿名内部类参数引用需要用final进行修饰?
08-26
今天小编就为大家分享一篇关于Java为什么匿名内部类参数引用需要用final进行修饰?，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
Java基础【final、权限、内部类、引用类型】
12-21
第一章 final关键字1.1 概述1.2 使用方式修饰类修饰方法修饰变量第二章 权限修饰符2.1 概述2.2 不同权限的访问能力第三章 内部类3.1 概述什么是内部类成员内部类访问特点3.2 匿名内部类【重点】前提格式使用方式第四...
Java提高篇之详解匿名内部类
01-20
在这篇博客中你可以了解到匿名内部类的使用、匿名内部类要注意的事项、如何初始化匿名内部类、匿名内部类使用的形参为何要为final。 　一、使用匿名内部类内部类 　匿名内部类由于没有名字，所以它的创建方式有...
java(1.8)字节码读例(匿名内部类)
01-20
源代码 public class ThreadDemo { public static void main(String[] args) { ... final int j = i; new Thread(new Runnable() { @Override public void run() { System.out.println(线程 + j);
Java 中 如何将“一个类的方法 ”作为参数传到“另一个类的方法”
qq_32719221的博客
09-09 4590
java 中 如何将“一个类的方法 ”作为参数传到“另一个类的方法” 在C++中通过指针调用即可，在Java中使用方法接口 方式一 方法接口 a 先定义一个接口(定义抽象方法,理解成函数参数的规范) public interface MethodInterface { //这个方法假如就是你想要传递的方法 public String test(String s); } b 不同函数实现接口（具体的函数参数） public class Method implements MethodIn
Java基础之函数式接口
qq_32719221的博客
10-09 530
函数式接口的概念 函数式接口在Java中是指：有且仅有一个抽象方法的接口。 函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。 函数式接口的使用:一般可以作为方法的参数和返回值类型 public class Demo { ...
Java多线程（三）之等待唤醒机制、线程池、Lambda表达式
qq_32719221的博客
09-14 433
【线程池、Lambda表达式】 主要内容 等待与唤醒案例 线程池 Lambda表达式 第一章 等待唤醒机制 1.1 线程间通信 **概念：**多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。 比如：线程A用来生成包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，那么线程A与线程B之间就存在线程通信问题。 为什么要处理线程间通...
java基础语法(八)之String类，static关键字，Arrays类，Math类
qq_32719221的博客
08-20 329
字符串 字符串的概述 String的路径java.lang不需要导包 API文档当中说：Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。 其实就是说：程序当中所有的双引号字符串，都是String类的对象。（就算没有new，也照样是。） 字符串的特点 字符串的内容永不可变，常量。【重点】 正是因为字符串不可改变，所以字符串是可以共享使用的。 字符串效果上相当于是char...
Java中Object类，时间日期类，System类，StringBuilder类，包装类
qq_32719221的博客
08-30 291
【Object类、常用API】 主要内容 Object类 Date类 DateFormat类 Calendar类 System类 StringBuilder类 包装类 第一章 Object类 1.1 概述 java.lang.Object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。 如果一个类没有特别指定父类， ...
Java多线程（二）之多线程原理，内存图，获取设置线程名称，创建线程第二种方式，线程同步
qq_32719221的博客
09-10 256
多线程原理_随机性打印结果 总结 JVM执行main方法，找OS开辟一条通向CPU的路径，这个路径叫main线程，主线程通过这个线程，这个路径可以执行main方法。当new MyThread的时候又开辟一条路径，mt.start() 执行run()方法，那么对于cpu而言，就有两条执行的路径，cpu就有了选择的权力，我们控制不了cpu,所以就有了随即打印的结果。 两个线程一个main线程，一个新线...
java中用final关键字修饰一个类表示什么
最新发布
03-26
在Java中，用final关键字修饰一个类表示该类不能被继承，即该类为最终类，不允许有子类。如果类中的方法也被用final修饰，那么这些方法不能被子类重写。使用final修饰类可以避免被继承后对原有代码进行额外扩展和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值