修饰符的分类

目录

3.修饰符

3.1修饰符的分类

3.2权限修饰符

3.3状态修饰符：

3.4final

3.5final修饰局部变量

3.6static

3.7static访问特点

---

3.修饰符

3.1修饰符的分类

修饰符分为两大类：

• 权限修饰符
• 状态修饰符

3.2权限修饰符

先到代码中演示再小结：

先准备两个包:

在第一个包中的操作:

public class Fu {
    //1.在Fu类里面有几个方法,看看有几个方法可以使用
    private void show1(){
        System.out.println("private");
    }
    void show2(){
        System.out.println("默认");
    }
    protected void show3(){
        System.out.println("protected");
    }
    public void show4(){
        System.out.println("public");
    }
    /*2.这四个方法分别用了四种权限修饰符，
    在不同的地方看看那些地方可以访问到这四种权限修饰符修饰的内容
     */

    //3.我们首先到父类里面看看能不能访问，首先要创建Fu的对象
    public static void main(String[] args) {
        Fu f = new Fu();
        f.show1();//private
        f.show2();//默认
        f.show3();//protected
        f.show4();//public
        //4.说明在本类中四种修饰符修饰的方法都可以访问到
    }
}
//5.接着在Zi类中继承Fu类看看
class Zi extends Fu {
    public static void main(String[] args) {
        //6.创建Fu类对象并调用方法
        Zi z = new Zi();
        //7.不显示show1，如果我们自己输入会显示报错
//      z.show1();//强制执行：java: 找不到符号
                //符号:   方法 show1()
                //位置: 类型为cn.itcast01.Zi的变量 z
        z.show2();//默认
        z.show3();//protected
        z.show4();//public
        //8.说明在继承中，这四种权限修饰符修饰过的方法除了private修饰过的方法不能访问，其余的都可以访问
    }
}
//9.在测试类中直接创建Fu类对象，通过对象调用方法
class Demo {
    public static void main(String[] args) {
        //10.创建Fu类对象并调用方法
        Zi z = new Zi();
        //11.不显示show1，如果我们自己输入会显示报错
//      z.show1();//强制执行：java: 找不到符号
        //符号:   方法 show1()
        //位置: 类型为cn.itcast01.Zi的变量 z
        z.show2();//默认
        z.show3();//protected
        z.show4();//public
        //12.说明在继承中，这四种权限修饰符修饰过的方法除了private修饰过的方法不能访问，其余的都可以访问
        //13.与Zi类同理
    }
}

 第二个包中的的操作:

//20.先导包
import com.itheima01.Fu;

//14.来看一下不同包下的Zi类继承Fu类可以访问那些方法
public class Zi extends Fu {
    public static void main(String[] args) {
        //15.创建Zi对象，调用方法
        Zi z = new Zi();
        //16.只有3和4方法
        z.show3();//protected
        z.show4();//public
        //17.如果强制执行1和2方法会报错
//         z.show1();
//         z.show2();
//        java: 找不到符号
//        符号:   方法 show1()
//        位置: 类型为cn.itcast02.Zi的变量 z

//18.跨包继承父类，子类只能访问后protected和public权限修饰符修饰的方法，默认都不行
    }
}

//19.在Demo类里面通过跨包创建Fu类对象看看
class Demo {
    public static void main(String[] args) {
        //21.创建itcast01中Fu类的对象
        Fu f = new Fu();
        f.show4();//public
        //22.只能访问public权限修饰符修饰符的方法
        //23.说明不同包下的无关的类它只能访问public修饰的
    }
}

小结:

3.3状态修饰符：

状态修饰符有两个：

• final（最终态）
• static（静态）

3.4final

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

程序中演示再总结：

 

//
    //1.Fu类里面有一个method方法
//    public void method(){
//        System.out.println("Fu method");
//    }
    //5.使用final修饰method方法
//    public final void method(){
//        System.out.println("Fu method");
//    }
//}
    //13.把上面的类和method方法注释掉,重新用final修饰Fu类
public final class Fu {
    public final void method(){
        System.out.println("Fu method");
    }
}
//14.这时继承这里就会报错了，因为Fu被final修饰说明它是最终类，最终类不可能有子类
//2.Zi类继承Fu类
class Zi{
    //7.我们在Zi类中定义一个变量和一个方法
//    public int age = 20;

    //11.使用final修饰变量
    public final int age = 20;//被final修饰过后age就变成常量，常量的值不能发生改变
    public void show(){
        //10.重新在方法内给age赋值为100
//        age = 100;//12.因为11.的操作这里就会报错，因为被final修饰的变量不能再赋值
        System.out.println(age);
    }

    //3.Zi改写Fu类method方法
    /*6.final修饰了Fu类method方法子类改写的method方法就会报错
    因为被final修饰的方法是最终方法，最终方法是不可以被重写的
     */
//    @Override
//    public void method(){
//        System.out.println("Zi method");
//    }
}
/*
    测试类
 */
class Demo {
    public static void main(String[] args) {
        //4.创建Zi类对象并调用方法
        Zi z = new Zi();
        /*9.因为final修饰了method方法，但是我们把Zi类中的重写方法注释掉了
        但是Zi继承了Fu类，Fu类里面有这个方法，所以还是可以用的因为final只是
        不可以重写，不是不可以访问
         */
//      z.method();//4. Zi method
        //9. Fu method
        //15.因为Zi类不能继承，所以z不能调用Fu类方法需要注释掉

        //8.我们再到测试内中调用show方法
        z.show();//8. 20
        //10. 100
    }
}

小结：

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

final修饰的特点：

• 修饰方法：表明该方法是最终方法，不能被重写
• 修饰变量：表明改变量是常量，不能再次被赋值
• 修饰类：表明该类是最终类，不能被继承

3.5final修饰局部变量

先到代码演示：

/*
    测试类
 */
public class FinalDemo {
    public static void main(String[] args) {
        //final修饰基本类型变量
        //1.给age赋值20
        //3.final修饰age
        final int age = 20;

        //2.给age赋值100
//      age = 100;//4.经过3的操作之后这里会报错，必须注释掉
        System.out.println(age);//1. 20 //2. 100


        //final修饰引用类型变量
        //6.创建Student对象
        //8.用final修饰引用类型的变量，s.age不会报错
        final Student s = new Student();
        //7.修改age的值为100
        s.age = 100;
        System.out.println(s.age);//6. 20,这个20是finaDemo中常量age的值
        //7.这一次输出100，
        //8.在控制台输出了100
        /*9.为什么用final修饰了引用类型变量s，age的值还可以改变呢？
        因为这个final修饰的是s，不是修饰的age，修饰s代表s的值不能变
        s的值是地址值，如果修改s的地址值就会报错
         */

        //10.修改s地址值
//      s = new Student();//报错：java: 无法为最终变量s分配值
    }
}

class Student {
    //5.定义一个变量，为了访问方便，用public修饰
    public int age = 20;
}

小结：

• 变量是基本类型：final修饰指的是基本类型的数据值不能发生改变。
• 变量是引用类型：final修饰指的是引用类型的地址值不能发生改变，但是地址值里面的内容是可以发生改变的。

3.6static

static关键字是静态的意思，可以修饰成员方法，成员变量。

先到代码演示再小结：

/*
    学生类
 */
public class Student {
    //1.学生类里面定义了三个成员变量和一个成员方法

    public String name;//姓名
    public int age;//年龄
//    public String university;//学校

    /*7.注释掉成员变量university，并改写加上static
    static表示共享的意思，也就是说university是被所有
    对象共享的
     */
    public static String university;

    public void show(){
        System.out.println(name+","+age+","+university);
    }
}
/*
    测试类
 */
class StaticDemo {
    public static void main(String[] args) {
        //10.在测试类中通过变量所在的类名给成员变量赋值，下面的都不给值了，就在这里给一次就可以了
        Student.university = "电子科技大学";
        //2.创建学生对象
        Student s1 = new Student();
        //3.直接通过对象给成员变量赋值,因为我们在学生类给的是public
        s1.name = "林青霞";
        s1.age = 30;
        /*9.一旦一个成员被静态修饰之后，我们不建议通过对象名去访问，
        虽然对象名可以访问，但是不建议。建议怎么访问呢？
        把下面通过对象访问university注释掉
        我们直接到最上面给它赋值*/

//        s1.university = "电子科技大学";
        //4.然后调用方法
        s1.show();//林青霞,30,电子科技大学


        //5.再来创建一个学生对象
        Student s2 = new Student();
        s2.name = "张曼玉";
        s2.age = 33;
        //8.因为s1对象给university变量赋值了，其他对象都是共享的，执行验证一下

//      s2.university = "电子科技大学";
        s2.show();//张曼玉,33,电子科技大学
        /*6.它们的姓名年龄的值是不一样的，但是它们都是来自同一个大学
        假如有很多学生都来自同一个大学如果每一个都这样写就太麻烦了有没有更简单的办法
        来写。比如我在s1对象赋值一次，后面都可以使用呢？我们把s2.university注释掉看看
        执行得到:张曼玉,33,null,发现张曼玉没有大学了，所以这样不行的，所以university这个变量
        不是这样来定义的，回到Student类中改写
         */
        //8.得到：张曼玉,33,电子科技大学

        /*10.执行没问题，所以被所有对象共享的成员，我们用静态修饰
        静态修饰过的成员可以通过对象名访问，也可以通过类名来访问，
        建议通过类名来访问
         */
    }
}

小结：

static关键字是静态的意思，可以修饰成员方法，成员变量。

static修饰的特点：

• 被类的所有对象共享：

这也是我们判断是否使用静态关键字的条件。

• 可以通过类名调用：

当然，也可以通过对象名调用。

推荐使用类名调用

3.7static访问特点

先到程序中演示再小结：

/*
    static访问特点
 */
public class Student {
    //非静态成员变量
    private String name = "林青霞";
    //静态成员变量
    private static String university = "电子科技大学";

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

    //非静态成员方法
    public void show2(){
        //1.非静态方法访问静态和非静态变量，没问题
        System.out.println(name);
        System.out.println(university);
        //2.非静态方法访问静态和非静态方法，不报错，没问题
        show1();
        show3();
        //3.由此可见一个非静态的成员方法它可以访问所有的静态和非静态的成员
    }

    //静态成员方法
    public static void show3(){
        //4.静态方法访问非静态变量，报错
//        System.out.println(name);
        //5.静态方法访问静态变量，没问题
        System.out.println(university);
        //6.静态方法访问非静态方法，报错
//        show1();
        //7.静态方法访问静态静态方法，没问题
        show4();
        //8.由此可见静态方法只能访问静态成员
    }

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

    }
}

小结：

非静态的成员方法：

• 能访问静态的成员变量
• 能访问非静态的成员变量
• 能访问静态的成员方法
• 能访问非静态的成员方法

静态成员方法：

• 能访问静态的成员变量
• 能访问静态的成员方法

总结成一句话就是：静态成员方法只能访问静态成员