[java]static关键字的四种用法,java中static关键字表明一个成员变量
本文为大家带来了一些关于java的知识，详细介绍了Java中静态关键字和内部类的使用。本文中的示例代码有详细的解释。下面就一起来看看吧，希望对你有帮助。
如何解决写爬虫IP受阻的问题？立即使用。
一. static 关键字
在Java中，用static修饰的成员称为静态成员或类成员，它们不属于某个特定的对象，由所有对象共享。
1. static修饰成员变量
静态修改的成员变量称为静态成员变量。
[静态成员变量的特征]:
不属于特定对象，是一个类的属性，由所有对象共享，不存储在对象的空间中。可以通过对象引用(不推荐)或类名来访问它，但通常更推荐使用类名来访问类变量，这些变量存储在方法区域中。类的生命周期将伴随着类的生命(也就是说，它将随着类的加载而创建，随着类的卸载而销毁)。公共课学生{
公共字符串名称；
公共字符串性别；
公共int age
公开双分；
公共静态字符串教室= rj2104
公共学生(字符串名称、字符串性别、整数年龄、双倍分数){
this.name=name
this.gender=性别；
this.age=年龄；
this.score=score
}
//.
公共静态void main(String[] args) {
//静态成员变量可以通过类名直接访问
System.out.println(学生.教室)；
学生s1=新生(李雷雷，男，18，3.8)；
学生S2=新生(韩梅梅，女，19，4.0)；
学生s3=新生(吉姆，男，18，2.6)；
//也可以通过对象访问：但是教室是由三个对象共享的
system . out . println(S1 . classroom)；
system . out . println(S2 . classroom)；
system . out . println(S3 . classroom)；
}
}
2. static修饰成员方法
一般类中的数据成员都设置为私有，而成员方法设置为公有，
在Java中，由static修饰的成员方法称为静态成员方法，它是一个类方法，不特定于一个对象。
静态成员通常通过静态方法来访问。
公共课学生2{
//.
私有静态字符串教室= rj2104
//.
公共静态字符串getClassRoom(){
回归课堂；
}
}
班级测试学生{
公共静态void main(String[] args) {
system . out . println(student 2 . get classroom())；
}
}[静态方法特性]:
如果它不属于某个特定的对象，那么它就是一个可以被对象或者类名调用的类方法。静态方法名(…)。更推荐使用后一种方法，这种方法不能访问静态方法中的任何非静态成员变量和非静态成员方法。因为在非静态方法中默认有这个参数，但是在静态方法中调用时这个引用不能被传递；除非在静态方法中新创建了一个对象，否则静态方法无法重写，也无法用来实现多态性
3. static成员变量的初始化
静态成员变量一般不在构造函数中初始化，构造函数初始化与对象相关的实例属性。
静态成员变量的初始化有两种：就地初始化和静态代码块初始化。
就地初始化：初始值在定义时直接给出。
公共课学生2{
//.
//就地初始化
私有静态字符串教室= rj2104
//.
}用静态代码块完成初始化
公共课学生2{
//.
私人静态弦乐教室；
//静态代码块初始化
静态{
classRoom= rj2104
}
//.
}
二. 内部类
在Java中，一个类可以在另一个类或方法中定义。前者称为内部类，后者称为外部类。类也是封装的一种表现。
内部类和外部类共享同一个java源文件，但是编译后内部类会形成一个单独的字节码文件。字节码文件的文件名一般是：外部类名$内部类名. class。
公共阶层远高于其他阶层
类内部类{
}
}
//OutClass是外部类。
//InnerClass根据内部类的定义，是内部类的位置。一般来说，可以分为以下几种形式：
1.成员内部类(普通内部类)
实例内部类：不被静态修改的成员内部类。
静态类：用Static修饰的成员内部类。
2.本地内部类
3.匿名内部类
1. 实例内部类
是不被静态修改的成员内部类。
[备注]:
外部类中的任何成员都可以直接访问实例的内部类方法；实例的内部类中不能有静态成员变量；如果没有定义，就只能是static final修饰的静态常量。该常数在程序编译时确定，实例内部类的位置与外部类成员的位置相同。因此，它还受到访问限定符(如public和private)的限制，因此，只有在存在外部类对象的情况下，才能创建实例内部类对象。默认情况下，非静态方法包含对外部类对象的引用和对其自身实例内部类对象的引用。当在实例内部类方法中访问同名成员时，应该首先访问自己的成员。如果要访问与外部类同名的成员，必须访问外部类名。这个。同名成员不能直接访问实例内部类中的成员。如果要访问，您必须公开类OutClass {
私有int a；
静态int b；
int c；
公共void方法A() {
a=10
system . out . println(a)；
}
公共静态void方法B() {
system . out . println(b)；
}
//实例内部类：未被静态修改
类内部类{
int c；
//实例的内部类中不能有静态成员变量。如果非要定义，只能用static final来修饰。
公共静态final int d=6；
public void methodInner() {
//在实例的内部类中，可以直接访问外部类中任何访问限定符修饰的成员。
a=100
b=200
methodA()；
methodB()；
system . out . println(d)；
//如果实例的外部类和内部类中存在同名的成员，则首先访问内部类自己的。
c=300
system . out . println(c)；
//如果要访问与外部类同名的成员，必须：外部类名。这个。同名的成员名称。
outclass . this . c=400；
system . out . println(out class . this . c)；
}
}
公共静态void main(String[] args) {
//外部类：对象创建和成员访问
OutClass OutClass=new OutClass()；
system . out . println(out class . a)；
system . out . println(out class . b)；
system . out . println(out class . c)；
out class . methoda()；
out class . methodb()；
System.out.println (==========访问实例的内部类=========)；
//若要访问实例内部类中的成员，必须创建实例内部类的对象。
//但是，公共内部类定义与外部类成员定义的位置相同，所以创建实例内部类对象时必须使用外部类。
//创建一个实例内部类对象
远远超过。InnerClass innerClass1=新的异类()。new inner class()；
inner class 1 . method inner()；
//上面的语法很怪异。也可以先创建外部类对象，然后创建实例的内部类对象。
远远超过。inner class inner class 2=out class . new inner class()；
inner class 2 . method inner()；
}
}
2. 静态内部类
由static修饰的内部成员类称为静态内部类。
[备注]:
在静态内部类中，只能访问外部类中的静态成员，除非在内部类中新创建了一个外部类的对象，通过外部类对象的引用来访问非静态成员。
创建静态内部类对象时，没有必要先创建外部类对象。
公共类OuterClass2 {
public int data1=1；
int data2=2
public static int data3=3
公共无效测试(){
system . out . println( out:test())；
}
//静态内部类：由static修饰的成员内部类
静态类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(data 2)；
//外部类的非静态成员，需要通过外部类的对象的引用来访问。
outer class 2 outer class=new outer class 2()；
system . out . println(outer class . data1)；
system . out . println(outer class . data 2)；
outer class . test()；
//在静态内部类中只能访问外部类的静态成员。
system . out . println(data 3)；
system . out . println(data 4)；
system . out . println(data 5)；
system . out . println(data 5)；
system . out . println(data 6)；
}
}
公共静态void main(String[] args) {
//静态内部类对象创建和成员访问
课外2。InnerClass2 innerClass2=新的外部类2。inner class 2()；
inner class 2 . func()；
}
}
3. 局部内部类
定义在外部类的方法体或{}中，一般很少使用。
[注意事项]
局部类只能在已定义的方法体内使用。
它不能被public和static之类的修饰符修改。
本地类生成的字节码文件略有不同：外部类名$ numeric内部类名。班级
ppublic class OutClass {
int a=10
公共void方法(){
int b=10
//局部内部类：在方法体内部定义。
//不能由访问限定符(如public和static)来修饰
类内部类{
public void methodInnerClass(){
system . out . println(a)；
system . out . println(b)；
}
}
//只能在这个方法体内部使用，不能在其他地方使用。
inner class inner class=new inner class()；
inner class . method inner class()；
}
公共静态void main(String[] args) {
//远胜。InnerClass innerClass=null编译失败。
}
}
4. 匿名内部类
匿名内部类是一种没有名字的嵌套类。
匿名内部类形成的字节码文件的文件名是：外部类名$ number.class。
4.1使用内部匿名的好处和演示
在实际开发中，我们会遇到以下情况：
一个接口/类的方法的执行过程在程序中只会执行一次，但是为了使用它，我们需要创建它的实现类/子类来实现/覆盖该方法。
为这种用途创建一个类对代码来说太麻烦了。这时候可以用匿名内部类来解决这个问题。
首先，我们来看看我们正常的实现逻辑。假设有一个接口，接口中只有一个方法。
公共接口界面{
void show()；
}为了使用这个接口的show方法，我们需要创建一个实现类，重写show方法的具体实现。
公共类测试实现接口{
@覆盖
公共void show() {
system . out . println( show()only once )；
}
}
公共类Main {
公共静态void main(String[] args) {
测试Test=new Test()；
test . show()；
}
}如果程序中只使用一次实现类测试，那么为这种使用创建一个类就太繁琐了。在这种情况下，它可以由匿名内部类实现，无需创建新的类，减少代码冗余，
请看下面的代码：
主类{
公共静态void main(String[] args) {
//编写方法一
Interface in=new Interface() {
@覆盖
公共void show() {
System.out.println(在匿名内部类中重写show())；
}
};
//调用接口方法
in . show()；
//书写方法2
新接口(){
@覆盖
公共void show() {
System.out.println(在匿名内部类中重写show())；
}
}.show()；//调用接口方法
}
}4.2匿名内部类的定义格式和使用
定义格式1:
定义格式2:
对“new interface name () {…}”格式的理解：
New代表创建一个新的object对象。
名称是匿名内部类需要实现的接口。
{…}是匿名内部类的内容。
[备注]:
创建对象时，匿名类只能使用一次。当[调用方法]时，匿名对象只能被调用一次。匿名内部类省略了[实现类/子类名称]，但是匿名对象省略了[对象名称]。匿名内部类可用于具体类、抽象类和接口，对方法的数量没有要求。公共类Class {
公共void显示(字符串){
system . out . println( Class:show())；
}
}
公共抽象类AbstractClass {
抽象void show(字符串s)；
}
公共接口界面{
void show(字符串s)；
}
公共类TestDome {
公共静态void main(String[] args) {
//重写普通类的方法
新类别(){
@覆盖
公共void显示(字符串){
system . out . println(s)；
}
}.show(普通类)；
//重写抽象类的抽象方法
新抽象类(){
@覆盖
void show(字符串){
system . out . println(s)；
}
}.show(抽象类)；
//实现接口的抽象方法
新接口(){
@覆盖
公共void显示(字符串){
system . out . println(s)；
}
}.显示(界面)；
}
}执行结果：
推荐：《java视频教程》以上是讲解Java中静态关键字和内部类使用的详细内容。更多请关注我们的其他相关文章！
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。