Java面向对象-package，import，访问控制修饰符，final，static关键字

package 关键字

• 用于声明包
• 作用：避免类的命名冲突
• 规则：同包中的类不能同名，不同包的类可以同名
• 类的全称：包名.类名
• 建议：包名常常有层次结构，所有字母都小写

import 关键字

• 用于导入类
• 同包中的类可以直接访问，但不同包中的类不能直接访问，若想访问：、
  1）类的全称----------------------------太繁琐，不建议
  2）先 import 导入类再使用类------建议

访问控制修饰符

• 作用：保护数据的安全（隐藏数据、暴露行为），实现封装
• 设计：
  1）数据（成员变量）私有化（private）
  2）行为（方法）大部分公开化（public）

共四种

1. public：公开的，任何类
2. private：私有的，本类
3. protected：受保护的，本类、子类、同包类
4. 默认的：什么也不写，本类、同包类

final 关键字

• 表示最终的、不可改变的
• 特点
  1. 修饰变量：变量不能被改变
  2. 修饰方法：方法不能被重写
  3. 修饰类：类不能被继承

static 关键字

• 表示静态的
• 可以设计
  1）静态变量
  2）静态块
  3）静态方法

静态变量

• 由static修饰的成员变量即为静态变量
• 成员变量分为两种：
  1）实例变量：没有static修饰，属于对象，存储在堆中，有几个对象就有几份，由对象/引用访问
  2）静态变量：有static修饰，属于类，存储在方法区中，只有一份，由类名访问

/** 静态变量的演示 */
public class StaticVar {
    int a;  //实例变量
    static int b;   //静态变量
    StaticVar(){
        a++;
        b++;
    }
    void show(){
        System.out.println("a="+a+",b="+b);
    }
}

public class StaticDemo {
    public static void main(String[] args) {
        StaticVar o1 = new StaticVar();
        o1.show();
        StaticVar o2 = new StaticVar();
        o1.show();
        StaticVar o3 = new StaticVar();
        o1.show();
        System.out.println(StaticVar.b);    //常常通过类名点来访问
    }
}

输出：

a=1,b=1
a=1,b=2
a=1,b=3
3

解释：
加载StaticVar.class到方法区中，其中存放了静态变量、构造方法以及其他的方法
new的对象存储在堆里，其中存放了实例变量、构造方法的地址以及其他方法的地址
new的对象的地址存放在栈里

• 何时用：对象所共享的数据

静态块

• 由static修饰的语句即为静态块
• 属于类，在类被加载期间自动执行，一个类只被加载一次，静态块只执行一次

public class StaticBlock {
    static{
        System.out.println("静态块");
    }
    StaticBlock(){
        System.out.println("构造方法");
    }
}

StaticBlock o4 = new StaticBlock();
StaticBlock o5 = new StaticBlock();
StaticBlock o6 = new StaticBlock();

输出：

静态块
构造方法
构造方法
构造方法

• 何时用：初始化 / 加载静态资源

public class Student {
    // 实例变量
    String name;
    int age;
    String stuld;
    
    // 静态变量
    static String className;
    
    // 静态初始化块
    static {
        className = "jsd2302";
    }
    
    // 构造方法
    public Student(String name, int age, String stuld) {
        this.name = name;
        this.age = age;
        this.stuld = stuld;
    }
}

静态方法

• 由static修饰的方法即为静态方法
• 属于类，存放在方法区中，只有一份
• 常常通过类名点来访问

/** 静态方法 */
public class StaticMethod {
    int a;  //实例变量（对象来访问）
    static int b;   //静态变量（类名来访问）
    
    void show(){    //有隐式this
        System.out.println(this.a);
        System.out.println(StaticMethod.b);
    }

    static void test(){ //没有隐式this
        //静态方法中没有隐式this传递
        //没有this就意味着没有对象
        //而实例变量a必须通过对象来访问
        //所以如下语句会发生编译错误
        //System.out.println(a);  //编译错误，静态方法中不能直接访问实例成员
        System.out.println(StaticMethod.b);
    }
}

• 何时用：方法的操作与对象无关（不需要访问对象的属性 / 行为）

static final 常量

• 由static和final共同修饰的成员变量，即为常量
• 建议：常量名所有字母都大写，多个单词之间用_分隔（NAME，CLASS_NAME）
• 必须声明同时初始化
• 常常通过类名来访问，不能被改变
• 常量在编译时，会将常量直接替换为具体的数，效率高

/** static final 常量的演示 */
public class StaticFinalDemo {
    public static void main(String[] args) {
        System.out.println(Loo.PI); //常常通过类名来访问
        //Loo.PI = 3.1415926; //编译错误，常量不能被改变

        //1)加载Loo.class到方法区中
        //2）静态变量num一并存储到方法区中
        //3）到方法区中获取num的值并输出
        System.out.println(Loo.num);

        //编译器在编译时会将常量直接替换为具体的数，效率高
        //相当于System.out.println(5);
        System.out.println(Loo.COUNT);
    }
}

class Loo{
    public static final double PI = 3.14159;
    //public static final int NUM;    //编译错误，常量必须声明同时初始化

    public static int num = 5;  //静态变量
    public static final int COUNT = 5;  //常量（静态常量）
}

• 何时用：在程序运行过程中数据永远不变，并且经常使用

补充

1. 必须是先package，然后import，最后class
2. 接口中的成员的默认权限为public
3. 重写方法时派生类的访问权限必须大于或者等于超类的方法
4. 接口的补充：

/** 接口的补充 */
public interface InterMore {
    void show();    //抽象方法，默认为public abstract-------最常用
    
    int NUM = 5;    //常量，默认public static final--------很少用
    static void test(){}    //静态方法，默认public----------很少用
    //private void sayHi(){}  //私有方法，jdk1.9开始支持-----很少用
}