修饰符和关键字

原创

转眼花落纷飞 2022-05-30 14:50:42 博主文章分类：Java面向对象 ©著作权

文章标签 代码块类变量初始化 文章分类 虚拟化云计算

©著作权归作者所有：来自51CTO博客作者转眼花落纷飞的原创作品，请联系作者获取转载授权，否则将追究法律责任

修饰符和关键字

访问修饰符基本介绍
静态变量(类变量static)

语法
访问类变量的方法
注意事项

静态方法(类方法static)

语法
类方法的调用
收学费练习题
类方法使用场景

开发工具类

注意事项
练习

代码块

基本介绍
语法
代码块的好处
使用注意事项和细节

final关键字

基本介绍
使用场景
注意事项和细节
练习

访问修饰符基本介绍

java介绍四种访问控制修饰符号控制方法和属性（成员变量）的

访问权限（范围）：

1.公开级别：用public修饰，对外公开

2.受保护级别：用protected修饰，对子类和同一个包中的类公开

3.默认级别：没有修饰符号（default），向同一个包的类公开

4.私有级别：private修饰，只有类本身可以访问

修饰符和关键字_代码块

静态变量(类变量static)

静态变量也叫类变量，是该类的所有对象共享的变量，任何一个该类的对象去访问它时

，取到的都是相同的值，同样任何一个该类的对象区修改它时，修改的也是同一个变量

语法

访问修饰符 static 数据类型 变量名;[主推]
static 访问修饰符 数据类型 变量名;

访问类变量的方法

类名.类变量名或者对象名.类变量名（静态变量的访问修饰符的访问权限和范围

和普通属性是一样的）

public class VisitStatic {
    public static void main(String[] args) {
        //类名.类变量名
        //说明：类变量是类的加载而创建，所以没有创建对象实例化也可以访问
        System.out.println(A.name);
        A a = new A();
        //对象名访问
        System.out.println("a.name"+" "+a.name);
    }
}
class A{
    //类变量
    //类变量的访问，必须遵守 相关的访问权限
    public static String name = "java程序";
    //普通属性/普通成员变量/非静态属性/非静态成员变量
    private int num = 10;
}

注意事项

1.什么时候需要类变量

当我们需要让某个类的了所有对象都共享一个变量时，就可以实用类变量(静态变量)

2.类变量与实例变量(普通属性)区别

类变量是该类的所有对象共享的，而实例变量是每个对象独享的。

3.加上static称为类变量或静态变量，否则称为实例变量/普通变量/非静态变量

4.类变量可以通过类名.类变量名或者对象名.类变量名来访问

(类变量的访问，必须遵守相关的访问权限)。

5.实例变量不能通过类名.类变量名方式访问

6.类变量是在类加载时就初始化了，那么即使你没有创建对象，只要类加载了，

就可以使用类变量

7.类变量的生命周期是随类的加载开始，随着类消亡而销毁

静态方法(类方法static)

静态方法也叫类方法，是该类的所有对象共享的方法，任何一个该类的对象去访问它时

，取到的都是相同的值，同样任何一个该类的对象区修改它时，修改的也是同一个方法

语法

访问修饰符 static 数据返回类型 方法名(){}
static 访问修饰符 数据返回类型 方法名(){}

类方法的调用

类名.类方法名 or 对象名.类方法名(准则是得满足访问修饰符的访问权限和范围)

收学费练习题

public class StaticMethod {
    public static void main(String[] args) {
        Stu tom = new Stu("tom");
        Stu.payFee(100);

        Stu jack = new Stu("jack");
        jack.payFee(200);

        //输出总学费
        Stu.showFee();
    }
}
class Stu{
    private String name;//普通成员
    //定义静态变量，来累积学生的学费
    private static double fee = 0;

    public Stu(String name) {
        this.name = name;
    }
    //静态方法
    //静态方法可以访问静态属性
    public static void payFee(double fee){
        Stu.fee += fee;//累计到
    }
    public static void showFee(){
        System.out.println("学校收到"+"总学费"+" "+Stu.fee);
    }
}

类方法使用场景

当方法不涉及到任何和对象相关的成员，则可以将方法设计成静态方法，提高开发效率

准确的说是把通用的方法设计成静态方法，这样就不需要创建对象就可以使用

工具类中的方法utils Math类、Collections集合类

每个工具类都有静态方法，使用该方法可以直接该类.方法名()即可使用

开发工具类

开发自己的工具类时，可以将方法做成静态的，方便调用

class MyTools{
    //求两个数的和
    public static double sum(double n1,double n2){
        return n1 + n2;
    }
}
public class StaticMethod {
    public static void main(String[] args) {
        //调用求和方法
        System.out.println(MyTools.sum(12,20));
    }
}

注意事项

1.类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区

类方法中无this的参数，普通方法中隐含着this的参数

2.类方法可以通过类名调用，也可以通过对象名调用

3.普通方法和对象有关，需要通过对象名调用，比如对象名.方法名(参数)，不能通过类名

调用。

4.类方法中不允许使用和对象有关的关键字，比如this和super。普通方法(成员方法)可以。

5.类方法(静态方法)中只能访问静态变量 or 静态方法。(必须遵守访问权限)

6.普通成员方法，既可以访问普通变量(方法)，也可以访问静态成员和非静态成员(必须遵守访问权限)

练习

public class Excerse1 {
    public static void main(String[] args) {
        new Test().count();
        new Test().count();
        System.out.println(Test.count);
    }
}
class Test{
    static int count = 8;
    public void count(){
        System.out.println("count = "+(count++));
    }
}

public class Excerse2 {
    public static void main(String[] args) {
        System.out.println("Number olf total is "+Person.getTotalPerson());
        Person p1 = new Person();
        System.out.println("Number olf total is "+Person.getTotalPerson());
    }
}
class Person{
    private int id;
    private static int total = 0;

    public static int getTotalPerson() {
        return total;
    }

    public Person() { //构造器
        total++;   //total = 1
        id = total;  //id = 1
    }
}

代码块

基本介绍

代码化块又称初始化块，属于类中的成员[是类的一部分]，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来。

但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显示

调用，而是加载类时，或创建对象时隐式调用。

语法

[修饰符]{代码}

注意：

1.修饰符可选，要写也只能写static

2.代码块分为两类，使用static修饰的叫静态代码块，没有static修饰的，叫普通代码块。

3.代码中可以为任何逻辑语句（输入、输出、方法调用、循环、判断等）

代码块的好处

1.相当于另外一种形式的构造器（对构造器的补充机制），可以做初始化的操作

2.场景：如果多个构造器中都有重复的语句，可以抽取到初始化块中，

提高代码的重用性(代码块优先于构造器被调用)

public class Codestatic {
    public static void main(String[] args) {
        move move1 = new move("左耳");
        move move2 = new move("钢铁侠",56);
        move move3 = new move("蜘蛛侠",200,"观看结束");

    }
}
class move{
    private String name;
    private  double price;
    private String director;
    
    //代码块优先于构造器，代码块先被调用
    {
        System.out.println("我打开电影界面");
        System.out.println("门票价格");
        System.out.println("电影结束");
    }
    public move(String name) {
        System.out.println("1被调用");
        this.name = name;
    }

    public move(String name, double price) {
        System.out.println("2被调用");
        this.name = name;
        this.price = price;
    }

    public move(String name, double price, String director) {
        System.out.println("3被调用");
        this.name = name;
        this.price = price;
        this.director = director;
    }
}

使用注意事项和细节

1.static代码块也叫静态代码块，作用是对类进行初始化，它随着类的加载

而执行，只会执行一次。普通代码块，每创建一个对象，就执行。

静态初始化块优先于普通初始化块。

2.类会在[创建对象实例时(new )]、[创建子类对象实例，父类也会被加载]、

[使用类的静态成员时(静态属性、静态方法)] 被加载。

3.普通的代码块，在创建对象实例时，会被隐式的调用。

被创建一次，就会调用一次。

如果只是使用类的静态成员时，普通代码块并不会执行

4.创建一个对象时，在一个类调用顺序是：

(1).调用静态代码块和静态属性初始化（注意：静态代码块和静态属性初始化调用的优先级一样

，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用）

(2).调用普通代码块和普通属性的初始化（注意：普通代码块和普通属性初始化

调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按照

定义顺序调用）

(3).调用构造方法

5.构造器的最前面其实隐含一个super()和调用普通代码块，

静态相关的代码块，属性初始化，在加载时，就执行完，

因此优先于构造器和普通代码块执行的

6.创建一个子类时，他们的静态代码块，静态属性初始化，普通代码块，

普通属性初始化，构造方法的调用顺序如下：

(1)父类的静态代码块和静态属性（优先级一样，按照定义顺序执行）

(2)子类的静态代码块和静态属性（优先级一样，按照定义顺序执行）

(3)父类的普通代码块和普通属性初始化（优先级一样，按照定义顺序执行）

(4)父类的构造方法

(5)子类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）

(6)子类的构造方法

7.静态代码块只能直接调用静态成员（静态属性和静态方法）,普通

代码块可以调用任意成员

final关键字

基本介绍

final中文意思是最终的，最后的

final可以修饰类、属性、方法、和局部变量

使用场景

1.当不希望类被继承时，可以使用final修饰

2.当不希望父类的某个方法被子类覆盖/重写（override）时，可以用final关键字修饰

3.当不希望类的某个属性的值被修改，可以用final修饰。

4.当不希望某个局部变量被修改，可以使用final修饰

注意事项和细节

1.final修饰的属性又叫常量；

2.final修饰的属性在定义时，必须赋初值，并且以后不能在修改，赋值

可以在如下位置之一【选择一个位置赋初值即可】

1).定义时：如public final double Taxdes = 0.08;

2).在构造器中

3）在代码块中

3.如果final修饰的属性是静态的，则初始化的位置只能是

1).定义时 2).在静态代码块不能在构造器中赋值。

4.final类不能继承，但是可以实例化对象

5.如果类不是final类，但是含有final方法，则该方法虽然不能重写，

但是可以被继承

6.如果一个类已经是final类了，不需要再将方法修饰成final方法

7.final不能修饰构造方法（构造器）

8.final和static往往搭配使用，效率更好，不会导致类加载(针对静态方面)，底层编译做了优化处理

9.包装类（Integer，Double，Float，Boolean等都是final），

String也是final类

练习

public class Circle {
    /**
     * 计算圆形的面积
     * 圆周率3.14*/
    public static void main(String[] args) {
        Gongshi gongshi = new Gongshi(5.00);
        System.out.println(gongshi.Circlesu());
    }
}
class Gongshi{
    private double radius;
    private final  double PI;

    public Gongshi(double radius) {
        this.radius = radius;
        PI = 3.14;
    }
    public double Circlesu(){
        return PI * radius * radius;
    }
}