Java修饰符和关键字

1、private：只能在本类中访问，子类不能继承访问。

public class People {
    String name;
    private int age;
}

public class Test {
    public static void main(String[] args) {
        People p = new People();
        p.age = 12;//报错
    }
}

可以在类中定义两个方法，用于给变量赋值和取值，因为是在类中的方法，所以可以访问变量。

public class People {
    String name;
    private int age;

    public void setAge(int age) {
        this.age = age;
    }

    public void getAge() {
        System.out.println(age);
    }
}

public class Test {
    public static void main(String[] args) {
        People p = new People();
        p.setAge(12);
        p.getAge();
    }
}

private并不能修饰外部类，对于顶层类(外部类)来说，只有两种修饰符：public和默认(default)，因为外部类的上一单元是包，所以外部类只有两个作用域：同包，任何位置。因此，只需要两种控制权限：包控制权限和公开访问权限，也就对应两种控制修饰符：public和默认(default)。但是private是可以修饰class的，只不过该类不能使顶层类，可以是内部类，内部类的上一级是外部类，那么对应的有四种访问控制修饰符：本类(private)，同包(default)，父子类(protected)，任何位置(public)。当一个内部类使用了private修饰后，只能在该类的外部类内部使用

2、public：可以跨包跨类访问

3、protected：不可以修饰类，所处理的是所谓“继承”的观念。对于同一包的其他类，protected＝默认，其它类可访问protected。对于不同包的类，继承的子类可以访问，而不同包的其他类则不能访问类的protected属性。

4、default：包内可见，修饰的类可以在同一个包中被实例化；不同包的子类不能访问。

权限大小：public>protectde>default>private

注意：

1.并不是每个修饰符都可以修饰类（指外部类），只有public和default可以。

2.所有修饰符都可以修饰成员变量，方法成员，构造方法。

3.为了代码安全起见，修饰符不要尽量使用权限大的，而是适用即可。比如，数据成员，如果没有特殊需要，尽可能用private.

4.修饰符修饰的是“被访问”的权限。

5、final关键字

final的意思是不可变，他可以修饰类、字段、方法。修饰类后类不能被扩展，也就是不能继承。修饰字段后字段的值不能被改变，因此如果有final修饰字段，应该对字段进行手动初始化。修饰方法后该方法不能被改变，也就是重写,但可以被继承。final不能用于修饰构造方法，构造器不是通过继承得到的，所以没有必要把它声明为final的。。如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。

6、abstract关键字

abstract是抽象的意思，用来修饰类和方法，修饰类后，该类为抽象类，不能被实例化，必需进行扩展。修饰方法后，该方法为抽象方法必须被子类重写（override）。

抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象类。方法抽象后类也无法是具体的，只能抽象。

抽象类不能被定义为private、final和static类型。

抽象类有构造方法，但不能创建对象。

抽象类就是为了继承而存在的，如果你定义了一个抽象类，却不去继承它，那么等于白白创建了这个抽象类

如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。如果子类没有实现父类全部的抽象方法，则必须将子类也定义为为abstract类。

一个类只能继承一个抽象类，而一个类却可以实现多个接口。

接口：

定义变量：public static final,不写的话编译器会加上
定义方法：public abstract

实现了接口的类必须实现接口中所有的抽象方法，否则这个类是抽象类。接口可以是多实现，因为接口中的方法没有具体实现，所以多实现的接口中有同名方法也没关系，有实现的类具体实现就可以了。

接口可以继承接口，并且可以多继承接口，实现了接口的类必须实现所有继承的接口。

7、static关键字

static用来修饰内部类，方法，字段。修饰内部类说明该内部类属于外部类而不属于外部类的某个实例。修饰字段说明该字段属于类而不属于类实例。修饰方法说明该方法属于类而不属于类实例。当某个方法不需要访问类中的成员变量，就可以用静态修饰，静态随着类的加载就加载了。

java 中的static关键字有两种作用，作用一是：只想为某特定域分配单一的存储空间，而不去考虑究竟要去创建多少对象，甚至不需要去创建对象。作用二是：希望某个方法不与包含它的类的任何对象关联在一起。也就是即不创建这个类的对象也能调用其中的方法。

静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类不带static的成员变量和成员方法，只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联！当对象生成，才会生成实例成员。static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。

• 静态变量在内存中只有一个拷贝，在类的所有实例中共享。

• 在静态方法中不能直接访问实例方法和实例变量，反之可以。

• 在静态方法中不能使用this和super关键字。

• 静态方法不能被abstract修饰。

• 静态方法和静态变量都可以通过类名直接访问

• 当类被加载时，静态代码块只被加载一次。类中不同的静态代码块按它们在类中出现的顺序依次执行。还有一种叫构造代码块，不带static关键字，只要类一实例化就调用

{
System.out.println(“类实例化时就调用”);
}

public class Test1 {
    static int i = 60;

    void fun() {
        for (i = 0; i < 3; i++) { // i=2以后继续执行，i=3?不执行，但此时i=3
            System.out.println(i); // 另外，for（）里并没有int i=0；所以仍然是静态变量，不是局部变量
        }
    }

    public static void main(String[] args) {
        Test1 guan = new Test1();
        guan.i = 30; // i=30
        guan.fun(); // i=3
        System.out.println(i);
    }
}// 最后输出i为3

静态变量和成员变量的区别：
静态变量属于类，成员变量属于对象；
静态变量可以被类和对象调用，成员变量只能被对象调用；
静态变量随着类的加载而加载，成员变量随着对象的加载而加载；
静态变量存储在方法区，成员变量存储在堆内存；