java基础---9. 面向对象

1. 概述

• 面向过程：当需要实现一个功能的时候，每一个具体的步骤都需要亲历亲为，详细处理每一个细节
• 面向对象：当需要实现一个功能的时候，不关心具体步骤，而是找一个已经具有该功能的人来帮我做事。

package cn.itcast.day05.demo01;
import java.util.Arrays;

public class Demo01PrintArray {
    public static void main(String[] args) {
        int[] array = {10,20,3,5,11,666};
        //面向对象 打印数组
        //JDK已经为我们提供了Arrays类，其中有一个是toString方法，直接就可以把数组变成想要的格式的字符串
        System.out.println(Arrays.toString(array));
    }
}

面向对象的语言中包含了3大特征：封装、继承、多态

2. 类和对象的关系

• 类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类的事物。
• 类是对一类事物的描述
• 对象是一类事物的实例
• 类是对象的模板，对象是类的实体

2.1 类的定义

public class Student {
    //成员变量（属性）：直接定义在类当中，在方法外面。
    //之前所学的定义在方法(包括main方法)中的变量都是局部变量
    String name;
    String age;

    //成员方法（行为）：与普通方法最显著的区别是没有关键字static
    public void eat(){
        System.out.println("吃饭饭");
    }
    public void sleep(){
        System.out.println("吃觉觉");
    }
    public void study(){
        System.out.println("学习！");
    }
}

2.2 对象的创建及使用

/*
通常情况下 一个类并不可以直接使用，需要根据类创建一个对象，才可以使用
1. 导包：也就是指出需要使用的类在什么位置
import 包名称.类名称；
import cn.itcast.day05.demo01.Student
对于和当前类同属于一个包的情况，可以省略包语句不写

2. 创建，格式：
类名称 对象名 = new 类名称();
Student stu = new Student();

3. 使用
使用成员变量：对象名.成员变量名
使用成员方法：对象名.成员方法名([参数])

注意事项：
如果成员变量没有赋值， 那么将会有一个默认值，规则和数组一样。
 */
public class Demo02Student {
    public static void main(String[] args) {
        //1. 导包 省略
        //2. 创建对象
        Student stu = new Student();
        //3. 使用
        System.out.println(stu.name);//null
        System.out.println(stu.age);//0

        //改变对象中成员变量的内容
        stu.name = "赵丽颖";
        stu.age = 18;
        System.out.println(stu.name);//赵丽颖
        System.out.println(stu.age);//18

        //4. 使用对象的成员方法
        stu.eat();
    }
}

2.3 手机类练习

• 定义

public class Phone {
    //成员变量
    String brand;
    double price;
    String color;
    //成员方法
    public void call(String who) {
        System.out.println("给"+who+"打电话");
    }
    public void sendMessage () {
        System.out.println("群发短信");
    }
}

-使用

public class Demo01PhoneOne {
    public static void main(String[] args) {
        Phone one = new Phone();
        System.out.println(one.brand);
        System.out.println(one.price);
        System.out.println(one.color);

        one.brand="苹果";
        one.price=8388.5;
        one.color="黑色";
        System.out.println(one.brand);
        System.out.println(one.price);
        System.out.println(one.color);

        one.call("乔布斯");
        one.sendMessage();

    }
}

2.4对象对应的内存图

• 方法区最先有数据，保存的是.class信息。两个.class相关信息都在方法区应该先从main方法开始执行。
• main方法进栈(压栈)，进栈之后做了一些事情：创建了一个对象（等号左边局部变量）Phone one。同时等号右边new Phone()在堆中开辟一段内存空间，并将其地址0x666，赋值给栈中的变量Phone one。
• 同时栈中new Phone()创建出的这个类里面所存放的内容由方法区告知(内容包括成员变量和成员方法)，将成员变量拿过来，并为其赋上默认值。而里面的成员方法保存的是一个地址值0x333。即成员方法的地址值保存在堆当中。
• 访问one.brand中的内容：通过one知道地址0x666,根据地址找到one.brand的当前值。
• 修改one.brand中的内容: 通过one知道地址0x666,根据地址找到one.brand的当前位置，并将其原先的值替换掉。
• 执行one.call("乔布斯")：通过one知道地址0x666，在根据0x333找到方法(两步走)，之后在方法区找到了一个call(String who)方法。
• 若想运行call(String who)方法，也需要进栈（注意：它是后进栈的，所以压着main方法，也叫压栈），之后根据参数“乔布斯”，得出给乔布斯打电话
• call(String who)方法该方法完成后，打上×，代表出栈，也叫弹栈。
• 之后运行one.sendMessage()，该方法进栈。。。出栈。。。
• main方法出栈

2.5 两个对象使用同一个方法

public class Demo02PhoneTwo {
    public static void main(String[] args) {
        Phone one = new Phone();
        System.out.println(one.brand);
        System.out.println(one.price);
        System.out.println(one.color);

        one.brand="苹果";
        one.price=8388.5;
        one.color="黑色";
        System.out.println(one.brand);
        System.out.println(one.price);
        System.out.println(one.color);

        one.call("乔布斯");
        one.sendMessage();
        System.out.println("===================================");
        Phone two = new Phone();
        System.out.println(two.brand);
        System.out.println(two.price);
        System.out.println(two.color);


        two.brand="三星";
        two.price=5999.0;
        two.color="蓝色";
        System.out.println(two.brand);
        System.out.println(two.price);
        System.out.println(two.color);

        two.call("欧巴");
        two.sendMessage();

    }
}

内存图如下：

2.6 两个引用指向同一个对象的地址

public class Demo03PhoneSame {
    public static void main(String[] args) {
        Phone one = new Phone();
        System.out.println(one.brand);//null
        System.out.println(one.price);//0.0
        System.out.println(one.color);//null

        one.brand="苹果";
        one.price=8388.5;
        one.color="黑色";
        System.out.println(one.brand);//苹果
        System.out.println(one.price);//8388.5
        System.out.println(one.color);//黑色

        one.call("乔布斯");//给乔布斯打电话
        one.sendMessage();//群发短信
        System.out.println("===================================");

        //将one当中保存的对象地址值赋值给two
        Phone two = one;
        System.out.println(two.brand);//苹果
        System.out.println(two.price);//8388.5
        System.out.println(two.color);//黑色
        
        two.brand="三星";
        two.price=5999.0;
        two.color="蓝色";
        System.out.println(two.brand);//三星
        System.out.println(two.price);//5999.0
        System.out.println(two.color);//蓝色

        two.call("欧巴");//给欧巴打电话
        two.sendMessage();//群发短信
    }
}

内存图如下：

2.7 使用对象类型作为方法的参数

public class Demo04PhoneParam {
    public static void main(String[] args) {
        Phone one = new Phone();
        one.brand = "苹果";
        one.price = 8388.0;
        one.color = "土豪金";
        method(one);//传递进去的参数就是对象的地址值
    }
    public static void method(Phone param) {
        System.out.println(param.brand);//苹果
        System.out.println(param.price);//8388.0
        System.out.println(param.color);//土豪金
    }
}

2.8 使用对象类型作为方法的返回值

public class Demo05PhoneReturn {
    public static void main(String[] args) {
        Phone two = getPhone();
        System.out.println(two.brand);//苹果
        System.out.println(two.price);//8388.0
        System.out.println(two.color);//玫瑰金
    }
    public static Phone getPhone() {
        Phone one = new Phone();
        one.brand = "苹果";
        one.price = 8388.0;
        one.color = "玫瑰金";
        //谁调用我，我就把one的地址交给谁
        return one;
    }
}

内存图如下：

3 成员变量与局部变量的区别

/*
成员变量和局部变量
1. 定义的位置不一样
局部变量：定义在方法内部
成员变量：定义在方法外部，直接写在类当中

2.作用范围不一样
局部变量：只有在方法当中可以使用
成员变量：整个类都可以通用

3. 默认值不一样
局部变量：没有默认值，如果要想使用，必须手动进行赋值，否则会报错
成员变量：如果没有赋值就会有默认值，规则和数组一样

4. 内存位置不一样(了解)
局部变量：跟着方法走，位于栈内存
成员变量：位于堆内存

5. 生命周期不一样
局部变量：随着方法进栈而诞生，随着方法出栈而消失
成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失
 */
public class Demo01VariableDifference {
    public void method(int param) {
        //方法的参数param是局部变量,
        //按道理说param没有默认值，
        System.out.println(param);//那为什么直接使用没有报错呢
        //原因：参数在方法被调用的时候必然会赋值
    }
}