Java 11 面向对象—参数传递

最新推荐文章于 2025-12-09 22:22:22 发布

原创最新推荐文章于 2025-12-09 22:22:22 发布 · 983 阅读

5 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

java入门

本文详细介绍了Java中对象的概念，强调对象是通过new运算符在堆内存中创建的，并讨论了引用如何保存对象的内存地址。此外，文章还探讨了参数传递的机制，指出Java中参数传递是按值传递，但对象参数实际上是传递对象的引用。通过实例展示了构造方法、this关键字的使用，以及静态与非静态方法的区别。最后，通过代码示例总结了this关键字的使用场景及其在实例方法和构造方法中的作用。

对象和引用

对象：目前在使用 new 运算符在堆内存中开辟的内存空间称为对象。
堆内存的空间

引用：是一个变量，不一定是局部变量。还可能是成员变量，引用保存了内存地址，指向了堆内存当中的对象。
空间的地址

所有访问实例相关的数据，都需要通过 “引用” 的方式访问，因为只有通过引用才能找到对象。

只有一个空的引用，访问对象的实例相关的数据会出现空指针异常。

class Student{
	Computer com; //com是一个引用的实例变量
public static void doSome(){
	Computer cc; //cc是一个引用的局部变量
	}

参数的传递

方法在调用的时候，参数是如何传递的？

java语言中，方法调用的时候，涉及到参数传递问题，
参数传递实际上是传递的变量中保存的具体的值。

int i = 10;
add(i);

等同于 add(10);

public class Test {
  public static void main(String[] args) {
    int i = 10;
    add(i);
    System.out.println("main--->" + i); // 10
  }

  public static  void add(int i){
    i ++;
    System.out.println("add --->" + i); // 11
  }
}

在这里插入图片描述

传递对象地址举例：

/*


*/
public class Test {
  public static void main(String[] args) {
    User u = new User(20);
    add(u);
    System.out.println("main--->" + u.age); // 21
  }

  public static void add(User u){
    u.age ++;
    System.out.println("add--->" + u.age); // 21
  }
}


class User{
  //实例变量
  int age;
  //构造方法
  public User(int i){
    age = i;
  }
}

在这里插入图片描述
小结：
方法调用的时候，涉及参数传递的问题，就是将变量中保存的 “值” 传递过去，只不过有时候这个值是一个字面值10，有时候，这个值是另一个java对象的内存地址。

int i = 10;
int j = i;
i传递给j，实际上只是将i变量中保存的10传递给了j，j实际上是一块全新的内存空间。

User u = 0x1234;
User u2 = u;
u传递给u2，实际上是将0x1234这个值赋值给了u2，u和u2实际上是两个不同的局部变量。但是他们这两个变量实际指向的是内存中同一个对象。

总结

OOA OOD OOP
封装继承多态
转换作用
类：抽象概念，抽象模板；包含两部分：状态 + 行为。
对象—>类抽象
类—>对象实例

成员变量：方法体外，全局变量
局部变量: 实例变量和静态变量
访问实例对象得首先创建对象，因为实例变量存储在 java堆内存中，需要先创建对象new，才能调用（通过引用访问）。

封装：将复杂的问题，封装起来，对外提供一个简单的操作入口，操作人员只能通过入口操作。
保证数据安全，操作简单，增加可移植性和可复制性。
1.属性私有化 private
2.提供两个方法 set 和 get，set修改实例变量，get读取数据。set涉及数据修改，需要做安全控制。

方法带static 类名.方法名
方法不带static 引用.方法名
set和get都不带static。

构造方法：作用：创建对象，初始化实例变量，构造方法不需要写返回值类型。
特点：方法名和类名一样
调用：new 运算符
调用后，返回一个数据变量，指向堆内存的开辟的空间

实例变量是在构造方法创建对象初始化的时候创建的
构造方法的初始化，不写，系统默认有。

this关键字

this 保存内存地址，指向自身

关于java语言当中的this关键字：
        1、this是一个关键字，翻译为这个
        2、this是一个引用，this是一个变量。this变量保存了内存地址，指向自身。
        3、this在实例方法中，this指向当前正在执行的动作的对线。（this代表当前对象）、this可以省略不写

在这里插入图片描述
当使用c1去访问该对象的话，整个过程中出现的this就是c1。
当使用c2去访问该对象的话，整个过程中出现的this就是c2。

package test3;


/*
关于java语言当中的this关键字：
        1、this是一个关键字，翻译为这个
        2、this是一个引用，this是一个变量。this变量保存了内存地址，指向自身。
        3、this在实例方法中，this指向当前正在执行的动作的对线。（this代表当前对象）、this可以省略不写
        4、this不能使用在static的方法当中
 */
public class Customer {

    //姓名 「对内存的对象内部中存储，所以访问该数据的时候，必须先创建对象，通过引用方式访问」
    String name; //实例变量： 必须采用引用的方式

    //构造方法
    public Customer(){

    }

    //不带有static关键字的一个的方法
    //顾客购物的行为
    // 每一个顾客购物的最终结果是不一样的
    // 所以购物这个行为属于对象级别的行为
    // 由于每一个对象在执行购物这个动作的时候最终结果不同，所以购物这个动作必须有对象的参与。

    // 没有static关键字的方法 实例方法，实例方法 必须 通过 引用 访问
    // 没有static关键字的变量 实例变量
    // 当一个行为执行的过程，需要对象的参与，那么这个方法一定要定义为 实例方法，不要带static。

    //以下方法定义为实例方法，因为每一个顾客在执行购物的时候，最终的结果是不同的。
    public void shopping(){
        System.out.println(this.name + " is shopping.");
//        System.out.println(name + " is shopping."); 0
    }

    public static void doSome(){
//        System.out.println(this.name); //erreor 执行过程中，没有当前对象，不存在this，因为this代表 当前对象
    }

    public static void doOther(){
        //可以采用以下方案，但是以下方案，绝对不是访问当前对象的name
        Customer c = new Customer();
        System.out.println(c.name); // 这里的name是创建出来c对象的name
    }
}

package test3;

/*

 */

public class Test {
  public static void main(String[] args) {
  // 创建Customer对象
    Customer c1 =new Customer();
    c1.name = "zs";
  // 再创建Customer对象
    Customer c2 = new Customer();
    c2.name = "ls";

    c1.shopping(); //zs在购物
    c2.shopping(); //ls在购物

    //调用doSome方法(修饰符上有static)
    // 采用 类名.方法名 的方式访问（不需要对象的参加）
    Customer.doSome();

    Customer.doOther();
  }
}

实例方法一定是有了对象之后，才能调用的。
带有static的方法不能直接访问实例变量和实例方法，因为没有对象的存在，当然new了一个之后就可以用了。

package test3;

/*

 */

public class Test {
  int num = 10;
  public static void main(String[] args) {

    //访问当前对象的属性
//    System.out.println(num); //error
    //想访问num怎么办？ ---》 new对象
    Test t = new Test();
    int num = t.num;

    doSome(); //带static方法调用

    t.doOther();// 实例方法调用： 引用.方法名
  }

  //带有static
  public static void doSome(){
    System.out.println("do Some!");
  }

  //实例方法
  public void doOther(){
    System.out.println("do Other!");
  }
}

创建对象构造函数构造方法一起使用综合例子

package test3;
/*
用来区分局部变量 和 实例变量的时候不可以省略
 */
public class User {

    //属性
    private int id; //这里id是局部id
    private String name;
    // 构造函数 set and get
    public void setId(int id){
        this.id = id; //this表示当前对象  ，这里 id是局部变量
    }

    // 构造方法
    public User(int id, String name){
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package test3;

/*

 */

public class Test {

  public static void main(String[] args) {

    User u1 = new User(100, "zs");
    System.out.println(u1.getId());
    System.out.println(u1.getName());

    //修改名字
    u1.setName("ls");
    System.out.println(u1.getId());
    System.out.println(u1.getName());
  }
}

例子2:
创建日期类
当程序员调用无参的构造方法。默认日期是1970-1-1
对外提供可以讲日期打印输出到输出台

package test3;

public class Date {

  // 属性
  private int year;
  private int month;
  private int date;

  // 构造函数
  public Date(int year, int month, int date) {
    this.year = year;
    this.month = month;
    this.date = date;
  }

  public Date() {
//    this.year = 1970;
//    this.month = 1;
//    this.date = 1;

    //构造方法的调用
    // 这种方法不会创建新的java对象，但同时又可以调用其他的构造方法
    this(1970,1,1);
  }

  public int getYear() {
    return year;
  }

  public void setYear(int year) {
    this.year = year;
  }

  public int getMonth() {
    return month;
  }

  public void setMonth(int month) {
    this.month = month;
  }

  public int getDate() {
    return date;
  }

  public void setDate(int date) {
    this.date = date;
  }

  public void print(){
    System.out.println(this.year + "年" + this.month + "月" + this.date + "日");
  }
}

package test3;

/*

 */

public class Test {

  public static void main(String[] args) {

    Date time1 = new Date();

    Date time2 = new Date(2008,8,8);

    time1.print();

    time2.print();
  }
}

根据以上例子总结—>This 用在哪里

1.可以用在实例方法当中，代表对当前对象调用。
2.可以用在构造方法当中，通过当前的构造方法调用其它方法，但是只能放在第一行，

将以上内存穿起来的例子

package test3;

/*

 */

public class Test {

  //带有static的方法
  public static void method1(){
    //调用doSome
      //完整方式的调用
    Test.doSome();
      //省略方式的调用
    doSome();
    //调用doOther
    Test t = new Test();
    t.doOther();
    //访问i
    int t2 = t.i;
  }
  //没有static的方法
  public void method2(){
    //调用doSome
    //完整方式的调用
    Test.doSome();
    //省略方式的调用
    doSome();
    //调用doOther
    this.doOther();
    //访问i
    int t2 = this.i;
  }

  // 主方法
  public static void main(String[] args) {

    //调用method1
    method1();
    //调用method2
    Test t = new Test();
    t.method2();
  }
  //没有static的变量
  int i = 10;

  //带有static的方法
  public static void doSome(){
    System.out.println("do Some!");
  }

  //没有static的方法
  public void doOther(){
    System.out.println("do Other!");
  }
}