特殊关键字

特殊关键字

包package是类或接口的容器

什么是包

包是类的组织方式，提供名空间和访问控制

类似于文件系统的组织

声明包中的类package

语法：package 包名称;

• 声明包要求是源代码文件的第一个语句
• 程序中最多只能有一条package语句,没有包定义的源代码文件成为默认包中的一部分 :
• 程序中如果有package语句,该语句必须是第一条语句（前面只能有注释或空行）

包的作用

• 包能将相关的源代码文件组织在一起
• 包减少了名称冲突带来的问题
• 可以使用package指明源文件中的类属于哪个具体的包

this和super关键字

this用于指代当前对象；super用于指代父类对象

this()表示调用另外一个构造器,super()表示调用父类中的某个构造器，()中的参数决定调用的是哪个构造器

public class A {
   public A() {
//需要调用A(String)这个构造器方法
   this("zhangsan"); //调用当前类中的另外一个构造器
}
public A(String name) {                               System.out.println("name:"+name);
  }
}
//另外的写法
public A(String name) {
   this(); //在当前构造器中调用另外一个构造器方法的语句必须是构造器方法中的第一句                            System.out.println("name:"+name);
}
//语法错误
public A(String name) {
    if(name!=null) 
    this(); 
 System.out.println("name:"+name);
}

//当定义构造器时，如果构造器方法中第一句不是this()或者super()时，默认第一句就是super()表示调用父 类的构造器 
public class B extends A {
  public B() {
super();//表示调用父类的无参构造器 
  } 
}
 
父类
public class A { 
  private A() {} 
  public A(int k) {} 
}
子类
public class B extends A {
   public B() { 
super(123); //如果不写则语法报错，因为默认会调用父类的无参构造器，但是父类的无参构造器为 private，子类中不能访问;super(123)表示调用父类中的带参构造器public A(int k)
   } 
}

this.成员属性用于表示当前对象的某个成员，一般用于局部变量和属性名称一致的场景下。super.成员属性用于表示父类中定义的某个属性，一般用于子类中覆盖定义了某个父类属性的场景下

public class A { 
private String name; 
public void setName(String name) {//局部变量名name和属性name重名，可以使用this.name表 示这个是属性，按照就近原则，当前方法中的name是局部变量
this.name = name;
}
}

public class A { 
  String name="A类";
}

public class B extends A {
  private int name=123;//和父类中的属性name重名，按照就近原则，当前类中的name就是子类中声明的 name，而不是父类中声明的name 
public void pp() { 
  System.out.println("子类中声明的name:"+name);//也可以写成this.name 
  System.out.println("父类中声明的name:"+super.name);//使用super.name引用父类中声明的name属 性，还需要考虑范围限定词的问题
}
public static void main(String[] args) {
  new B().pp();//new运算符的优先级高于点运算符
}
}

this.成员方法()用于表示当前对象的某个成员方法；super.成员方法()用于表示当前类的父类中定义的某个成员方法，一般用于覆盖定义时【就近原则】

public class A { 
  public void pp() { 
System.out.println("this is A class"); 
  }
}

public class B extends A {
   public void pp() {//子类中定义的方法签名和父类中的一致，实际上就是方法的覆盖 
System.out.println("this is B class");
}
public void cc() { 
// this.pp();//调用B类中声明的方法pp                       System.out.println("this is B.cc()"); 
        super.pp();//调用父类中被子类同名方法覆盖的方法,注意范围限定词 
}
public static void main(String[] args) {
     new B().cc(); 
   } 
}

在static方法中不允许使用this/super之类关键字

关键字##

意思是最终的、不可变的

修饰属性

final修饰变量时，变量被必须初始化，并且不能被修改。初始化可以定义final变量时直接初始化或者在构造函数中初始化

public class A {
    private final String name="123"; //使用final一般用于定义常量，可以在声明的同时进行赋值，例 如PI=3.1415。一般常量的命名规则为全大写，下划线分词USE_NAME
   public void pp() {
// name="abc"; final表示name一旦赋值则不能修改

   }
}
public class A { 
  private final String name;
   public A() { 
//定义final属性如果在构造器中赋值，则必须在所有当前类的构造器中赋值 
name="123456"; 
}
 public A(int k) { 
     name="rrrr"; 
 }
    public void pp() { // name="abc"; final表示name一旦赋值则不能修改 
    }
}   

修饰局部变量

public class A {
   public void pp() { 
// final int kk=123; 声明的同时直接进行赋值操作          final int kk; //先声明后赋值 
     System.out.println("其它操作");
kk=222;
// kk++;final变量一旦赋值则不允许进行修改操作 System.out.println(kk); 
  }
}

修饰方法

final修饰方法则该方法不能被子类重写

public class A { 
public final void pp() {
System.out.println("this is A class");
}
}
public class B extends A {
public void pp() { //因为A类中的方法pp有final修饰，则该方法不允许覆盖定义，但是允许重载 System.out.println("this is B class");
}
public void pp(int k) {} 
}

修饰类

final修饰一个类,则该类不能被继承

通过private构造器也达到了类似的不允许继承的效果，但是要求类中的所有构造器都是私有

扩展

表示字串的3种类型String、StringBuàer、StringBuilder都是final类型的类，所以都不允许继承

总结

final属性上可以声明的同时直接赋值或者在构造器中赋值

public class A{
private final int kk;
public A(int counter){
kk=counter; 
} 
}

final临时变量，可以声明的同时赋值或者在第一次使用之前进行赋值

注意：final类型的变量一旦赋值则不允许修改，但是如果是复杂类型是不允许修改地址，但是可以修改

属性

final方法表示这个方法不允许在子类中重新定义（覆盖\重写）

final类表示这个类不允许被继承

静态static关键字

用于修饰成员，包括成员属性【类属性或者静态属性】、成员方法【类方法或者静态方法】

• 随着类加载，随着类消失
• 优先于对象，用类名直接访问

public class A {
public static int kk=123;//静态属性
public static void pp() {}//静态方法
public static void main(String[] args) { //针对静态属性，即可以直接以类名的方式进行调用，也可以创建对象后当作普通属性进行调用
System.out.println(A.kk);//采用类名称直接调用 A.pp(); //采用类名称直接调用
A a=new A(); 
System.out.println(a.kk); //采用对象名的方式进行调用 a.pp();//采用对象名的方式进行调用
}
}

静态属性

static属性是当前类的所有对象所共有的共同属性(只有一个，而普通属性各个对象都有自己的，相互隔离)，任何一个当前类对象修改这个属性，所有其他类对象的这个属性都会受影响

执行过程：

• 静态属性，在类加载完毕后则自动进行静态资源处理

A a;这里并没有创建A对象，但是C自动创建了，执行了static C c=new C();

• 如果是调用new操作

  非静态属性

  构造器

执行顺序： 静态属性—属性—构造器