Java的static关键字、内部类详解
温馨提示：
本文最后更新于 2022年08月30日，已超过 605 天没有更新。若文章内的图片失效（无法正常加载），请留言反馈或直接联系我。
一. static 关键字
1. 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);
}
}<br/> 2. 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());
}
} 【静态方法特性】:
1.不属于某个具体的对象，是类方法
2.可以通过对象调用，也可以通过 类名.静态方法名(…) 方式调用，更推荐使用后者
3.不能在静态方法中访问任何非静态成员变量和非静态成员方法；因为非静态方法中默认有this参数，但在静态方法中调用时候无法传递this引用；除非在静态方法中新new一个对象，再通过对象引用去访问此对象
4.静态方法无法重写，不能用来实现多态
3. static成员变量的初始化
二. 内部类
内部类和外部类共用同一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件， 一般形成的字节码文件文件名为：外部类名字$内部类名字.class
public class OutClass {
class InnerClass{
}
}
// OutClass是外部类
// InnerClass是内部类<br/> 1. 实例内部类
【注意事项】:
1.外部类中的任何成员都可以在实例内部类方法中直接访问
2.实例内部类当中不能有静态的成员变量；非要定义，那么只能是被static final修饰的静态常量，常量是在程序编译的时候就确定的
3.实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束
4.实例内部类对象必须在先有外部类对象前提下才能创建
5.实例内部类的非静态方法中默认包含了一个指向外部类对象的引用和一个指向自身实例内部类对象的引用
6.在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名称.this.同名成员 来访问
7.外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。
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();
}
}<br/> 2. 静态内部类
3. 局部内部类
4. 匿名内部类
4.1 使用匿名内部的好处与演示
public interface Interface {
void show();
}<br/> 为了使用该接口的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();
}
}<br/> 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();//调用接口方法
}
}<br/> 4.2 匿名内部类的定义格式和使用
接口名称 引用名 = new 接口名称() {
// 覆盖重写所有抽象方法
};
引用名.方法调用<br/> 定义格式2：
new 接口名称() {
// 覆盖重写所有抽象方法
}.方法调用;<br/> 正文到此结束
- 本文标签： Java 后端
- 本文链接： http://www.92cxy.cn/article/22
- 版权声明： 本文由王小东原创发布，转载请遵循《署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0)》许可协议授权
热门推荐
相关文章
该篇文章的评论功能已被站长关闭
