面向对象与封装

一、概述

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

面向对象： 当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事儿。

面向对象三大特征： 即封装、继承和多态

public class Demo01PrintArray {
    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));
    }
}

二、类和对象

2.1 类

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

现实中，描述一类事物：

属性 ：就是该事物的状态信息。

行为 ：就是该事物能够做什么。

2.2 对象

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

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

2.3 类的定义

• 格式

public class ClassName {
  //成员变量
  //成员方法
}

• 定义类 ： 就是定义类的成员，包括成员变量和成员方法。
• 成员变量 ： 和以前定义变量几乎是一样的。只不过位置发生了改变。在类中，方法外。
• 成员方法 ： 和以前定义方法几乎是一样的。只不过把static去掉，static的作用在面向对象后面课程中再详细讲解。

public class Student {
    //成员变量  
       String name；//姓名  
    int age；//年龄
    //成员方法
       //学习的方法
       publicvoid study() {
        System.out.println("好好学习，天天向上");
    }
      //吃饭的方法
      public void eat() {
        System.out.println("学习饿了要吃饭");
      }
}

2.4 使用对象

① 导包

import 包名.类名

对于和当前类属于同一个包的情况，可以省略导包语句不写。

② 创建

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

③ 使用

对象名.成员变量名
对象名.成员方法名(参数)

2.5 默认值

若成员变量未赋值，则会有一个默认值，规则与数组相同。

三、对象的内存图解

3.1 一个对象

成员方法在堆中保存的是地址值！方法依次入栈，并在调用完成后出栈。

3.2 两个对象

3.3 两个引用一个对象

3.4 对象作为方法参数

3.5 对象作为方法返回值

四、成员变量与局部变量

区别：

① 定义的位置不同

局部变量：在方法内部

成员变量：在方法外部，直接写在类中

② 作用范围不同

局部变量：只用方法中才可以使用，出了方法便不可使用

成员变量：整个类都可以使用

③ 默认值不同

局部变量：无默认值，只有赋值了才可使用

成员变量：如果未赋值，会有默认值

④ 内存的位置不一样

局部变量：位于栈内存

成员变量：位于堆内存

⑤ 生命周期不一样

局部变量：随着方法进栈而诞生，随着方法出栈而消失。（通常情况下生命周期更短）

成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失。

五、封装性

封装就是将一些细节信息隐藏起来，对于外界不可见。

① 方法就是一种封装

② 关键字private也是一种封装

使用private修饰变量，那么本类中可以随意访问，但是超出了本类范围之外便不可直接访问，可以使用成员方法间接访问。

• 间接访问private成员变量，就是定义一对儿Getter/Setter方法

  • 必须叫setXxx或者是getXxx命名规则。
  • 对于Getter来说，不能有参数，返回值类型和成员变量对应；
  • 对于Setter来说，不能有返回值，参数类型和成员变量对应。

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

六、this

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

七、构造方法

7.1 格式

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

1. 构造方法必须和类名称一致。
2. 构造方法不要写返回值类型，连void都不写。
3. 构造方法不能return一个具体的返回值。
4. 如果未编写构造方法，那么编译器会默认使用一个空的构造方法（无参数，方法体为空）。 public 类名(){}
5. 如果编写了至少一个构造方法，那么编译器将不会生成空构造方法。若使用 new 类名() 来创建对象会报错。
6. 构造方法可以重载

7.2 标准的类

一个标准的类（也叫Java Bean）应该具有以下几个部分：

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

• 使用 alt + insert 快捷键可以生成Getter/Setter方法和构造方法。

八、static

一旦使用了static关键字，那么这样的内容不再属于对象自己，而是属于所在类，所以凡是本类的对象，共享同一份。

8.1 修饰成员变量

可以用对象名来调用，也可以直接通过类名来调用，推荐使用类名来调用。

典型用法：用于自动生成学号。

public class Student {
    private int id; // 学号
    private String name; // 姓名
    private int age; // 年龄
    static String room; // 所在教室
    private static int idCounter = 0; // 学号计数器，每当new了一个新对象的时候，计数器++
    public Student() {
        this.id = ++idCounter;
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.id = ++idCounter;
    }
}

8.2 修饰成员方法

• 可以用对象名来调用，也可以直接通过类名来调用，推荐使用类名来调用。

• 对于本类中的静态方法，访问时可以省略类名。

① 静态方法只能调用静态变量和静态方法，不能访问非静态变量和静态方法（因为在内存当中先有的静态内容，后有的非静态内容）。而普通方法可以访问静态也可以访问非静态。

② 静态方法中不能用this关键字。

8.3 static的内存图解

8.4 静态代码块

public class 类名称{
    static{
        ...
    }
}

1.当第一次使用本类时，静态代码块执行唯一的一次。

2.静态代码块比非静态代码块优先执行，所以它先于构造方法执行。

典型用法：用来一次性地对静态成员变量进行赋值。

九、匿名对象

匿名对象就是只有右边的对象，没有左边的名字和赋值运算符：

new 类名().方法名();//调用
new 类名().变量名;//调用

注意：匿名对象只能使用唯一的一次，下次再用不得不再创建一个新对象，如果确定一个对象只要使用一次时，就可以使用匿名对象。

匿名对象可以作为方法的参数和返回值。