day06_类与对象

已于 2022-07-19 15:56:25 修改
阅读量277 收藏 1
点赞数
分类专栏： 1_javaSE 文章标签： java
于 2022-07-18 20:20:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39535978/article/details/125859312
版权

面向对象_day01

学习目标：

1. 面向过程与面向对象编程思想
2. 类的定义与对象的创建
3. 匿名对象
4. 类的成员详细讲解

视频教程：https://www.bilibili.com/video/BV1RF411N7LU?spm_id_from=333.999.0.0

一、面向过程与面向对象

面向过程与面向对象是两种编程思想；什么是编程思想呢？编程思想就是编程的思维方式；面向过程的编程思维方式与面向对象的思维方式是截然不同的。

面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

例如：解决吃饭问题，面向过程与面向对象实现思路如下：

  • 面向过程：考虑买什么菜，做什么饭，怎么做，做多少，然后吃饭，洗碗；重心在于如何完成这件事。

  • 面向对象：考虑谁会做饭，找到这个人；去饭店吃饭；重心在于调用谁完成这件事。

例如：解决洗衣服问题，面向过程与面向对象实现思路如下：

  • 面向过程：考虑用什么洗，凉水洗还是热水洗，洗完是甩干，还是晾晒；重心在于如何完成这件事。

  • 面向对象：考虑谁会洗衣服，找到这个人完成这件事；去干洗店洗衣服；重心在于调用谁完成这件事。

例如：解决出行问题，面向过程与面向对象实现思路如下：

  • 面向过程：考虑是开车还是步行还是骑行，考虑最佳路线，是否堵车；重心在于如何完成这件事。

  • 面向对象：告诉助理，我要去哪里，我要几点去，几点到，剩下的交给助理去做；重心在于调用谁完成这件事。

二、类与对象

上面讲了，面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

那么什么是类？什么是对象呢？

2.1 类与对象的关系

类是指一类事物的抽取，一类事物的概括。比如：人是一类事物。动物是一类事物。宠物狗是一类事物。对象:具体的实例。比如小红是对象。北京动物园的那只老虎。楼上的那条京巴。 类与对象的关系:类是一类事物的总结概括，对象是该类中具体实例，个体。

类(Class)和对象(Object)是面向对象的核心概念。

  • 类是对一类事物的描述，是抽象的、概念上的定义

  • 对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。

在这里插入图片描述

可以理解为： 类 类 = 抽象概念的人；象 对象 = 实实在在的某个人、悟空、八戒、沙僧

面向对象程序设计的重点是 类的设计

2.2 类的设计与对象的创建

类的设计， 其实就是类的成员的设计

2.2.1 类的成员

类是指一类事物的抽取，我们拿人这个类举例，我们可以抽取出人的体重 身高，性别等属性，还可以抽取出学习、吃饭、睡觉等行为。所以抽取类中的成员可以抽取出类的属性和行为。

定义类的格式如下

在这里插入图片描述

Java中用类class来描述事物也是如此。常见的类的成员有

  • 属 性：对应类中的成员变量
  • 行 为：对应类中的成员方法

定义类的具体语法：

在这里插入图片描述

其中：属性又叫成员变量，也叫字段，定义的方式和定义变量的方式一样，只是位置不同。

定义方法的语法:

在这里插入图片描述

其中 ：

  • 修饰符：public, 缺省,private, protected等等
  • 返回值类型：
    • 没有返回值：void
    • 有返回值，声明出返回值的类型。与方法体中“ “return ” 返回值” 搭配使用。返回值类型可以是基本类型和引用类型。
  • 方法名 ：属于标识符，命名时遵循标识符命名规则和规范，“ 见名知意”
  • 形参列表：可以包含零个，一个或多个 参数。多个参数时，中间用“, ”隔开
  • 返回值：方法在执行完毕后返还给调用它的程序的数据

示例1：定义一个Person类，该类的字段有：name、sex、height、weight;行为有：study、eat、sleep方法。

参考答案：

/**
 * 定义一个Person类，该类的字段有：name、sex、height、weight;行为有：study、eat、sleep方法。
 */
public class Person {
    //定义成员变量/字段/属性
    //姓名
    String name;
    //性别 0 代表男，1代表女
    int sex;
    //身高
    int height;
    //体重
    int weight;

    //定义方法
    //定义学习方法
    void study(){
        System.out.println("胖叔讲Java，一路相伴");
    }
    // 定义吃饭方法
    void eat(){
        System.out.println("吃的是北京烤鸭");
    }
    // 定义睡觉方法
    void sleep(){
        System.out.println("早睡早起身体好");
    }
}

2.2.2 对象的创建与使用

对象是类的具体实现实例；所以使用类必须根据类创建对象，然后调用对象的属性和方法。

创建对象的语法：

在这里插入图片描述

调用属性和方法的语法：

在这里插入图片描述

示例1：根据上边定义的Person类创建对象，调用属性和方法

/**
 * 定义一个Person类，该类的字段有：name、sex、height、weight;行为有：study、eat、sleep方法。
 */
public class Person {
    //定义成员变量/字段/属性
    //姓名
    String name;
    //性别 0 代表男，1代表女
    int sex;
    //身高
    int height;
    //体重
    int weight;

    //定义方法
    //定义学习方法
    void study(){
        System.out.println("胖叔讲Java，一路相伴");
    }
    // 定义吃饭方法
    void eat(){
        System.out.println("吃的是北京烤鸭");
    }
    // 定义睡觉方法
    void sleep(){
        System.out.println("早睡早起身体好");
    }

    /*程序入口*/
    public static void main(String[] args) {
        //定义person对象
        Person person = new Person();
        //给属性赋值（调用属性）
        person.name="胖叔讲java";
        person.sex=0;
        person.height=168;
        person.weight=185;
        //查看属性（调用属性）
        System.out.println(person.name);
        System.out.println(person.sex);
        System.out.println(person.height);
        System.out.println(person.weight);
        //调用方法
        person.study();
        person.eat();
        person.sleep();
    }
}

问题分析？上面的学习方法存在问题，到底收获了哪些知识，没有返回结果；吃饭方法也存在问题，不可能天天吃烤鸭，方法体代码写死了，代码不灵活；接下来我们优化代码

参考答案：


/**
 * 定义一个Person类，该类的字段有：name、sex、height、weight;行为有：study、eat、sleep方法。
 */
public class Person {
    //定义成员变量/字段/属性
    //姓名
    String name;
    //性别 0 代表男，1代表女
    int sex;
    //身高
    int height;
    //体重
    int weight;

    //定义方法
    //定义学习方法
    String study(){
        System.out.println("胖叔讲Java，一路相伴");
        return "类与对象";
    }
    // 定义吃饭方法
    void eat(String food){
        System.out.println("吃的是:"+food);
    }
    // 定义睡觉方法
    void sleep(){
        System.out.println("早睡早起身体好");
    }

    /*程序入口*/
    public static void main(String[] args) {
        //定义person对象
        Person person = new Person();
        person.eat("鸡蛋西红柿");
        person.eat("肉夹馍");
        String result = person.study();
        System.out.println(result);
    }
}

2.3 对象的生命周期

在学习完类的设计与对象的创建语法之后，接下来我们讲解对象在jvm中运行的生命周期；首先我们完成一个示例，让后根据示例讲解jvm内存运行过程。

示例1：定义User类，类中有属性：id、name、age、phone；方法有showMessage展示用户信息

参考代码：

/**
 定义User类，类中有属性：id、name、age、phone；方法有showMessage展示用户信息
 */
public class User {
    // 用户唯一标识
    int id;
    // 姓名
    String name;
    // 年龄
    int age;
    // 手机号
    String phone;

    //展示用户信息
    void showMessage(){
        System.out.println("id:"+id+",name:"+name+",age:"+age+",phone:"+phone);
    }

    /*程序入口*/
    public static void main(String[] args) {
        //创建对象
        User user = new User();
        //赋值
        user.id = 1;
        user.name = "小红";
        user.age = 18;
        user.phone = "138389438";
        //查看信息
        user.showMessage();

        //创建对象2
        User user2 = new User();
        //赋值
        user2.id = 2;
        user2.name = "小明";
        user2.age = 19;
        user2.phone = "138389538";
        //查看信息
        user2.showMessage();
    }
}

在讲解user对象jvm运行过程之前，我们先复习以下jvm的内存结构

在这里插入图片描述

每块内存负责的职责如下：

  1. Java虚拟机栈（Java Virtual Machine Stacks）：描述的是Java方法执行的内存模型：每个方法在执行的同时都会创建一个栈帧（Stack Frame），栈帧中存储着局部变量表、操作数栈、动态链接、方法出口等信息。每一个方法从调用直至执行完成的过程，会对应一个栈帧在虚拟机栈中入栈到出栈的过程。与程序计数器一样，Java虚拟机栈也是线程私有的。

    局部变量和引用地址都是在栈内存中。

  2. 堆：此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在Java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。

  3. 方法区：用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。方法区存放的数据只有一份。

  4. 本地方法栈（Native Method Stack）：与Java虚拟机栈作用很相似，它们的区别在于虚拟机栈为虚拟机执行Java方法（即字节码）服务，而本地方法栈则为虚拟机使用到的Native方法服务。例如调用本地c/c++的方法。

  5. 程序计数器：程序计数器是记录当前线程所执行指令的行数。

user对象的生命周期如下

在这里插入图片描述

2.4 练习

练习1：定义一个钟表类，属性有秒针，分钟针，时针。方法有runSecond(),runMinute(),runHour()来描述指针的运行，要求最后完成钟表正常运行。

参考答案：

public class Clock {
    //1.定义秒针
    int second;
    //2.定义分钟针
    int minute;
    //4.定义小时针
    int hour;
    //5.定义运行秒针方法
    void runSecond(){
        second++;
        if(second==60) {
            second = 0;
            //minute++;
            runMinute();
        }
    }
    //6.定义分钟针运行
    void runMinute() {
        minute++;
        if(minute==60) {
            minute=0;
            //hour++;
            runHour();
        }
    }
    //7.定义小时
    void runHour() {
        hour++;
        if(hour==24) {
            hour = 0;
        }
    }
    public static void main(String[] args) {
        //1.创建钟表对象
        Clock clock = new Clock();
        //2.初始化值
        clock.second = 10;
        clock.minute = 51;
        clock.hour = 15;
        //3.打印时钟
        while(true) {
            //4.后面详细讲这个代码,这里只是测试,让程序听1000毫秒在执行
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("时钟："+clock.hour+":"+clock.minute+":"+clock.second);
            clock.runSecond();
        }
    }
}

类的访问机制：

  • 在一个类中的访问机制：类中的方法可以直接访问类中的成员变量和成员方法。
  • 在不同类中的访问机制：先创建要访问类的对象，再用对象访问类中定义的成员

2.5 小节

  1. 类与对象的关系
  2. 类的定义与对象的创建
  3. 对象在jvm的运行过程
  4. 类的访问机制

三、匿名对象

3.1 什么是匿名对象

像这种new Person()不保存对象内存地址的对象叫匿名对象

示例：

/**
 * 匿名对象
 */
public class AnonymousObject {
    void study(){
        System.out.println("胖叔讲java");
    }

    /*程序入口*/
    public static void main(String[] args) {
        //匿名对象调用方法
        new AnonymousObject().study();
        // == 比较基本类型比较的是内容是否相等，比较引用类型比较的是地址是否相等
        // 匿名对象是两个对象，所以地址不相等
        System.out.println(new AnonymousObject()==new AnonymousObject());
    }
}

jvm运行过程

在这里插入图片描述

3.2 应用场景

匿名对象的应用场景

  • 如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。
  • 我们经常将匿名对象作为实参传递给一个方法调用

示例:

public class AnonymousObject2 {
    int id = 1;
    String name = "张三";
    int age = 18;
}

public class AnonymousObject2Use {

    public void useAnonymousObject2(AnonymousObject2 anonymousObject2){
        System.out.println("id:"+anonymousObject2.id+",name:"+anonymousObject2.name+",age:"+anonymousObject2.age);
    }

    public static void main(String[] args) {
        //匿名对象当作参数使用
        AnonymousObject2Use anonymousObject2Use = new AnonymousObject2Use();
        anonymousObject2Use.useAnonymousObject2(new AnonymousObject2());
    }
}

四、类的成员详解

上边讲了类与对象的基本使用，我们在类中定义类属性和方法；其实类的成员包含很多内容，如下所示：

在这里插入图片描述

本章节详细讲解成员变量、方法、构造方法、其他类的成员会在后面章节详细讲解。

4.1 成员变量

4.1.1 成员变量与局部变量的区别

在方法体外，类体内声明的变量称为成员变量。在方法体内部声明的变量称为局部变量。成员变量和局部变量的区别如下：

在这里插入图片描述

示例1：成员变量与局部变量区别

/**
 * 成员变量与局部变量的区别
 */
public class VariableDemo {
    //成员变量可以被private、public、static、final修饰，这些修饰符含义后面详细讲解
    private int id;
    private String name;

    /*程序入口*/
    public static void main(String[] args) {
        //局部变量只能用final修饰
        //private int i; //报错
        int j = 1;
        //局部变量必须初始化才能使用
        System.out.println(j);
        //创建对象，成员变量有默认值
        VariableDemo variableDemo = new VariableDemo();
        System.out.println(variableDemo.id);
        System.out.println(variableDemo.name);

    }
}

4.1.2 成员变量的默认值

当一个对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值。除了 基本数据类型之外的变量类型都是引用类型。具体默认值如下:

在这里插入图片描述

示例2：成员变量默认值

/**
 * 成员变量默认值
 */
public class VariableDemo2 {
    byte v1;
    short v2;
    int v3;
    long v4;
    float v5;
    double v6;
    char v7;
    boolean v8;

    /*程序入口*/
    public static void main(String[] args) {
        VariableDemo2 variableDemo2 = new VariableDemo2();
        System.out.println(variableDemo2.v1);
        System.out.println(variableDemo2.v2);
        System.out.println(variableDemo2.v3);
        System.out.println(variableDemo2.v4);
        System.out.println(variableDemo2.v5);
        System.out.println(variableDemo2.v6);
        System.out.println(variableDemo2.v7);
        System.out.println(variableDemo2.v8);
    }
}

4.2 方法

什么是方法？

  • 方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。
  • 将功能封装为方法的目的是，可以实现代码重用，简化代码
  • Java里的方法不能独立存在，所有的方法必须定义在类里

4.2.1 方法的基本应用

定义方法的语法如下：
在这里插入图片描述

其中 ：

  • 修饰符：public, 缺省,private, protected等等
  • 返回值类型：
    • 没有返回值：void
    • 有返回值，声明出返回值的类型。与方法体中“ “return ” 返回值” 搭配使用；返回值类型可以是基本类型和引用类型。
  • 方法名 ：属于标识符，命名时遵循标识符命名规则和规范，“ 见名知意”
  • 形参列表：可以包含零个，一个或多个 参数。多个参数时，中间用“, ”隔开
  • 返回值：方法在执行完毕后返还给调用它的程序的数据。

方法 的分类：按照是否有形参及返回值

在这里插入图片描述

注意：无返回的方法也可以使用return关键字，代表结束方法的执行。具体使用参照下面示例：

示例1：方法的分类演示

/**
 * 方法定义的分类
 */
public class MethodDemo {
    // 无参数，无返回值方法
    void method1(){
        System.out.println("胖叔讲java，一路相伴");
    }
    // 有参数，无返回值方法
    void method2(String arg){
        System.out.println("有参数无返回值方法，参数是："+arg);
    }
    // 无参数，有返回值方法
    String method3(){
        return "结果"; //返回的内容必须和返回类型保持一致
    }
    // 有参数，有返回值方法
    String method4(String arg){
        System.out.println("有参数有返回值方法，参数是："+arg);
        return "结果2";
    }

    public static void main(String[] args) {
        //创建对象
        MethodDemo methodDemo = new MethodDemo();
        //调用方法
        methodDemo.method1();
        methodDemo.method2("小红");
        String result = methodDemo.method3();
        System.out.println(result);
        String result2 = methodDemo.method4("小明");
        System.out.println(result2);
    }

}

示例2：无返回值方法使用return关键字

/**
 * 无返回值方法使用return关键字
 */
public class MethodDemo2 {
    /**
     * 需求：从1打印到指定目标数
     *
     * return 结束该方法运行。 返回值类型是void return 后面不加值，直接写分号。
     */
    public void method1(int target){
        int i = 1;
        while(true){
            System.out.println(i);
            if(i==target){
                return;
            }
            i++;

        }
    }

    public static void main(String[] args) {
        MethodDemo2 methodDemo2 = new MethodDemo2();
        methodDemo2.method1(1100);
    }
}

小结：

  • 方法被调用一次，就会执行一次
  • 没有具体返回值的情况，返回值类型用关键字void表示，那么方法体中可以不必使用return语句。如果使用，仅用来结束方法。
  • 定义方法时，方法的结果应该返回给调用者，交由调用者处理。
  • 方法中只能调用方法或属性，不可以在方法内部定义方法。

4.2.2 方法的重载

重载的概念：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

重载的特点：与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。

示例：返回两个数字/三个数字的和

package top.psjj.demo1;

/**
 * 方法的重载，求两个数的和
 */
public class OverloadMethod {
    int sum(int a,int b){
        return a+b;
    }
    int sum(int a,int b,int c){
        return a+b+c;
    }
    double sum(double a,double b){
        return a+b;
    }
    double sum(double a,double b ,double c){
        return a+b+c;
    }

    public static void main(String[] args) {
        //创建对象
        OverloadMethod overloadMethod = new OverloadMethod();
        //调用方法:方法重载,优点：感觉上像是调用一个方法实现了多个功能，实际还是调用了多个方法。
        int result = overloadMethod.sum(1, 2);
        System.out.println(result);
        double result2 = overloadMethod.sum(1.1, 2.2);
        System.out.println(result2);
        int result3 = overloadMethod.sum(1, 2, 3);
        System.out.println(result3);
        double result4 = overloadMethod.sum(1.1,2.2,3.3);
        System.out.println(result4);
    }
}

练习题1：编写程序，定义三个重载方法并调用。方法名为mol。三个方法分别接收一个int参数、两个int参数、一个字符串参数。分别 执行平方运算并输出结果，相乘并输出结果，输出字符串信息。 在主类的main ()方法中分别用参数区别调用三个方法。

练习题2：定义三个重载方法max()，第一个方法求两个int值中的最大值，第二个方 法求两个double值中的最大值，第三个方法求三个double值中的最大值， 并分别调用三个方法。

4.2.3 方法的可变参数

什么是可变参数？

JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参

可变参数语法:

  • 声明格式：**方法名(参数的类型名 …参数名) **
  • 可变参数：传递实参的个数是可变的，可以是0个，1个 ，2个 …
  • 可变个数形参的方法与同名的方法之间，彼此构成重载
  • 可变参数方法的使用与方法参数部分使用数组是一致的
  • 方法的参数部分有可变形参，需要放在形参声明的最后
  • 在一个方法的形参位置，最多只能声明一个可变个数形参

示例：通过可变参数计算n个数的最大值，最小值。

/**
 * 可变参数：通过可变参数计算n个数的最大值，最小值。
 */
public class NumberUtils {
    //args 代表参数
    void printMaxAndMin(double... args) {
        //1.可变参数的数据全部存放在args的数组中
        double min;
        double max;
        if(args.length>0) {
            //2.如果传入参数就初始化最大值和最小值
            min = args[0];
            max = args[0];
            for(int i=0;i<args.length;i++) {
                if(min>args[i]) {
                    min = args[i];
                }
                if(max<args[i]) {
                    max = args[i];
                }
            }
            //3.打印最大值和最小值
            System.out.println("最大值:"+max);
            System.out.println("最小值:"+min);
        } else {
            System.out.println("没有传递参数无法计算最大值和最小值");
        }

    }
    public static void main(String[] args) {
        NumberUtils numberUtils = new NumberUtils();
        numberUtils.printMaxAndMin(-1.1,2.2,3.3,9.3);
        numberUtils.printMaxAndMin();
    }
}

示例2：

/**
 * 求n个整数的和，至少传入一个参数
 */
public class SumDemo {
    //1.只可以有一个可变参数而且必须在最后
    int sum(int number,int... args) {
        int sum = 0;
        sum+=number;
        if(args.length>0) {
            for(int i=0;i<args.length;i++) {
                sum+=args[i];
            }
        }
        return sum;
    }
    public static void main(String[] args) {
        SumDemo sumDemo = new SumDemo();
        int result = sumDemo.sum(1,2,3);
        System.out.println(result);
    }
}

练习题：通过可变参数计算n个数的最大值，最小值，和，平均值。

4.2.4 方法的值的传递机制

Java里方法的参数传递方式只有一种：值传递。 即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

  • 形参是基本数据和String类型：将实参基本数据类型变量的“数据值”传递给形参
  • 形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参

示例1：测试方法参数传递是传递实际参数的副本

public class MethodDemo {
    //Java里方法的参数传递方式只有一种：值传递。 即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。
    void method1(int i){
        //改变参数值
        i++;
        System.out.println(i);
    }
    //Java里方法的参数传递方式只有一种：值传递。 即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。
    void method2(User user){
        //改变参数的地址
        user = new User();
        //给新地址重新赋值
        user.id = 2;
        user.name = "李四";
        user.show();
    }

    public static void main(String[] args) {
        //创建对象
        MethodDemo methodDemo = new MethodDemo();
        //将变量i传入method1方法中，是将i的副本传入方法中i的值不受影响
        int i = 5;
        methodDemo.method1(i);
        System.out.println(i);
        //将user对象传入method2方法中，是将user对象的内存地址副本传入方法中
        User user = new User();
        user.id = 1;
        user.name = "张三";
        // method2对传入的副本的地址更改了，对原来地址内容没有影响
        methodDemo.method2(user);
        user.show();

    }
}
class User {
    int id;
    String name;
    void show(){
        System.out.println("id:"+id+",name:"+name);
    }
}

示例2：当实际参数是基本类型和引用类型的区别

/**
 * 值传递，基本类型和引用类型的区别
 */
public class MethodDemo2 {
    //传递基本类型传递的是值的副本，方法体内改变参数的值不会影响外部变量
    void method1(int i){
        //改变参数值
        i++;
        System.out.println(i);
    }
    //传递引用类型传递的是值的副本，但是值的副本和外部变量却指向堆内存同一块内存地址
    //所以改变改变user地址的内容，外部的对象的属性也就变了
    void method2(User user){
        user.id = 2;
        user.name = "李四";
        user.show();
    }

    public static void main(String[] args) {
        MethodDemo2 methodDemo2 = new MethodDemo2();
        //传递基本类型传递的是值的副本，方法体内改变参数的值不会影响外部变量
        int i = 1;
        methodDemo2.method1(i);
        System.out.println(i);
        //传递引用类型传递的是值的副本，但是值的副本和外部变量却指向堆内存同一块内存地址
        //所以改变改变user地址的内容，外部的对象的属性也就变了
        User user = new User();
        user.id = 1;
        user.name = "张三";
        methodDemo2.method2(user);
        user.show();

    }
 

}
class User {
    int id;
    String name;
    void show(){
        System.out.println("id:"+id+",name:"+name);
    }
}

练习题：定义一个数组工具类数组反转,数组排序。

小结：java参数传递机制只有一种，值传递，既将实参的复制品的值传入参数；如果是基本类型和String传递的数数据值，对外部变量没有影响；如果传递是引用类I型那个，传递的是地址值，可能堆外部变量有影响。

4.2.5 方法的递归

什么是递归？递归就是方法本身调用方法本身。

示例1：用方法打印1-100的数；

public class RecursiveDemo  {
	//1.用递归的方式：从1打印到100
	void print(int i) {
		if(i<=100) { 
			System.out.println(i);
			i++;
			print(i);
		}
	}
	public static void main(String[] args) {
		RecursiveDemo recursiveDemo = new RecursiveDemo();
		recursiveDemo.print(1);
	}
}

示例2：递归必须指定程序出口,否者报错：StackOverflowError 栈溢出错误

public class RecursiveDemo2 {
    //递归调用没有指定方法出口，无限调用
    void print(int i) {
        System.out.println(i);
        i++;
        print(i);
    }
    public static void main(String[] args) {
        RecursiveDemo2 recursiveDemo2 = new RecursiveDemo2();
        recursiveDemo2.print(1);
    }
}

练习题1：请用递归计算出1-100的和

练习题2：请用Java写出递归求阶乘(n!)的算法

4.3 构造方法

4.3.1 构造方法的基本使用

在java类中定义的构造方法是用来创建对象的，它的定义语法如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G7N3U0eZ-1658146485325)(assets/14.png)]

示例1：在User类型中定义构造方法并使用

public class User {
    int id;
    String name;
    int age;
    //定义构造方法
    User(int userId,String userName,int userAge){
        id = userId;
        name = userName;
        age = userAge;
    }

    public static void main(String[] args) {
        //使用构造方法创建对象
        User user = new User(1,"张三",21);
        //查看user信息
        System.out.println("id:"+user.id+",name:"+user.name+",age:"+user.age);
    }
}

4.3.2 构造方法的重载

构造方法是一种特殊的方法，也可以进行方法的重载;

示例1：

public class User {
    int id;
    String name;
    int age;
    //定义构造方法
    User(int userId,String userName,int userAge){
        id = userId;
        name = userName;
        age = userAge;
    }
    //构造方法的重载
    User(int userId,String userName){
        id = userId;
        name = userName;
    }
    User(){

    }

    public static void main(String[] args) {
        //使用构造方法创建对象
        User user = new User(1,"张三",21);
        //查看user信息
        System.out.println("id:"+user.id+",name:"+user.name+",age:"+user.age);

        //创建对象，查看用户信息
        User user2 = new User(2,"李四");
        System.out.println("id:"+user2.id+",name:"+user2.name+",age:"+user2.age);

        //创建对象，查看用户信息
        User user3 = new User();
        System.out.println("id:"+user3.id+",name:"+user3.name+",age:"+user3.age);
    }
}

4.3.3 默认构造方法

在一个类中如果没定义构造方法，系统会默认定义一个无参数的构造方法;在一个类中如果定义了构造方法，系统将不会默认定义构造方法

示例1：

public class Person {
    int id;
    String name;

    /**
     * 当类中没有定义构造方法时，系统会默认定义如下构造方法
     */
    /*public Person(){

    }*/
    /**
     * 当类中定义了构造方法时，系统不会默认定义构造方法
     */
    public Person(int personId,String personName){
        id = personId;
        name = personName;
    }
    public static void main(String[] args) {
        //创建对象
        Person person = new Person();

    }
}

4.3.4 构造方法注意事项

使用构造方法时需要注意以下几点：

  • 它具有与类相同的名称
  • 它不声明返回值类型。（与声明为void不同）
  • 不能被static、final、synchronized、abstract 等修饰，不能有 return语句返回值
  • 构造方法是一种特殊的方法，支持重载

4.4 小结

  1. 成员变量与局部变量的区别

  2. 成员变量的默认值

  3. 方法的重载

  4. 可变参数

  5. 方法的值传递机制

  6. 方法的递归

  7. 构造方法

五、this关键字

5.1 this关键字概述

在Java中，this关键字比较难理解，它的作用和其词义很接近。单词含义是这个 的意思 。this关键字可以使用在方法和构造方法体内。

  • 它在方法内部使用，即这个方法所属对象的引用；
  • 它在构造器内部使用，表示该构造器正在初始化的对象。
  • this 可以调用类的属性、方法和构造器

5.2 this 入门案例

我们先看如下案例，发现构造方法的参数名不能和成员变量名一样，否者无法初始化；示例代码如下：

public class User {
    int id;
    String name;
    int age;

    /**
     *java 使用变量有就近原则 从当前最近{} 范围查找变量，找到就是使用，找不到才去成员变量找
     * 所以，这里面的id=id name = name age=age其实是参数给参数自己赋值，根本没有调用成员变量
     */
   /* User(int id,String name,int age){
        id = id;
        name = name;
        age = age;
    }*/
    // this关键字，表示该构造方法正在初始化的对象
    User(int id,String name,int age){
        this.id = id;
        this.name = name;
        this.age = age;
    }
    void show(){
        System.out.println("id:"+id+",name:"+name+",age:"+age);
    }
    /*程序入口*/
    public static void main(String[] args) {
        User user = new User(1,"张三",18);
        user.show();
        User user2 = new User(2,"李四",19);
        user2.show();

    }
}

5.3 this关键字应用场景

this关键字可以使用在方法和构造方法体内。

  • 它在方法内部使用，即这个方法所属对象的引用；
  • 它在构造器内部使用，表示该构造器正在初始化的对象。
  • this 可以调用类的属性、方法和构造器

示例1：this在构造方法中应用

public class User {
    int id;
    String name;
    int sex;
    User(int id,String name,int sex){
        //this代表当前正在初始化的user对象，
        // 含义是user.id = id; user.name = name user.sex = sex;
        //但此时只能通过this引用正在初始化的对象。
        this.id = id;
        this.name = name;
        this.sex = sex;
    }
    User(int id,String name){
        // this(参数列表)调用的是构造方法 调用的上面的构造方法
        this(id,name,0);
        // 代表当前正在初始化的user对象 this.show()等价于user.show(),但此时只能通过this引用正在初始化的对象。
        this.show();
    }
    void show(){
        System.out.println("id:"+id+",name:"+name+",sex:"+sex);
    }

    /*程序入口*/
    public static void main(String[] args) {
        User user = new User(1,"张三");

    }
}

示例2：this在普通方法中应用

public class User {
    int id;
    String name;
    int sex;

    User(int id, String name, int sex) {
        this.id = id;
        this.name = name;
        this.sex = sex;
    }
    void method1(){
        System.out.println("方法");
    }
    void show(){
        //在方法中不可以调用构造器，不能使用this(1,"张三",1);
        //当前方法所属对象调用method1()
        this.method1();
        //当前方法所属对象 id name sex 属性
        System.out.println("id:"+this.id+",name:"+this.name+",sex:"+this.sex);
    }

}

5.4 小结

this可以使用在构造器和方法中，在构造器中可以使用

  • this.属性
  • this.方法
  • this(构造方法参数列表)

在普通方法中可以使用

  • this.属性
  • this.方法

六、总结

  1. 类与对象
  2. 成员变量
  3. 成员方法
  4. 方法重载
  5. 可变参数
  6. 值传递
  7. 递归
  8. 构造方法
  9. this关键字应用
胖叔讲Java
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
day06_自定义类型、ArrayList类.pdf
11-02
"day06_自定义类型、ArrayList类" 自定义类型是Java中的一个重要概念，它允许开发者创建自己的数据类型，以描述现实生活中的事物。在Java中，自定义类型是一种引用数据类型，它可以包含多个方法与属性，供我们使用...
day12_Object类、常用API.pdf
11-02
equals()方法的作用是指示其他某个对象是否与此对象“相等”。equals()方法的源码中比较两个对象的内存地址是否相同，相同则返回true。实际应用中，比较内存地址是否相同并没有意义，我们可以定义对象自己的比较方式...
匿名对象的特性和使用场景你知道吗？
m0_72532428的博客
05-12 2439
匿名对象的特性和使用场景
Java中的匿名对象基本概念和使用方式
kepengs的博客
07-20 902
概念： 创建对象时，只有new 类名()；这种创建对象的语句，却没有把对象地址赋值给某个变量。这是一种创建对象的简化写法，应用范围有限。 格式： new 类名（参数列表）; 应用场景： 1.创建匿名对象直接调用方法，没有变量名。 new Scanner(System.in).nextInt(); 2.一旦调用两次，就会执行两次new，就会创建两个对象。 new Scanner(System.in).nextInt(); new Scanner(System.in).nextInt(
【C++】匿名对象超详细详解（什么是匿名对象？对象可以是哪些类型呢？）
最新发布
weixin_45031801的博客
05-01 2061
在C++中，匿名对象（Anonymous Object）是指在没有被命名的情况下创建的临时对象。它们通常用于在单个语句中执行一系列操作或调用某个函数，并且不需要将其结果存储到变量中。
Java语言程序设计 类和对象（匿名对象的使用、方法的重载、可变个数的形参以及方法形参的传递）
qq_54190116的博客
05-20 197
接着上一篇文章，梳理一下今天的知识：还是类和对象 1.匿名对象的使用： 匿名对象也就是你只需要使用一次，不需要再建立一个对象，使用一个匿名的对象来调用方法 这里的Phone p=new Phone(); p.sendMail(); 就是建立了一个对象 而这里new Phone().sendMail();就是匿名对象，不需要建立特定的对象而直接调用方法，结果都是相同的： 2.方法的重载：（overload） 在同一个类中，允许存在一个以上的同名方法，只要他们...
匿名对象的使用场景与概述
巴胡子
10-18 1233
匿名对象的含义： 没有名字的对象 应用场景： 当方法只调用一次的时候可以使用匿名对象 可以当做参数进行传递，但是无法在传参之前做其他的操作 注意：匿名对象可以调用成员变量，也可以赋值，但是赋值并没有意义，因为只能使用一次 好处： 匿名对象调用一次就可以被垃圾回收器给回收，而有名字的方法只有使用完毕，等待方法结束后才会被垃圾回收器回收 package fangfa.com; publ...
spring_day06_spring_
10-03
标题中的"spring_day06_spring_"表明这是关于Spring框架的第六天学习内容，而描述中的"heima source code day 06"暗示我们将探讨的是有关Heima（可能是一个项目或公司的名称）的源代码，这与Spring框架的集成或者在...
day07【类与对象、封装、构造方法】.pdf
11-02
类与对象、封装、构造方法 类和对象是面向对象编程的基础概念，它们之间的关系是面向对象编程的核心。类是对一类事物的描述，是抽象的；对象是一类事物的实例，是具体的。类是对象的模板，对象是类的实体。 面向...
day06【类与对象、封装、构造方法】.pdf
02-20
day06【类与对象、封装、构造方法】.pdf
Java基础---匿名对象的理解和使用
愚者的博客
05-22 313
匿名对象 概念：没有名字的对象 语法： new 类名(); 用法： 1.对象被创建之后，如果其中某个方法只调用一次，可以用匿名对象去调 用，可以节省空间； 2.作为方法的实际参数； 3.作为方法的返回值。 注意：匿名对象可以用来给成员变量赋值，但是一旦赋值，它就变成了垃圾， 即使没被处理，我们也用不了。 （就像幽灵，你知道这个空间里有它，但你捕获不到它） package com.DaYu; public class Demo08 { public static vo
Java面向对象初级——6.匿名对象的使用
lyx434681575的博客
10-26 520
对匿名对象进行讲解
Java中匿名对象的概念和使用
qq_41847894的博客
05-14 561
匿名对象的概念 顾名思义就是没有名字的对象，即创建的对象没有赋予一个变量作为名字。 Phone p = new People(); //有名对象，对象名为p new People(); //匿名对象,没有对象名 匿名对象的使用 需要特别注意的就是匿名对象只能调用一次，具体如何使用直接上代码： public class Test { public static void main(String[] args) { //此处创建一个有名对象p Pe
匿名对象概念和使用
qq_34723470的博客
09-01 7943
匿名对象就是没有名字的对象：     Student stu = new Student();//这个stu就是对象，名字就是stu     new Student();//这个也是一个对象，但是没有名字   gc回收回收堆内存中对象的机制是，栈中没有变量指向该对象，那么该对象就是垃圾，可以被回收。匿名对象如下方式被创建： new Student().show()
24.匿名对象是什么？有什么作用？匿名对象的总结
嘻哈怪才的博客
12-29 2696
匿名对象是什么？有什么作用？ 格式：new 构造方法(参数) 含义：匿名对象就是没有名字的对象，没有对象名的对象 作用: <1>提高开发效率；匿名对象当前行使用之后，如果没有其他引用数据类型的变量保存其地址，直接销毁； <2>简化代码结构 <3>通过匿名对象直接调用成员方法； <4>使用匿名对象作为方法的参数； public class Test { //成员变量 private String name; private Strin
什么是匿名对象，匿名对象怎么使用
DTJ990226的博客
07-29 4781
匿名对象没有名字，只能使用一次 new Phone().sendEmail(); new Phone().playGame(); 上面这两种是匿名对象。 new Phone().price = 1999; new Phone().showPrice();//0.0 匿名对象结果不同。 class Phone{ double price;//价格 public void s...
day05_git
weixin_39535978的博客
07-18 150
git、gitee
day15_泛型
weixin_39535978的博客
07-26 136
泛型
面向对象编程：类与对象详解
"面向对象程序设计语言课件，讲解了类和对象的概念，以及与之相关的成员函数、构造函数、析构函数、对象成员、静态成员和指向类成员的指针等核心概念。通过示例介绍了如何定义一个简单的日期类Tdate，包括其公有成员...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值