static，final和访问控制修饰符

访问权限常规设置模式：

• 数据(成员变量)私有化(private)
• 行为(方法)公开化(public)------------------绝大部分方法都是公开的

 

成员变量分两种：

• 实例变量：没有static修饰，属于对象的，存储在堆中，有几个对象就有几份
  通过对象/引用打点来访问
• 静态变量：有static修饰，属于类的，存储在方法区中，只有一份
  常常通过类名点来访问

访问控制修饰符：------------------保护数据的安全

• public：公开的，任何类
• private：私有的，本类
• protected：受保护的，本类、派生类、同包类
• 默认的：什么也不写，本类、同包类
  说明：
  1. java不建议默认访问权限
  2. 类的访问权限只能是public或默认的，类中成员的访问权限如上4种都可以
  3. 访问权限由小到大依次为：private<默认的<protected<public

//访问控制符的演示

public class A {

    public int a;     //任何类

    protected int b;  //本类、派生类、同包类

    int c;            //本类、同包类

    private int d;    //本类

 

    void show(){

        a = 1;

        b = 2;

        c = 3;

        d = 4;

    }

}

 

class B{ //---------------------private

    void show(){

        A o = new A();

        o.a = 1;

        o.b = 2;

        o.c = 3;

        //o.d = 4; //编译错误

    }

}

 

package oo;

import oo.Aoo;

public class C { //---------------演示同包

    void show(){

        A o = new A();

        o.a = 1;

        //o.b = 2; //编译错误

        //o.c = 3; //编译错误

        //o.d = 4; //编译错误

    }

}

 

class D extends A{ //跨包继承---------protected

    void show(){

        a = 1;

        b = 2;

        //c = 3; //编译错误

        //d = 4; //编译错误

    }

}

 

 

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

• 修饰变量：变量不能被改变

class E{

    int a = 5;

    final int b = 5;

    void show(){

        a = 55;

        //b = 55; //编译错误，final修饰的变量，不能被改变

    }

}

 

 

• 修饰方法：方法不能被重写

class F{

    void show(){}

    final void test(){}

}

class G extends F{

    void show(){}

    //void test(){} //编译错误，final修饰的方法，不能被重写

}

 

 

• 修饰类：类不能被继承

final class H{}

//class I extends H{} //编译错误，final的类不能被继承

class J{}

final class K extends J{} //正确，不能当老爸，但能当儿子

 

 

static：静态的

• 静态变量：
  • 由static修饰
  • 属于类，存储在方法区中，一份
  • 常常通过类名点来访问
  • 何时用：所有对象所共享的数据(图片、音频、视频等)

//演示静态变量

class L{

    int a;

    static int b;

    L(){

        a++;

        b++;

    }

    void show(){

        System.out.println("a="+a+",b="+b);

    }

}



public class StaticDemo {

    public static void main(String[] args) {

        L o1 = new L();

        o1.show();

        L o2 = new L();

        o2.show();

        L o3 = new L();

        o3.show();

        System.out.println(L.b); //常常通过类名点来访问

    }

}

 

 

• 静态方法：

  • 由static修饰
  • 属于类，存储在方法区中，一份
  • 常常通过类名点来访问
  • 静态方法中没有隐式this传递，所以不能直接访问实例成员，只能直接访问静态成员
  • 何时用：方法的操作与对象无关----方法中不需要访问对象的属性或行为

//演示静态方法

class M{

    int a; //实例变量(对象来访问)

    static int b; //静态变量(类名来访问)

    void show(){ //有隐式this

        System.out.println(this.a);

        System.out.println(M.b);

    }

    static void test(){ //没有隐式this

        //静态方法中没有隐式this传递

        //没有this就意味着没有对象

        //而实例成员a必须通过对象来访问

        //所以如下语句会发生编译错误

        //System.out.println(a); //编译错误

        System.out.println(M.b);

    }

}

//演示静态方法的应用场景

class N{

    int a; //实例变量---描述对象的属性

    //show()方法中需要访问对象的属性a，说明show()的操作与对象有关---不能静态方法

    void show(){

        System.out.println(a);

    }

    //plus()方法中不需要访问对象的属性和行为，说明plus()的操作与对象无关-可以静态方法

    static void plus(int num1,int num2){

        int num=num1+num2;

        System.out.println(num);

    }

}

public class StaticDemo {

    public static void main(String[] args) {

        N.plus(5,7); //常常通过类名点来访问

    }

}

 

 

• 静态块：

  • 由static修饰
  • 属于类，在类被加载时自动执行，因为一个类只被加载一次，所以静态块也只执行一次
  • 何时用：加载/初始化静态资源(图片、音频、视频等)

//演示静态块

class P{

    static{

        System.out.println("静态块");

    }

    P(){

        System.out.println("构造方法");

    }

}

public class StaticDemo {

    public static void main(String[] args) {

        P o4 = new P();

        P o5 = new P();

    }

}