Java学习之修饰符

2021-06-04

Java中修饰符的使用

1.Java权限修饰符

1.2Java_Modifier包下的Fu类

package Java_Modifier;
//父类

public class 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修饰");
    }

    public static void main(String[] args) {
        Fu f = new Fu();
        f.show1();
        f.show2();
        f.show3();
        f.show4();
    }
}

1.3Java_Modifier包下的Test_Demo类

package Java_Modifier;
//同包下并继承测试

public class Test_Demo extends Fu {
    public static void main(String[] args) {
        Fu f = new Fu();
        f.show2();
        f.show3();
        f.show4();
    }
}

1.4Java_Modifier包下的Test_Demo2类

package Java_Modifier;
//同包但没有关系下测试

public class Test_Demo2 {
    public static void main(String[] args) {
        Fu f = new Fu();
        f.show2();
        f.show3();
        f.show4();
    }
}

1.5Java_Modifier2包下的Test_Demo类

package Java_Modifier2;
import Java_Modifier.Fu;
//不同包导包下测试

public class Test_Demo {
    public static void main(String[] args) {
        Fu f = new Fu();
        f.show4();
    }
}

1.6Java_Modifier2包下的Test_Demo2类

package Java_Modifier2;
import Java_Modifier.Fu;
//不同包导包并继承测试

public class Test_Demo2 extends Fu {
    public static void main(String[] args) {
        Fu f = new Fu();
        f.show4();
    }
}

2.总结表格(在黑马老师的基础上有所修改)

修饰符	同一类中	同一个包中子类无关类	不同包的子类	不同包的无关类
private	√
默认	√	√
protected	√	√
public	√	√	√	√

3.Java中的final修饰符

3.1介绍final

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

3.2代码演示

package Java_Modifier3;

public final class Fu {
    public final void show(){
        System.out.println("Fu类内容");
    }
}

public class Zi extends Fu { //会报错：Cannot inherit from final 'Java_Modifier3.Fu'
    private final int age = 10;
    @Override
    public void show(){ //会报错：'show()' cannot override 'show()' in 'Java_Modifier3.Fu'; overridden method is final
        age = 20; //会报错：Cannot assign a value to final variable 'age'
        System.out.println("Zi类中的内容");
        System.out.println(age);
    }
}

public class Demo_1 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}

3.3 final修饰局部变量代码演示

package Java_Modifier4;

public class Demo_1 {
    public int age = 10;
}

public class Demo_2 {
    public static void main(String[] args) {
        //final修饰普通变量
        final int age = 30;
        //age = 40; //报错：Cannot assign a value to final variable 'age'
        System.out.println(age);
        //final修饰引用类型的变量
        final Demo_1 s = new Demo_1();
        System.out.println(s.age);
        s.age = 20;
        System.out.println(s.age);
    }
}

3.4 final修饰符总结

final修饰的特点

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

final修饰局部变量

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

4.static修饰符

4.1介绍

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

4.2代码演示1

package Java_Modifier5;

public class Phone {
    public String name;
    public int price;
    //使用static修饰品牌变量
    public static String brands;
}

public class Test {
    public static void main(String[] args) {
        //使用类名引用变量并赋值
        Phone.brands = "小米";
        Phone p_1 = new Phone();
        p_1.name = "小米4";
        p_1.price = 100;
        System.out.println(p_1.name + p_1.brands + p_1.price);
        Phone p_2 = new Phone();
        p_2.name = "小米6";
        p_2.price = 200;
        System.out.println(p_2.name + p_2.brands + p_2.price);
    }
}

4.3代码演示2

package Java_Modifier6;
//static访问特点

public class Demo_1 {
    //非静态成员变量
    private String name;
    //静态成员变量
    private static int age;
    //非静态成员方法1
    public void show1(){
        System.out.println(name);
        System.out.println(age);
        show1();
        show4();

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

    }
    //静态成员方法3
    public static void show3(){
//        System.out.println(name);
        System.out.println(age);
//        show1();
        show4();

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

    }

}

4.4总结

static修饰特点

被类的所有对象共享，这也是我们判断是否使用静态关键字的条件
可以通过类名调用，当然也可以通过类名调用，推荐使用类名调用

static访问特点

非静态的成员方法

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

静态成员方法

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

总而言之：静态成员方法只能访问静态成员