Java系列（11）——关键字

本系列博客汇总在这里：Java系列_汇总

---

一、简介

  关键字就是程序发明者规定的有特殊含义的单词，又叫保留字，是用来标识文件中各个记录的特定数据项目的值，简单的说就是电脑语言里事先定义的，有特别意义的标识符。

二、this 关键字

1. this 只能在类的方法中使用。

2. this 代表当前调用这个 this 所在的方法的对象的自身。

3. this 可以再在方法内区分同名的类的属性和参数名，有 this 的一定是属性，没有 this 的一定是方法的参数名。

4. 谁调用 xxx（方法名），xxx 中的 this 就代表是谁。

5. 示例

   class Welcome
   {	
   		public static void main(String[] args)
   		{
   			Car car=new Car();			
   			//给car对象的属性赋值
   			car.color="黄色";
   			car.carNo=88888;
   			car.name="大黄蜂";			
   			//打印对象
   			System.out.println(car.name);			
   			//调用run方法
   			car.run();
   			car.introduce();
   		}
   }
   

   class Car
   {
   	String color;
   	int carNo;
   	String name;
   	public void run()
   	{
   		//System.outprintln(name+”车在跑”)；
   		System.out.println(this.name);
   		//谁调用run，这里的this指调用run的对象的本身，所以这里run被下面的car调用以后，this.name就是car这个类里的name属性
   	}	
   	
   	public void introduce()
   	{
   		System.out.println("我是一辆"+this.color+"车牌是"+this.carNo+this.name+"车");
   		//同上理
   	}
   }
   

   
   当直接打印一个对象时，输出的是对象的地址（JDK 所提供的一个地址，形如：[e-mail]）。

6. 内存结构
   
   根据主类 Welcome 一步一步往下走可以得到，方法区的 main 方法先进栈，然后在堆内存里创建一个 car，同时把 car 的 class 文件也加载到内存，在这个文件里检测到有两个方法，将他们加载到方法区，再在堆内存里通过 new 创建 car 对象，同时可以给 car 的属性赋值，car 的属性在赋值之前，是 null 或者是 0。由于在 Car car=new Car(); 中第二个 car 是一个引用，所以一定在栈内存里有一个地址，如果只在栈内存里打印 car 对象，打印出来的就是这个地址 car @c791b9，而这个地址是指向堆内存里的地址 car @c791b9，主方法里调用 run 方法后，run 方法会进栈，car 调用 run 方法，而 run 方法里有 this，根据 this 的性质，它同样指向 car 的地址 car @c791b9。

三、static 关键字

1、修饰在属性上

1. 格式：static 数据类型 变量名；

2. 类属性访问
   （1）类名.类属性名（推荐使用）。
   （2）对象名.类名属性（不推荐使用）。

3. 示例

   	class Welcome
   	{
   		public static void main(String[] args)
   		{					
   			System.out.println("---------------使用类名来调用类方法----------------------");
   			Student.study();
   			Student.sleep();
   			
   			System.out.println("---------------使用对象来调用方法------------------------");
   			Student student = new Student();
   			student.study();	
   			student.sleep();		
   		}	
   	}
   

   class Student
   {
   	static String name = "魏宇轩";
   	
   	/**
   	 *对象的方法。每一个老师实例可以使用
   	 */
   	public static void study()
   	{		
   		System.out.println(name+"同学在上课");		
   	} 
   		
   	/**
   	 *类方法
   	 */
   	public static void sleep()
   	{			
   		System.out.println(name+"同学在睡觉");	
   	} 
   }
   

   
   

4. 修饰在属性上的内存结构
   

5. 类属性的生命周期
   （1）User.class 加载到 jvm 中时类属性就产生了。
   （2）jvm 消失时类属性就消失了。

6. 对象属性
   （1）当对象被创建时就产生了。
   （2）当对象所在的方法执行完毕后就会被垃圾回收机制回收掉。

2、修饰在方法上

1. 格式

   public static 返回值类型（void） 方法名（数据类型  参数名，...）
   {
   	方法体
   	return 结果；
   }
   

2. 类方法的调用：
   （1）类名.类方法名（推荐使用）
   （2）对象名.类方法名（不推荐使用）
3. 示例程序及结果图同上。
4. 综上所述，static 修饰方法后只能使用 static 修饰的变量，这种方法多用于工具类。工具类就是别人已经写好方法，我们只需要调用就可以了，但这种方法必须掌握。

四、super 关键字

• 示例

  /*
  	父类
  */
  class Teacher
  {
  	String name = "刘成娟";	
  	int age = 9;		
  	public void sleep()
  	{		
  		System.out.println("刘成娟老师在睡觉");
  	}	
  }
  

  /*
  	子类
  */
  class JavaTeacher extends Teacher
  {	
  	String name = "康彦丰";
  	int age = 8;		
  	public void sleep()
  	{	
  		System.out.println("康彦丰老师在睡觉");
  	}	
  	public void teachJava()
  	{		
  		//默认情况下单独使用对象属性时都隐藏了this
  		System.out.println("-------------------用子类属性----------------------------");
  		System.out.println(this.name+"老师在教JAVA  年龄：" +this.age);//用子类属性（this可省略）
  		System.out.println("-------------------用父类属性----------------------------");
  		System.out.println(super.name+"老师在教JAVA  年龄：" +super.age);
  	
  		System.out.println("--------------------调用子类的sleep方法-------------------");
  		this.sleep();
  		System.out.println("--------------------调用父类的sleep方法-------------------");
  		super.sleep();
  	}  
  }
  

  class Welcome
  {
  	public static void main (String[] args)
  	{		
  		JavaTeacher jt = new JavaTeacher();		
  		jt.teachJava();
  	}
  }
  

  
  所以，当子类和父类同时具有相同的属性和方法时，直接调用同名方法和同名属性，父类方法和属性直接被覆盖掉，故此使用 super 关键字来区分父类和子类里面的同名方法。但是实际工作中是没有人在子类和父类里定义同名的属性和方法的，但 super 有这个功能。

五、final 关键字

1、修饰在属性上

修饰在属性上时，属性的值不能再改变（复写）。

2、修饰在方法上

修饰在方法上时，子类无法覆盖父类里面的同名方法。

3、修饰在类上

修饰在类上时，该类不能被继承。

4、final，finally，finalize 的区别

1. final：修饰在属性上，属性值不能再修改；修饰在方法上，方法不能被重写；修饰在类上，类不能被继承。
2. finally：和try…catch异常处理模块一同使用的语句，它在最后一定会被执行。
3. finalize：用于垃圾回收，如果对象在堆中没有任何引用时，jvm 会调用 finalize 来回收这个对象。

如有错误，欢迎指正！