一.可见性关键字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