欢迎光临
我们一直在努力

三个修饰符

一、abstract 

        1. abstract可以用于修饰符类

                 (1) 被abstract修饰符的类称为抽象类 语法: abstract class 类名{}

                (2) 抽象类编译之后生成独立的 .class 文件

                (3) 抽象类不能单独创建对象,但是可以声明引用

                (4) 抽象类中可以定义成员变量和成员方法

                (5) 抽象类中有构造方法,抽象类中构造方法供子类创建对象,先去完成父类对象的创建时应用。  

       2. abstract 可以用于修饰符方法

                (1) 被abstract修饰符的方法称为抽象方法

                (2) 抽象方法只有方法的声明部分,没有方法的实现部分(连 {} 都没有) 语法: 访问修饰符 abstract 返回值类型 方法名(形参列表);

                        注意:访问修饰符 和 abstract 之间没有位置的先后顺序。

                (3) 抽象方法只能定义在抽象类中;但是抽象类中既可以有抽象方法,也可以有非抽象方法。

                (4) 注意:如果子类继承抽象类,子类不想成为抽象类,则需要覆盖父类(抽象类)中所有的抽象方法, 否则子类也必须定义为抽象类。

      3. 抽象类的作用:强制使用多态。

二、static

        1. static可以用于修饰属性 

                (1) 被static修饰的属性称为 静态属性、静态变量、类变量

                (2) 语法:访问修饰符 static 数据类型 属性名; 访问修饰符 static 数据类型 属性名 = 值; 注意:访问修饰符和static 没有先后位置的要求。

                (3) 特点:静态属性是全类共有的属性,与创建多少对象没有关系。

                (4) 应用: a. 对象名.静态属性名 b. 类名.静态属性名 

        2. static 可以用于修饰方法 

                (1) 被 static 修饰符方法称为静态方法。

                (2) 语法:访问修饰符 static 返回值类型 方法名(形参列表){ // 方法的实现 } 注意:访问修饰符 和 static 没有位置先后要求。

                (3) 使用:类名.静态方法名(实参); 对象名.静态方法名(实参); // 不建议使用

                (4) 注意:

                        a. 静态方法中只能直接访问本类的静态成员(静态属性和静态方法);静态方法中不能直接访问本类的非静态的成员(非静态的属性和方法)

                        b. 非静态方法中既可以访问本类的非静态成员(实例变量和成员方法),也可以直接访问 本类的静态的成员(静态属性和方法)

                        c. 静态方法中不能使用 this/super关键字

                        d. 静态方法允许被子类继承,静态方法只能被静态方法覆盖,但是没有多态的应用 注意:如果在静态方法中访问非静态成员,则可以利用创建对象,用对象名调用非静态的成员。 思考:System.out.println() ; System: 类名 out:静态的属性,类型为对象类型的属性 println():方法,是out类型中的方法

        3. static 可以用于修饰初始化代码块

                (1) 初始化代码块也被称为动态代码块 

                        a. 位置:定义类以内,方法以外的 {}

                        b. 作用:在创建对象时,按照和属性定义先后顺序,完成对属性的初始化工作。 对象创建的过程: 分配空间:为属性赋默认值 初始化属性:为属性第二次赋值的机会 -》动态代码块执行 执行构造方法:为属性第三次赋值的机会

        (2) 被 static 修饰的初始化代码块称为静态初始化代码块,简称静态代码块。 

                a. 位置:定义在类以内,方法以外,同时被 static 修饰 {}

                b. 作用:在类加载时,按照和静态属性定义的先后顺序,完成对静态属性的初始化工作。

                c. 类加载:

                        I. 概念:当JVM第一次使用一个类的时候,通classPath(类路径)找到对应的.class文件,从.class文件 中读取该类的信息(包、类名、父类、属性、成员方法、构造方法等),读取之后将信息存储在 JVM内存中,一个类只进行一次类加载。

                        II. 类加载时机(什么情况会导致一个类进行类加载):

                ① 第一次创建该类对象:先进行类加载,再完成对象的创建

                ② 第一次使用该类的静态成员(静态属性和静态方法):会进行类加载

                ③ 子类的类加载会导致其父类先进行类加载:先加载其父类,再加载子类

                         -> 第一次调用子类中的静态成员:先加载其父类,再加载子类

                         -> 第一次创建子类对象:先加载,再完成对象的创建:

                带有类加载创建对象的过程:

                        先加载:先加载其父类,再加载子类

                                先加载父类:为父类的静态属性分配空间并完成父类静态属性的初始化

                                                                           —》 父类的静态代码块被执行

                               再加载子类:为子类的静态属性分配空间并完成子类静态属性的初始化

                                                                          —》子类的静态代码块被执行

                       在 完成对象的创建:先创建父类对象,再子类对象

                                先完成父类对象的创建:

                                        初始化父类的属性:—》父类的动态代码块被执行

                                        执行父类的构造方法

                               再完成子类对象的创建:

                                        初始化子类的属性:—》子类的动态代码块被执行

                                        执行子类的构造方法

                 注意:只声明引用不会导致类加载。  

        4. static 可以用于修饰内部类

三、final

        1. 变量(局部变量、实例变量、静态变量)

                (1) final修饰的变量是作用范围内的常量,只允许一次赋值,不允许更改,可以多次被使用。

                (2) final的实例变量不再分配默认值,为其初始化的时机:

                        a. 声明的同时对其初始化

                        b. 在构造方法中对其初始化,但是必须保证每一个构造方法都对其从初始化

                        c. 借助动态代码块对其初始化

                (3) final 修饰的静态属性不再分配默认值,为其初始化的时机:

                        a. 声明的同时对其初始化

                        b. 借助静态初始化代码块对其初始化

                        注意:final 修饰的引用,代表引用中存储对象的地址不能改变。

        2. final 可以用于修饰方法:可以被子类继承,但是不允许被覆盖。

        3. final 可以用于修饰类:被final修饰的类不能被继承,即没有子类。

                例如:String / System / Math 等。

赞(0)
未经允许不得转载:171主机测评 » 三个修饰符
分享到: 更多 (0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址