java 修饰符
Java提供了许多种修饰符,主要分为两类:
一:访问修饰符
二:非访问修饰符
访问控制修饰符
Java中有四种访问控制修饰符,用来保护对于类、变量、方法以及构造方法的访问。
private : 在同一类里可见。可以修饰:变量,方法,内部类。
default(什么也不写): 在同一包里可见。可以修饰:类,接口,变量,方法。
protected :对同一包内的类和所有子类可见。可以修饰:变量,方法,内部类。
public :对所有的类可见。可以修饰:类,接口,变量,方法。
修饰符 | 当前类 | 同一包内 | 子孙类 (不同包) | 其他包 |
---|---|---|---|---|
public | Y | Y | Y | Y |
protected | Y | Y | Y | N |
default | Y | Y | N | N |
private | Y | N | N | N |
class A {
/*
* private,默认,protected,public修饰变量
*/
private int a;
int b;
protected int c;
public int d;
//private 修饰构造方法
private A() {
super();
}
//默认的构造方法
A(int a) {
super();
this.a = a;
}
//protected 修饰构造方法
protected A(int a, int b) {
super();
this.a = a;
this.b = b;
}
//public 修饰构造方法
public A(int a, int b, int c, int d) {
super();
this.a = a;
this.b = b;
this.c = c;
this.d = d;
}
//private 修饰方法
private void method() {
}
//默认的方法
void method2() {
}
//protected 修饰方法
protected void method3() {
}
//public 修饰方法
public void method4() {
}
//private 修饰内部类
private class C{
}
//protected 修饰内部类
protected class D{
}
}
//public 修饰类
public class B {
}
//默认 修饰接口
interface C{
}
//public 修饰接口
public interface D {
}
注意:一个.java文件中只能有一个public类,且和文件名相同。
非访问控制修饰符
static :静态的:
修饰的成员被称为类成员,类成员属于整个类,不属于单个对象。所以类成员不能访问实例成员。
静态内容随着类的加载而加载,且只加载一次。
可修饰的内容
属性、方法、代码块、内部类
静态变量
static关键字用来声明独立于对象的静态变量,无论类实例化多少个对象,静态变量只有一个(被所有实例化对象共享)。静态变量也被称为类变量。局部变量不能被声明为静态变量。
所以当一个实例化对象改变静态变量时,所有实例化对象调用此静态变量的值是被修改过的。
静态方法
static关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。
对静态变量和静态方法可以直接使用类.静态变量
和类.静态方法
的方式来使用。
public class StaticUse {
private static int m = 100;
public StaticUse() {
addM();
}
public static int getM() {
return m;
}
public static void addM() {
m++;
}
public static void main(String[] args) {
System.out.println("m = " + StaticUse.getM());
new StaticUse();
System.out.println("m = " + StaticUse.getM());
}
}
运行结果
final修饰符
final:最终的
可修饰的内容
变量、方法、类
#### final变量
变量一旦被赋值后,不能够被重新赋值。
1.final修饰属性:赋值的位置:显式初始化、代码块中初始化、构造器中初始化
2.final修饰局部变量:
final 修饰符通常和 static 修饰符一起使用来创建类常量。
public class D{
//显式初始化a
final int a = 10;
final int c;
final int d;
//代码块中初始化d
{
d = 50;
}
//下面是两个全局常量
public static final int CONSTANT = 20;
static final String TITLE = "去扰嶟";
//构造器中初始化c
public D(){
final int b = 30;
c = 40;
}
}
final方法
父类中的final方法可以被子类继承,不能被子类重写。
public class A{
public final void method(){
}
}
final类
final类不能被继承。
public final class A{
}
abstract修饰符
abstract:抽象的
可修饰的内容
方法、类
abstract 修饰类
抽象类不能用来实例化对象。
抽象类中有构造方法,子类可在实例化时调用。
abstract class A{
public abstract void a();//抽象方法
}
abstract 修饰方法
抽象方法只有方法的声明,没有方法体,方法的具体实现由子类重写。
抽象方法不能被声明为final和static。
有抽象方法的类一定是抽象类,抽象类可以不包含抽象方法。
public abstract class A{
abstract void a();//抽象方法
}
class B extends A{
//重写抽象方法
@Override
void a(){
....
}
}