Java之类与对象(内存分配机制、成员方法、构造器、作用域、this关键字)

最新推荐文章于 2024-08-01 15:05:06 发布

KuronumaAoi

最新推荐文章于 2024-08-01 15:05:06 发布

阅读量15

点赞数 1

文章标签： java 开发语言 jvm

Java之类与对象

1.类和对象

//定义一个猫类
class Cat {
    //对象中的数据称为 
    //实例字段/属性/成员变量
    String name;
    int age;
    String color;
    
    
}

总结：

类是一个自定义数据类型
对象是一个类的实例

实例化一个对象：

public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat(); //创建一个Cat类对象
    }
}

类和对象的区别与联系：

类是抽象的，概念的，代表一类事物,比如人类,猫类.., 即它是数据类型。
对象是具体的，实际的，代表一个具体事物, 即是实例。
类是对象的模板，对象是类的一个个体，对应一个实例。

对象在内存中的存在形式：

Java之类与对象(内存分配机制、成员方法、构造器、作用域、this关键字)_类与对象

分析： 由上图可以看出，执行 Cat cat = new Cat(); 时，首先会对Cat 类的信息进行加载，然后再对其进行空间的分配。对象 cat 存储的是一个地址，cat 通过存储的地址来获取数据，即对象是引用类型。

1.2 属性/成员变量/实例字段

对象中的数据称为 实例字段 （属性/成员变量），操作数据的过程称为方法。属性是类的一个组成部分，一般是基本数据类型,也可是引用类型(对象，数组)。比如我们前面定义猫类的int age 就是属性。

注意事项与细节：

属性的定义语法同变量，示例：访问修饰符属性类型属性名; 访问修饰符：控制属性的访问范围有四种访问修饰符 public, proctected, 默认, private 。
属性的定义类型可以为任意类型，包含基本类型或引用类型。
属性如果不赋值，有默认值，规则和数组一致。具体说: int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000， boolean false，String null。

1.3 创建对象

先声明再创建
Cat cat ; //声明对象cat cat = new Cat(); //创建
直接创建
Cat cat = new Cat();

1.3.1 通过对象访问属性

基本语法：

对象名.属性名；

例如：

1.3.2 类和对象的内存分配机制

定义一个 Person 类（包括：名字，年龄）。

Person p1 = new Person();
p1.age = 10;
p1.name = "小明";
Person p2; //此时，变量p2不是一个对象，实际上它也没有引用任何对象。
p2 = p1;

System.out.println(p2.age);

内存图如下：

Java之类与对象(内存分配机制、成员方法、构造器、作用域、this关键字)_构造器_02

可以更明显的看出， p2 = p1; 是让 p2 引用一个已有的对象 p1 。

1.3.3 Java 内存的结构分析

栈：一般存放基本数据类型(局部变量) 。
堆：存放对象(Cat cat , 数组等) 。
方法区：常量池(常量，比如字符串)，类加载信息。

1.3.4 Java 创建对象的流程简单分析

先加载 Person 类信息(属性和方法信息, 只会加载一次)
在堆中分配空间, 进行默认初始化(看规则) 。
把地址赋给 p , p 就指向对象。
进行指定初始化，比如 p.name =”jack” p.age = 1

1.4 成员方法

1.4.1 使用成员方法的方式

成员方法的好处

提高代码的复用性
可以将实现的细节封装起来，然后供其他用户来调用即可

成员方法的定义

访问修饰符返回数据类型方法名（形参列表..） {//方法体语句； return 返回值; }

形参列表：表示成员方法输入 cal(int n) ， getSum(int num1, int num2)
返回数据类型：表示成员方法输出, void 表示没有返回值
方法主体：表示为了实现某一功能代码块
return 语句不是必须的。

用下面一个例子来说明，使用中的细节：

public class MethodDetail {
public static void main(String[] args) {
    AA a = new AA();
    int[] res = a.getSumAndSub(1, 4);
    System.out.println("和=" + res[0]);
    System.out.println("差=" + res[1]);
    //细节: 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型 的参数
    byte b1 = 1;
    byte b2 = 2;
    a.getSumAndSub(b1, b2);//byte -> int
    //a.getSumAndSub(1.1, 1.8);//double ->int(×)
    //细节: 实参和形参的类型要一致或兼容、个数、顺序必须一致
    //a.getSumAndSub(100);//× 个数不一致
    a.f3("tom", 10); //ok
    //a.f3(100, "jack"); // 实际参数和形式参数顺序不对
    }
    }
    class AA {
    //细节: 方法不能嵌套定义
    public void f4() {
    //错误
    // public void f5() {
    // }
    }
    public void f3(String str, int n) {
    }
    //1. 一个方法最多有一个返回值 [思考，如何返回多个结果 返回数组 ]
    public int[] getSumAndSub(int n1, int n2) {
        int[] resArr = new int[2]; //
        resArr[0] = n1 + n2;
        resArr[1] = n1 - n2;
        return resArr;
    }
    //2. 返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)
    // 具体看 getSumAndSub
    //
    //3. 如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值;
    // 而且要求返回值类型必须和 return 的值类型一致或兼容
    public double f1() {
        double d1 = 1.1 * 3;
        int n = 100;
        return n; // int ->double
        //return d1; //ok? double -> int
    }
    //如果方法是 void，则方法体中可以没有 return 语句，或者 只写 return ;
    //老韩提示：在实际工作中，我们的方法都是为了完成某个功能，所以方法名要有一定含义
    //，最好是见名知意
    public void f2() {
        System.out.println("hello1");
        System.out.println("hello1");
        System.out.println("hello1");
        int n = 10;
        //return ;
	}
}

访问修饰符 (作用是控制方法使用的范围)
如果不写默认访问，[有四种: public, protected, 默认, private],
返回数据类型

一个方法最多有一个返回值 [思考，如何返回多个结果返回数组 ]
返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)
如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值; 而且要求返回值类型必须和 return 的值类型一致或兼容
如果方法是 void，则方法体中可以没有 return 语句，或者只写 return ;

方法名
遵循驼峰命名法，最好见名知义，表达出该功能的意思即可, 比如得到两个数的和 getSum, 开发中按照规范。
形参列表

一个方法可以有 0 个参数，也可以有多个参数，中间用逗号隔开，比如： getSum(int n, int m)
参数类型可以为任意类型，包含基本类型或引用类型，比如 printArr(int[][] map)
调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数！
方法定义时的参数称为形式参数，简称形参；方法调用时的传入参数称为实际参数，简称实参，实参和形参的类型要一致或兼容、个数、顺序必须一致！

方法体
里面写完成功能的具体语句，可以为输入、输出、变量、运算、分支、循环、方法调用，但是里面不能再定义方法！ 即：方法不能嵌套定义！！！

方法调用的细节

同一个类中的方法调用：直接调用即可。
跨类中的方法 A类调用 B 类方法：需要通过对象名调用。比如：对象名.方法名（参数）
特别说明：跨类的方法调用和方法的访问修饰符有关。

1.4.2 更改器方法和访问器方法

更改器方法 ：调用方法之后，对象的状态会发生改变
访问器方法 ：只访问对象而不修改对象的方法称为访问器方法。

1.5 成员方法的传参机制

如何将参数传递给方法（或函数），主要有2种传递方式：

按值调用：表示方法接收的是调用者提供的值。
按引用调用：表示方法接收的是调用者提供的变量地址

方法可以修改按引用传递的变量的值，而不能修改按值传递的变量的值。

Java程序设计语言总是采用 按值调用 。也就是说，方法得到的是所有参数值的一个副本。

编写一个交换2个 Person 类的方法：

public static void swap(Person x, Person y) {
    Person temp = x;
    x = y;
    y = temp;
}

如果Java 对对象采用的是按引用传递，那么这个方法就应该可以实现交换：

但是，这个方法并没有改变存储在变量 a 和 b 中的对象引用。swap 方法的参数 x 和 y 被初始化为两个对象引用的副本，这个方法交换的是这两个副本。

Java之类与对象(内存分配机制、成员方法、构造器、作用域、this关键字)_内存存在形式_03

最终，白费力气。在方法结束时参数变量 x 和 y 被丢弃了。原来的变量 a 和 b 仍然引用这个方法调用之前所引用的对象。

这个过程说明：Java程序设计语言对对象采用的不是按引用传递，实际上，对象引用是按值传递的。

1.5 方法的重载

Java 中允许同一个类中，多个同名方法的存在，但要求形参列表不一致！

重载的好处：

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

例如：

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 的和

注意事项和使用细节：

方法名：必须相同
形参列表：必须不同（形参类型或个数或顺序，至少有一样不同，参数名无要求）
返回类型：无要求

1.6 可变参数

基本概念：

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

基本语法：

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

//1. int... 表示接受的是可变参数，类型是 int ,即可以接收多个 int(0-多)
//2. 使用可变参数时，可以当做数组来使用 即 nums 可以当做数组
//3. 遍历 nums 求和即可
public int sum(int... nums) {
    //System.out.println("接收的参数个数=" + nums.length);
    int res = 0;
    for(int i = 0; i < nums.length; i++) {
    	res += nums[i];
    }
    return res;
}

注意事项和细节：

可变参数的实参可以为 0 个或任意多个。
可变参数的实参可以为数组。
可变参数的本质就是数组。
可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后。
一个形参列表中只能出现一个可变参数。

public class VarParameterDetail {
//编写一个 main 方法
public static void main(String[] args){
    //细节: 可变参数的实参可以为数组
        int[] arr = {1, 2, 3};
        T t1 = new T();
        t1.f1(arr);
    }
}
class T {
    public void f1(int... nums) {
    System.out.println("长度=" + nums.length);
    }
	//细节: 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
    public void f2(String str, double... nums) {
    }
	//细节: 一个形参列表中只能出现一个可变参数
	//下面的写法是错的.
   // public void f3(int... nums1, double... nums2) {
	// }
}

1.7 作用域

1.7.1 基本使用

在Java 编程中，主要的变量就是属性（成员变量）和局部变量。
我们说的局部变量一般是指在成员方法中定义的变量。
java中作用域的分类

全局变量：也就是属性，作用域为整个类体
局部变量：也就是除了属性之外的其他变量，作用域为定义它的代码块中

全局变量（属性）可以不赋值，直接使用，因为有默认值，局部变量必须赋值后，才能使用，因为没有默认值。

1.7.2 注意事项和使用细节

属性和局部变量可以重名，访问时遵循就近原则。
在同一个作用域中，比如在同一个成员方法中，2个局部变量，不能重名。
属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。局部变量，生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁，即在一次方法的调用过程中。
作用域范围不同

全局变量/属性：可以被本类使用，或其他类使用（通过对象调用）
局部变量：只能在本类中对应的方法中使用

修饰符不同

全局变量/属性可以加修饰符
局部变量不可以加修饰符

1.8 构造器/构造方法

1.8.1 基本介绍

基本语法：

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

说明：

构造器的修饰符可以默认，也可以是 public protected private
构造器没有返回值
方法名和类名字必须一样
参数列表和成员方法一样的规则
构造器的调用, 由系统完成
在创建对象时，系统会自动的调用该类的构造器完成对象的初始化。

1.8.2 注意事项和使用细节

一个类可以定义多个不同的构造器，即构造器重载
比如：我们可以再给Person类定义一个构造器，用来创建对象的时候，只指定人名，不需要指定年龄。
构造器名和类名要相同
构造器没有返回值
构造器是完成对象的初始化，并不是创建对象。
在创建对象时，系统自动的调用该类的构造方法
如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器（也叫默认构造器），比如 Dog() {},
一旦定义了自己的构造器，默认构造器就覆盖了，就不能再使用默认的无参构造器，除非显式的定义一下： Dog(){}

1.9 对象创建流程分析

class Person {
    int age = 90;
    String name;
    Person(String n, int a) {
        name = n;
        age = a;
    }
}

分析 Person p = new Person("小熊",18); 的创建流程。

加载 Person 类信息（Person.class）,只会加载一次。
在堆中分配空间（有一个空间的地址）
完成对象的初始化

默认初始化 age = 0; name = null;
显式初始化 age = 90; name = null;
构造器初始化，age = 18; name = "小熊";
把对象在堆中的地址返回给 p （p 是对象名，也可以理解为对象的引用）

1.10 this 关键字

1.10.1 隐式参数与显式参数

class Cat {
    String name;
    int age;
    
    public void addage(int a) {
        age++;
    }
}

addage 方法有2个参数。第一个参数称为 隐式参数 ，是出现在方法名前的 Cat 类型的对象。第二个参数是位于方法名后面括号中的数值，这是一个 显式参数 。（有人把隐式参数称为方法调用的目标或接收者）。

可以看到，显示参数显式的列在方法声明中，例如 int a 。隐式参数没有出现在方法声明中。

在每一个方法中，关键字 this 指示隐式参数。即当前对象。

class Person {
    String name;
    int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        //this 指示隐式参数，也就是所构造的对象
    }
}

1.10.2 this 的注意事项和使用细节

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

class Person {
    String name;
    int age;
    
    public Person() {
        this("小熊",20);//将会调用匹配的构造器
      //this() 只能在构造器中使用，并且必须是构造器中的第一条语句
        System.out.println();
    }
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        //this 指示隐式参数，也就是所构造的对象
    }
}

原创作者: u_16183599 转载于: https://blog.51cto.com/u_16183599/11377617

KuronumaAoi

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Java之类与对象(内存分配机制、成员方法、构造器、作用域、this关键字)

Java之类与对象1.类和对象登录后复制 //定义一个猫类class Cat { //对象中的数据称为 //实例字段/属性/成员变量 String name; int age; String color; }1.2.3.4.5.6.7.8.9.10.总结：...
复制链接

扫一扫