第二章_面向对象

一、类和对象

• 面向对象和面向过程的思想对比
  • 面向过程：是一种以过程为中心的编程思想，实现功能的每一步，都是自己实现的
  • 面向对象：是一种以对象为中心的编程思想，通过指挥对象实现具体的功能
• 类的理解
  • 类是对现实生活中一类具有共同属性和行为的事物的抽象
  • 类是对象的数据类型，类是具有相同属性和行为的一组对象的集合
  • 简单理解：类就是对现实事物的一种描述
• 类的组成
  • 属性：指事物的特征，例如：手机事物（品牌，价格，尺寸）
  • 行为：指事物能执行的操作，例如：手机事物（打电话，发短信）
• 类和对象的关系
  • 类：类是对现实生活中一类具有共同属性和行为的事物的抽象
  • 对象：是能够看得到摸的着的真实存在的实体
  • 简单理解：类是对事物的一种描述，对象则为具体存在的事物

1、类的定义

• 类的组成
  • 属性：在类中通过成员变量来体现（类中方法外的变量）
  • 行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）
• 类的定义步骤
  • ① 定义类
  • ② 编写类的成员变量
  • ③ 编写类的成员方法

public class Student {
    // 属性 : 姓名, 年龄
    // 成员变量: 跟之前定义变量的格式一样, 只不过位置发生了改变, 类中方法外
    String name;
    int age;

    // 行为 : 学习
    // 成员方法: 跟之前定义方法的格式一样, 只不过去掉了static关键字.
    public void study(){
        System.out.println("学习");
    }
}

2、对象的创建和使用

• 创建对象的格式
  • 类名 对象名 = new 类名();
• 调用成员的格式
  • 对象名.成员变量
  • 对象名.成员方法();

public class TestStudent {
    public static void main(String[] args) {
        // 类名 对象名 = new 类名();
        Student stu = new Student();
        // 对象名.变量名
        // 默认初始化值
        System.out.println(stu.name);  // null
        System.out.println(stu.age);   // 0
        stu.name = "张三";
        stu.age = 23;
        System.out.println(stu.name);  // 张三
        System.out.println(stu.age);   // 23
        // 对象名.方法名();
        stu.study();
        // com.sjyl.object1.Student@b4c966a
        // 全类名(包名 + 类名)
        System.out.println(stu);
    }
}

二、对象内存图

• 单个对象内存图
  • 对象在堆内存中保存了成员属性以及成员方法的地址

• 两个对象内存图
  • 多个对象在堆内存中，都有不同的内存划分，成员变量存储在各自的内存区域中，成员方法多个对象共用的一份
  • 每个堆内存中都单独保存了成员方法的地址
  • Student s2 = new Student();.class文件不需要再加载一次

• 两个引用指向同一对象内存图
  • 当多个对象的引用指向同一个内存空间（变量所记录的地址值是一样的）；只要有任何一个对象修改了内存中的数据，随后无论使用哪一个对象进行数据获取，都是修改后的数据

三、成员变量和局部变量

• 类中位置不同：成员变量（类中方法外）局部变量（方法内部或方法声明上）
• 内存中位置不同：成员变量（堆内存）局部变量（栈内存）
• 生命周期不同：成员变量（随着对象的存在而存在，随着对象的消失而消失）局部变量（随着方法的调用而
  存在，随着方法的调用完毕而消失）
• 初始化值不同：成员变量（有默认初始化值）局部变量（没有默认初始化值，必须先定义，赋值才能使用）

四、private关键字

• private概述
  • 概述 : private是一个修饰符，可以用来修饰成员（成员变量，成员方法）
  • 特点 : 被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用， 提供相应的操作
    • 提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
    • 提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰

/*
    学生类
    private : 私有的
    private是一个权限修饰符
    可以用来修饰成员(变量,方法)
    特点: 只能在本类当中进行访问
 */
public class Student {
    String name;
    private int age;
    // 设置值
    public void setAge(int a){
        if(a >= 0 && a <= 120){
            age = a;
        }else{
            System.out.println("您的年龄不合理");
        }
    }
    // 获取值
    public int getAge(){
        return age;
    }
    public void show(){
        System.out.println(name + "..." + age);
    }
}
public class TestStudent {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.name = "张三";
        //stu.age = 23;
        stu.setAge(-23);
        stu.show();
    }
}

五、this关键字

• this关键字作用
  • 局部变量和成员变量如果重名，java使用的就近原则
  • this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）
  • 方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
  • 方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量
• this代表所在类对象的引用
  • 方法被哪个对象调用，this就代表哪个对象

public class Student {
    private String name;
    private int age;

    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    public void show() {
        System.out.println(name + "," + age);
    }
}

六、类的封装

• 封装概述
  • 是面向对象三大特征之一（封装，继承，多态）
  • 是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的
• 封装原则
  • 将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
  • 成员变量private，提供对应的getXxx()/setXxx()方法
• 封装的好处
  • 通过方法来控制成员变量的操作，提高了代码的安全性
  • 把代码用方法进行封装，提高了代码的复用性

七、构造方法

• 构造方法的格式
  • 方法名与类名相同，大小写也要一致
  • 没有返回值类型，连void都没有
  • 没有具体的返回值（不能由retrun带回结果数据）
• 构造方法的执行时机
  • 创建对象的时候调用，每创建一次对象，就会执行一次构造方法
  • 不能手动调用构造方法
• 构造方法的作用
  • 用于给对象的数据（属性）进行初始化

public class Student {
    private String name;
    private int age;

    // 1. 如果一个类中没有编写任何构造方法, 系统将会提供一个默认的无参数构造方法
    public Student(){}

    // 2. 如果手动编写了构造方法, 系统就不会再提供默认的无参数构造方法了
    public Student(String name, int age){
        this.name = name;
        this.age = age;
        System.out.println("我是Student类的构造方法");
    }
    public void show(){
        System.out.println(name + "..." + age);
    }
}
public class TestStudent {
    public static void main(String[] args) {
        Student stu1 = new Student("张三",23);
        stu1.show();
        Student stu2 = new Student();
    }
}

• 构造方法的注意事项
  • 如果没有定义构造方法，系统将给出一个默认的无参数构造方法
  • 如果定义了构造方法，系统将不再提供默认的构造方法
• 推荐的使用方式
  • 无论是否使用，都手动书写无参数构造方法，和带参数构造方法

八、标准类的代码编写和使用

• Student类

/*
    JavaBean类: 封装数据
 */
public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void show(){
        System.out.println(name + "..." + age);
    }
}

• 测试类

public class TestStudent {
    public static void main(String[] args) {
        // 1. 无参数构造方法创建对象, 通过setXxx方法给成员变量进行赋值
        Student stu1 = new Student();
        stu1.setName("张三");
        stu1.setAge(23);
        stu1.show();

        // 2. 通过带参数构造方法, 直接给属性进行赋值
        Student stu2 = new Student("李四",24);
        stu2.show();
    }
}