常用关键字分析

一.可见性关键字

1).范围

• 一个项目:public 
• 一个包:public,protected,default
• 一个类:public,protected,default,private

package test1;
public class Student {
	public String name = "张三";
	int score = 77;
	protected String cardNo = "435452354235";
	private int age = 20;

	protected void showInfo() {
		//各种可见性关键在同一个类中都能够被直接访问到
		System.out.println("Name:" + name + ",Score:" + score + ",CardNo.:" + cardNo
				+ ",Age:" + age);
	}
}

package test1;
public class JNStudent extends Student {
	public void showInfo2() {
		// private不能被同一个包的类直接访问
		System.out.println("Name:" + name + ",Score:" + score + ",CardNo.:" + cardNo);
		System.out.println("Age:" + age);//编译报错
	}
}

package test2;
public class UNStudent extends Student {
	public void showInfo2() {
		// 子类是可以直接访问父类中的protected属性和方法的
		System.out.println("Name:" + name + ",Score:" + score + ",CardNo.:" + cardNo
				+ ",Age:" + age);
		System.out.println("Name:" + name + ",CardNo.:" + cardNo);
	}
}

public class Test {
	public static void main(String[] args) {
		Student s = new Student();
		s.name = "张三";

		// private,default和protected类型变量在不同包中不能被直接访问
		s.score = 77;// 编译报错
		s.cardNo = "54235435342";// 编译报错
		s.age = 23;// 编译报错

		s.showInfo();// 编译报错

		JNStudent s1 = new JNStudent();
		s1.showInfo2();// 编译能通过
	}
}	

2).protected和default的区别

protected类型的方法和属性,在子类中都可以被访问到(即使不在同一个包里)，而default类型的只能在同一个包里面才能被直接访问到

   

3).关键字使用原则

关键字一般的使用原则是，作用域是尽量的少。类的属性一般为private类型，而对外提供访问的方法则是public类型

二.final关键字

1. final关键字修饰的变量一旦被赋值便不能再改变
2. final修饰的方法不能够被被继承的类重写

eg：

将上例中Student类中的属性的类型前加上final之后，任何对他们的修改都会报错

将Student类中的showInfo()方法加上final修饰符号之后，子类将不能再对其重写

public class Student {
	public final String name="张三";
	final int score = 77;
	protected final String cardNo = "435452354235";
    private final int age = 20;
 
    protected final void changeInfo(){
    	//final关键字修饰的变量是不能够被重新赋值
    	name = "李四";
    	score = 25;
    }
}

class NewStudent extends Student{
	public void changeInfo(){//编译报错，子类不能重写父类的final方法
		
	}
}

三.static关键字

1. static类型的变量是在类加载时初始化，而且只加载一次，它的值被修改时，其他的类和对象使用的都是修改以后的值

        static类型变量又叫类变量，用"类名.静态变量"形式直接使用

2. static方法又叫类方法,在一个类被使用到时被加载到内存，但并不执行，用"类名.静态方法"形式直接使用

3. static代码块在类加载时便执行

public class Test {
	public static void main(String[] args) {
		C c = new C();
		C.change();
	}
}

class A {
	public A() {
		System.out.print("A");
	}
}

class B {
	public B() {
		new A();
		System.out.print("B");
	}
}

class C {
	static A a = new A();
	B b = new B();

	public C() {
		System.out.print("C");
	}

	public static void change() {
		B b = new B();
	}

}

分析：因为要使用到C类，所以C被加载到内存中，static A a = new A();执行执行构造方法打印出A,而静态方法的加载是不需执行的

然后程序进入main方法中.创建C类型的对象，先初始化属性,a是静态变量，已初始化，不再执行，创建B类型对象，打印出AB，在执行C的构造方法，创建C类型对象，打印出C.

接着回到main方法中，调用C的类方法change(),创建一个B类型对象，打印出AB。

所以最终的结果是AABCAB

四.super和this关键字

1).this代表的是指当前对象，简而言之，即谁使用这个类，this便是谁

2).类似的，super在子类中出现代表当前父类对象

eg:

public class UNStudent extends Student {

	public void showInfo() {
		super.showInfo();// super引用的是父类Student对象
		this.showInfo2();// this引用是当前使用到UNStudent对象
	}

	private void showInfo2() {
		System.out.println("I' a new student!");
	}

	public static void main(String[] args) {
		UNStudent s1 = new UNStudent();
		s1.showInfo();
	}
}

程序执行后的结果是:

Name:张三,Score:77,CardNo.:435452354235,Age:20

I' a new student!