【Java】static关键字,内部类

简介: 【Java】static关键字,内部类

一. static 关键字

在Java中,被static修饰的成员,称之为静态成员,也可以称为类成员,其不属于某个具体的对象,是所有对象所共享的。

1. static修饰成员变量

static修饰的成员变量,称为静态成员变量

【静态成员变量特性】:

  • 不属于某个具体的对象,是类的属性,所有对象共享的,不存储在某个对象的空间中
  • 既可以通过对象引用访问(不推荐使用),也可以通过类名访问,但一般更推荐使用类名访问
  • 类变量存储在方法区当中
  • 生命周期伴随类的一生(即:随类的加载而创建,随类的卸载而销毁)
public class Student{
    public String name;
    public String gender;
    public int age;
    public double score;
    public static String classRoom = "rj2104";
    public Student(String name, String gender, int age, double score) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.score = score;
    }
    // ...
    public static void main(String[] args) {
        // 静态成员变量可以直接通过类名访问
        System.out.println(Student.classRoom);
        Student s1 = new Student("Li leilei", "男", 18, 3.8);
        Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
        Student s3 = new Student("Jim", "男", 18, 2.6);
        // 也可以通过对象访问:但是classRoom是三个对象共享的
        System.out.println(s1.classRoom);
        System.out.println(s2.classRoom);
        System.out.println(s3.classRoom);
    }
}

2. static修饰成员方法

一般类中的数据成员都设置为private,而成员方法设置为public,

Java中,被static修饰的成员方法称为静态成员方法,是类的方法,不是某个对象所特有的

静态成员一般是通过静态方法来访问的。

public class Student2{
    // ...
    private static String classRoom = "rj2104";
    // ...
    public static String getClassRoom(){
        return classRoom;
    }
}
class TestStudent {
    public static void main(String[] args) {
        System.out.println(Student2.getClassRoom());
    }
}

【静态方法特性】:

不属于某个具体的对象,是类方法

可以通过对象调用,也可以通过 类名.静态方法名(…) 方式调用,更推荐使用后者

不能在静态方法中访问任何非静态成员变量和非静态成员方法;因为非静态方法中默认有this参数,但在静态方法中调用时候无法传递this引用;除非在静态方法中新new一个对象,再通过对象引用去访问此对象

静态方法无法重写,不能用来实现多态

3. static成员变量的初始化

静态成员变量一般不会放在构造方法中来初始化,构造方法中初始化的是与对象相关的实例属性

静态成员变量的初始化分为两种:就地初始化 和 静态代码块初始化。

  1. 就地初始化:在定义时直接给出初始值
public class Student2{
    // ...
    //就地初始化
    private static String classRoom = "rj2104";
    //...
}
  1. 用静态代码块完成初始化
public class Student2{
    // ...
    private static String classRoom;
    //静态代码块初始化
    static {
        classRoom = "rj2104";
    }
    // ...
}

二. 内部类

在 Java 中,可以将一个类定义在另一个类或者一个方法的内部, 前者称为内部类,后者称为外部类。内部类也是封装的一种体现。


内部类和外部类共用同一个java源文件,但是经过编译之后,内部类会形成单独的字节码文件, 一般形成的字节码文件文件名为:外部类名字$内部类名字.class73d8c9be8b2a4960a39693770de0ac9a.png

public class OutClass {
    class InnerClass{
    }
}
// OutClass是外部类
// InnerClass是内部类

根据内部类定义的位置不同,一般可以分为以下几种形式:

  1. 成员内部类(普通内部类)
  • 实例内部类:未被static修饰的成员内部类
  • 静态内部类:被static修饰的成员内部类
  1. 局部内部类
  2. 匿名内部类

1. 实例内部类

即未被static修饰的成员内部类。

【注意事项】:

外部类中的任何成员都可以在实例内部类方法中直接访问

实例内部类当中不能有静态的成员变量;非要定义,那么只能是被static final修饰的静态常量,常量是在程序编译的时候就确定的

实例内部类所处的位置与外部类成员位置相同,因此也受public、private等访问限定符的约束

实例内部类对象必须在先有外部类对象前提下才能创建

实例内部类的非静态方法中默认包含了一个指向外部类对象的引用和一个指向自身实例内部类对象的引用

在实例内部类方法中访问同名的成员时,优先访问自己的,如果要访问外部类同名的成员,必须:外部类名称.this.同名成员 来访问

外部类中,不能直接访问实例内部类中的成员,如果要访问必须先要创建内部类的对象。

public class OutClass {
    private int a;
    static int b;
    int c;
    public void methodA() {
        a = 10;
        System.out.println(a);
    }
    public static void methodB() {
        System.out.println(b);
    }
    // 实例内部类:未被static修饰
    class InnerClass {
        int c;
//实例内部类当中 不能有静态的成员变量. 非要定义,那么只能是被static final修饰的
        public static final int d = 6;
        public void methodInner() {
// 在实例内部类中可以直接访问外部类中:任意访问限定符修饰的成员
            a = 100;
            b = 200;
            methodA();
            methodB();
            System.out.println(d);
// 如果外部类和实例内部类中具有相同名称成员时,优先访问的是内部类自己的
            c = 300;
            System.out.println(c);
// 如果要访问外部类同名成员时候,必须:外部类名称.this.同名成员名字
            OutClass.this.c = 400;
            System.out.println(OutClass.this.c);
        }
    }
    public static void main(String[] args) {
// 外部类:对象创建 以及 成员访问
        OutClass outClass = new OutClass();
        System.out.println(outClass.a);
        System.out.println(outClass.b);
        System.out.println(outClass.c);
        outClass.methodA();
        outClass.methodB();
        System.out.println("=============实例内部类的访问=============");
// 要访问实例内部类中成员,必须要创建实例内部类的对象
// 而普通内部类定义与外部类成员定义位置相同,因此创建实例内部类对象时必须借助外部类
// 创建实例内部类对象
        OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();
        innerClass1.methodInner();
// 上述语法比较怪异,也可以先将外部类对象先创建出来,然后再创建实例内部类对象
        OutClass.InnerClass innerClass2 = outClass.new InnerClass();
        innerClass2.methodInner();
    }
}

2. 静态内部类

被static修饰的内部成员类称为静态内部类。、

【注意事项】:

  1. 在静态内部类中只能访问外部类中的静态成员,除非在内部类当中new一个外部类的对象,通过外部类对象的引用去访问其中的非静态成员。
  2. 创建静态内部类对象时,不需要先创建外部类对象
public class OuterClass2 {
    public int data1 = 1;
    int data2 = 2;
    public static int data3 = 3;
    public void test() {
        System.out.println("out::test()");
    }
    // 静态内部类:被static修饰的成员内部类
    static class InnerClass2 {
        public int data4 = 4;
        int data5 = 5;
        public static int data6 = 6;
        public void func() {
            System.out.println("out::func()");
            //test();
            // 编译失败,在静态内部类中不能直接访问外部类中的非静态成员
            //System.out.println(data1);
            //System.out.println(data2);
            //外部类的非静态成员,需要通过外部类的对象的引用才能访问。
            OuterClass2 outerClass = new OuterClass2();
            System.out.println(outerClass.data1);
            System.out.println(outerClass.data2);
            outerClass.test();
            // 在静态内部类中只能访问外部类的静态成员
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data5);
            System.out.println(data6);
        }
    }
    public static void main(String[] args) {
        // 静态内部类对象创建 和 成员访问
        OuterClass2.InnerClass2 innerClass2 = new OuterClass2.InnerClass2();
        innerClass2.func();
    }
}

3. 局部内部类

定义在外部类的方法体或者{ }中,一般使用的非常少。

【注意事项】

  1. 局部内部类只能在所定义的方法体内部使用
  2. 不能被public、static等修饰符修饰
  3. 局部内部类生成的字节码文件稍有区别:外部类名字$数字内部类名字.class

73d8c9be8b2a4960a39693770de0ac9a.png

ppublic class OutClass {
    int a = 10;
    public void method(){
        int b = 10;
        // 局部内部类:定义在方法体内部
        // 不能被public、static等访问限定符修饰
        class InnerClass{
            public void methodInnerClass(){
                System.out.println(a);
                System.out.println(b);
            }
        }
        // 只能在该方法体内部使用,其他位置都不能用
        InnerClass innerClass = new InnerClass();
        innerClass.methodInnerClass();
    }
    public static void main(String[] args) {
    // OutClass.InnerClass innerClass = null; 编译失败
    }
}

4. 匿名内部类

匿名内部类,就是没有名字的一种嵌套类

匿名内部类形成的字节码文件文件名为:外部类名字$数字.class

73d8c9be8b2a4960a39693770de0ac9a.png

4.1 使用匿名内部的好处与演示

在实际开发中,我们会遇到下面的情况:

一个接口/类的方法的某个执行过程在程序中只会执行一次,但为了使用它,我们需要创建它的实现类/子类去实现/重写方法。


代码中为了这一次的使用去创建一个类,未免太过麻烦,此时就可以使用匿名内部类来解决这个问题


首先来看我们正常的实现逻辑,假设有一个接口,接口当中只有一个方法

public interface Interface {
    void show();
}

为了使用该接口的show方法,我们需要去创建一个实现类,重写show方法的具体实现

public class Test implements Interface{
    @Override
    public void show() {
        System.out.println("只执行一次show()");
    }
}
public class Main {
    public static void main(String[] args) {
        Test test = new Test();
        test.show();
    }
}

如果实现类Test在程序中只使用一次,那么为了这一次的使用去创建一个类太过繁琐,这种情况下就可以用匿名内部类来实现,无需创建新的类,减少代码冗余,

看下面代码:

class Main {
    public static void main(String[] args) {
        //写法一
        Interface in = new Interface() {
            @Override
            public void show() {
                System.out.println("匿名内部类中重写show()");
            }
        };
        //调用接口方法
        in.show();
        //写法二
        new Interface() {
            @Override
            public void show() {
                System.out.println("匿名内部类中重写show()");
            }
        }.show();//调用接口方法
    }
}

4.2 匿名内部类的定义格式和使用

定义格式1:

接口名称 引用名 = new 接口名称() {
    // 覆盖重写所有抽象方法
};
引用名.方法调用

定义格式2:

new 接口名称() {
    // 覆盖重写所有抽象方法
}.方法调用;

对格式“new 接口名称() {…}”的理解:


new代表创建一个新的对象对象

接口名称就是匿名内部类需要实现哪个接口

{…}中是匿名内部类的内容

【注意事项】:


匿名内部类,在【创建对象】的时候,只能使用唯一 一次。

匿名对象,在【调用方法】的时候,只能调用唯一 一次。

匿名内部类是省略了【实现类/子类名称】,但是匿名对象是省略了【对象名称】

匿名内部类可以用在具体类、抽象类、接口上,且对方法个数没有要求。

public class Class {
    public void show(String s){
        System.out.println("Class::show()");
    }
}
public abstract class AbstractClass {
    abstract void show(String s);
}
public interface Interface {
    void show(String s);
}
public class TestDome {
    public static void main(String[] args) {
        //重写普通类的方法
        new Class(){
            @Override
            public void show(String s) {
                System.out.println(s);
            }
        }.show("普通类");
        //重写抽象类的抽象方法
        new AbstractClass(){
            @Override
            void show(String s) {
                System.out.println(s);
            }
        }.show("抽象类");
        //实现接口的抽象方法
        new Interface(){
            @Override
            public void show(String s) {
                System.out.println(s);
            }
        }.show("接口");
    }
}

执行结果:

73d8c9be8b2a4960a39693770de0ac9a.png

目录
相关文章
|
7天前
|
缓存 安全 Java
Volatile关键字与Java原子性的迷宫之旅
通过合理使用 `volatile`和原子操作,可以在提升程序性能的同时,确保程序的正确性和线程安全性。希望本文能帮助您更好地理解和应用这些并发编程中的关键概念。
35 21
|
2月前
|
存储 安全 Java
探索 Java 静态变量(static)的奥秘
本文深入探讨了Java中的静态变量(`static`),从初印象、使用场景、访问方式、初始化、线程安全、优缺点到最佳实践,全面解析其特性和应用场景。静态变量属于类而非实例,适用于共享数据、定义全局常量和工具类中的变量。它在类加载时初始化,生命周期贯穿整个程序运行。然而,多线程环境下需注意线程安全问题,可通过`synchronized`或原子类解决。优点包括共享数据方便和提高性能,但也存在线程安全和代码耦合度增高的缺点。最佳实践建议谨慎使用、保证线程安全、遵循命名规范并封装访问。掌握静态变量的正确用法,能让你的代码更加高效简洁。
71 11
|
2月前
|
Java 编译器 开发者
Java中的this关键字详解:深入理解与应用
本文深入解析了Java中`this`关键字的多种用法
166 9
|
3月前
|
存储 缓存 Java
Java 并发编程——volatile 关键字解析
本文介绍了Java线程中的`volatile`关键字及其与`synchronized`锁的区别。`volatile`保证了变量的可见性和一定的有序性,但不能保证原子性。它通过内存屏障实现,避免指令重排序,确保线程间数据一致。相比`synchronized`,`volatile`性能更优,适用于简单状态标记和某些特定场景,如单例模式中的双重检查锁定。文中还解释了Java内存模型的基本概念,包括主内存、工作内存及并发编程中的原子性、可见性和有序性。
Java 并发编程——volatile 关键字解析
|
2月前
|
JSON Java 数据挖掘
利用 Java 代码获取淘宝关键字 API 接口
在数字化商业时代,精准把握市场动态与消费者需求是企业成功的关键。淘宝作为中国最大的电商平台之一,其海量数据中蕴含丰富的商业洞察。本文介绍如何通过Java代码高效、合规地获取淘宝关键字API接口数据,帮助商家优化产品布局、制定营销策略。主要内容包括: 1. **淘宝关键字API的价值**:洞察用户需求、优化产品标题与详情、制定营销策略。 2. **获取API接口的步骤**:注册账号、申请权限、搭建Java开发环境、编写调用代码、解析响应数据。 3. **注意事项**:遵守法律法规与平台规则,处理API调用限制。 通过这些步骤,商家可以在激烈的市场竞争中脱颖而出。
|
3月前
|
缓存 安全 Java
Java volatile关键字:你真的懂了吗?
`volatile` 是 Java 中的轻量级同步机制,主要用于保证多线程环境下共享变量的可见性和防止指令重排。它确保一个线程对 `volatile` 变量的修改能立即被其他线程看到,但不能保证原子性。典型应用场景包括状态标记、双重检查锁定和安全发布对象等。`volatile` 适用于布尔型、字节型等简单类型及引用类型,不适用于 `long` 和 `double` 类型。与 `synchronized` 不同,`volatile` 不提供互斥性,因此在需要互斥的场景下不能替代 `synchronized`。
2359 3
|
4月前
|
JavaScript 前端开发 Java
java中的this关键字
欢迎来到我的博客,我是瑞雨溪,一名热爱JavaScript与Vue的大一学生。自学前端2年半,正向全栈进发。若我的文章对你有帮助,欢迎关注,持续更新中!🎉🎉🎉
75 9
|
4月前
|
设计模式 JavaScript 前端开发
java中的static关键字
欢迎来到瑞雨溪的博客,博主是一名热爱JavaScript和Vue的大一学生,致力于全栈开发。如果你从我的文章中受益,欢迎关注我,将持续分享更多优质内容。你的支持是我前进的动力!🎉🎉🎉
71 8
|
4月前
|
Java 开发者
在Java多线程编程的世界里,Lock接口正逐渐成为高手们的首选,取代了传统的synchronized关键字
在Java多线程编程的世界里,Lock接口正逐渐成为高手们的首选,取代了传统的synchronized关键字
67 4
|
Java Android开发
java基础篇 之 再探内部类跟final
java基础篇 之 再探内部类跟final
97 0
java基础篇 之 再探内部类跟final

热门文章

最新文章