java中方法的细分(普通方法，静态方法，构造方法)

努力彪

已于 2022-10-14 19:58:40 修改

阅读量2.2k

点赞数 3

分类专栏： javase基础文章标签： java

于 2021-01-16 18:33:32 首次发布

本文链接：https://blog.csdn.net/qq_41972686/article/details/112718736

版权

javase基础专栏收录该内容

23 篇文章 4 订阅

订阅专栏

1.1普通方法

方法通俗点来讲用于描述一个对象的行为.例如一个人可以有很多行为，吃饭睡觉打豆豆，而这些行为是由方法来实现的。

行为也被称作方法或者函数.

代码示例：

class Person {
    public int age = 18;
    public String name = "张三";

    public void show() {
        System.out.println("我叫" + name + ", 今年" + age + "岁");
    }
}

class Test {
    public static void main(String[] args) {
        Person person = new Person();
        person.show();
    }
}

// 执行结果
我叫张三,今年18岁

此处的 show 方法, 表示 Person 这个对象具有一个 "展示自我" 的行为.

这样的 show 方法是和 person 实例相关联的. 如果创建了其他实例, 那么 show 的行为就会发生变化

Person person2 = new Person(); person2.name = " 李 四 "; 
person2.age = 20;
person2.show()

// 执行结果
我叫李四, 今年20岁

方法中还有一种特殊的方法称为 构造方法 (construction method)。

在实例化对象的时候会被自动调用到的方法, 方法名字和类名相同, 用于对象的初始化.虽然我们前面已经能将属性就地初始化, 但是有些时候可能需要进行一些更复杂的初始化逻辑, 那么就可以使用构造方法.后面我们会详细介绍构造方法的语法.

1.2静态方法

static关键字修饰方法，此方法称为静态方法，同时也成为类方法
1.访问方式：通过类名.静态成员方法名()，同时需要注意的是通过对象的引用也是可以访问静态成员变量的，虽然在书写时编译器(idea)可能会报错，但是运行时是不会报错的。

2.特点：

静态方法属于类，而不属于类的对象。

可以直接调用静态方法，而无需创建类的实例。

静态方法可以访问静态数据成员，并可以更改静态数据成员的值。

代码示例：

class TestDemo {
    public int a;
    public static int count;

    public static void change() {
        count = 100;
        //a = 10; error	不可以访问非静态数据成员
    }
}

public class Main{
    public static void main(String[] args) {
        TestDemo.change()；//无需创建实例对象 就可以调用
        System.out.println(TestDemo.count);
    }

注意事项：静态方法和实例无关, 而是和类相关. 因此会导致几种情况:

(1): 在静态方法的内部是不能访问实例成员变量的，同样也不能调用实例成员方法

(2): 注意不管是静态的方法还是非静态的方法中都不能定义静态的变量,但是可以定义非静态的
原因：因为静态的变量属于类并不属于方法，也就是我们俗称的类变量

(3):this和super两个关键字不能在静态上下文中使用(this 是当前对象的引用, super是父类对象的引用，而静态是不依赖对象的，所以不能在静态方法中使用this和super关键字).

(4):所有被static所修饰的方法或者属性，全部不依赖于对象。

1.3构造方法

1.3.1基本语法

构造方法是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作.

实例化对象的过程分为两步：

1.为对象分配内存空间

2.调用合适的构造方法，合适意味着构造方法并不止一个。

语法规则

方法名称必须与类名称相同
每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）
构造方法没有返回值类型声明

注意事项

1.如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数

2.若类中定义了构造方法，则默认的无参构造将不再生成

3.构造方法支持重载. 规则和普通方法的重载一致.

4.构造函数的作用就是构造对象，同时也可以在构造对象的同时对对象的成员进行初始化

5.不同的构造方法的调用主要是看括号内部参数是什么，就调用相对应的即可

代码示例：

class People {
    private String name;
    private int age;
    public String sex;
    public static int count;

    //构造方法
    People() {
        System.out.println("不带有参数的构造方法");
    }

    People(String name) {
        System.out.println("带有1个参数，String的构造方法！");
    }

    People(String name, int age) {
        System.out.println("带有2个参数，String，int的构造方法！");
    }

    People(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public void print() {
        System.out.println("name=" + name + " " + "age=" + age + " " + "sex=" + sex);
    }
}

public class LeiHeDuiXiang3 {

    public static void main(String[] args) {
        //不同的构造方法的调用主要是看括号内部参数是什么，就调用相对应的即可
        //输出结果为 System.out.println("不带有参数的构造方法");
        People person = new People();
        //输出结果为 System.out.println("带有1个参数，String的构造方法！");
        People person1 = new People("songbiao");
        //输出结果为System.out.println("带有2个参数，String，int的构造方法！");
        People person2 = new People("songbiao", 100);

        System.out.println("==============================================");
        //构造函数的作用就是构造对象，同时也可以在构造对象的同时对对象的成员进行初始化
        People person3 = new People("songbiao", 100, "男");
        person3.print();
    }
}

在这里注意一个点。假若我们此时去掉People()这个任何参数的构造函数的话，当我们new People()的时候程序便会报错，为什么？
答：因为当我们不定义构造函数时，其实编译器会默认给我们生成一个无参数的构造函数，而当我们定义了其他的有参的构造函数而没有定义无参数的构造函数时，此时系统不会再默认为我们定义无参数的构造函数了，那么当我们通过语句new People()实例化一个对象时，便找不到对应的构造函数了，那么此时需要我们自己定义一个无参数的构造函数。

1.3.2this关键字(重点)

this表示当前对象引用(注意不是当前对象). 可以借助 this 来访问对象的字段和方法.

在这里讲下为什么this是对象的引用而不是对象？
答：首先来看下实例化一个对象分为几步吧：
第1步：为对象分配内存
第2步：调用合适的构造方法。注意：合适二字意味着构造函数可不止一个
this不是对象的原因是当我们完成对构造方法的调用后对象才会创建，而我们此时能在构造函数中去使用this,则说明this出现在对象创立之前，所以this并不是指对象
当我们在实例化对象的时候，第一步是为对象分配内存，既然有了内存就一定有了地址，地址是存在引用当中的，所以我们说此时this指的是对象的引用。

this的三种使用方式：

1：this访问成员变量
2：this调用成员方法
3：this调用构造方法：在一个方法内部调用另外一个构造方法

代码示例：

class People1 {
    private String name;
    private int age;
    public String sex;
    public static int count;

    //this调用构造方法
    People1() {
        /*
        注意this不能调用本身的构造函数，不然会陷入死循环
        this();
        */

        /*
        this在调用构造方法时只能放在第一行并且只能调用一次构造函数
        this在调用构造方法时只能用在构造方法中
        */
        this("songbiao");
        /*
        注意此时this如果想要调用第二个构造函数便会报错
        this("haha",10);
         */
        System.out.println("haha");
    }

    People1(String name) {
        System.out.println("hehe");
    }

    People1(String name, int age) {
        System.out.println("heheda");
    }


    //普通成员方法
    public void eat() {
        People1 p = new People1();
        System.out.println("吃饭");
    }

    /*1.普通的成员方法中是可以使用this来访问实例成员变量和静态成员变量的
      2.普通的成员方法中是可以使用this来调用实例成员方法和静态成员方法的

    */
    public  void print() {
        //使用this来访问实例成员变量
        System.out.println("name=" + this.name + " " + "age=" + this.age + " " + "sex=" + sex);
        //使用this来访问静态成员变量，虽然不妥但是编译时不会出错的
        System.out.println(this.count);
        //使用this来调用实例成员方法
        this.eat();
        //使用this来调用静态成员方法，虽然不妥但是编译时不会出错的
        this.func1();
        //可以直接调用静态成员方法
        func1();
        //可以直接调用实例成员方法
        eat();
         /*
         注意不管是静态的方法还是非静态的方法中都不能定义静态的变量,但是可以定义非静态的
         原因：因为静态的变量属于类并不属于方法，也就是我们俗称的类变量
         static int a=10;(不允许）
        */
        //可以直接访问静态成员方法
        count++;
    }


    public static void func1() {
        int a = 10;
        System.out.println("sss");
    }

    /*
    静态方法中是不能使用this的，原因是this代表对象的引用，而静态是不依赖对象的
     */
    public static void func() {
        // 静态方法中不能使用this访问实例成员变量或者静态成员变量
        //System.out.println(this.name);
        //System.out.println(this.count);
        //静态方法中不能使用this调用实例成员方法或者静态成员方法
        //this.print();
        //this.func1();
        //静态方法中不能直接调用非静态成员方法
        //print();
        //静态方法中可以直接调用静态成员方法
        func1();
        //静态方法中可以直接访问静态成员变量
        count++;
        /*注意不管是静态的方法还是非静态的方法中都不能定义静态的变量,但是可以定义非静态的
          static int a=10;(不允许)
        //总结：静态方法中不能访问成员变量，同时也不能调用成员方法，并且不能在静态方法中定义静态变量
        */
        System.out.println("此方法为静态方法");
    }
}

public class LeiHeDuiXiang4 {
    public static void main(String[] args) {
        People1 person = new People1();
        person.eat();
    }
}

下面我们来逐个分析：

1：this关键字可以在构造方法中使用，那么我们来看代码：

 People1() {
        /*
        注意this不能调用本身的构造函数，不然会陷入死循环
        this();
        */
        /*
        this在调用构造方法时只能放在第一行并且只能调用一次构造函数
        this在调用构造方法时只能用在构造方法中

        */
        this("songbiao");
        /*
        注意此时this如果想要调用第二个构造函数便会报错
        this("haha",10);
         */
        System.out.println("haha");
    }

1.首先我们可以使用this关键字在一个构造方法中去调用另一个构造方法，但是不能调用本身，这样会陷入死循环。

2.this方法在调用当前类的其他构造方法时只能将调用语句放在构造方法中的第一行并且只能调用一次。

3.this如果想要调用第二个构造函数便会报错，说明一个构造函数中只能调用一次其他构造函数。

2.this可以在普通成员方法中使用，下面来看代码：

public void print() {
        //使用this来访问实例成员变量
        System.out.println("name=" + this.name + " " + "age=" + this.age + " " + "sex=" + sex);
        //使用this来访问静态成员变量，虽然不妥但是编译时不会出错的
        System.out.println(this.count);
        //使用this来调用实例成员方法
        this.eat();
        //使用this来调用静态成员方法，虽然不妥但是编译时不会出错的
        this.func1();
        //可以直接调用静态成员方法
        func1();
        //可以直接调用实例成员方法
        eat();
         /*
         注意不管是静态的方法还是非静态的方法中都不能定义静态的变量,但是可以定义非静态的
         原因：因为静态的变量属于类并不属于方法，也就是我们俗称的类变量
         static int a=10;(不允许）
        */
        //可以直接访问静态成员方法
        count++;
    }

1.在普通成员方法中可以使用this关键字来访问成员变量，调用成员方法，虽然使用this关键字访问静态成员变量和调用静态成员方法时编译器(idea)会报错，但是运行时是不会出错的。

2.在普通成员方法中也可以直接访问成员变量和成员方法。

3. this不可以在静态成员方法中使用，下面来看代码：

public static void func() {
        // 静态方法中不能使用this访问实例成员变量或者静态成员变量
        //System.out.println(this.name);
        //System.out.println(this.count);
        //静态方法中不能使用this调用实例成员方法或者静态成员方法
        //this.print();
        //this.func1();
        //静态方法中不能直接调用非静态成员方法
        //print();
        //静态方法中可以直接调用静态成员方法
        func1();
        /*注意不管是静态的方法还是非静态的方法中都不能定义静态的变量,但是可以定义非静态的
          static int a=10;(不允许)
        //总结：静态方法中不能访问成员变量，同时也不能调用成员方法，并且不能在静态方法中定义静态变量
        */
        //静态方法中可以直接访问静态成员变量
        count++;
        System.out.println("此方法为静态方法");
    }
}

此时我们会发现this不可以在静态方法中使用，这是为什么呢？

答：因为this代表对象的引用，而静态是不依赖对象的。

所以在静态成员方法中只能访问静态的成员变量以及调用静态成员方法。

在这里再次强调下：注意不管是静态的方法还是非静态的方法中都不能定义静态的变量,但是可以定义非静态的，因为静态的变量属于类并不属于方法，也就是我们俗称的类变量

努力彪

关注

3
点赞
踩
31

收藏

觉得还不错? 一键收藏
1
评论
java中方法的细分(普通方法，静态方法，构造方法)

1.1普通方法方法通俗点来讲用于描述一个对象的行为.例如一个人可以有很多行为，吃饭睡觉打豆豆，而这些行为是由方法来实现的。行为也被称作方法或者函数.代码示例：class Person { public int age = 18; public String name = "张三"; public void show() { System.out.println("我叫" + name + ", 今年" + age + "岁"); }}
复制链接

扫一扫