java关键字总结

java关键字目前常用的主要有：public，private,protected,final,static,this,super,package,abstract,boolean,break,byte,case,catch,char,class,const,continue,default,do,while,double,if,else,true,false,finally,float,for,goto,,implements,import,int,instanceof,interface,new,null,try,catch,return,void
主要介绍一下：以下这些关键字


1,关于访问限定符的关键字：public是范围最大的，protcted次之，接着是默认，最小的是private。 具体为：
a，public：定义的变量，属性或方法可以在同一个工程中每个地方都可以使用如在A类中定义了一个公有的变量，public int num；那么在不与A相同包下的另外一个类B也可以直接使用这个变量。

b，protected：定义的变量，属性或方法在同一个包中是可以被使用的，但是在别的包下不能用，但是当不同包下的子类调用该变量或属性时，是允许的

c，默认的 ：无访问限定符的变量，属性，或方法在同一个包下也可以使用，但不在同一个包中即不可使用，其中包括子类调用父类也不可以。

d， private：在同一个类中可以被使用。在别的类中即不可使用

ps： 关于默认，在接口中的属性和方法必须是public ,默认是public
子类在重写父类的方法时候，不能减小方法的可见范围????
原因是：重写也叫覆写，修饰符、返回类型、参数就是要和父类一摸一样才叫覆写，意思是说各个地方都需要完美的盖住，在面向接口编程中，重写是子类有自己的逻辑要实现，同时又不破坏已写好程序逻辑的好方法

举个例子，在父类中是public的方法，如果子类中将其降低访问权限为private，那么子类中重写以后的方法对于外部对象就不可访问了，这个就破坏了继承的含义。所以不能够降低其方法的可见范围。
======================================================================
2，super与this关键字
super代表父类，this代表子类，其功能是相似的
先介绍this吧。
this的2个功能
1：this指对象：代码如下
public class A{
String name;
public void setName(String name){
this.name = name;//this指代当前对象
}

public void test(){

}
}
2:this表示当前类的一种构造方法：代码如下
public class A{
public A() {
this("默认");
}

public A(String name) {
this.name = name;
}
}

即this即代表A,而当this里面的实参的个数不同时，即代表该类不同的构造方法
这样做的好处是当调用无参的构造方法时，可以默认给对象初始化


super的用法：
1,super指子类继承父类时，super就代表父类，如需要在子类中调用父类的方法时，可以直接使用super.方法名(参数列表)调用。父类的公有属性也可以直接super.调用

2，super用于子类的构造方法中，在子类的构造方法中会直接调用父类的无参构造方法，而当父类没有无参构造方法时，子类就必须要显示调用父类的有参构造方法。且当创建子类对象时，调用的顺序为先调用父类的构造方法，再调用子类的构造方法


======================================================================
3，final,static关键字

1，final:final意为最终的，最后的，顾名思义，即由final创建的类，属性，方法都为最后的，不能修改。简单地说就是用final修饰的类不能被继承（因为已经是最后的）,由final修饰的属性，即不能修改值，为一个常量。final修饰的方法，当子类继承父类时，子类可以调用final修饰的方法，但是不能重写final修饰的方法。因为不可改变。
代码如下：

public final class A{} 表示不能被继承
private final int age=100; 表示只能赋值一次，必须初始化，不能修改
public final void trst(){ 表示不能被重写

}
final int age=100; 表示只能赋值一次，必须初始化，不能被修改
2，static:static意为静态的，只能定义属性，方法，代码块
简单地说就是在一个类中，由static修饰的属性，方法，代码块，都是放在存放类的地址中，当类创建对象时，只能把非静态的属性，方法等传递给对象，而静态的依旧在类中，为对象们所共有。
示例代码：
public class A{
private static String name; 这一个类所有的对象共同使用的一个变量指向同一个地址
public static void test(){} 表示这个方法的调用只和类型相关
}
static的属性和方法是不需要对象的，只需要通过类名来调用
A.name="AAA";
A.test();


代码段 static { //在主函数之前执行，来初始化数据

}
试请分析一下如下代码：
类A
package cjl.keyword0713.a;

public class A {

public A(){

System.out.print("A");
}


}
----------------------------------------------------------------------类B
package cjl.keyword0713.a;

public class B extends A {

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

}
----------------------------------------------------------------------
类C
package cjl.keyword0713.a;

public class C {

private static A a = new A();
private B b = new B();

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

public static void main(String args[]){

C.change();

}

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



}
问题是C中主函数运行之后的结果是？
结果是： AAB
下面简单分析一下：
程序运行时，首先先加载类C的静态属性，这样就会实例化A，创建A的对象时会调用A的构造方法，这样就会先输出A,之后再加载类C的静态方法，注意方法只有调用的时候才能执行其代码，因此此时不执行change方法，等类C的静态方法加载结束后，就开始调用主函数，因为静态方法是直接用类名.方法名调用，故未创建类的对象，因此无需加载类C的非静态属性，且不需调用其构造方法，这是只调用静态的Change方法，change方法中是创建B的对象，肯定会调用B的构造方法，我们不难看到B是先继承A的，所以要先调用A的构造方法，再调用B的构造方法，因此会依次输出AB,所以答案就为：AAB