天外天工作室移动- Android 组培训#2

目标读者：

了解 Java 基本数据类型
掌握 Java 输出、for、if 等基本语法
熟练应用函数，了解函数重载等基本知识
熟练使用 IntelliJ IDEA

引入

面向对象编程 (OOP) 是一种程序设计方法或者编程思想，它使用类和对象来进行程序设计。相对于面向过程程序设计，面向对象编程具有易维护、易扩展、编程效率高的优点。

基本概念

类 (Class)
类是具有某些共同属性的对象的集合，他为属于该类的对象提供了统一的抽象描述，下面是一个简单的类的代码。

public class Apartment {

     //成员变量    
    private int size;
    private int floor;
    private Decoration decoration;

     //成员方法
    public Apartment(int size, int floor, Decoration decoration) {
        this.size = size;
        this.floor = floor;
        this.decoration = decoration;
    }

    public int getSize() {
        return size;
    }

    public int getFloor() {
        return floor;
    }

    public Decoration getDecoration() {
        return decoration;
    }

    public void updateDecoration() {
        if (this.decoration == Decoration.NULL) {
            this.decoration = Decoration.SIMPLE;
        } else if (this.decoration == Decoration.SIMPLE) {
            this.decoration = Decoration.LUXURY;
        } else {
            System.out.println("Your apartment's decoration is already the best!");
        }
    }
}

代码开头的 "public class Apartment" 为类声明，后面大括号及里面的内容为类体，类声明和类体组成一个完整的类。
类体中包含有成员变量和成员方法，用于描述这个类各项属性、行为。
成员变量是全局变量，当全局变量和局部变量重名时 (e.g. obj)，this.obj 指全局变量，obj 指局部变量。
注：this 关键字是指向自身的指针，还有更多用法。

权限修饰符：
类、成员变量、成员方法最前面的单词叫做权限修饰符，表明从项目的哪些地方可以访问这个类、变量、方法。具体见下表：

是否能访问	同一文件	同一包	子类	不同包
public	√	√	√	√
protected	√	√	√
default（缺省）	√	√
private	√

注：包即为文件夹。类不可用private修饰。

构造方法 (Constructor)
构造方法是一种比较特殊的方法，它与类同名，无返回值，在用该类实例化一个对象的时候需要被调用。如果不写构造方法，编译器会自动生成一个无参数且方法体中无代码的默认构造方法。如果实现了构造方法，则不再生成该默认构造方法。
对象 (Object)
对象是描述客观事物的一个实体，由类实例化来生成。下面是 Demo 中 main 函数：

public class Main {

    public static void main(String[] args) {

        Apartment apartment = new Apartment(200, 3, Decoration.SIMPLE);

        apartment.updateDecoration();

        int apartmentSize = apartment.getSize();
        int apartmentFloor = apartment.getFloor();
        Decoration apartmentDecoration = apartment.getDecoration();

        String strApartmentDecoration = apartmentDecoration.toString().toLowerCase();

        System.out.println("I have a " + apartmentSize + " square metres " + 
                              apartmentFloor +  " decorated house on the " +
                              strApartmentDecoration + " floor.");

    }
}

如上所说，在实例化对象的时候，需要调用构造方法并传入参数，由此得到一个对象，然后便可使用访问该对象可以访问的成员变量和成员方法。

封装：
封装就是尽可能的隐藏对象的内部细节，只暴露有限的接口和外界进行交互。例如上面将 Apartment 类中成员变量 size、floor 设置为 private 的，无法直接从外部访问，只能在实例化对象的时候调用构造方法进行定义，通过 getSize() 和 getFloor() 方法获取他们的值，无法在对象被实例化后再对其进行改变。而成员变量 decoration 也只能通过 updateDecoration() 一个方法来有条件的进行改变。
枚举类型 (Enum)
枚举类是一个特殊的类，将一组值放进枚举类，这组值中的每一个值就都可以作为这个类的对象，如 Apartment 类中的成员变量 decoration 的类型 Decoration 就是我定义的一个枚举类:

public enum Decoration {
    NULL,
    SIMPLE,
    LUXURY
}

继承（Inherit）
继承就是子类 (SubClass) 继承父类 (SuperClass) 的特征和行为，在 Java 中表现为继承父类的成员变量和成员方法，父类 private 的成员不能被继承，所以先把 Apartment 类的成员变量修改为用 protected 修饰的，再写一个 Villa 类，继承自 Apartment 类。子类的构造方法必须调用父类的构造方法，因此如果要实现和父类不同的构造方法需要在父类中新增一个无参数且方法体为空的构造方法。

Apartment 类新增和修改的部分：

public class Apartment {

    protected Apartment(){
    }

    protected int size;
    protected int floor;
    protected Decoration decoration;
     ........
     ........
}

Villa 类：

public class Villa extends Apartment {

    public Villa(int size) {
        if (size < 250) {
            this.size = 250;
        } else {
            this.size = size;
        }
        this.floor = 1;
        this.decoration = Decoration.LUXURY;
    }

    @Override
    public void updateDecoration() {
        System.out.println("Come on! Give us a break!");
    }

    @Override
    public int getSize() {
        return super.getSize();
    }
}

可见，子类具有父类所有的特征，但是可以有一些自己独有的特征，在此例中为 size 最小为250，floor 只能为 1，decoration 必须为 LUXURY。

重写（Overriding）
子类中包含跟父类方法签名一样的方法，父类的方法会被覆盖掉，我们就说该方法被重写。如需调用父类原有的成员方法，可使用 super 关键字。
多态
多态指在父类中定义好的成员，被不同的子类继承后可以表现出不同的特征或行为。方法重写就是多态的一个表现方面。

设计模式时间：Builder 设计模式

当一个类需要初始化的成员变量比较多、比较复杂时，仅使用构造方法来初始化对象就显得冗余且难以理解，这里介绍一个经典的解决办法：利用 Builder 设计模式实现链式调用来获取对象。
先展示一下加入两个新的成员变量后复杂的 Apartment 类及两个新的枚举类：

public class Apartment {


    public int size;
    public int floor;
    public Decoration decoration;
    public City city;
    public Location location;
     ......
     ......
}

public enum City {
    BEIJING,
    SHANGHAI,
    TIANJIN
}

public enum Location {
    INSIDE,
    OUTSIDE
}

现在 Apartment 类有五个需要初始化的成员变量，全使用构造方法进行初始化便需要传入五个参数，让代码难以阅读。
Builder 设计模式需要新建一个类叫做 ApartmentBuilder：

public class ApartmentBuilder {
    private Apartment apartment = new Apartment();

    ApartmentBuilder size(int size) {
        apartment.size = size;
        return this;
    }

    ApartmentBuilder floor(int floor) {
        apartment.floor = floor;
        return this;
    }

    ApartmentBuilder decoration(Decoration decoration) {
        apartment.decoration = decoration;
        return this;
    }

    ApartmentBuilder city(City city) {
        apartment.city = city;
        return this;
    }

    ApartmentBuilder location(Location location) {
        apartment.location = location;
        return this;
    }

    Apartment build() {
        return apartment;
    }
}

如上所示，ApartmentBuilder 类只有一个 Apartment 类型的私有成员变量 apartment，ApartmentBuilder 类中除 build() 方法外的每个方法都是给 apartment 进行赋值，然后返回 ApartmentBuilder 自身，build()返回 apartment，便可实现链式调用初始化 apartment 对象:

public class Main {

    public static void main(String[] args) {
         ......
         ......
       Apartment complexApartment = new ApartmentBuilder()
                .size(250)
                .floor(4)
                .decoration(Decoration.SIMPLE)
                .city(City.SHANGHAI)
                .location(Location.INSIDE)
                .build();
    }
}

代码来源

本文中所有代码均来自我用 IntelliJ IDEA 写的一个 Java 的小 demo，已上传至 GitHub:
tjwhm/javaDemo
master 分支仅有 Apartment 类，
inherit 分支多包含了 Apartment 类的一个子类：Villa 类，
builder 分支包含复杂化的 Apartment 类及 ApartmentBuilder 类。