修饰符和关键字

访问修饰符基本介绍

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;
    }
}