Java面向对象-(1)

    39

断点调试

所谓断点调试,就是在程序特定行设置一个止动点,当程序运行至此位置便自动暂停,从而实现逐步细化的深度调试。此过程可观察各变量实时数值,并在遇到bug时立即显现错误代码所在行,便于精准分析和定位问题。

无疑,熟练掌握断点调试技术对于编程人员而言至关重要。

不仅如此,借助该方法还能够对比java底层源码执行过程,进一步提升程序员的编程能力与技术水平。

此外断点调试期间,处于执行状态,依照对象操作方式运行。

例子:

A extends B;
 
B b = new A(); 

//编译类型是B,运行类型是A
 
b.xx();

//编译类型看左边,运行类型看右边

类变量

引出:

定义了一个名为 count 的整型数值来表示总体数量,每当有新的数量产生,count 值便自动增加 1,且该计数数据被全部对象所共用。

例子:

class Version_T0 {
    private String name;
    public static int count = 0;

    public Version_T0(String name) {
        this.name = name;
    }

    public void join() {
        System.out.print(name + "加入了捉妖队列..");
        count++;
    }
}

public class Main {
    public static void main(String[] args) {
        Version_T0 version_t0_1 = new Version_T0("人才-1");
        version_t0_1.join();
        Version_T0 version_t0_2 = new Version_T0("人才-2");
        version_t0_2.join();
        Version_T0 version_t0_3 = new Version_T0("人才-3");
        version_t0_3.join();

        System.out.println("当前共有" + Version_T0.count + "开始捉妖。");
    }
}
//count是共享的,Version_T0_1.count、Version_T0_2.count、Version_T0_3.count都是同一个count
//所以Version_T0_1.count,Version_T0_2.count,Version_T0_3.count的输出结果是一样的。

什么是类变量:

类变量(又名静态变量)是类中每个对象所共享的,无论哪个对象访问或更改它,其结果总是相同的。

如何定义类变量:

定义方式如下:

访问修饰符 static + 数据类型 + 变量名; // 推荐

static + 访问修饰符 + 数据类型 + 变量名;

如何访问类变量?

有两种方法:

类名。类变量名

或 对象名。类变量名

(记住,静态变量的访问权限和范围与普通属性相同)

推荐使用 > 类名。类变量名

注意事项:

  1. 何时使用类变量:
    当你希望某类中的所有对象共享一个变量时,可考虑使用类变量。例如,定义学生类,计算所有学生的学费总额。

  2. 类变量与实例变量的差异:
    类变量是对象共有的,而实例变量则是独立的。

  3. 将 static 用于标识类变量,否则为实例变量。

  4. 类变量可通过类名。类变量名或对象名。类变量名访问,但java设计者更倾向于前者。

  5. 实例变量无法通过类名。类变量名访问。

  6. 类变量在类加载时即被初始化,无需创建对象。

  7. 类变量生命周期跟随类消亡而销毁。

类方法

类方法也叫静态方法

形式:

  1. 访问修饰符 static 数据返回类型 方法名 (){} // 推荐
    public static void print(){}

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

类方法的调用:

使用方式:类名或对象名,以及类中的方法名称(需遵循访问修饰符决定的可见性和作用域)。

类方法使用场景:

若无需调用与对象关联的成员,可把方法设为静态方法以提升开发效率。

小结:

在实际编程中,为了方便使用,常用一些通用的方法设置为静态方法。如此便无需建立对象即可实现如:列表输出、冒泡排序、执行算术运算等等功能。

注意事项:

  1. 类方法和普通方法都是随着类的加载而加载的,将结构信息存储在方法区:
    类方法中无 this 的参数
    普通方法中蕴含着 this 的参数

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

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

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

  5. 类方法 (静态方法) 中,只能访问 静态变量 或 静态方法。

  6. 普通成员方法,即可以访问 普通变量 (方法),也可以访问静态变量 (方法)。

小结:

静态方法仅能访问静态成员而非静态方法则可访问静态与非静态成员(需遵循访问权限)。

代码块

基本介绍:

代码块,又称初始化块,属于类的成员(成为类的一部分)。它与方法相似,都用{}包裹逻辑语句,但无方法名、返回值和参数,仅有方法体。它并非通过对象或类显式调用,而是在类加载或创建对象时隐式调用。

基本语法:

[修饰符]{
     code
};

注意:

  1. 修饰符仅 static可选。

  2. 代码块分两类,static修饰者为静态代码块,无static者为普通代码块。

  3. 逻辑语句不限。

  4. ";"号可写可省。

代码块优点:

颇似构造器另一形态(构造器的增强),能做初始化。

若多个构造器中有重复语句,可抽取至初始化块,增强代码复用性。

例子:

class Movie{
    private String name;
    private double price;
    private String direcotr;
 
    //3个构造器-->重载
 
    public Movie(String name){
        System.out.print("电影屏幕打开……");
        System.out.print("广告开始……");
        System.out.print("电影正式开始……");
        this.name = name;
    }
 
    public Movie(String name,double price){
        System.out.print("电影屏幕打开……");
        System.out.print("广告开始……");
        System.out.print("电影正式开始……");
        this.name = name;
        this.price = price;
    }
 
    public Movie(String name,double price,String direcotr){
        System.out.print("电影屏幕打开……");
        System.out.print("广告开始……");
        System.out.print("电影正式开始……");
        this.name = name;
        this.price = price;
        this.direcotr = direcotr;
    }
}
  1. 三个构造器皆含相同语句

  2. 冗长且重复

  3. 此刻,我们可将这些语句置于代码块内

  4. 无论调用何种构造器,创建对象时,均会首先执行代码块内容

  5. 代码块调用顺序优于构造器。

例子:

class Movie {
    private String name;
    private double price;
    private String director;

    {
        System.out.print("电影屏幕打开……");
        System.out.print("广告开始……");
        System.out.print("电影正式开始……");
    }

    // 3个构造器-->重载
    public Movie(String name) {
        this.name = name;
        System.out.println("构造器-->Movie(String name)被调用");
    }

    public Movie(String name, double price) {
        this(name); // 调用只有一个参数的构造器
        this.price = price;
    }

    public Movie(String name, double price, String director) {
        this(name, price); // 调用有两个参数的构造器
        this.director = director;
    }
}
输出结果:电影屏幕打开……
         广告开始……
         电影正式开始……
         构造器-->Movie(String name)被调用

注意事项:

  1. static 代码块初始化类,仅执行一次,随类加载。一般代码块随对象创建执行。
    static 代码块随类加载执行,仅一次。
    一般代码块随对象创建调用,一次一调用。

  2. 类何时加载?
    - 创建对象实例时(new)
    - 创建子类实例,父类加载,父类先于子类加载
    - 使用类的静态成员时(静态属性、方法)
    一般代码块在创建对象实例时隐式调用,一次创建,调用一次。仅使用类静态成员时,一般代码块不执行。

  3. 创建对象实例时,类调用顺序如下:
    首先,调用静态代码块和静态属性初始化。
    其次,调用普通代码块和普通属性初始化。
    最后,调用构造方法。
    代码示例:执行步骤://(1)->(2)->(3)->(4)->(5)

class A{
    private static int n1 = getVal();//(1)
    private int n2 = getVal2();//(3)
    {//(4)
        System.out.print("普通代码块执行");
    }
        static {//(2)
        System.out.print("静态代码块执行");
    }
    public A01(){//(5)
        super();
        System.out.print("A01的构造器");
    }
    public static int getVal(){
        System.out.print("getVal方法执行");
        return 10;
    }
    public  int getVal2(){
        System.out.print("getVal2方法执行");
        return 30;
    }
}

构造器前部包含super ()和普通代码块的调用,以及静态相关代码块和属性初始化。它们会在类加载时完成,优先于构造器和普通代码块执行。

例子:

class A {
    public A() {
        super();
        // 调用普通代码块
        System.out.print("Ciallo~ (∠・ω< )⌒☆");
    }

    public static void main(String[] args) {
        A a = new A();
    }
}

在创建子类时(继承关系),静态代码块、静态属性初始化、普通代码块、普通属性初始化以及构造方法的调用顺序如下。

1. 父类静态块与属性(优先级同,按序)
2. 子类静态块与属性(优先级同,按序)
3. 父类普通块与属性初始化(优先级同,按序)
4. 父类构造方法
5. 子类普通块与属性初始化(优先级同,按序)
6. 子类构造方法

静态代码块只能调用静态成员(包括静态属性和方法),而普通代码块则可调用任何成员。

Java 显示调用与隐式调用

主动调用为显式调用,无需显式调用但已执行即为隐式调用。

显式调用:

直接使用类名调用。

隐式调用:

基于事件的隐式调用风格,即构件不直接调用过程,而触发或广播一个或多个事件。其他构件中的过程在事件中注册,当事件触发时,系统自动调用所有注册过程,从而实现一个事件引发另一模块过程的调用。

作者:FichteHerbst.
文章地址:
版权声明: 本站所有文章除特别声明外 ,均采用 CC BY-NC-SA 4.0 协议。
非商业转载及引用请注明出处(作者、原文链接),商业转载请联系作者获得授权。

消息盒子

# 暂无消息 #

只显示最新10条未读和已读信息