一，this关键字
1，当成员变量和局部变量重名时，可以使用this关键字来区分。
this关键字代表的是本类对象，this一般是在一个函数中，哪个对象在调用this所在的函数，this就代表哪个对象。
//this关键字的使用2，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();
}
}
理解下面这个程序的执行过程就可以明白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的，其实就是一个常量，这个常量不需要改变，所以写成了大写。