07 - 面向对象编程（基础部分）

有些事情做了，是因为必须要做，但不代表我就一点不害怕啊。

1.类与对象

1.1 介绍

学习java最核心最重要的就是要理解面向对象。

类是抽象的，概念的，代表一类事物，比如人类，猫类，狗类.., 即它是数据类型。

对象是具体的，实际的，代表一个具体事物,，是实例，具体的张三、李四、小花猫、大黄狗。

类是对象的模板，对象是类的一个个体，对应一个实例。

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

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

2.成员方法 

人类：除了有一些属性外(年龄，姓名...)，人类还有一些行为，比如：说话、跑步、玩游戏、听音乐，这些就要用成员方法才能完成。

class Person {
    // 属性
    String name;
    int age;

    // 方法(成员方法)
    //1. public 表示方法是公开
    //2. void ： 表示方法没有返回值
    //3. speak() : speak 是方法名， () 形参列表
    //4. {} 方法体，可以写我们要执行的代码
    public void speak() {
        System.out.println("我今天真的有好好吃饭！");
    }
}

3.成员方法传参机制

3.1 基本数据类型的传参机制

示例

public static void main(String[] args) {
    int a = 10;
    int b = 20;
    // 创建 AA 对象 名字 obj
    AA obj = new AA();
    obj.swap(a, b); //调用 swap
    System.out.println("main 方法 a=" + a + " b=" + b);//a=10 b=20
}


class AA {
    public void swap(int a,int b){
        System.out.println("\na 和 b 交换前的值\na=" + a + "\tb=" + b);//a=10 b=20
        // 完成了 a 和 b 的交换
        int tmp = a;
        a = b;
        b = tmp;
        System.out.println("\na 和 b 交换后的值\na=" + a + "\tb=" + b);//a=20 b=10
    }
}

结论

基本数据类型，传递的是值（值拷贝），形参的改变不影响实参。

3.2 引用数据类型的传参机制

B 类中编写一个方法 test100，可以接收一个数组，在方法中修改该数组，看看原来的数组是否变化？

B 类中编写一个方法 test200，可以接收一个 Person(age,sal)对象，在方法中修改该对象属性，看看原来的对象是否会变化?

public class MethodParameter02 {
    public static void main(String[] args) {
        // 测试1
        // B b = new B();
        // int[] arr = {1, 2, 3};
        // b.test100(arr);//调用方法
        // System.out.println(" main 的 arr 数组 ");
        // //遍历数组
        // for(int i = 0; i < arr.length; i++) {
        //     System.out.print(arr[i] + "\t");
        // }
        // System.out.println();

        // 测试2
        Person p = new Person();
        p.name = "jack";
        p.age = 10;
        b.test200(p);
        System.out.println("main 的 p.age=" + p.age);
    }
}


class Person {
    String name;
    int age;
}


class B {
    public void test200(Person p) {
        p = new Person();
        p.name = "tom";
        p.age = 99;
    }

    public void test100(int[] arr) {
        arr[0] = 200;
        // 遍历数组
        System.out.println(" test100 的 arr 数组 ");
        for(int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
    }
}

结论

引用类型传递的是地址，可以通过形参影响实参。

4.方法重载

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

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

5.可变参数

java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。

语法

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

}

代码示例

public class VarParameter01 {
    public static void main(String[] args) {
        TestMethod m = new TestMethod();
        System.out.println(m.sum(1, 5, 100)); //106
        System.out.println(m.sum(1,19)); //20
    }
}


class TestMethod {
    public int sum(int... nums) {
        int res = 0;
        for(int i = 0; i < nums.length; i++) {
            res += nums[i];
        }
        return res;
    }
}

注意

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

6. 作用域

介绍

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

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

注意事项

1. 属性和局部变量可以重名，访问时遵循最近原则。
2. 在同一个作用域中，比如在同一个成员方法中，两个局部变量，不能重名。
3. 属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。局部变量，生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁。即在一次方法调用过程中。
4. 作用域范围不同：全局变量/属性可以被本类使用，或其他类使用（通过对象调用）；局部变量：只能在本类中对应的方法中使用。
5. 修饰符不同：全局变量/属性可以加修饰符；局部变量不可以加修饰符。

7.构造方法/构造器

构造方法又叫构造器（constructor），是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。

public class Constructor01 {
    public static void main(String[] args) {
        Person p1 = new Person("路明非", 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;

    // 构造器
    public Person(String pName, int pAge) {
        System.out.println("构造器被调用~~ 完成对象的属性初始化");
        name = pName;
        age = pAge;
    }
}

注意：

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

8.对象创建的流程分析

class Person {
    int age;
    String name;

    Person(int dAge, String dName) {
        name = dName;
        age = dAge;
    }
}

Person p = new Person("18", "路明非");

流程分析：

1. 加载Person类信息（Person.class），只会加载一次。
2. 在堆中分配空间（地址）。
3. 完成对象的初始化（构造器的初始化，age = 18，name = 路明非）。
4. 把对象在堆中的地址（引用），返回给p。

9. this 关键字

虚拟机给每个对象分配this，代表当前对象。

public Person(String name, int age){
    // this.name 就是当前对象的属性 name
    this.name = name;
    // this.age 就是当前对象的属性 age
    this.age = age;
}

this图解

 this使用注意：

1. this关键字用来访问本类的属性、方法、构造器。
2. this用于区分当前类的属性和局部变量。
3. 访问成员方法的语法：this.方法名(参数列表)。
4. this不能在类定义的外部使用，只能在类定义的方法中使用。