修饰符

修饰符: 权限修饰符、状态修饰符

权限修饰符的分类: private、默认、protected、public

同包下: 除了不能访问private修饰的对象外，其他都可以访问 不同包下的有关类: 除了不能访问private修饰的对象和默认的对象，其他都可以访问 不同包下的无关类: 只能访问public修饰的对象

总结: 1、同一个类中可以访问谁修饰的对象: private、默认、protected、public 2、同一个包中的子类无关类可以访问谁修饰的对象: 默认、protected、public 3、不同包的子类可以访问谁修饰的对象: protected、public 4、不同包的无关类可以访问谁修饰的对象: public

状态修饰符的分类: final(最终态)、static(静态)

final关键字是最终的意思。可以修饰成员方法、成员变量、类

final修饰的特点: 1、如果修饰的是成员方法: 则表明该方法是最终方法，不能被重写 2、如果修饰的是成员变量: 则表明表示该变量是常量，不能被再次赋值 3、如果修饰的是类: 则表明该类是最终类，不能被任何子类继承

static关键字是静态的意思，可以修饰成员方法，成员变量 static修饰的特点，如下 1、被类的所有对象共享(这也是我们判断是否使用静态关键字的条件) 2、可以通过类名调用，也可以通过对象名调用。推荐使用类名调用

修饰符练习如下

xxxxxxxxxx
package ch7;

public class a_3_1Fu {  //下面只演示同包下的

    //private修饰的对象
    private void show1() {
        System.out.println("private");
    }

    //默认
    void show2() {
        System.out.println("默认");
    }

    //protected修饰的对象
    protected void show3() {
        System.out.println("protected");
    }

    //public修饰的对象
    public void show4() {
        System.out.println("public");
    }

    public static void main(String[] args) {
        //创建Fu的对象，测试看有哪些方法可以使用
        a_3_1Fu f = new a_3_1Fu();
        f.show1();
        f.show2();
        f.show3();
        f.show4();
    }
}

xxxxxxxxxx
package ch7;

//继承父类
public class a_3_2Zi extends a_3_1Fu {

    public static void main(String[] args) {
        //创建Zi的对象，测试看有哪些方法可以使用
        a_3_2Zi z = new a_3_2Zi();
        z.show2();
        z.show3();
        z.show4();
        //这里的子不能访问父中的show1()方法
    }
}

xxxxxxxxxx
package ch7;

public class a_3_3测试 {

    public static void main(String[] args) {
        //创建Fu的对象，测试看有哪些方法可以使用
        a_3_1Fu f = new a_3_1Fu();
        f.show2();
        f.show3();
        f.show4();
        //这里的子不能访问父中的show1()方法
    }
}

xxxxxxxxxx
package ch7;

public class a_3_4Fu {

    public void method() {
        System.out.println("父类-method方法");
    }

    //如果给上面加上final修饰符，如下。则子类里的的重写method就会报错，因为父类的method被final修饰了
    //子类里的的重写method会报错的根本原因: 被final修饰的方法叫最终方法，不允许被重写
    /*public final void method() {
        System.out.println("父类-method方法");
    }*/

//上面是方法被final修饰会导致的情况
//------------------------------------------------------------------------------------------------------
//下面是变量被final修饰会导致的情况

    public int age = 19;
    public void show() {

        //如果给age重新赋值，如下  会正常输出100
        age = 100;

        System.out.println(age);
    }

    //如果给上面的变量age加上final修饰符，如下。则下面的重写赋值就会报错，说明此时age变成了常量，不允许修值
    /*public final int age = 19;
    public void show() {

        //如果给age重新赋值
        age = 100;

        System.out.println(age);
    }*/

//上面是变量被final修饰会导致的情况
//------------------------------------------------------------------------------------------------------
//下面是类被final修饰会导致的情况

    //直接在类上加一个final，如下。这个不做具体演示
    /*public final void method2() {
        System.out.println("父类-method2方法");
    }*/

    //则子类会报错，因为这里的父类加了final就变成最终类，最终类不允许存在子类，所以子类继承不了父类
}

xxxxxxxxxx
package ch7;

//继承父类
public class a_3_5Zi extends a_3_4Fu {

    //重写父类的method方法
    @Override
    public void method() {
        System.out.println("子类重写父类的method方法");
    }

//上面是方法被final修饰会导致的情况
//------------------------------------------------------------------------------------------------------
//下面是变量被final修饰会导致的情况

//上面是变量被final修饰会导致的情况
//------------------------------------------------------------------------------------------------------
//下面是类被final修饰会导致的情况

    public void method2() {
        System.out.println("子类重写父类的method方法");
    }
}

x
package ch7;

public class a_3_6测试 {

    public static void main(String[] args) {

        //创建子类对象
        a_3_5Zi z = new a_3_5Zi();
        z.method();

//上面是方法被final修饰会导致的情况
//------------------------------------------------------------------------------------------------------
//下面是变量被final修饰会导致的情况

        z.show();

}

static静态修饰符的练习

xxxxxxxxxx
package ch7;

public class a_4_1Student {

    //定义三个成员变量
    public String name;
    public int age;

    //public String university;
    //如果让上面那行的university共享，即需要加上static状态修饰符，如下
    public static String university;

    public void show() {
        System.out.println(name + "," + age + "," + university);
    }
}

xxxxxxxxxx
package ch7;

public class a_4_2测试 {

    public static void main(String[] args) {

        //共享变量之后，只需要这里写一次。下面都不需要再写一遍
        a_4_1Student.university = "厦门大学";

        //学生对象
        a_4_1Student s1 = new a_4_1Student();
        s1.name = "张三";
        s1.age = 30;
        //共享变量之后，下面那行的university也不需要再赋值了。直接在上面输入a_4_1Student.university = "厦门大学"
        //s1.university = "厦门大学";
        s1.show();

        //学生对象
        a_4_1Student s2 = new a_4_1Student();
        s2.name = "李四";
        s2.age = 30;

        //共享变量之后，下面那行的university就不需要赋值了
        //s2.university = "厦门大学";
        s2.show();

        /*观察可发现，张三和李四都属于厦门大学，如何让university变量共享呢，避免重复输入，如下
        即在a_4_1Student文件里面定义university变量时加上static状态修饰符*/

    }
}

static访问特点的练习

非静态的成员方法: 1、能访问静态的成员变量 2、能访问非静态的成员变量 3、能访问静态的成员方法 4、能访问非静态的成员方法

静态的成员方法: 1、能访问静态的成员变量 2、能访问静态的成员方法

总结: 静态成员方法只能访问静态成员

小提示，建议品味一下: 1、先存在(先加载)的不可以访问后加载的，后存在的可以访问先存在的 2、执行加载时先加载类，static修饰的成员变量和成员方法属于类 3、随后加载，没有static修饰的成员变量和成员方法被调用时加载*/

注意我们平时写的main方法就是静态的

xxxxxxxxxx
package ch7;

public class a_5_1Student {

    //非静态成员变量
    private String name = "张三";
    //静态成员变量
    private static String university = "福建大学";

    //非静态成员方法
    public void show1() {
    }

    //非静态成员方法
    public void show2() {
        //访问非静态成员变量
        System.out.println(name);
        //访问静态成员变量
        System.out.println(university);
        //访问非静态成员方法
        show1();
        //访问静态成员方法
        show3();
    }

    //静态成员方法
    public static void show3() {
    }

    //静态成员方法
    public static void show4() {
        //访问非静态成员变量,报错，即不能访问
        //System.out.println(name);

        //访问静态成员变量
        System.out.println(university);

        //访问非静态成员方法,报错，即不能访问
        //show1();

        //访问静态成员方法
        show3();
    }
}