JavaSE第6篇：面向对象

一、面向对象

1、面向对象：人关注对象、人关注具体事物信息

2、对象: 只要是客观存在的事物皆为对象

面向对象程序设计的重点是类的设计

设计类就是设计类的成员

思考：人把大象装进冰箱 ?

面向过程POP思想：强调的是过程（动作也就是方法）
1、把冰箱打开 2、抬起大象、塞进冰箱 3、把冰箱门关闭

面向对象OOP思想：强调的是对象（对象就是实体）

    人:类 {
        打开(冰箱) {
            冰箱.打开功能
        }
        抬起(大象) {
            大象.进入(冰箱)；
        }
        关闭(冰箱) {
            冰箱.闭合
        }
    }

    冰箱 {
        打开() {
        }
        闭合() {
        }
    }

    大象 {
        进入(冰箱) {
            比如头先进去
        }
    }

面向对象的特点:1、是一种常见思想。2、复杂变简单。3、执行者变指挥者。

二、类和对象

1、类和对象

类: 类是描述对象将会拥有的特征(属性)和行为(方法)

类的特点:类是对象的类型,具有相同属性和方法的一组对象的集合,方法和属性组成

对象：是实际存在的该类事物的每个个体、因此而成为实例(instance)

2、类的结构：属性和方法

属性Field：类的成员变量

方法Method：类中的成员方法

/**
 * 类的成员构成
 */
public class Person {

    //属性或成员变量
    private String pName;

    //构造器
    public Person() {

    }

    public Person(String name) {
        this.pName = name;
    }

    //方法或者函数
    public void run() {
        System.out.println("跑步");
    }

    //代码块
    {
        pName = "周杰伦";
    }

    //内部类
    class Dog{
        String dName;
    }
}

3、类和对象的创建

面向对象的思想落地

1、创建类、设计类的成员

2、创建对象

类名 对象名 = new 类名();

创建类的对象就是实例化

3、使用对象

对象名.属性

对象名.方法()

理解
如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性非static、如果我们修改一个对象的属性a则不影响另外一个对象的属性值。

内存解析
对象的内存解析

三、类的成员变量与局部变量

区别:
1、作用域不同
成员变量:在整个类中使用,也可以被关联的类使用
局部变量:只能在方法中使用

2、初始值不同
成员变量有一个默认的初始值
局部变量不会有初始值

3、同一个方法中局部变量不能重名,不同方法中可以有同名局部变量

4、成员变量和局部变量同名时,局部变量更有优先级

5、成员变量在堆内存中，局部变量在栈内存中

四、方法

方法描述类应该具有的功能

1、声明和使用

修饰符 返回值类型 方法名(形参列表){
方法体
return 返回值
}

return关键字:使用在方法体中
return作用：
1、结束一个方法
2、有返回值类型的方法 使用return返回 ‘数据’
3、return 后面没有语句

注意点：
方法的使用中、可以调用当前类的属性或方法
特殊：方法A中又调用了方法A。称为递归方法

2、方法重载和重写

方法重载:
同一个类中出现两个或两个以上的方法名相同,参数个数,顺序,类型不同的方法
方法重载的条件:
1、必须是在同一个类中
2、方法名相同
3、参数个数、顺序或类型不同
4、与方法的修饰符和返回值类型没有关系

两同一不同：同一个类、相同方法名。不同参数列表
方法重写
返回值类型,方法名,参数个数都要与继承父类的方法相同
子类中出现了和父类中方法声明一模一样的方法(方法名、参数列表和返回值类型都一样)，也被称为方法覆盖、方法重写

3、可变个数形参方法

JDK5.0新增的内容、5.0以前传入的是数组、之后是可变形参数
使用：
可变形参的格式 数据类型…参数名
当调用可变形参的方法时，传入的参数个数可以是0个1个多个
可变形参的方法与本类中方法名相同、形参不同方法之间构成重载
可变形参的方法与本类中方法名相同、形参类型也相同的数组之间不构成重载。换句话就是二者不能共存(数组和可变形参数)
可变形参在方法中最多有一个，而且是参数的最后一个位置、声明在末尾

    @Test
    public void  args(){
        show("实参1","实参2");
    }

    public void  show(String s){
        System.out.println("单个形参==："+s);
    }

    public void  show(String... s){
        for (String s1 : s) {
            System.out.println("可变形参==："+s1);
        }
    }

4、递归方法

递归方法：一个方法体内调用它自身

		//求1-100的和
    public static int getSum(int n) {
        if (n == 1) {
            return 1;
        } else {
            return n + getSum(n - 1);
        }
    }

五、JVM内存结构与对象内存解析

典型代码

Person p1 = new Person();
Person p2 = new Person();
Person p3 =p1;//没有新创建一个对象、共用一个堆空间中的对象实体

注意：p3没有创建一个新对象、共用一个堆空间中的对象实体p1

说明：如果一个类创建了多个对象，则每一个对象都独立的拥有一套类的属性(非static)。

意味着：如果我们修改一个对象的属性a，则不影响另外一个对象的属性a的值(非static)

对象的内存解析图

数组对象的内存解析图

将Java源代码使用javac命令经过编译器生成一个或多个字节码文件，使用Java命令将字节码文件使用JVM中的类加载器和解释器对生成的字节码文件进行解释运行(注意：运行的时候才将文件加载进内存)。意味着：需要将字节码文件对应的类加载到内存中，涉及到内存解析。

六、匿名对象的使用

1、匿名对象：我们创建的对象没有显示的赋给一个变量名
2、只能调用一次 new Person().name 进行调用

/**
 * phone商场
 */
class PhoneMall {
    public void  showPhone(Phone phone){
        phone.sendEmail();
        phone.playGame();
    }
}

    public static void main(String[] args) {
        //创建一个phone商场调用phone在内存中是同一个对象
        PhoneMall phoneMall = new PhoneMall();
        phoneMall.showPhone(new Phone());//匿名对象的使用
    }

七、方法参数的值传递机制

1、变量的赋值

1、变量是基本数据类型、此时赋值的是变量所保存的数据值
2、变量是引用数据类型、此时赋值的是数据保存的一个地址值
注意：引用数据类型的值默认是null或者地址值

方法形参的值传递机制： 值传递
形参：方法定义时小括号内的参数
实参：方法调用时实际传递给形参的数据

2、值传递机制：基本数据类型

如果参数是基本数据类型、此时实参赋给形参的是实参真实存储的数据值

    public static void main(String[] args) {
        //交换两个变量的值
        int m = 10;
        int n = 20;
        System.out.println("交换前m:" + m + ",n：" + n);
//        int temp = m;
//        m = n;
//        n = temp;
        ArrayUtils arrayUtils = new ArrayUtils();
        arrayUtils.swap(10, 20);//实参，调用后两个变量值没有替换
        //swap方法确实变量进行了交换，但是方法销毁后下面输出的是定义的变量m和n确实没有交换过来
        System.out.println("交换后m:" + m + ",n：" + n);
    }

    /**
     * 交换两个变量值的方法
     * m,n形参
     */
    public void swap(int m, int n) {
        int temp = m;
        m = n;
        n = temp;
        //System.out.println("swap交换后m:" + m + ",n：" + n);
    }

注意：swap方法确实变量进行了交换，但是方法销毁后就出栈了，下面输出的是定义的变量m和n确实没有交换过来

3、值传递机制：引用数据类型

方法参数是引用数据类型，此时实参赋给形参的是存储数据的一个地址值

class Data {
    int m = 10;
    int n = 20;

    /**
     * 交换两个变量的值
     *
     * @param data
     */
    public void swap(Data data) {
        int temp = data.m;
        data.m = data.n;
        data.n = temp;
    }
}

    public static void main(String[] args) {
        Data data = new Data();
        //交换两个变量的值
        data.m = 10;
        data.n = 20;
        System.out.println("交换前m:" + data.m + ",n：" + data.n);
        //交换
//        int temp = data.m;
//        data.m = data.n;
//        data.n = temp;
        data.swap(data);
        System.out.println("交换前后:" + data.m + ",n：" + data.n);

    }

练习：值传递内存图

八、深拷贝浅拷贝区别

1、概念

深拷贝浅拷贝与对象克隆操作相关的概念：用于描述在复制对象时对对象内部引用的处理方式

2、浅拷贝

在浅拷贝中，只有对象本身被复制，而不会复制对象内部的引用对象，
也就是说复制的对象和原始对象共享内部引用对象，如果原始对象包含引用类型的属性，那么这些属性在浅拷贝后会指向相同的引用对象

3、深拷贝

在深拷贝中不仅对象本身被复制，而且对象内部的引用对象也会被复制，从而创建一个全新的的独立对象。
如果原始对象包含引用类型的属性，那么这些属性在深拷贝后会指向不通的引用对象。

应用中
需要根据对象的结构和业务需求选择适当的拷贝方式，浅拷贝通常高效，但在需要独立对象的情况下可能会出现问题，深拷贝可以确保 每个对象都是独立的，但在复杂对象结构中可能会引入更多的复杂性

 @Test
    public void test1() {
        //地址
        Address address = new Address("北京");

        Teacher t1 = new Teacher("张三", address);

        //浅拷贝
        Teacher t2 = new Teacher(t1.getName(), t1.getAddress());

        //深拷贝
        //拷贝地址对象
        Address address3 = new Address(address.getCity());
        //拷贝老师对象
        Teacher t3 = new Teacher(t1.getName(), address3);

        //比较
        System.out.println("原始对象：" + t1.getAddress().getCity());
        System.out.println("浅拷贝对象：" + t2.getAddress().getCity());
        System.out.println("深拷贝对象：" + t3.getAddress().getCity());

        //修改对象的值
        t1.getAddress().setCity("上海");
        System.out.println("==============================修改后对象的值===============================");
        System.out.println("原始对象：" + t1.getAddress().getCity());
        System.out.println("浅拷贝对象：" + t2.getAddress().getCity());
        System.out.println("深拷贝对象：" + t3.getAddress().getCity());
    }

总结