Java 类和对象

• Java 类和对象
  • 1. 面向对象程序设计
    • 1.1 万物皆类
    • 1.2 创建类和对象
      • 1.2.1 匿名对象
      • 1.2.2 对象的内存解析
  • 2. 类的成员组成
    • 2.1 类的成员：成员变量
    • 2.2 类的成员：方法
  • 3. 方法重载（Overload）

Java 类和对象

如果你没有对象，那就new一个吧

1. 面向对象程序设计

• 在编程范式中，主要有面向过程（Process-Oriented Progamming, POP）和面向对象（Object Oriented Progaming, OOP）两种编程设计思路。
• 面向过程（例如C语言）更多关注过程，以函数为组织单位，是一种执行者思维，适用于简单问题。
• 面向对象（例如C++、Java）关注焦点为类，以类为组织单位，是一种设计者思维，适用于复杂问题。

1.1 万物皆类

• 类（Class）：具有相同特征的事物的抽象
• 对象（Object）：类中实际存在的成员，也成为实例（instance）
  举个栗子：
  人就是一个类，每个人就是人类的对象；
  汽车也是一个类，华为的尊界S800就是其中一个对象；
  手机也是一个类，iPhone 16就是其中一个对象;
  猫猫也是一个类，布偶就是其中一个对象。

1.2 创建类和对象

面向对象的本质就是设计类，而我们刚才提到类是一种抽象，是具有相同特征的事物。具体来讲，类的相同特征我们通常用属性和行为来表示，即我们抽象出类的属性和行为来代表一个类。

• 属性（Field）：又称为成员变量，描述类的状态信息
• 行为：又称为成员方法或方法（Method）、函数，描述类的具体功能或操作

有时属性、成员变量和字段，行为、方法和函数等称谓会混合使用。我们需要自行辨别含义。不必纠结具体称谓，结合上下文，尽量使用统一表述即可。

话不多讲上代码

// 定义一个Person类
public class Person{
    // 声明成员变量
    String name;
    int age;

    // 声明成员方法、函数
    public void eat(){
        System.out.println("人需要吃饭")；
    }

    public void sleep(){
        System.out.println("人需要睡觉")；
    }
}

现在我们有类了，就可以创建对象了。使用关键字 new
语法为：类名 对象名 = new 类名（）

public PersonTest{
    public static void main(String[] args){
        // 创建Person类的对象
        Person p = new Person();
    }
}

至此成功创建完一个Person类的对象p,既然p是Person的一个实例，必然具备该类的属性和方法。使用对象名.属性和对象名.方法的方式来调用属性和方法

public PersonTest{
    public static void main(String[] args){
        // 创建Person类的对象
        Person p = new Person();

        // 访问属性
        p.age = 22;
        System.out.println(p.age);
        // 访问方法
        p.eat();
        p.sleep();

    }
}

小结：面向对象三步骤

• 类的定义
• 创建类的对象，即类的实例化
• 对象调用类的属性或方法

1.2.1 匿名对象

考虑一种情况，我们只需要某个对象使用一次，那么这个对象的名字就无关紧要了，就可以使用匿名方式创建对象。

    new Person().eat();
    new Person().sleep();

1.2.2 对象的内存解析

结论是所有对象实例和数组都在堆空间上，而局部变量、方法等在虚拟机栈上。

public PersonAddressTest{
    public static void main(String[] args){
        Person p1 = new Person();

        System.out.println(p1);// Person@6acbcfc0
        System.out.println(new Person());// Person@5f184fc6
    }
}

2. 类的成员组成

类的成员有：成员变量、方法、构造器、代码块、内部类等。我们会逐步展开讲解。

2.1 类的成员：成员变量

声明成员变量语法格式

[修饰符1] class 类名{
    [修饰符2] 数据类型 成员变量名 [= 初始化值]；
}

• 说明：
  • 位置——必须在类中，方法外
  • 修饰符——public、protected、缺省、private、static、final
  • 数据类型——基本数据类型 或 引用数据类型
  • 成员变量名——属于标识符，一般见名知意
  • 初始化——可以显示赋值，也可以不赋值，使用默认值

辨析：成员变量和局部变量

• 成员变量：在方法体外，类内声明的变量
• 局部变量：在方法体内部等位置声明的变量

public class Person{
    int age;   // 成员变量
    String name;  // 成员变量
    
    public void eat(){
        String info = "蛋炒饭";  // info 局部变量
        System.out.println("人喜欢吃" + info);
    }

    public void sleep(int hour){  // hour 局部变量
        System.out.println("人每天至少保证" + hour + "小时的睡眠");
    }
}

成员变量和局部变量的异同点

• 相同点
  • 变量声明格式相同，数据类型 变量名 = 初始化值
  • 变量必须先声明，再初始化，最后使用
• 不同点

成员变量的初始化赋值

成员变量类型	初始化值
byte	0
short	0
int	0
long	0L
float	0.0F
double	0.0
char	0
boolean	false
引用类型	null

2.2 类的成员：方法

声明方法的语法

[修饰符] 返回值类型 方法名 ([形参列表]) [throws 异常列表]{   // 方法头，方法签名，从方法头即可看出该方法的功能
    方法体的功能代码                                       // 方法体
}

• 说明
  1. 方法体的位置一定在类内，先声明后使用
  2. 方法调用一次执行一次，不调用不执行
  3. 方法体中可以调用类的属性或方法，但是不得在方法中定义方法

3. 方法重载（Overload）

• 概念：在同一个类中，我们可以定义一系列方法，他们功能类似，命名相同，只有参数列表不同，这就是方法重载

• 特点：与修饰符、返回值类型无关，只看参数列表，根据方法参数列表不同来调用

举个例子，我们之前使用System.out.println()语句，它会根据()中不同类型的参数进行匹配，找到参数个数和参数类型都一致的方法

public class PrintStreamTest{
    public static void main(String[] args){
        System.out.println(3);// 3
        System.out.println(1.8f);// 1.8
        System.out.println("hello world");// hello world

        int[] arr = new int[]{1,2,3};
        System.out.println(arr);// 地址值
    }
}

public class PrintStream {
    public void println(byte x){···};
    public void println(short x){···};
    public void println(int x){···};
    public void println(long x){···};
    public void println(float x){···};
    public void println(double x){···};
    public void println(char x){···};
    public void println(boolen x){···};
}

举例：

// 返回两个整数的和
public int add(int x,int y){
    return x+y;
}

和以上方法构成重载

// 返回三个整数的和
public int add(int x,int y,int z){
    return x+y+z;
}
// 返回两个小数的和
public double add(double x,double y){
    return x+y;
}

// 以下不是重载
public double add(int a,int b){
    ···
}