15.Java中static，this，super，final关键字的用法

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

package zx.javatest.a;
//关键字static
//static关键字是静态的【类名访问】
public class Static1 {
	public  static  String  name="zhangsan";
	//构造方法
	public Static1(){
		//默认类名.静态成员变量名称
		System.out.println(Static1.name);
		//this.静态成员变量名称
		System.out.println(this.name);
		//类名和this可以省略
		System.out.println(name);
	}
	//实例方法
	public void  shili(){
		//默认类名.静态成员变量名称
		System.out.println(Static1.name);
		//this.静态成员变量名称
		System.out.println(this.name);
		//类名和this可以省略
		System.out.println(name);
	}
	//静态方法
	public static  void staticMethod(){
		//默认类名.静态成员变量名称
		System.out.println(Static1.name);
		//类名和this可以省略
		System.out.println(name);
	}
}

 

package zx.javatest.a;
//静态成员变量【类变量】可以在其他类中的任意一个方法中调用
//可以类名调用，也可以对象调用。
public class Static2 {
	//可以修饰变量--被static修饰的变量是静态成员变量【类变量】
	public static String name = "张三";
}

 

package zx.javatest.a;

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

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

package zx.javatest.b;

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

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

package zx.javatest.b;

public class Static5 {
	public Static5(){
		//类名.静态方法
		Static4.statictest();
		Static4 s4 = new Static4();
		//对象.静态方法
		s4.statictest();
	}
	public  void  shili(){
		//类名.静态方法
		Static4.statictest();
		Static4  tc=new Static4();
		//对象.静态方法
		tc.statictest();
	}
	public static  void  staticMethod(){
		//类名.静态方法
		Static4.statictest();
		Static4  tc=new Static4();
		//对象.静态方法
		tc.statictest();
	}
}

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

2.this关键字 【当前类对象】
    this关键字出现类中的方法里，表示使用当前类默认的构造方法创建的当前类对象。
    this代替了new 构造方法创建对象。
    this当前类对象。
    在同一个类中，我们要使用类中的变量和方法时，需要对象调用。
    我们应该new 构造方法()创建对象，然后使用创建的对象类调用类中的变量和方法。
    this关键字出现类中的方法里，表示使用当前类默认的构造方法创建的当前类对象。
    this当前类对象。
    this代替了new 构造方法创建对象。
    静态方法中不能使用this。

package zx.javatest.c;
//关键字this
public class This1 {
	public String shili = "今天";
	public static String jingtai= "天气";
	public This1 (){
		System.out.println(new This1().shili);
		System.out.println(new This1().jingtai);
		new This1().testMethod();
		new This1().staticMethod1();
		
		This1 mc=new This1();
		System.out.println(mc.shili);
		System.out.println(mc.jingtai);
		mc.testMethod();
		mc.staticMethod1();
	}
	
    public void shili(){
    	System.out.println(new This1().shili);
		System.out.println(new This1().jingtai);
		new This1().testMethod();
		new This1().staticMethod1();
		
		This1 mc=new This1();
		System.out.println(mc.shili);
		System.out.println(mc.jingtai);
		mc.testMethod();
		mc.staticMethod1();
	}  
    public static void staticMethod2(){
    	System.out.println(new This1().shili);
		System.out.println(new This1().jingtai);
		new This1().testMethod();
		new This1().staticMethod1();
		
		This1 mc=new This1();
		System.out.println(mc.shili);
		System.out.println(mc.jingtai);
		mc.testMethod();
		mc.staticMethod1();
	}
    public void testMethod(){
		System.out.println("测试用的实例方法");
  	}  
    public static void staticMethod1(){
    	System.out.println("测试用的静态方法");
    }
}

package zx.javatest.c;

public class This2 {
	public  String  shili="";
	public static String  jingtai="";
	
	public This2(){
		//this===new MyClass2()
		System.out.println(this.shili);
		System.out.println(this.jingtai);
		this.testMethod();
		this.staticMethod1();
	}
	
    public void shili(){
    	System.out.println(this.shili);
		System.out.println(this.jingtai);
		this.testMethod();
		this.staticMethod1();
	}
    
    //静态方法中不能使用this
    public static void staticMethod2(){
    	//System.out.println(this.shilibianliang);
	//System.out.println(this.staticbianliang);
	//this.testMethod();
	//this.staticMethod1();
    	
    	This2 mc=new This2();
	System.out.println(mc.shili);
	System.out.println(mc.jingtai);
	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 zx.javatest.d;
//关键字super
public class Super1 {
	public String  pername="Person中的实例变量";
	public static String  perstatic="Person中的静态变量";
	
	public  Super1(){
		System.out.println("父类无参数构造方法");
	}
	public  Super1(String name){
		System.out.println("父类有参数构造方法");
	}
	
	public  void  personShiLi(){
		System.out.println("父类中的实例方法");
	}
	public static void  personStatic(){
		System.out.println("父类中的静态方法");
	}
}

package zx.javatest.d;

public class Super2 extends Super1{
	public Super2(){
		//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类不能被继承，没有子类。

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

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

package zx.javatest.e;
//父类
//final关键字
public final class Final1 {

}

package zx.javatest.e;
//被final关键字修饰java类不能被继承，没有子类
//public class Final2 extends Final1{

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

 

package zx.javatest.f;

public class Final3 {
//可以修饰方法，被final修饰的方法，不能被重写
	public final void  testClassShiLi(){
		System.out.println("TestClass类的实例方法");
	}
}

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