黑马程序员_Java基础_this,super,static,final关键字

一，this关键字

1，当成员变量和局部变量重名时，可以使用this关键字来区分。

this关键字代表的是本类对象，this一般是在一个函数中，哪个对象在调用this所在的函数，this就代表哪个对象。

//this关键字的使用
class Person
{
	private String name;
	private int age;
	Person(int age)
	{
		this.age = age;
	}
	Person(String name)
	{
		this.name = name;
	}
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}

	public void speak()
	{
		System.out.println("name="+this.name+"...age="+this.age);
		this.show();
	}
	public void show()
	{
		System.out.println(this.name);
	}

	/*
	需求：给人定义一个用于比较年龄是否相同的功能。也就是是否是同龄人。
	*/
	public boolean compare(Person p)
	{
		return this.age==p.age;

	}
}

class PersonTest
{
	public static void main(String[] args) 
	{

		Person p1 = new Person(20);
		Person p2 = new Person(25);
		boolean b = p1.compare(p2);
		System.out.println(b);
		
		//Person p = new Person("lisi");
		//Person p1 = new Person("zhangsan");
		//p.speak();
		//p1.speak();
		//p.speak();
	}
}

2，this可以用于在构造函数中调用其他的构造函数，但是在调用其他构造函数的时候，要定义在构造函数的第一行，因为初始化动作要先执行。

理解下面这个程序的执行过程就可以明白this在构造函数间的调用过程了。

class Person
{
	private String name;
	private int age;
	
	Person()
	{
		System.out.println("person run");
	}
	Person(String name)
	{
		this();
		this.name =name;
	}
	Person(String name,int age)
	{
		this(name);
		this.age = age;	
	}

}

class  Demo
{
	public static void main(String[] args) 
	{
		Person p = new Person("lisi",30);
	}
}

二，super关键字和this的用法几乎相同，它的不同在于，super指向的是父类的对象，而this指向的是本类的对象。

下面这个程序时面向对象里面继承的示例代码，里面几乎涵盖了super的所有使用方法。

class Person {
	public String name;
	public int age;
	int num = 12;
	Person(String name,int age) {
		this.name = name;
		this.age = age;
	}


	/*public void setName(String name) {
		this.name = name;
	}


	public void setAge(int age) {
		this.age = age;
	}*/


	public void sayHello() {
		System.out.println(name + ":" + age);
	}
}


class Student extends Person {
	int num = 13;
	Student(String name,int age) {
		super(name,age);
	}
	// 重写父类中的sayHello方法
	public void sayHello() {
		System.out.println("我叫：" + name + ",今年" + age + "岁了");
		System.out.println(super.num + "::" + this.num);//默认的this,可以省略
	}
}


class Demo {
	public static void main(String[] args) {
		Student s = new Student("zhangsan",25);
		/*s.setName("zhangsan");
		s.setAge(25);*/
		s.sayHello();
	}
}

三，static(静态)关键字

1，static关键字特点：

（1）他是一个修饰符，是用来修饰成员的（成员变量和成员方法）。

（2）static修饰的成员被所有的对象共享。

（3）static优先于对象存在，因为static的成员随着类的加载就已经存在于内存中了。

（4）static修饰的成员可以通过类名直接调用。类名.静态成员

（5）static修饰的数据时共享数据，对象中存储的是特有数据。

2，成员变量和静态变量的区别：

（1）两个变量的生命周期不同，成员变量随着对象的创建而存在，随着对象的被回收而释放。

静态变量随着类的加载而存在，随着类的消失而消失。

（2）调用方式不同，成员变量只能被对象调用，静态成员变量可以被对象调用，还可以被类名调用。

（3）别名不同，成员变量也称为实例变量，静态变量称为类变量。

（4）数据的存储位置不同，成员变量存储在堆内存中，也叫做对象的特有数据，而静态变量数据

存储在方法区（共享数据区）的静态区，所以也叫做对象的共享数据。

3，静态在使用时应该注意：

（1）静态方法只能访问静态成员，而非静态成员既可以访问非静态成员也可以访问静态成员。

（2）静态方法中不可以使用this关键字和super关键字。

（3）主函数是静态的。

4，静态的使用：

（1）静态变量：

当分析对象中所具备的成员变量的值都是相同的。这时，这个成员就可以被修饰成静态的。只要数据在对象中都是不相同的，就是对象的特有数据，必须存储在对象中，是非静态的。如果是相同的数据，对象不需要做修改，只需要使用即可，不需要定义在对象中，定义成静态的。

（2）静态函数:

函数是否用静态修饰，就参考一点，就是该函数的功能是否有访问到对象中的特有数据。简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要该功能就是非静态的。如果不需要就可以将该功能定义成静态的，当然也可以定义成非静态的。但是非静态需要对象调用，而仅创建对象调用非静态的没有访问特有数据的方法，该对象的创建时没有意义的。

（3）静态的优缺点

优点：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。还可以直接被类名调用。

缺点：生命周期过长。访问出现局限性。(静态虽好，只能访问静态。)

class Person {
	int age;
	static int num = 9;
	Person(int age) {
		this.age = age;
	}
	
	public static void speak() {
		System.out.println(num);
	}
	
	public void show() {
		System.out.println("age = " + age);
	}
}

public class Test {
	public static void main(String[] args) {
		Person p = new Person(30);
		p.show();
		p.speak();//这种方式不建议使用，减一使用下面的方式
		Person.speak();
	}
}

四，静态代码块

1，静态代码块格式：
static
{
静态代码块中的执行语句。
}

2，静态代码块的特点：随着类的加载而执行，只执行一次，并且优于主函数。主函数是程序的入口，并且是直接由JVM直接调用的。

3，静态代码块的作用是给类进行初始化。

class StaticCode
{
	int num = 9;
	StaticCode()
	{
		System.out.println("c");
	}

	static
	{
		System.out.println("d");
	}
	{
		System.out.println("construct"+this.num);
	}

	StaticCode(int x)
	{
		System.out.println("e");
	}
	public static void show()
	{
		System.out.println("show run");
	}
}

class StaticCodeDemo 
{
	static
	{
		System.out.println("a");
	}
	public static void main(String[] args) 
	{
		//new StaticCode(4);//打印结果是：a,b,d,construct9,e
		//StaticCode.show(); //打印结果：a,b,d,run show
		//StaticCode s = new StaticCode(); //a,b,d,construct9,c

		//StaticCode.show();//打印结果：a,b,d,show run
	}
	static
	{
		System.out.println("b");
	}
}

五，fina关键字

1.fian关键字的特点是：

（1）可以用来修饰类，方法，变量

（2）final修饰的类不能被继承

（3）fianl修饰的方法不可以被覆盖

（4）fianl修饰的变量只能被赋值一次

（5）fianl既可以修饰成员变量也可以修饰局部变量，内部类只能访问被fianl修饰的局部变量

2，什么时候使用final呢？

当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字。方便于阅读。而这个值不需要改变，所以加上final修饰。作为常量：常量的书写规范所有字母都大写，如果由多个单词组成。单词间通过_连接。

在java文档中有很多字段就是fianl的，其实就是一个常量，这个常量不需要改变，所以写成了大写。