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

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

     static--静态的【提前分配内存】

     修饰的变量就是静态成员变量【类变量】，可以用类名访问，也可以用对象访问

     修饰的方法就是静态方法量【类方法】，可以用类名访问，也可以用对象访问

     例如：

package com.wangxing.statictest;

//static--关键字【被赋予特殊含义的单词】
//含义：静态的【提前分配内存】
//位置：1.变量数据类型嵌满【静态成员变量】
//       静态成员变量在命名时，变量名称全字母大写
//       实例变量在命名，变量名称全字母小写
//      2.静态方法--方法的返回值类型前面
public class TestStatic {
		//1.变量数据类型嵌满【静态成员变量】
			public static String name="sansan";
			
		//2.静态方法--方法的返回值类型前面
			public static void staticMethod(){
				System.out.println("静态方法");
			}
			
		/*
		 * 总结
		 * 1.静态成员变量【类变量】/静态方法【类方法】可以使用类名调用，也可以使用对象调用
		 * 2.静态成员变量可以在同类之间共享数据
		 * 3.静态方法不能出现this关键字
		 * 4.静态方法中不能访问实例方法/实例变量
		*/

}

     this---本类对象【出现在哪一个类中就表示哪一个类的对象】

      本类中调用本类的实例变量\类变量\实例方法\类方法，可以省略；

      this是不能出现在静态方法中；

      例如：

package com.wangxing.thistest;
//this关键字【当前类的对象】
//this出现在哪一个类中就表示哪一个类的对象

public class TestThis {
		//实例变量
	public String name1="this实例变量";
	/*	
	public TestThis(){
		System.out.println("无参构造方法");
	}
	*/
	public TestThis(String name){
		System.out.println("有参的构造方法，参数是name");
	}
	
	public TestThis(int int1){
		System.out.println("有参的构造方法，参数是int1");
	}
	//实例方法
	public void shiliMethod(){
		//在这个实例方法中使用一下当前类的实例变量
		//TestThis t1=new TestThis();//当前类TestThis的对象
		//我们在访问类中的变量只能通过对象访问
		//System.out.println(new TestThis().name1);
		//System.out.println(t1.name1);
		//this--当前类的对象
		//this===>new TestThis();
		//同一个类中实例方法访问实例变量，默认this.实例变量，this.被省略
		System.out.println(this.name1);
		System.out.println(name1);
		//因为类中的变量【不包括局部变量】和方法【不包括构造方法】，可以通过对象方法
		//那么我们在访问类中的变量和方法是，就需要先创建对象
		//1.本类之外的其他类中，我们创建对象new 构造方法()
		//2.本类中，我们创建对象new 构造方法()，本类中new 构造方法()创建对象可以用this代替
		//这时我们认为本类的对象就是this
		//所以在本类中访问本类的变量和方法使用this是可以的
		//java程序=对象+消息
		
	}
}		

package com.wangxing.thistest;

public class TestMain {

	public static void main(String[] args) {
		//TestThis tt1=new TestThis();
		//tt1.shiliMethod();
		new TestThis("canshu").shiliMethod();
		new TestThis(5555).shiliMethod();

	}

}

      super--子类中表示父类对象

       子类中访问父类构造方法“super([参数])”。子类中访问父类的实例方法/实例变量”super.实例变量/实例方法”。

package com.wangxing.supertest;
//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(String  name){
		//super();
		new Object().getClass();
		//super.getClass();
	}
		
}

     final---最终的

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

      fianl修饰的静态成员变量叫静态常量。【静态常量全字母大写】

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

      final修饰的类不能被继承，没有子类。

     例如：

package com.wangxing.finaltest;
//final--最终的
//final可以修饰java类，没有子类 ，不能被继承
//final可以修饰java类中的方法，可以继承，不能被重写
//final可以修饰java类中的变量，不能被修改【常量】
//注意：抽象类/接口中的抽象方法不能用final修饰
//public final class TestFinal{}
public class TestFinal {
		public final String name1="zhangsan";
		public final static String NAME2="lisi";
		//final可以修饰java类中的方法，不能被重写
		public final void method1(){
			System.out.println("父类中的方法");
		}
		public void method2(){
			final String name3="wangwu";
			System.out.println(name3);
			//name3="chengliu;"
		}
		
	
}

package com.wangxing.finaltest;

public class SunTest extends TestFinal{
		/*
	public void method1(){
			System.out.println("父类的方法");
		}
		*/
        //父类中的方法是被final修饰的，所以无法重写，会报错
}

package com.wangxing.finaltest;

public class TestMain {

	public static void main(String[] args) {
		//SunTest f1=new SunTest();
		//f1.NAME2;
		
		//final可以修饰java类中的变量，不能被修改【常量】
		TestFinal t2=new TestFinal();
		System.out.println(t2.name1);
		//t2.name1="sansan";
		System.out.println(TestFinal.NAME2);
		System.out.println(t2.NAME2);
		//t2.NAME2="sisi";

	}

}