static/this/super/final关键字的用法_static方法中使用super关键字-CSDN博客

本文链接：https://blog.csdn.net/ZTW0070/article/details/125426457

本文详细介绍了Java编程语言中的四个关键关键字：static、this、super和final。static用于声明静态变量和静态方法，可以在类级别上进行访问。this关键字在类的方法中引用当前对象。super关键字用于在子类中访问父类的成员。final关键字则用于定义不可变的类、变量和方法。文章通过示例代码解释了这些关键字的用法和限制。

摘要由CSDN通过智能技术生成

1.static关键字

static关键字是静态的【类名访问】
static关键字可以修饰：
1.可以修饰变量，被static修饰的变量是静态成员变量【类变量】
1.1 静态成员变量【类变量】可以在本类中的任意一个方法中调用
构造方法/实例方法中，默认类名.静态成员变量名称，也可以this.静态成员变量名称，类名和this可以省略
静态方法中，默认类名.静态成员变量名称，类名可以省略
构造方法/实例方法/静态方法中，默认类名.静态成员变量名称，类名可以省略

package com.wangxing.statictest1;
public  class MyClass {
	//可以修饰变量--被static修饰的变量是静态成员变量【类变量】
	public  static  String  name="zhangsan";
	//构造方法
	public MyClass(){
		//默认类名.静态成员变量名称
		System.out.println(MyClass.name);
		//this.静态成员变量名称
		System.out.println(this.name);
		//类名和this可以省略
		System.out.println(name);
	}
	//实例方法
	public void  shili(){
		//默认类名.静态成员变量名称
		System.out.println(MyClass.name);
		//this.静态成员变量名称
		System.out.println(this.name);
		//类名和this可以省略
		System.out.println(name);
	}
	//静态方法
	public static  void staticMethod(){
		//默认类名.静态成员变量名称
		System.out.println(MyClass.name);
		//类名和this可以省略
		System.out.println(name);
	}
}

1.2 静态成员变量【类变量】可以在其他类中的任意一个方法中调用
可以类名调用，也可以对象调用。

package com.wangxing.statictest1;
public  class MyClass {
	//可以修饰变量--被static修饰的变量是静态成员变量【类变量】
	public  static  String  name="zhangsan";
}

package com.wangxing.statictest1;
public class OtherClass {
	//构造方法
	public  OtherClass(){
		//类名.静态成员变量名称
		System.out.println(MyClass.name);
		MyClass  mc=new MyClass();
		//对象.静态成员变量名称
		System.out.println(mc.name);
	}
	//实例方法
	public  void  shili(){
		//类名.静态成员变量名称
		System.out.println(MyClass.name);
		MyClass  mc=new MyClass();
		//对象.静态成员变量名称
		System.out.println(mc.name);
	}
	//静态方法
	public static  void  staticMethod(){
		//类名.静态成员变量名称
		System.out.println(MyClass.name);
		MyClass  mc=new MyClass();
		//对象.静态成员变量名称
		System.out.println(mc.name);
	}	
}

2.可以修饰方法，被static修饰的方法是静态方法【类方法】
2.1 静态方法可以在本类中的任意一个方法中调用
构造方法/实例方法中，默认类名.静态方法，也可以this.静态方法，类名和this可以省略
静态方法中，默认类名.静态方法，类名可以省略
构造方法/实例方法/静态方法中，默认类名.静态方法，类名可以省略

package com.wangxing.statictest2;

public class TestClass {
	//可以修饰方法，被static修饰的方法是静态方法【类方法】
	public static  void  staticMethod(){
		System.out.println("静态方法【类方法】");
	}
	//构造方法
	public  TestClass(){
		TestClass.staticMethod();
		this.staticMethod();
		staticMethod();
	}
	//实例方法
	public void shili(){
		TestClass.staticMethod();
		this.staticMethod();
		staticMethod();
	}
	//静态方法
	public static void testStatic(){
		TestClass.staticMethod();
		staticMethod();
	}
		
}

2.2 静态方法可以在其他类中的任意一个方法中调用
可以类名调用，也可以对象调用。

package com.wangxing.statictest2;
public class TestClass {
	//可以修饰方法，被static修饰的方法是静态方法【类方法】
	public static  void  staticMethod(){
		System.out.println("静态方法【类方法】");
	}
}

package com.wangxing.statictest2;
public class OtherClass {
	public  OtherClass(){
		//类名.静态方法
		TestClass.staticMethod();
		TestClass  tc=new TestClass();
		//对象.静态方法
		tc.staticMethod();
	}
	public  void  shili(){
		//类名.静态方法
		TestClass.staticMethod();
		TestClass  tc=new TestClass();
		//对象.静态方法
		tc.staticMethod();
	}
	public static  void  staticMethod(){
		//类名.静态方法
		TestClass.staticMethod();
		TestClass  tc=new TestClass();
		//对象.静态方法
		tc.staticMethod();
	}
	
}

总结：
1.同一个类中，构造方法/实例方法中访问静态变量/静态方法，可以类名，也可以this,类名和this可以省略；静态方法中访问静态变量/静态方法，默认类名访问,类名可以省略。
2.其他类中，构造方法/实例方法/静态方法中访问静态变量/静态方法，可以类名访问，也可以对象访问
3.静态方法中使用this.
4.同一个类中静态方法中，不能访问当前类中的实例元素。

2.this关键字【当前类对象】

this关键字出现类中的方法里，表示使用当前类默认的构造方法创建的当前类对象
this代替了new 构造方法创建对象。
this当前类对象

在同一个类中，我们要使用类中的变量和方法时，需要对象调用
我们应该new 构造方法()创建对象，然后使用创建的对象类调用类中的变量和方法

package com.wangxing.demo1;

public class MyClass {
	public  String  shilibianliang="";
	public static String  staticbianliang="";
	
	public MyClass(){
		System.out.println(new MyClass().shilibianliang);
		System.out.println(new MyClass().staticbianliang);
		new MyClass().testMethod();
		new MyClass().staticMethod1();
		
		MyClass mc=new MyClass();
		System.out.println(mc.shilibianliang);
		System.out.println(mc.staticbianliang);
		mc.testMethod();
		mc.staticMethod1();
	}
	
    public void shili(){
    	System.out.println(new MyClass().shilibianliang);
		System.out.println(new MyClass().staticbianliang);
		new MyClass().testMethod();
		new MyClass().staticMethod1();
		
		MyClass mc=new MyClass();
		System.out.println(mc.shilibianliang);
		System.out.println(mc.staticbianliang);
		mc.testMethod();
		mc.staticMethod1();
	}  
    public static void staticMethod2(){
    	System.out.println(new MyClass().shilibianliang);
		System.out.println(new MyClass().staticbianliang);
		new MyClass().testMethod();
		new MyClass().staticMethod1();
		
		MyClass mc=new MyClass();
		System.out.println(mc.shilibianliang);
		System.out.println(mc.staticbianliang);
		mc.testMethod();
		mc.staticMethod1();
	}
    public void testMethod(){
		System.out.println("测试用的实例方法");
  	}  
    public static void staticMethod1(){
    	System.out.println("测试用的静态方法");
    }
}

this关键字出现类中的方法里，表示使用当前类默认的构造方法创建的当前类对象
this当前类对象
this代替了new 构造方法创建对象。
静态方法中不能使用this

package com.wangxing.demo1;

public class MyClass2 {
	public  String  shilibianliang="";
	public static String  staticbianliang="";
	
	public MyClass2(){
		//this===new MyClass2()
		System.out.println(this.shilibianliang);
		System.out.println(this.staticbianliang);
		this.testMethod();
		this.staticMethod1();
	}
	
    public void shili(){
    	System.out.println(this.shilibianliang);
		System.out.println(this.staticbianliang);
		this.testMethod();
		this.staticMethod1();
	}
    
    //静态方法中不能使用this
    public static void staticMethod2(){
    	//System.out.println(this.shilibianliang);
	//System.out.println(this.staticbianliang);
	//this.testMethod();
	//this.staticMethod1();
    	
    	MyClass2 mc=new MyClass2();
	System.out.println(mc.shilibianliang);
	System.out.println(mc.staticbianliang);
	mc.testMethod();
	mc.staticMethod1();
    }
    
    public void testMethod(){
		System.out.println("测试用的实例方法");
  	}
      
    public static void staticMethod1(){
    	System.out.println("测试用的静态方法");
    }
}

3.super关键字【父类对象/构造方法】

super关键字出现在子类中，表示父类对象/父类构造方法
如果super关键字后面有"()",表示父类构造方法
如果super关键字后面没有"()",表示父类对象
super()---父类无参数构造方法
super(参数)---父类有参数构造方法
super.变量名称---此时super表示父类对象，调用父类成员变量
super.方法名称(参数)---此时super表示父类对象，调用父类方法
子类的实例方法中不能使用super()/super(参数)调用父类构造方法
子类的静态方法中不能使用super。

package com.wangxing.test1;
//父类
public class Person {
	public String  pername="Person中的实例变量";
	public static String  perstatic="Person中的静态变量";
	
	public  Person(){
		System.out.println("父类无参数构造方法");
	}
	public  Person(String name){
		System.out.println("父类有参数构造方法");
	}
	
	public  void  personShiLi(){
		System.out.println("父类中的实例方法");
	}
	public static void  personStatic(){
		System.out.println("父类中的静态方法");
	}
}

package com.wangxing.test1;

public class SunClass extends Person{

	public SunClass(){
		//super()---父类无参数构造方法
		//super();
		//super(参数)---父类有参数构造方法
		//super("zhangsan");
		System.out.println("子类SunClass的构造方法");
		
		//super.变量名称---此时super表示父类对象，调用父类成员变量
		System.out.println("super.变量名称=="+super.pername);
		System.out.println("super.变量名称=="+super.perstatic);
		//super.方法名称(参数)---此时super表示父类对象，调用父类方法
		super.personShiLi();
		super.personStatic();
	}
	
	public  void  sunShiLi(){
		System.out.println("子类中的实例方法");
		//子类的实例方法中不能使用super()/super(参数)调用父类构造方法
		//super()---父类无参数构造方法
		//super();
		//super(参数)---父类有参数构造方法
		//super("zhangsan");
		
		//super.变量名称---此时super表示父类对象，调用父类成员变量
		System.out.println("super.变量名称=="+super.pername);
		System.out.println("super.变量名称=="+super.perstatic);
		//super.方法名称(参数)---此时super表示父类对象，调用父类方法
		super.personShiLi();
		super.personStatic();
	}

//子类的静态方法中不能使用super。
	public static void  sunStatic(){
		System.out.println("子类中的静态方法");
		//子类的实例方法中不能使用super()/super(参数)调用父类构造方法
		//super()---父类无参数构造方法
		//super();
		//super(参数)---父类有参数构造方法
		//super("zhangsan");
		//super.变量名称---此时super表示父类对象，调用父类成员变量
		//System.out.println("super.变量名称=="+super.pername);
		//System.out.println("super.变量名称=="+super.perstatic);
		//super.方法名称(参数)---此时super表示父类对象，调用父类方法
		//super.personShiLi();
		//super.personStatic();
	}
}

4.final关键字

final关键字中文含义为最终的意思

1.可以修饰java类,被final关键字修饰java类不能被继承，没有子类

package com.wangxing.test1;
//final关键字可以修饰java类
public final class TestClass {
}

package com.wangxing.test1;
//被final关键字修饰java类不能被继承，没有子类
//public class SunClass extends TestClass{

//}

2.可以修饰变量,被final修饰的变量，不能被重新赋值

package com.wangxing.test1;
public class TestMain {
	public static void main(String[] args) {
		final String  name="zhangsan";
		//name="lisi"; //被final修饰的变量，不能被重新赋值
		System.out.println(name);
	}
}

3.可以修饰方法，被final修饰的方法，不能被重写

package com.wangxing.test2;
public  class TestClass {
	public final void  testClassShiLi(){
		System.out.println("TestClass类的实例方法");
	}
}

package com.wangxing.test2;
public class SunClass extends TestClass{
	//public  void  testClassShiLi(){
		//System.out.println("SunClass子类重写父类方法");
	//}
}