06 类与对象、封装、构造方法

类与对象、封装、构造方法

一、面向对象思想的概述

• **面向过程：**当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节。

• **面向对象：**当需要实现一个功能的时候，不关心具体的步骤。

• 对比

  import java.util.Arrays;
  
  public class PrintArray {
      public static void main(String[] args) {
          int[] array = {1, 2, 3, 4, 5, 6};
  
          //打印数组，格式为[1, 2, 3, 4, 5, 6]
          //面向过程
          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(Arrays.toString(array));
      }
  }
  

二、类和对象的关系

1. 什么是类

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

2. 什么是对象

• 对象：是一类事物的具体实现。对象是类的一个实例，必然具备该类事物的属性和行为。

3. 类与对象的关系

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

三、类的定义

• 成员变量：属性
• 成员方法：行为
• 注意：
  • 成员变量是直接定义在类当中的，在方法外边。
  • 成员方法不要写static关键字。

//定义Student类
public class Student {
    //成员变量
    String name;
    int age;

    //成员方法
    public void eat(){
        System.out.println("吃饭！");
    }
    public void sleep(){
        System.out.println("睡觉！");
    }
    public void study(){
        System.out.println("学习！");
    }
}

四、对象的创建及其使用

• 通常情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用。

• 步骤：

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

  public class UseStudent {
      public static void main(String[] args) {
          Student stu = new Student();
          System.out.println(stu.name); // null
          System.out.println(stu.age);  // 0
  
          stu.name = "zhuguli";
          stu.age = 22;
          System.out.println(stu.name); // zhuguli
          System.out.println(stu.age);  // 22
          stu.eat();   // 吃饭
          stu.sleep(); // 睡觉
          stu.study(); // 学习
      }
  }
  

• **注意：**如果成员变量没有进行赋值，那么将会有一个默认值(规则与数组一样)：

  • 如果是整数型，默认为0；
  • 如果是浮点型，默认为0.0；
  • 如果是字符型，默认为\u0000；
  • 如果是布尔型，默认为false；
  • 如果是引用型，默认为null。

五、手机类练习

/*
定义一个类，用来模拟“手机”事物
属性：品牌、价格、颜色
行为：打电话、发短息
*/
public class Phone {
    String brand;
    double price;
    String color;

    public void callSomeone(String name){
        System.out.println("call " + name + " !");
    }
    public void sendMessage(String name){
        System.out.println("send to " + name + " !");
    }
}

//使用Phone类
public class UsePhone {
    public static void main(String[] args) {
        Phone iphone = new Phone();
        iphone.brand = "Apple";
        iphone.price = 8888;
        iphone.color = "gold";
        System.out.println(iphone.brand);  // Apple
        System.out.println(iphone.price);  // 8888.0
        System.out.println(iphone.color);  // gold
        iphone.callSomeone("zhuguli"); // call zhuguli !
        iphone.sendMessage("zhuguli"); // send to zhuguli !
    }
}

六、一个对象的内存图

七、两个对象使用同一方法的内存图

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

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

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

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

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

十一、成员变量和局部变量的区别

1. 定义的位置不一样

• **局部变量：**在方法的内部。
• **成员变量：**在方法的外部，在类的内部。

2. 作用的范围不一样

• **局部变量：**只有在方法当中才可以使用，出了方法就不能再用。
• **成员变量：**整个类全都可以使用。

3. 默认值不一样

• **局部变量：**没有默认值，如果想要使用，必须手动进行赋值。
• **成员变量：**如果没有赋值，会有默认值，规则和数组一样。

4. 内存的位置不一样

• **局部变量：**位于栈内存。
• **成员变量：**位于堆内存。

5. 生命周期不一样

• **局部变量：**随着方法进栈而诞生，随着方法出栈而消失。
• **成员变量：**随着对象创建而诞生，随着对象被垃圾回收而消失。

十二、面向对象三大特征之封装性

• **面向对象三大特征：**封装、继承、多态。
• 封装就是将一些细节信息隐藏起来，对于外界不可见。
• 封装性在Java当中的体现：
  • 方法就是一种封装。
  • 关键字private也是一种封装。

十三、private关键字的作用及使用

• 一旦使用了private进行修饰，那么本类中仍然可以随意访问，但是，超出了本类范围之外就不能再直接访问了。
• **间接访问private成员变量：**定义一对Getter/Setter方法。
• Getter/Setter方法的定义必须遵守setXxx/getXxx命名规则。
• 对于Getter来说，不能有参数，返回值类型和成员变量对应。
• 对于Setter来说，不能有返回值，参数类型和成员变量对应。

public class Person {
    String name;
    private int age;

    public void setAge(int a){
        age = a;
    }
    public int getAge(){
        return age;
    }
    public void showInfo(){
        System.out.println("My name is: " + name + " and my age is: " + age);
    }
}

public class UsePerson {
    public static void main(String[] args) {
        Person person = new Person();
        person.showInfo();  // My name is: null and my age is: 0
        person.name = "zhuguli";
        person.setAge(22);
        person.showInfo();  // My name is: zhuguli and my age is: 22
    }
}

十四、练习使用private关键字定义学生类

• 对于基本类型当中的boolean值，Getter方法一定要写成isXxx的形式，而setXxx规则不变。

public class Person {
    private String name;
    private int age;
    private boolean male;

    public void setName(String str){
        name = str;
    }
    public String getName(){
        return name;
    }

    public void setAge(int a){
        age = a;
    }
    public int getAge(){
        return age;
    }

    public void setMale(boolean bool){
        male = bool;
    }
    public boolean isMale(){
        return male;
    }

}

public class UsePerson {
    public static void main(String[] args) {
        Person person = new Person();

        person.setName("zhuguli");
        person.setAge(22);
        person.setMale(true);

        System.out.println("姓名：" + person.getName());
        System.out.println("年龄：" + person.getAge());
        System.out.println("是否为男性：" + person.isMale());
    }
}

十五、this关键字的作用

• 当方法的局部变量和类的成员变量重名的时候，根据就近原则，优先使用局部变量。
• 如果需要访问本类中的成员变量，需要使用格式：this.成员变量名;
• 通过谁调用的方法，谁就是this。

public class Person {
    String name;

    public void sayHello(String name){
        System.out.println(name + ", 你好！我是 " + this.name);
    }
}

public class UsePerson {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "zhuguli";
        person.sayHello("zhuzhuxia");   // 你好！我是 zhuguli
    }
}

十六、构造方法

• 构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。

• 格式：

  public 类名称(参数类型 参数名称){
      方法体;
  }
  

• 注意事项：

  • 构造方法的名称必须和所在的类名称完全一样。
  • 构造方法不要写返回值类型。
  • 构造方法不能return一个具体的返回值。
  • 如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法(没有参数、方法体)。public Student() {}
  • 一旦编写了至少一个构造方法，那么编译器将不再赠送。
  • 构造方法也是可以进行重载的。
    • 重载：方法名相同，参数列表不同。

public class Student {

    //成员变量
    private String name;
    private int age;

    //无参构造方法
    public Student() {
        System.out.println("执行无参构造方法！");
    }

    //全参构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("执行全参构造方法！");
    }

    //Setter Getter方法
    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 class UseStudent {
    public static void main(String[] args) {

        //使用无参构造方法
        Student stu1 = new Student();  // 执行无参构造方法！
        stu1.setName("zzz");
        stu1.setAge(18);
        System.out.println("姓名：" + stu1.getName() + " 年龄：" + stu1.getAge());  // 姓名：zzz 年龄：18
        //使用全参构造方法
        Student stu2 = new Student("zzx", 20);  // 执行全参构造方法！
        System.out.println("姓名：" + stu2.getName() + " 年龄：" + stu2.getAge());  // 姓名：zzx 年龄：20
        stu2.setName("zgl");
        stu2.setAge(22);
        System.out.println("姓名：" + stu2.getName() + " 年龄：" + stu2.getAge());  // 姓名：zgl 年龄：22
    }
}

十七、定义一个标准的类

• 一个标准的类通常要拥有下面四个组成部分：

  • 所有的成员变量都要使用private关键字修饰
  • 为每一个成员变量编写一对Getter/Setter方法
  • 编写一个无参数的构造方法
  • 编写一个全参数的构造方法

• 这样标准的类叫做***Java Bean***