面向对象编程学习-优快云博客

一、数组巩固：数组的合并、去重与排序

需求

实现两个 int 类型数组的合并、去重并排序功能。例如：{1,2,5,3,8,9}和{1,3,0}合并去重排序后得到{0,1,2,3,5,8,9}

实现步骤

合并数组：创建新数组，长度为两个原数组长度之和，使用System.arraycopy()复制元素，（数组长度不可变）
排序数组：使用Arrays.sort()对合并后的数组进行排序（这里我们不需要再自己写排序方法，而只需要调用官方提供的排序方法，灵活，高效，解放了我们的时间精力）
去重处理：
- 创建临时数组存储不重复元素
- 遍历排序后的数组，通过标志位判断元素是否已存在
- 最后将有效元素拷贝到新数组中

代码实现

package com.qf.homework;

import java.util.Arrays;

public class Homework {
    public static void main(String[] args) {
        test();
    }

    public static void test(){
        int[] arr1 = {1,2,4,5,3,8,9};
        int[] arr2 = {1,0,3,4,5,8,10};

        // 1.合并数组
        int[] arr3 = new int[arr1.length + arr2.length];
        System.arraycopy(arr1,0,arr3,0,arr1.length);
        System.arraycopy(arr2,0,arr3,arr1.length,arr2.length);

        // 2.排序
        Arrays.sort(arr3);

        // 3.去重
        int[] arr4 = new int[arr3.length];
        int index = 0;
        for (int i = 0; i < arr3.length; i++) {
            int n = arr3[i];
            boolean flag = false;
            for (int j = 0; j < index; j++) {
                if (n == arr4[j]) {
                    flag = true;
                }
            }
            if (!flag) {
                arr4[index] = n;
                index++;
            }
        }
        
        // 拷贝有效元素
        int[] arr5 = new int[index];
        System.arraycopy(arr4,0,arr5,0,index);
        System.out.println("合并去重排序后:"+Arrays.toString(arr5) );
    }
}

二、面向对象编程基础

2.1 面向对象编程介绍

面向过程：关注实现步骤，事无巨细全部考虑（如 C 语言）
面向对象：关注对象和交互，将事情交给对象完成（如 Java）
核心区别：面向对象更注重代码复用，将功能封装到对象中
就像从家到学校要骑一辆自行车，面向过程就像是用各种原料现场造一辆车来使用，面向对象便是直接租用共享单车。面向对象无需关心车是怎么制造的，直接使用这辆车就好，当然，车不是凭空而来的，要先造了车，才有车直接用，面向对象底层都需要面向过程编程来实现。

2.2 核心概念

类：具有相似属性和行为的事物的抽象模板
属性：描述事物特征的变量（名词）
行为：事物能执行的操作（方法，动词）
对象：类的具体实例，拥有具体的属性值和可执行的行为

2.3 类的定义

语法规则

类名要求见名知意，使用大驼峰命名法，单词拼接时，第一个单词小写，后面单词首字母大写
属性定义在类中方法外，格式：[访问修饰符] 数据类型属性名;
方法定义在类中，不加 static 关键字（通过对象调用）

示例：手机类

package com.qf.oop;

public class Phone {
    // 属性
    public double price;
    String brand;
    String color;

    // 方法
    public void call(String phoneNum){
        System.out.println("打电话给"+phoneNum );
    }

    public void play() {
        System.out.println("打游戏" );
    }
}

示例：英雄类

package com.qf.oop;

public class Hero {
    int hp;      // 血量
    int lv;      // 等级
    String type; // 类型

    public void attack(){
        System.out.println("攻击" );
    }
}

2.4 对象的创建与使用

创建对象

// 语法：类名 对象名 = new 类名();
Phone phone = new Phone();
Hero hero = new Hero();

操作属性和方法

// 访问属性
double price = phone.price;
String color = phone.color;

// 给属性赋值
phone.price = 3000.0;
phone.color = "黑色";
phone.brand = "HUAWEI";

// 调用方法
phone.call("110");
phone.play();

2.5 多对象与引用

一个类可以创建多个对象，对象间相互独立
多个引用可以指向同一个对象，此时操作一个引用会影响该对象

// 多个对象示例
Phone p1 = new Phone();
p1.brand = "OPPO";
p1.price = 2999.0;

Phone p2 = new Phone();
p2.brand = "vivo";
p2.price = 2799.0;

// 多个引用指向同一对象
Phone p3 = new Phone();
Phone p4 = p3; // p3和p4指向同一个对象
p3.price = 3999.0;
System.out.println(p4.price); // 输出3999.0

三、对象内存模型

3.1 内存分配规则

类加载进内存
方法执行时进入栈内存
new创建的对象进入堆内存
堆中对象包含：内存地址、属性（有默认值）、方法引用

3.2 内存示意图

单个对象内存：引用变量在栈，对象在堆，引用存储对象地址
多个对象内存：每个对象在堆中占据独立空间，引用各自指向不同对象
多引用同一对象：多个引用在栈中存储相同的堆内存地址

四、成员变量与局部变量

特性	成员变量 (属性)	局部变量
位置	类中方法外	方法内
作用域	类中所有方法	当前方法内
内存位置	堆中的对象中	栈中的方法里
初始化	new 时赋默认值	方法调用时必须手动赋值

特殊情况

局部变量可以和成员变量重名，遵循就近原则
使用this关键字可以指定访问成员变量

public class Person {
    String name; // 成员变量

    public void eat() {
        String name = "小王"; // 局部变量
        System.out.println(this.name + "在吃"); // this指定访问成员变量
        System.out.println(name + "在吃"); // 访问局部变量
    }
}

五、引用类型传递练习

T1：基本类型与引用类型赋值区别

class MyClass{
    int value;
}
public class TestRef{
    public static void main(String args[]){
        int a = 10;
        int b = a;
        b++ ;
        System.out.println(a); // 10（基本类型赋值是值传递）
        
        MyClass mc1 = new MyClass();
        mc1.value = 10;
        MyClass mc2 = mc1;
        mc2.value ++;
        System.out.println(mc1.value); // 11（引用类型赋值是地址传递）
    }
}

T2：引用类型作为返回值

class ClassA{
    int value = 10;
}
public class TestReturnRef{
    public static void main(String args[]){
        ClassA ca = new ClassA();
        ca = getObject(); // 每次调用都返回新对象
        ca = getObject();
        ca = getObject();
        System.out.println(ca.value); // 20
    }
    public static ClassA getObject(){
        ClassA newObject = new ClassA();
        newObject.value += 10; // 10+10=20
        return newObject;
    }
}

T3：方法参数传递机制

class ClassA{
    int value;
}
public class TestClassA{
    public static void main(String args[]){
        int value = 10;
        changeInt(value);
        System.out.println(value); // 10（基本类型传值，不影响原值）
        
        ClassA ca = new ClassA();
        ca.value = 10;
        changeObject(ca);
        System.out.println(ca.value); // 11（引用类型传地址，影响对象）
    }
    public static void changeInt(int value){
        value++;
    }
    public static void changeObject(ClassA ca){
        ca.value++;
    }
}

T4：引用重新赋值

class ClassA{
    int value;
}
public class ChangeRef{
    public static void main(String args[]){
        ClassA ca = new ClassA();
        changeValue(ca);
        System.out.println(ca.value); // 100
        changeRef(ca);
        System.out.println(ca.value); // 100（方法内重新赋值不影响外部引用）
    }
    public static void changeValue(ClassA ca){
        ca.value = 100;
    }
    public static void changeRef(ClassA ca){
        ca = new ClassA(); // 指向新对象
        ca.value = 200;
    }
}