常用关键字分析

 一.可见性关键字public,private,protected,default辨析
1).范围
一个项目:public
一个包:public,protected,default
一个类:public,protected,default,private
eg:

 

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);
	}

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

 
 
public class JNStudent extends Student{
public void sowInfo(){
    //private不能被同一个包的类直接访问
    System.out.println("姓名:"+name+"学分:"+score+"卡号:"+cardNo);
    }
}


package test2;
public class UNStudent extends Student{
public void sowInfo(){
    //子类是可以直接访问父类中的protected属性和方法的
    System.out.println("姓名:"+name+"卡号:"+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();//报错

UNStudent s1 = new UNStudent();
s1.showInfo();//编译能通过
}

}


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="张三";
int final score = 77;
protected final String cardNo = "435452354235";
    private final int age = 20;
   
    protected final void showInfo(){
    //各种可见性关键在同一个类中都能够被直接访问到
    System.out.println("姓名:"+name+"学分:"+score+"卡号"+cardNo+"年龄:"+age);
    }
   
}


三.static关键字
1)static类型的变量是在类加载时初始化，而且只加载一次，它的值被修改是，其他的类和对象使用的都是修改以后的值
  static类型变量又叫类变量，用"类名.静态变量"形式直接使用
2)static方法又叫类方法,在一个类被使用到时被加载到内存，但并不执行，用"类名.静态方法"形式直接使用
3)static代码块在类加载时便执行

此处附上一道淘宝面试题以飨读者:
public class A {
public A() {
System.out.print("A");
}
}

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

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

public C() {
System.out.println();
}

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

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

答案在分析的最后位置。
分析：因为要使用到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{

private Animal pet = new Animal(){
private int length = 0;


public void showInfo(){
this.length = 56;//this引用的是匿名类的当前对象
super.showInfo();super引用的是父类当前对象
System.out.println("长度:"+length);

}


};

public void showInfo(){
super.showInfo();
pet.showInfo();
}

public static void main(String[] args) {
UNStudent s1 = new UNStudent();
s1.showInfo();
}
}
程序执行后的结果是:
姓名:张三学分:77卡号435452354235年龄:20
种类:Wolf体重:20
长度:56