Java面向对象之递归调用、方法重载、可变参数、作用域、构造方法/构造器及this 关键字

最新推荐文章于 2024-02-22 10:49:19 发布

一切随心走_水瓶

最新推荐文章于 2024-02-22 10:49:19 发布

阅读量540

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/wcg920212/article/details/121500623

版权

java 专栏收录该内容

54 篇文章 2 订阅

订阅专栏

1、递归调用

1.1、定义

递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁

1.2、递归调用机制

打印问题
阶乘问题

public class Recursion_ {
    public static void main(String[] args) {
        T t = new T();
        t.test(4);  // n=2  n=3  n=4

        int res = t.factorial(5);
        System.out.println("res=" + res);  // res=120
    }
}

class T {
    public void test(int n) {
        if (n > 2) {
            test(n - 1);
        }
        System.out.println("n=" + n);
    }

    public int factorial(int n) {
        if (n == 1) {
            return 1;
        } else {
            return factorial(n - 1) * n;
        }
    }
}

在这里插入图片描述

1.3、递归重要规则

在这里插入图片描述

2、方法重载

2.1、定义

java 中允许同一个类中，多个同名方法的存在，但要求形参列表不一致！
比如：System.out.println(); out 是 PrintStream 类型

2.2、重载的好处

减轻了起名的麻烦
减轻了记名的麻烦

2.3、重载代码

类：MyCalculator
方法：calculate

calculate(int n1, int n2) // 两个整数的和
calculate(int n1, double n2) // 一个整数，一个 double 的和
calculate(double n2, int n1) // 一个 double, 一个 Int 和
calculate(int n1, int n2,int n3) // 三个 int 的和

public class OverLoad {
    public static void main(String[] args) {
        MyCalculator myCalculator = new MyCalculator();
        System.out.println(myCalculator.calculate(10, 20));
        System.out.println(myCalculator.calculate(10, 20.65));
        System.out.println(myCalculator.calculate(30.98, 17));
        System.out.println(myCalculator.calculate(10, 20, 30));
    }
}

class MyCalculator {

	// 下面的四个 calculate 方法构成了重载
	
    // 1) calculate(int n1, int n2)  // 两个整数的和
    public int calculate(int n1, int n2) {
        return n1 + n2;
    }

    // 没有构成方法重载, 仍然是错误的, 因为是方法的重复定义, 和 (1) 冲突了
    // public void calculate(int n1, int n2) {
    // System.out.println("calculate(int n1, int n2) 被调用");
    // int res = n1 + n2;
    // }

    // 没有构成方法重载, 仍然是错误的, 因为是方法的重复定义, 只是形参的变量名变了, 和 (1) 冲突了
    // public int calculate(int a1, int a2) {
    // System.out.println("calculate(int n1, int n2) 被调用");
    // return a1 + a2;
    // }

    // 2) calculate(int n1, double n2)  // 一个int, 一个 double 的和
    public double calculate(int n1, double n2) {
        return n1 + n2;
    }

    // 3) calculate(double n2, int n1)  // 一个 double, 一个 int 和
    public double calculate(double n2, int n1) {
        return n2 + n1;
    }

    // 4) calculate(int n1, int n2,int n3)  // 三个 int 的和
    public int calculate(int n1, int n2, int n3) {
        return n1 + n2 + n3;
    }
}

2.4、注意事项和使用细节

在这里插入图片描述

3、可变参数

3.1、定义

java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。就可以通过可变参数实现

3.2、基本语法

访问修饰符 返回类型 方法名(数据类型... 形参名) { 

}

3.3、代码实现

// 计算N个数字的和
public class getSum {
    public static void main(String[] args) {
        System.out.println(new A().getSum(10, 20, 30, 40, 50));  // 150
        // 可变参数的实参可以为数组
        int[] arrList = {1, 2, 3, 4, 5, 6};
        System.out.println(new A().getSum(arrList));  // 21
        System.out.println(new A().getValue("hello", 10.67, 10, 20, 30.98f));  // hello10.6760
    }
}

class A {
    public int getSum(int... args) {
        int sum = 0;
        for (int i = 0; i < args.length; i++) {
            sum += args[i];
        }
        return sum;
    }
	
	// 可变参数可以和普通类型的参数一起放在形参列表, 但必须保证可变参数在最后
    public String getValue(String n1, double n2, float... args) {
        int sum = 0;
        for (int i = 0; i < args.length; i++) {
            sum += args[i];
        }
        return n1 + n2 + sum;
    }
    
    // 一个形参列表中只能出现一个可变参数 (下面的写法是错的)
    // public void test(int...args1, float...args2) {
    //
    // }
}

3.4、注意事项和使用细节

在这里插入图片描述

4、作用域

4.1、定义

在这里插入图片描述

4.2、代码实现

public class VarScope {
    public static void main(String[] args) {

    }
}

class Cat {
    // 全局变量: 也就是属性, 作用域为整个类体 Cat: cry eat 等方法使用属性
    // 属性在定义时, 可以直接赋值
    int age = 10;  // 指定的值是 10

    // 全局变量(属性)可以不赋值, 直接使用, 因为有默认值
    double weight;

    public void hi() {
        // 局部变量必须赋值后, 才能使用, 因为没有默认值
        int num = 100;
        String address = "北京";
        System.out.println("num=" + num);
        System.out.println("address=" + address);
        System.out.println("weight=" + weight);  // 属性
    }

    public void cry() {
        // 1. 局部变量一般是指在成员方法中定义的变量
        // 2. n 和 name 就是局部变量
        // 3. n 和 name 的作用域在 cry 方法中
        int n = 10;
        String name = "jack";
        System.out.println("在 cry 中使用属性 age=" + age);

        int n2;
        // System.out.println(n2);  // 局部变量如果没给值使用, 直接报错 (局部变量必须给值才能使用)
        n2 = 5;
        System.out.println(n2);  // 局部变量n2赋值以后就可以正常使用了
    }

    public void eat() {
        System.out.println("在 eat 中使用属性 age=" + age);
        // System.out.println("在 eat 中使用 cry 的变量 name=" + name); //错误
    }
}

4.3、注意事项和细节使用

在这里插入图片描述

public class VarScopeDetail {
    public static void main(String[] args) {
        Person p1 = new Person();
        /*
         * 属性生命周期较长, 伴随着对象的创建而创建, 伴随着对象的销毁而销毁
         * 局部变量, 生命周期较短, 伴随着它的代码块的执行而创建, 伴随着代码块的结束而销毁, 即在一次方法调用过程中
         */
        p1.say();  // 当执行 say 方法时，say 方法的局部变量比如 name, 会创建, 当 say 执行完毕后
                   // name 局部变量就销毁, 但是属性(全局变量)仍然可以使用

        Tests t1 = new Tests();
        t1.test();  // 第 1 种跨类访问对象属性的方式

        t1.test2(p1);  // 第 2 种跨类访问对象属性的方式
    }
}

class Tests {
    // 全局变量/属性: 可以被本类使用, 或其他类使用 (通过对象调用)
    public void test() {
        Person p1 = new Person();
        System.out.println(p1.name);  // jack
    }

    public void test2(Person p) {
        System.out.println(p.name);  // jack
    }
}

class Person {
    //属性可以加修饰符(public protected private...)
    // 局部变量不能加修饰符
    public int age = 20;
    String name = "jack";

    public void say() {
        // 属性和局部变量可以重名, 访问时遵循就近原则
        String name = "king";
        System.out.println("say() name=" + name);  // say() name=king
    }

    public void hi() {
        String address = "北京";
        // String address = "上海";  // 错误,重复定义变量
        String name = "tom"; // 可以
    }
}

5、构造方法/构造器

5.1、需求引出

我们来看一个需求：前面我们在创建人类的对象时，是先把一个对象创建好后，再给他的年龄和姓名属性赋值，如果现在我要求，在创建人类的对象时，就直接指定这个对象的年龄和姓名，该怎么做? 这时就可以使用构造器

5.2、基本语法

[修饰符] 方法名(形参列表){ 
	方法体; 
}

5.3、重要说明

构造器的修饰符可以默认，也可以是 public protected private
构造器没有返回值
方法名和类名字必须一样
参数列表和成员方法一样的规则
构造器的调用, 由系统完成

5.4、基本介绍

构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。
它有几个特点：

方法名和类名相同
没有返回值
在创建对象时，系统会自动的调用该类的构造器完成对象的初始化

5.5、代码实现

public class Constructor {
    public static void main(String[] args) {
        // 当我们 new 一个对象时, 直接通过构造器指定名字和年龄
        Person p1 = new Person("jack", 18);
        System.out.println("p1 的信息如下");
        System.out.println("p1 对象 name=" + p1.name);
        System.out.println("p1 对象 age=" + p1.age);
    }
}

class Person {
    String name;
    int age;

    // 1. 构造器没有返回值, 也不能写 void
    // 2. 构造器的名称和类 Person 一样
    // 3. (String pName, int pAge) 是构造器形参列表, 规则和成员方法一样
    public Person(String pName, int pAge) {
        System.out.println("构造器被调用, 完成对象的属性初始化");
        name = pName;
        age = pAge;
    }
}

console输出

构造器被调用, 完成对象的属性初始化
p1 的信息如下
p1 对象 name=jack
p1 对象 age=18

5.6、注意事项和使用细节

在这里插入图片描述

public class ConstructorDetail {
    public static void main(String[] args) {
        Person p1 = new Person("king", 40);  // 第 1 个构造器
        Person p2 = new Person("tom");  // 第 2 个构造器
        Dog dog1 = new Dog();  // 使用的是默认的无参构造器
    }
}

class Dog {
    // 如果程序员没有定义构造器, 系统会自动给类生成一个默认无参构造器(也叫默认构造器)
    // 使用 javap 指令 反编译看看  javap -c xxx.class / javap -c xxx
    /*
        默认构造器
        Dog() {
        }
    */
    // 一旦定义了自己的构造器, 默认的构造器就覆盖了, 就不能再使用默认的无参构造器
    // 除非显式的定义一下, 即: Dog(){} (这点很重要)
    public Dog(String dName) {
        // ...
    }

    Dog() {  // 显式的定义一下 无参构造器
    }

}

class Person {
    String name;
    int age;  // 默认 0

    // 第一个构造器, 指定人名和年龄
    public Person(String pName, int pAge) {
        name = pName;
        age = pAge;
    }

    // 第二个构造器, 只指定人名, 不指定年龄
    public Person(String pName) {
        name = pName;
    }
}

5.7、对象创建的流程分析

在这里插入图片描述

6、this关键字

6.1、需求引出

在这里插入图片描述

public class This_ {
    public static void main(String[] args) {
        Dog dog1 = new Dog("小黄", 3);
        System.out.println("dog1 的 hashcode=" + dog1.hashCode());
        dog1.info();  // dog1 调用了 info()方法
        System.out.println("============");
        Dog dog2 = new Dog("小白", 2);
        System.out.println("dog2 的 hashcode=" + dog2.hashCode());
        dog2.info();
    }
}

class Dog {
    String name;
    int age;

    // public Dog(String dName, int dAge) {//构造器
    // name = dName;
    // age = dAge;
    // }
    // 如果我们构造器的形参, 能够直接写成属性名就更好了
    // 但是出现了一个问题, 根据变量的作用域原则
    // 构造器的 name 是局部变量, 而不是属性
    // 构造器的 age 是局部变量, 而不是属性
    public Dog(String name, int age) {
        //构造器
        // this.name 就是当前对象的属性name
        this.name = name;
        // this.age 就是当前对象的属性 age
        this.age = age;
        System.out.println("this.hashCode=" + this.hashCode());
    }

    public void info() {
        //成员方法,输出属性 x 信息
        System.out.println("this.hashCode=" + this.hashCode());
        System.out.println(name + "\t" + age + "\t");
    }
}

6.2、this深入理解（流程图）

在这里插入图片描述

6.3、注意事项和使用细节

this 关键字可以用来访问本类的属性、方法、构造器
this 用于区分当前类的属性和局部变量
访问成员方法的语法：this.方法名(参数列表)
访问构造器语法：this(参数列表); 注意只能在构造器中使用(即只能在构造器中访问另外一个构造器, 必须放在第一条语句)
this 不能在类定义的外部使用，只能在类定义的方法中使用

public class TestPerson {
    public static void main(String[] args) {
        Person p1 = new Person("张三", 18);
        Person p2 = new Person("张三", 18);
        System.out.println("p1 和 p2 比较的结果=" + p1.compareTo(p2));
    }
}

// 定义 Person 类，里面有 name、age 属性，
// 并提供 compareTo 比较方法，用于判断是否和另一个人相等，
// 提供测试类 TestPerson 用于测试, 名字和年龄完全一样，就返回 true, 否则返回 false
class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public boolean compareTo(Person p) {
        return this.name.equals(p.name) && this.age == p.age;
    }
}

public class TestPerson {
    public static void main(String[] args) {
        Person p1 = new Person("张三", 18);
    }
}

class Person {
    String name;
    int age;

    public Person(int age) {
        System.out.println("Person(int age) 构造器被调用了");
        this.age = age;
    }

    public Person(String name) {
        System.out.println("Person(String name) 构造器被调用了");
        this.name = name;
    }

    public Person(String name, int age) {
        // 访问构造器语法: this(参数列表)
        // 注意只能在构造器中使用(即只能在构造器中访问另外一个构造器, 必须放在第一条语句)
        this("李四");  // 执行 public Person(String name) 的构造器
        System.out.println("Person(String name, int age) 构造器被调用了");
        // this("李四");  // 报错 (this 必须放在第一条语句)
        this.name = name;
        this.age = age;
    }
}

一切随心走_水瓶

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java面向对象之递归调用、方法重载、可变参数、作用域、构造方法/构造器及this 关键字

文章目录1、递归调用1.1、定义1.2、递归调用机制1.3、递归重要规则2、方法重载2.1、定义2.2、重载的好处2.3、重载代码2.4、注意事项和使用细节3、可变参数3.1、定义3.2、基本语法3.3、代码实现3.4、注意事项和使用细节4、作用域4.1、定义4.2、代码实现4.3、注意事项和细节使用5、构造方法/构造器5.1、需求引出5.2、基本语法5.3、重要说明5.4、基本介绍5.5、代码实现5.6、注意事项和使用细节5.7、对象创建的流程分析6、this 关键字6.1、需求引出6.2、this深入理
复制链接

扫一扫