Java权限修饰符的介绍，代码块的构造，匿名内部类的介绍

已于 2024-07-14 18:45:37 修改
阅读量827 收藏 15
点赞数 9
分类专栏： Java 文章标签： java 开发语言
于 2024-06-15 15:55:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiugtt6141121/article/details/139703771
版权

第一章.权限修饰符

1 概述

在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限，

  • public：公共的,最高权限,被public修饰的成员,在哪里都能访问

  • protected：受保护的

  • default：:默认的 注意 不写权限修饰符就是默认权限,不能直接把default写出来

  • private：私有的,只能在自己的类中直接访问

    我们只需要知道一个成员被这四个权限修饰符修饰在4种情况下能不能访问就行了

2 不同权限的访问能力

publicprotecteddefault（空的）private
同类yesyesyesyes
同包不同类yesyesyesno
不同包子父类yesyesnono
不同包非子父类yesnonono

public具有最大权限,private有最小权限

编写代码时,如果没有特殊的考虑,建议这样使用权限:

1.属性:用private -> 封装思想
2.成员方法public -> 便于调用
3.构造public -> 便于new对象

第二章.final关键字

1.概述:最终的
2.使用:
a.修饰一个类
b.修饰一个方法
c.修饰一个局部变量
d.修饰一个成员变量
e.修饰一个对象

1.final修饰类

1.格式:
public final class 类名{}
2.特点:
被final修饰的类不能被继承

public final class Animal {
}

public class Dog /*extends Animal*/{
}

2.final修饰方法

1.格式:
修饰符 final 返回值类型 方法名(形参){
方法体
return 结果
}
2.特点:
被final修饰的方法,不能被重写

3.注意:
final和abstract不能同时修饰一个方法

public abstract class Animal {
    public final void eat(){
        System.out.println("动物要干饭");
    }

    //public abstract final void drink();
}

public class Dog extends Animal{
/*    public void eat(){
        System.out.println("狗啃骨头");
    }*/

}

3.final修饰局部变量

1.格式:
final 数据类型 变量名 = 值
2.特点:
被final修饰的变量不能二次赋值

public class Test01 {
    public static void main(String[] args) {
        final int i = 10;
        //i = 20; 被final修饰的变量不能二次赋值
        
        final int j;
        j = 100;
        //j = 200;
                
    }
}

4.final修饰对象

1.格式:
final 数据类型 对象名 = new 对象();
2.特点:
被final修饰的对象,地址值不能改变,但是对象中的属性值可以改变

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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 class Test02 {
    public static void main(String[] args) {
        //Person p1 = new Person("金莲",26);
        //System.out.println(p1);//地址值
        //p1 = new Person("涛哥",18);
        //System.out.println(p1);//地址值

        final Person p1 = new Person("金莲",26);
        System.out.println(p1);//地址值
        //p1 = new Person("涛哥",18);
        //System.out.println(p1);//地址值

        p1.setName("大郎");
        p1.setAge(30);
        System.out.println(p1.getName()+"..."+p1.getAge());
    }
}

5.final修饰成员变量

1.格式:
final 数据类型 变量名 = 值
2.特点:
a.需要手动赋值
b.不能二次赋值

public class Student {
    final String name = "广坤";

    public Student() {
    }

    //有参构造现在属于二次赋值了
    /*public Student(String name) {
        this.name = name;
    }*/

    public String getName() {
        return name;
    }
    //set方法现在属于二次赋值了
    /*public void setName(String name) {
        this.name = name;
    }*/
}

第三章.代码块

1.构造代码块

1.格式:
{
代码
}

2.执行特点:优先于构造方法执行,每new一次,就会执行一次

public class Person {
    public Person(){
        System.out.println("我是无参构造方法");
    }

    //构造代码块
    {
        System.out.println("我是构造代码块");
    }
}

public class Test01 {
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person();
    }
}

2.静态代码块

1.格式:
static{
代码
}

2.执行特点:
静态代码块优先于构造代码块和构造方法执行的,而且只执行一次

public class Person {
    public Person(){
        System.out.println("我是无参构造方法");
    }

    //构造代码块
    {
        System.out.println("我是构造代码块");
    }

    //静态代码块
    static{
        System.out.println("我是静态代码块");
    }
}

public class Test01 {
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person();
    }
}

3.静态代码块使用场景

如果想让一些数据最先初始化,而且只需要初始化一次,就可以将这些数据放到静态代码块中

第四章.内部类

1.什么时候使用内部类:
当一个事物的内部,还有一个部分需要完整的结构去描述,而这个内部的完整结构又只为外部事物提供服务,那么整个内部的完成结构最好使用内部类

比如:人类都有心脏,人类本身需要用属性,行为去描述,那么人类内部的心脏也需要心脏特殊的属性和行为去描述,此时心脏就可以定义成内部类,人类中的一个心脏类

2.在java中允许一个类的定义位于另外一个类内部,前者就称之为内部类,后者称之为外部类
class A{
class B{

  }

}

类A就是类B的外部类
类B就是类A的内部类

3.分类:
成员内部类(静态,非静态)
局部内部类
匿名内部类(重点)

1 静态成员内部类

1.格式:直接在定义内部类的时候加上static关键字
public class A{
static class B{

  }

}

2.注意:
a.内部类可以定义属性,方法,构造等
b.静态内部类可以被final或者abstract修饰
被final修饰之后,不能被继承
被abstract修饰之后,不能new
c.静态内部类不能调用外部的非静态成员
d.内部类还可以被四种权限修饰符修饰

3.调用静态内部类成员:
外部类.内部类 对象名 = new 外部类.内部类()

public class Person {
    public void eat(){
        System.out.println("人要干饭");
    }

    static class Heart{
        public void jump(){
            System.out.println("心脏哐哐哐跳");
        }
    }
}

public class Test01 {
    public static void main(String[] args) {
       // 外部类.内部类 对象名 = new 外部类.内部类()
        Person.Heart heart = new Person.Heart();
        heart.jump();
    }
}

2 非静态成员内部类

1.格式:直接在定义内部类的时候加上static关键字
public class A{
class B{

  }

}

2.注意:
a.内部类可以定义属性,方法,构造等
b.静态内部类可以被final或者abstract修饰
被final修饰之后,不能被继承
被abstract修饰之后,不能new
c.静态内部类不能调用外部的非静态成员
d.内部类还可以被四种权限修饰符修饰

3.调用非静态内部类成员:
外部类.内部类 对象名 = new 外部类().new 内部类()

public class Person {
    public void eat(){
        System.out.println("人要干饭");
    }

    class Heart{
        public void jump(){
            System.out.println("心脏哐哐哐跳");
        }
    }
}

public class Test01 {
    public static void main(String[] args) {
       // 外部类.内部类 对象名 = new 外部类().new 内部类()
        Person.Heart heart = new Person(). new Heart();
        heart.jump();
    }
}

外部类的成员变量和内部类的成员变量以及内部类的局部变量重名时,怎么区分?

public class Student {
 String name = "金莲";
 class Heart{
     String name = "大郎";
     public void display(String name){
         System.out.println(name);//内部类的局部变量
         System.out.println(this.name);//内部类的成员变量
         System.out.println(Student.this.name);//外部类的成员变量
     }
 }
}


public class Test02 {
 public static void main(String[] args) {
     Student.Heart heart = new Student().new Heart();
     heart.display("涛哥");
 }
}

3.局部内部类

3.1.局部内部类基本操作

1.可以定义在方法中,代码块中,构造中

public class Person {
    public void eat(){
        class Heart{
            public void jump(){
                System.out.println("心脏哐哐哐的跳");
            }
        }

        new Heart().jump();
    }
}


public class Test01 {
    public static void main(String[] args) {
        Person person = new Person();
        person.eat();
    }
}

3.2.局部内部类实际操作

3.2.1.接口类型作为方法参数传递和返回

1.接口作为方法参数,传递实参时,传递的是实现类对象

2.接口作为返回值类型返回,实际返回的是实现类对象

public interface USB {
    public abstract void open();
}

public class Mouse implements USB{
    @Override
    public void open() {
        System.out.println("鼠标打开");
    }
}

public class Test01 {
    public static void main(String[] args) {
        Mouse mouse = new Mouse();
        method(mouse);
        System.out.println("================");

        USB usb = method01();//USB usb = new Mouse();
        usb.open();
    }

    /*
       接口作为方法参数,传递实参时,传递的是实现类对象
     */
    public static void method(USB usb){//USB usb = mouse -> 多态
        usb.open();
    }

    /*
      接口作为返回值类型返回,实际返回的是实现类对象
    */
    public static USB method01(){
        //Mouse mouse = new Mouse();
        //return mouse;
        return new Mouse();
    }
}
3.2.2.抽象类作为方法参数和返回值

1.抽象类作为方法参数传递,传递实参时,传递的是其子类对象

2.抽象类作为方法返回值类型返回时,实际返回的是其子类对象

public abstract class Animal {
    public abstract void eat();
}

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗啃骨头");
    }
}

public class Test02 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        method01(dog);
        System.out.println("=================");
        Animal animal = method02();//Animal animal = new Dog()
        animal.eat();
    }

    public static void method01(Animal animal){//Animal animal = dog
        animal.eat();
    }

    public static Animal method02(){
        return new Dog();
    }
}
3.2.3.普通类做方法参数和返回值

普通类作为方法参数传递,传递的是对象

普通类作为方法返回值返回,返回的是对象

public class Person {
    public void eat(){
        System.out.println("人要干饭");
    }
}


public class Test03 {
    public static void main(String[] args) {
        Person person = new Person();
        method01(person);
        System.out.println("==================");
        Person person1 = method02();//Person person1 = new Person()
        person1.eat();
    }
    public static void method01(Person person){
        person.eat();
    }

    public static Person method02(){
        return new Person();
    }
}
3.2.4.局部内部类实际操作
public interface USB {
    void open();
}


public class Test01 {
    public static void main(String[] args) {
        USB usb = method();//USB usb = new Mouse()
        usb.open();
    }

    public static USB method(){
        //局部内部类
        class Mouse implements USB{

            @Override
            public void open() {
                System.out.println("鼠标打开");
            }
        }

        return new Mouse();
    }
}

4.匿名内部类(重点)

所谓的匿名内部类,可以理解为没有显式声明出类名的内部类

1.问题描述:我们如果想实现接口,简单使用一次抽象方法,我们就需要创建一个实现类,实现这个接口,重写抽象方法,还要new实现类对象,所以我们在想如果就单纯的想使用一次接口中的方法,我们能不能不这么麻烦呢?可以
a.创建实现类,实现接口
b.重写方法
c.创建实现类对象
d.调用方法

2.如果就想单纯的使用一下接口中的方法,我们就没必要经过以上四步了,我们可以四合一

3.匿名内部类怎么学:就按照一种格式来学,这一种格式就代表了实现类对象或者子类对象

4.格式:
new 接口/抽象类(){
重写方法
}.重写的方法();

=================================

类名 对象名 = new 接口/抽象类(){
重写方法
}
对象名.重写的方法();

public interface USB {
    void open();
    void close();
}

public class Test01 {
    public static void main(String[] args) {
        new USB(){

            @Override
            public void open() {
                System.out.println("usb打开了");
            }

            @Override
            public void close() {
                System.out.println("usb关闭了");
            }
        }.open();

        System.out.println("===================");

        USB usb = new USB() {
            @Override
            public void open() {
                System.out.println("USB打开了");
            }

            @Override
            public void close() {
                System.out.println("USB关闭了");
            }
        };
        usb.open();
        usb.close();
    }
}

1.什么时候使用匿名内部类:

​ 当简单调用一次接口中的方法,我们就可以使用匿名内部类

2.将一种格式代表实现类对象或者子类对象来看待,来学习

3.匿名内部类会编译生成的,咱们不要管,我们只需要利用咱们讲的格式去new对象,调用重写的方法即可

4.1 匿名内部类复杂用法_当参数传递

public interface USB {
    void open();
}

public class Test01 {
    public static void main(String[] args) {
        method01(new USB() {
            @Override
            public void open() {
                System.out.println("usb打开了");
            }
        });
    }
    public static void method01(USB usb){
        usb.open();
    }
}

在这里插入图片描述

4.2 匿名内部类复杂用法_当返回值返回

public interface USB {
    void open();
}


public class Test02 {
    public static void main(String[] args) {
        USB usb = method01();
        usb.open();

    }

    public static USB method01(){
        return new USB() {
            @Override
            public void open() {
                System.out.println("USB打开了");
            }
        };
    }
}

攒了一袋星辰
关注
  • 9
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java中的内部类详细总结
09-04
局部内部类是在方法、构造器或块中定义的类，其作用域仅限于该方法、构造器或块。局部内部类可以访问其所在作用域内的所有局部变量和方法，以及外部类的所有成员。但局部内部类不能声明为`static`，也不能有`static...
java代码-20210510 测试内部类1
07-16
局部内部类是在方法、构造器或块中定义的类，其作用域仅限于该方法、构造器或块。匿名内部类通常用于创建一次性使用的简单类，特别是在实现接口时。静态内部类与普通内部类的区别在于，它可以独立于外部类实例存在，...
[Java] 权限修饰符、内部类与代码块相关题目
Regino的博客
04-07 484
本文包含了 Java 中权限修饰符、内部类与代码块的相关题目。。。
java跨包访问内部类_Java---- 匿名对象 内部类 包 访问修饰符 构造代码块
weixin_35805055的博客
02-26 363
匿名对象匿名对象是指创建对象，只有创建对象的语句，却没有把对象地址值赋值给某个变量。创建一个普通对象：Person p=new person( );创建一个匿名对象：new Person()；匿名对象的特点：创建匿名对象直接使用，没有变量名。匿名对象在没有指定其引用变量时，只能使用一次。有名字对象，引用类型变量，可以反复使用匿名对象，没有引用变量，只能用一次匿名对象可以当参数传递public cl...
Java笔记-面向对象之构造方法 内部类 访问修饰符 代码块
destinationnn的博客
04-26 527
一 构造方法1.1构造方法介绍    在开发中经常需要在创建对象的同时明确对象的属性值，比如员工入职公司就要明确他的姓名、年龄等属性信息。    那么，创建对象就要明确属性值，那怎么解决呢？也就是在创建对象的时候就要做的事情，当使用new关键字创建对象时，怎么给对象的属性初始化值呢？这就要学习Java另外一门小技术，构造方法。    那什么是构造方法呢？从字面上理解即为构建创造时用的方法，即就是对...
Java基础_Static，静态代码块，final，包权限修饰符,内部类
平塘大鱼儿
04-18 283
staticstatic 表示静态的作用修饰成员变量（静态变量，只有一个储存空间，被所有的对象共享，可以通过类名调用使用方便！）修饰成员方法（静态方法。只有一个储存空间，可以通过类名调用使用方便）修饰内部类注意：不能修饰顶层类，构造方法，局部变量，抽象类，接口。 静态方法只能访问“静态成员”。 普通方法都可以访问。特点1、只有一个储存空间，被所有对象共享可以节省储存空间。2、成员方法：静态方法和普...
13_Java面向对象_第5天（static、final、匿名对象、内部类、包、修饰符、代码块）_讲义
02-16
本讲义主要涵盖了Java中的几个核心概念，包括`static`、`final`、匿名对象、内部类、包、修饰符以及代码块。下面将逐一详细阐述这些知识点。 1. **`static`关键字**： `static`关键字在Java中用于声明类级别的变量...
java中关于内部类的使用详解
09-05
- 成员内部类（非静态）可以在成员位置上，被 public、protected、private 或者默认修饰符修饰。 2. 静态内部类： - 如果内部类定义了静态成员，那么这个内部类必须声明为静态的。静态内部类与外部类之间的关系更...
11.【final、权限、内部类】.zip
01-31
- 局部内部类定义在方法、构造器或块中，作用域仅限于该方法、构造器或块。 - 匿名内部类没有名称，通常用于简化单次使用的类或接口实现。 - 静态内部类类似于普通的成员类，但可以用`static`修饰，可以独立于外部类...
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 833
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
Spring Security 授权
persistence_PSH的博客
07-14 905
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 1026
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 835
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
Java 线程池详解
qq_41591215的博客
07-13 966
线程池是一组已经初始化并等待执行任务的线程集合。通过使用线程池，我们可以避免频繁地创建和销毁线程，从而节省资源和减少系统开销。线程池的核心思想是通过复用线程来提高性能。
【JAVA】相关程序组件
qq_44077764的博客
07-15 162
【JAVA】相关程序组件
【Java算法】前缀和 下
最新发布
2302_79806056的博客
07-18 879
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
liangzai215的专栏
07-15 501
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
Java基础面试题：数组长度、访问修饰符与匿名内部类详解
匿名内部类没有自己的构造函数，因此必须依赖父类的构造器进行实例化。虽然无法直接创建匿名类的对象引用，但可以通过覆盖父类的方法实现多态，表现出灵活的行为。 5. new语句与匿名类： 创建匿名类的`new`语句...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

攒了一袋星辰

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值