Java关键字

袁文胜

package：

• 声明包；package 包名，例如：package name
  
• 创建包时建议包名使用全小写，可以使用.
  
• 避免类名重复；同包中的类不可以有相同的类名，不同包中的类类名可以同名
  
• 相同包中的类可以直接访问，不同包中的类不能直接访问，需要通过包名.类名的方式来访问
  

//a.aa包
package a.aa; //声明a.aa包
public class a1 { //a.aa包的a1类
    b.bb.b1 aa = new b.bb.b1(); //a1类需要访问b1类则需要包.类名的方式来访问
}

//b.bb包
package b.bb; //声明b.bb包
public class b1 { //b.bb包的b1类
    b2 bb = new b2(); //b1可以直接访问b2
}
package b.bb; //声明b.bb包
public class b2 { //b.bb包的b2类
    b1 bb = new b1(); //b2可以直接访问b1
}import：

• 导入类，方便跨包访问
  

//a.aa包
package a.aa; //声明a.aa包
import b.bb.b1; //在a.aa包，导入b1类
public class a1 { //a.aa包的a1类
    b1 aa = new b1(); //导入类后，可以直接访问
}

//b.bb包
package b.bb; //声明b.bb包
public class b1 { //b.bb包的b1类
}访问控制修饰符：

• public：公开的，可以被任何类访问
  
• protected：受保护的，所在类、派生类、同包类能访问
  
• 默认（什么也不写）：本类，同包类能访问
  
• private：私有的，只有所在类能访问
  

• 用于保护数据安全，设置访问权限
  
• 类的访问控制修饰符只有public和默认两种方式，类中的成员（变量、方法）的访问控制修饰符可以是public、protected、默认、private任意一种
  
• Java不建议使用默认的访问控制修饰符
  

//a.aa包
package a.aa; //声明a.aa包
import b.bb.b1; //在a.aa包，导入b1类
public class a1 { //a1类
    void a1test() {
        b1 aa = new b1();
        aa.a = 1;
        //aa.b = 2; //报错，a1和b1不同包
        //aa.c = 3; //报错，a1和b1不同包
        //aa.d = 4; //报错，a1和b1不同包
    }
}
package a.aa; //声明a.aa包
import b.bb.b1; //在a.aa包，导入b1类
public class a2 extends b1{ //a2类，继承b1类
    void a2test() {
        a = 1;
        b = 2; //a2是b1的派生类，可正常访问
        //c = 3; //报错，a1和b1不同包
        //d = 4; //报错，a1和b1不同包
    }
}

//b.bb包
package b.bb; //声明b.bb包
public class b1 { //b1类
    public int a;
    protected int b;
    int c;
    private int d;
    void b1test() {
        a = 1;
        b = 2;
        c = 3;
        d = 4;
    }
}
package b.bb; //声明b.bb包
public class b3 { //b3类
    b1 cc = new b1();
    void b3test() {
        cc.a = 1;
        cc.b = 2;
        cc.c = 3;
        //cc.d = 4; //报错，b1和b3是不同类
    }
}static静态修饰：

• 静态变量和静态方法由static修饰
  
• 静态变量是属于类的变量（实例变量是属于对象的变量）
  
• 静态变量和静态方法在内存中只加载一次，如果对象的变量中有共享的部分，可将变量设置为静态变量；静态变量适用于存放图片、音乐、视频等多媒体数据
  
• 静态变量和静态方法直接通过类名.静态变量或静态方法进行访问
  
• 静态方法没有隐式的this，因此与对象实例变量访问有关的方法，不可以使用静态方法；与对象无关的方法可以设置成静态方法
  

静态变量
//静态变量
public class a {
    int a1;
    static int a2;
    a() {
        a1++;
        a2++;
    }

}
public class b {
    public static void main(String[] args) {
        a b1 = new a();
        a b2 = new a();
        a b3 = new a();
    }
}
//运行结果：
1-1
1-2
1-3
//实例变量一直是1，每次创建一个新的对象，就会出现一个实例变量，构造方法中赋值是多少实列变量就是多少；
//静态变量只有一个，会一直叠加

//访问静态变量
public class b {
    public static void main(String[] args) {
        a.a2 = 100; //类名.静态变量
        System.out.println(a.a2); //输出100
    }
}静态方法
package test;
public class aaa {
    int a1;
    static int a2;
    void test1() {
        System.out.println(a1);
    }
    static void test2() { //静态方法
        //System.out.println(a1); //报错：a1是实例变量与对象有关，因静态方法不支持this.
        System.out.println(a2);
    }
}

package test;
public class StaticMethod {
    public static void main(String[] args) {
        aaa a1 = new aaa();
        a1.test1();
        aaa.test2(); //通过类名.方法名调用静态方法
    }
}
补充：静态块

• 静态块：static {}
  
• 一个类中可以有多个静态块，加载顺序由上到下
  
• 静态块和静态方法搭配使用
  
• 静态块和类一样，只在方法区加载一次
  

package test;
public class aaa {
    static int a1;
    static int a2;
    static {
        a1 = 1;
        a2 = 2;
    }
    static void test2() {
        System.out.println(a1 + "," + a2);
    }
}

package test;
public class StaticMethod {
    public static void main(String[] args) {
        aaa.test2();
    }
}final：

• final修饰的变量，变量的值不能被修改
  
• final修饰的方法不能重写
  
• final修饰的类不能被继承，可以继承其他类
  

static final（常量）:

• 声明的同时必须初始化
  
• 常量通过类名.常量名访问
  
• 常量的命名建议使用全大写，单词之间使用_分开
  
• 编译时Java会将常量直接替换成具体的值，效率高
  
• 程序运行时数据永远不变，且使用频率高的，适合作为常量
  

package test;
public class aaa {
    public static final double a1 = 1.23;
}

package test;
public class StaticMethod {
    public static void main(String[] args) {
        System.out.println(aaa.a1);
    }
}