【Java】Java学习（六）—— 面向对象思想

上一篇： Java学习（五）—— 方法和数组

第十五部分 面向对象思想

15.1 面向对象思想概述

Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下， 使用Java语言去设计、开发计算机程序。 这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算 机事件的设计思想。 它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。

• 区别

  • 面向过程：强调步骤。
  • 面向对象：强调对象。

• 特点： 面向对象的语言中，包含了三大基本特征，即封装、继承和多态。

public class PrintArray {

    public static void main(String[] args) {
        int[] array = { 10, 20, 30, 40, 50, 60 };

        // 要求打印格式为：[10, 20, 30, 40, 50]
        // 面向过程
        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            if (i == array.length - 1) { 	// 如果是最后一个元素
                System.out.println(array[i] + "]");
            } else { 	// 如果不是最后一个元素
                System.out.print(array[i] + ", ");
            }
        }
        System.out.println("==============");

        // 面向对象
        // 找一个JDK给我们提供好的Arrays类，
        // 其中有一个toString方法，直接就能把数组变成想要的格式的字符串
        System.out.println(Arrays.toString(array));
    }

}

15.2 类和对象

15.2.1 类

• 类： 是一组相关属性（事物的状态信息）和行为（事物能够做什么）的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。

• 举例： 一只小猫

  • 属性：名字、体重、年龄、颜色
  • 行为：走、跑、叫

15.2.2 对象

• 对象： 是一类事物的具体体现。对象是类的一个实例，必然具备该类事物的属性和行为。
• 举例： 一只小猫
  • 属性：tom、5kg、2 years、yellow
  • 行为：溜墙根走、蹦跶的跑、喵喵叫

15.2.3 类和对象的关系

• 类是对一类事物的描述，是抽象的
• 对象是一类事物的实例，是具体的
• 类是对象的模板，对象是类的实体

15.3 类的定义

• 定义格式：

public class ClassName {
  //成员变量（对应事物的属性）
  //成员方法（对应事物的行为）
}

• 成员变量： 和以前定义变量几乎是一样的。只不过位置发生了改变。在类中，方法外。
• 成员方法： 和以前定义方法几乎是一样的。只不过把static去掉。

public class Student {

    // 成员变量
    String name; // 姓名
    int age; 		 // 年龄

    // 成员方法
    public void eat() {
        System.out.println("吃饭！");
    }

    public void sleep() {
        System.out.println("睡觉！");
    }

    public void study(String subject) {
        System.out.println("学习" + subject);
    }

}

15.4 对象的使用

• 三个步骤：
  • 导包：指出需要使用的类在什么位置。格式为import 包名称.类名称，对于和当前类属于同一个包的情况，可以省略导包语句不写。
  • 创建对象：类名称 对象名 = new 类名称();
  • 使用成员变量：对象名.成员变量名
    使用成员方法：对象名.成员方法名(参数)

public class StudentDemo {

    public static void main(String[] args) {
        // 1. 导包。
        // 需要使用的Student类，和StudentDemo位于同一个包下，所以省略导包语句不写

        // 2. 创建对象
        Student stu = new Student();

        // 3. 使用成员变量
        System.out.println(stu.name); // null
        System.out.println(stu.age); // 0
        System.out.println("=============");

        // 改变对象当中的成员变量数值内容
        stu.name = "斋藤飞鸟";
        stu.age = 18;
        System.out.println(stu.name); // 斋藤飞鸟
        System.out.println(stu.age); // 18
        System.out.println("=============");

        // 4. 使用成员方法
        stu.eat();
        stu.sleep();
        stu.study("Java");
    }
  
}

• 如果成员变量没有进行赋值，那么将会有一个默认值，规则如下：

	数据类型	默认值
基本类型	整数（byte，short，int，long）	0
	浮点数（float，double）	0.0
	字符（char）	‘\u0000’
	布尔（boolean）	false
引用类型	数组，类，接口	null

15.5 对象内存图

• 创建Phone类

public class Phone {

    // 成员变量
    String brand; // 品牌
    double price; // 价格
    String color; // 颜色

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

    public void sendMessage() {
        System.out.println("群发短信");
    }
}

15.5.1 只有一个对象的内存图

• 定义测试类

public class Demo01PhoneOne {

    public static void main(String[] args) {
        // 根据Phone类，创建一个名为one的对象
        Phone one = new Phone();
        System.out.println(one.brand); // null
        System.out.println(one.price); // 0.0
        System.out.println(one.color); // null
        System.out.println("=========");

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

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

}

1. 通过上图，我们可以理解，在栈内存中运行的方法，遵循"先进后出，后进先出"的原则。变量one指向堆内存中的空间，寻找方法信息，去执行该方法。
2. 但是，这里依然有问题存在。创建多个对象时，如果每个对象内部都保存一份方法信息，这就非常浪费内存了，因为所有对象的方法信息都是一样的。那么如何解决这个问题呢？请看如下图解。

15.5.2 两个对象使用同一方法内存图

• 定义测试类

public class Demo02PhoneTwo {

    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
        System.out.println("=========");

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

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

        Phone two = new Phone();
        System.out.println(two.brand); // null
        System.out.println(two.price); // 0.0
        System.out.println(two.color); // null
        System.out.println("=========");

        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); // 蓝色
        System.out.println("=========");

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

}

对象调用方法时，根据对象中方法标记（地址值），去类中寻找方法信息。这样哪怕是多个对象，方法信息只保存一份，节约内存空间。

15.5.3 两个引用指向同一个对象的内存图

• 定义测试类

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
        System.out.println("=========");

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

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

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

        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); // 蓝色
        System.out.println("=========");

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

}

15.6 对象类型作为方法参数和返回值

• 创建Phone类

public class Phone {

    // 成员变量
    String brand; // 品牌
    double price; // 价格
    String color; // 颜色

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

    public void sendMessage() {
        System.out.println("群发短信");
    }
}

15.6.1 对象类型作为方法参数

• 定义测试类

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); // 土豪金
    }

}

当一个对象作为参数，传递到方法当中时，实际上传递进去的是对象的地址值。

15.6.2 对象类型作为方法返回值

• 定义测试类

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 = "玫瑰金";
        return one;
    }

}

当使用一个对象类型作为方法的返回值时，返回值其实就是对象的地址值。

15.7 成员变量和局部变量区别

• 在类中的位置不同
  • 成员变量：类中，方法外
  • 局部变量：方法中或者方法声明上(形式参数)
• 作用范围不一样
  • 成员变量：类中
  • 局部变量：方法中
• 初始化值的不同
  • 成员变量：有默认值
  • 局部变量：没有默认值。必须先定义，赋值，最后使用。
• 在内存中的位置不同
  • 成员变量：堆内存
  • 局部变量：栈内存
• 生命周期不同
  • 成员变量：随着对象的创建而存在，随着对象的消失而消失。
  • 局部变量：随着方法的进栈而存在，随着方法的出栈而消失。

public class VariableDifference {

    String name; // 成员变量

    public void methodA() {
        int num = 20; // 局部变量
        System.out.println(num);
        System.out.println(name);
    }

    public void methodB(int param) { // 方法的参数就是局部变量
        // 参数在方法调用的时候，必然会被赋值的。
        System.out.println(param);

        int age; // 局部变量
//        System.out.println(age); // 没赋值不能用

//        System.out.println(num); // 错误写法！
        System.out.println(name);
    }

}

上一篇： Java学习（五）—— 方法和数组
下一篇： Java学习（七）—— 封装