访问控制与封装、内存图

1. package 和 import       
   1. package: 1.作用 ：为了避免类名冲突
                      2.规定：同包中的类不能重名
                      3.类的全称：包名.类名  包名常常有层次结构
                      4.包名所有字母都小写
   2. import : 同包中的类可以直接访问，但不能包中的类不能直接访问，若想访问：

      • 先import导入类再访问类------建议

      • 类的全称----------------------------太繁琐，不建议

2. 访问控制修饰符

   1. public ：公开的 任何类     一般行为（方法）公开化

   2. private : 私有的 本类    一般 数据（成员变量）私有化

   3. protected：受保护的 本类、子类、同包类 之间是或者关系

   4. 默认的：什么也不写  本类、同包类
      注意：1.类的访问权限只能是public或默认的，
                 2.类中成员的访问权限如上4种都可以

3. final：最终的、不可改变的------------------单独应用几率低

   1. 修饰变量：变量不能被改变

   2. 修饰方法：方法不能被重写

   3. 修饰类：类不能被继承

4. static：静态的
   1. 静态变量

      1. 由static修饰

      2. 属于类，存储在方法区中，只有一份

      3. 常常通过类名点来访问

      4. 何时用：所有对象所共享的数据(图片、音频、视频等)
          

         class Loo{
             int a; //实例变量
             static int b; //静态变量
             Loo(){
                 a++;
                 b++;
             }
             void show(){
                 System.out.println("a="+a+"，b="+b);
             }
         }
         
         public class StaticDemo {
             public static void main(String[] args) {
                 Loo o1 = new Loo();
                 o1.show();
                 Loo o2 = new Loo();
                 o2.show();
                 Loo o3 = new Loo();
                 o3.show();
                 System.out.println(Loo.b); //常常通过类名点来访问
             }
         }

   2. 静态方法：

      1. 由static修饰

      2. 属于类，存储在方法区中，只有一份

      3. 常常通过类名点来访问

      4. 静态方法中没有隐式this传递，所以不能直接访问实例成员，只能直接访问静态成员

      5. 何时用：方法的操作与对象无关(不需要操作对象的数据)
          

         class Moo{
             int a; //实例变量(对象点来访问)
             static int b; //静态变量(类名点来访问)
         
             void show(){ //有隐式this
                 System.out.println(this.a);
                 System.out.println(Moo.b);
             }
             static void test(){ //没有隐式this
                 //静态方法没有隐式this传递
                 //没有this就意味着没有对象
                 //而实例变量a必须由对象点来访问
                 //所以如下语句发生编译错误
                 //System.out.println(a); //编译错误
                 System.out.println(Moo.b);
             }
         }
         
         //演示静态方法何时用
         class Noo{
             int a; //实例变量(描述对象的属性)
             //在show()中访问对象的属性a了，说明show()与对象有关，不能设计为静态方法
             void show(){
                 System.out.println(a);
             }
             //在plus()中并没有访问对象的属性，说明plus()与对象无关，可以设计为静态方法
             static int plus(int num1,int num2){
                 int num = num1+num2;
                 return num;
             }
         }
         
         public class StaticDemo {
             public static void main(String[] args) {
                 Moo.test(); //常常通过类名点来访问
             }
         }

   3. 静态块：

      1. 由static修饰

      2. 属于类，在类被加载期间自动执行，一个类只被加载一次，所以静态块只执行一次

      3. 何时用：初始化/加载静态资源(图片、音频、视频等)
          

         //演示静态块
         class Poo{
             static{
                 System.out.println("静态块");
             }
             Poo(){
                 System.out.println("构造方法");
             }
         }
         
         public class StaticDemo {
             public static void main(String[] args) {
                 //1)加载Poo.class到方法区中，同时自动执行静态块
                 //2)new Poo()时，自动调用构造方法
                 Poo o4 = new Poo();
                 //1)new Poo()时，自动调用构造方法
                 Poo o5 = new Poo();
                 //1)new Poo()时，自动调用构造方法
                 Poo o6 = new Poo();
             }
         }

内存图