javaSE-----static \ this \ super \ final 关键字的用法

static \ this \ super \ final 关键字的用法

static–静态的【提前分配内存】
修饰的变量就是静态成员变量【类变量】，可以用类名访问，也可以用对象访问
修饰的方法就是静态方法量【类方法】，可以用类名访问，也可以用对象访问
例如：

package com.wangxing.test1;
//static--关键字【被赋予特殊含义的单词】
//含义:静态的【提前分配内存】
//位置:1.变量数据类型前面【成员变量】--静态成员变量【类变量】
//    静态成员变量【类变量】:命名时变量名称全字母大写
//    实例变量---:命名时变量名称全字母小写
//    2.方法的返回值前面--静态方法【类方法】
public  class TestStatic {
	//1.变量数据类型前面【成员变量】--静态成员变量【类变量】
	//静态成员变量【类变量】:命名时变量名称全字母大写
	public  static  String  NAME="zhangsan";
	
	//2.方法的返回值前面--静态方法【类方法】
	public  static  void  staticMethod(){
		System.out.println("");
	}
	
}

总结:

• 1.静态成员变量【类变量】/静态方法【类方法】可以使用类名调用，也可以用对象调用
• 2.静态成员变量【类变量】可以在同类对象之间共享数据
• 3.静态方法【类方法】不能出现this关键字
• 4.静态方法【类方法】中不能访问实例变量/实例方法

this—本类对象【出现在哪一个类中就表示哪一个类的对象】
本类中调用本类的实例变量\类变量\实例方法\类方法，可以省略
this是不能出现在静态方法中
例如:

package com.wangxing.test1;

//this关键字--当前类的对象
//this出现在哪一个类中就表示哪一个类的对象
public class TestThis {
	//全局变量（实例变量）
	public  String  testname="TestThis实例变量";
	//无参构造方法
	public TestThis(){
		
	}
	//有参构造方法
	public TestThis(String name){
		System.out.println("有参数构造方法，参数是name=="+name);
	}
	public  TestThis(int name){
		System.out.println("有参数构造方法，参数是name=="+name);
	}
	//实例方法
	public void  shiliMethod(){
		//在这个实例方法中使用一下当前类TestThis这个类的对象
		TestThis  tt1=new TestThis(); //当前类TestThis这个类的对象
		//我们要在TestThis这个类中的实例方法中访问当前类的实例变量
		//实例变量只能通过对象访问
		System.out.println(new TestThis().testname);
		System.out.println(tt1.testname);
		//this--当前类的对象
		//this===>new TestThis();
		//同一个类中实例方法访问实例变量，默认this.实例变量，this可以省略
		System.out.println(this.testname);
		System.out.println(testname);
	}
}

总结：
因为类中的变量【不包括局部变量】和方法【不包括构造方法】，可以通过对象方法
那么我们在访问类中的变量和方法时，就需要先创建对象
1.本类之外的其他类中，我们创建对象new 构造方法()
2.本类中，我们创建对象new 构造方法()，本类中new 构造方法()创建对象可以用this代替
这时我们认为本类的对象就是this
所以在本类中访问本类的变量和方法使用this是可以的

super–子类中表示父类对象
子类中访问父类构造方法“super([参数])”。
子类中访问父类的实例方法/实例变量”super.实例变量/实例方法”。
例如:

package com.wangxing.test1;

//super---父类对象
//位置:子类中
//构造方法--super([参数]);在子类中访问父类的构造方法
//     --super.变量/方法;在子类中访问父类的变量/方法[super==父类对象]  
//实例方法--super.变量/方法;在子类中访问父类的变量/方法[super==父类对象]
//类方法--不能出现super关键字
//注意:默认我们虽创建出来的java类会继承java.lang.Object
//java.lang.Object表示一个对象类【一切皆对象】
public class TestSuper {
	//构造方法
	public TestSuper(){
		super();//不报错证明有继承
		new Object().getClass();
		//super===》new Object()---父类对象
		super.getClass();
	}
	//无参构造函数
	public TestSuper(String name){
		super();
	}
	//实例方法
	public void ShiliMethod(){
	    //super();   //报错
		new Object().getClass();
		//super===》new Object()---父类对象
		super.getClass();
	}
	//类方法
	public static void StaticMethod(){
		//super();   //报错
//		super.getClass();   //报错
		//类方法中不能有super
	}
}

总结：
super—父类对象
位置:子类中
构造方法–super([参数]);在子类中访问父类的构造方法
–super.变量/方法;在子类中访问父类的变量/方法[super父类对象]
实例方法–super.变量/方法;在子类中访问父类的变量/方法[super父类对象]
类方法–不能出现super关键字
注意:默认我们虽创建出来的java类会继承java.lang.Object

final—最终的

• final修饰的变量不能被重新赋值。
• fianl修饰的静态成员变量叫静态常量。【静态常量全字母大写】
  例如: public final static String TEXT=“java”;
• final修饰的方法不能被重写。
• final修饰的类不能被继承，没有子类。

例如：
1.final修饰的类不能被继承

package com.wangxing.test1;

//final修饰的类不能被继承，没有子类。
public final class TestClass {
		   public final String  name="zhangsan";
		   public final void info() {
			   System.out.println("父类TestClass类的实例方法");
		   }
}

测试子类：

package com.wangxing.test1;

//TestClass的子类
public class MyClass  extends TestClass {

}

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

package com.wangxing.test1;

public class TestMain {
	public static void main(String[] args) {
		//创建对象
		TestClass ts=new TestClass();
		System.out.println("TestClass=="+ts.name);
		ts.name="lisi";
		System.out.println("TestClass=="+ts.name);
	}
}

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

package com.wangxing.test1;

//final修饰的类不能被继承，没有子类。
public class TestClass {
	public final String  name="zhangsan";
	public final void info() {
		System.out.println("父类TestClass类的实例方法");
	 }
}

package com.wangxing.test1;

//TestClass的子类
public class MyClass  extends TestClass {
	/*
	 *报错，不能重写
	public void info() {
		System.out.println("子类重写info");
	*/
	 }
}

package com.wangxing.test1;

public class TestMain {
	public static void main(String[] args) {
		//创建对象
		TestClass ts=new TestClass();
		System.out.println("TestClass=="+ts.name);
//		ts.name="lisi";
		System.out.println("TestClass=="+ts.name);
		ts.info();
		MyClass mc=new MyClass();
		mc.info();//子类有继承info
	}
}