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(){
....
}
}
