访问修饰符：

​ 给程序中某个元素(如方法，变量等)定性，就可以使用修饰词

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.tests;

import java.util.Arrays;

public class Modifier {
    public final static int C=15;
    int[] arr={9,5,7,6,3,1};

    public static void main(String[] args) {
        Modifier m=new Modifier();
        Arrays.sort(m.arr);
        System.out.println(Arrays.toString(m.arr));
        System.out.println(C);
    }
}

这个程序中使用了大部分常见的修饰词.

package:

​ 用来指示程序所在的包，管理文件，区分类全名.

​ 书写位置:程序最顶端，即第一行第一句.

​ 命名规则:域名后缀.域名.项目名.模块名;

1
package com.tests

import:

​ 用来导入所需要的程序，若使用import声明了所需要的类，有利于减少工作量

1
import java.util.Arrays;

​ 引入了java.util包下Arrays类；(包名就是文件夹名，类名就是包下的.java文件)

访问权限修饰符

​ 用来控制相应元素的可见范围和访问权限，

  1. public
  2. protected
  3. default(默认)
  4. private

修饰类：

​ 外部类：public befault 可用;

​ 内部类：所有（内部类，同一个源文件下不同文件名的类）

修饰成员变量:

​ 所有，可见范围不同

本类中 同一个包中 不同包子类 不同包的其他类中
public 可见 可见 可见 可见
protected 可见 可见 可见 不可见
default 可见 可见 不可见 不可见
private 可见 不可见 不可见 不可见

修饰方法:

​ 可见性同修饰成员变量，但是有不同点

​ 父类的私有方法子类不能重写

应尽量使用private修饰成员变量，可以提高代码的安全性.

为了在其他类中可以对成员变量重新设置值获取值，我们可以定义相应成员变量的共有方法进行操作.即Get/Set方法

1
2
3
4
5
6
7
8
9
10
11
12
13
private String name;

public void setName(String name){

    this.name=name//修饰成员变量的值.

}

public String getName(){

    return name;

}

final:

​ 修饰类：该类不能有子类，即不能被继承.

​ 修饰成员变量：可以直接初始化，也可以在构造器初始化，但是不能再次赋值.

​ 修饰局部变量：只能初始化一次.

​ 修饰方法：不能在子类中被重写，只能被使用

static：

​ 意思是静态的.

​ 修饰成员变量:

  • 不属于对象的数据结构
  • 属于类的，通常使用类名调用.
  • 静态变量与类的信息一起存在方法区中，只存在一份，是对象的公共资源.

​ 修饰方法:

  • 通常的方法：都是与具体对象有关系，即对象的方法（行为）

  • static方法，与具体对象无关，是类的方法，常用类名去调用， 常与参数有关系

  • static方法内因为无法使用this关键字，所以不能直接访问非静态成员变量与方法.

  • 静态方法的作用:一般用于设计成工具方法和工厂方法.

    工具方法：Arrays.sort(); Math.random();

​ 修饰代码块

1
2
3
static{

}
  • 存储在方法区中，只加载一次，与对象无关.
  • 执行时机为加载类的信息期间，指的是在实例化之前加载.
  • 通常用于加载程序中所需的静态资源，如图片，音频等

运行时机：实例化之前执行，每次实例化之前都会执行一次

下面写一个实例，体会一下static的用法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class StaticTest {
    static int num = 0;
 
    public StaticTest(){
        num++;
    }

    static{
        System.out.println("静态代码块中的内容");
    }

    public void outPut(){
        System.out.println("普通方法中的内容");
    }

    public static void staticFun(){
        System.out.println("静态方法中的内容");
    }

    public static void main(String[] args) {
        StaticTest st1=new StaticTest();
        st1.outPut();
        //st1.staticFun;  //无法这么调取静态方法.
        StaticTest.staticFun();
        System.out.println("第一次new后num的值为:"+StaticTest.num);
        StaticTest st2=new StaticTest();
        st2.outPut();
        System.out.println("第二次new后num的值为:"+num);
        StaticTest st3=new StaticTest();
        st3.outPut();
        System.out.println("第三次new后num的值为:"+num);
    }
}

运行之后的结果为:

1
2
3
4
5
6
7
8
静态代码块中的内容
普通方法中的内容
静态方法中的内容
第一次new后num的值为:1
普通方法中的内容
第二次new后num的值为:2
普通方法中的内容
第三次new后num的值为:3

可以看到静态代码块中的内容被最先执行，被定义为static的变量num每次new之后都会+1，且静态方法只能由类名调用.

常量:

一般是一些特殊的值，一般使用成员变量，用类名调取，声明时必须初始化

修饰词为public static final 变量名

命名时字母全部大写.

如:Math.PI;圆周率