06 - 面向对象基础

1. 基本概念

面向对象（OO: object-oriented）

• 把数据及对数据的操作方法放在一起，作为一个相互依存的整体——对象。
• 对同类对象抽象出其共性，形成——类。
• 类中的大多数数据，只能用本类的方法进行处理。
• 类通过一个简单的外部接口与外界发生关系，对象与对象之间通过消息进行通信。
• 程序流程由用户在使用中决定。
• 对象即为人对各种具体物体抽象后的一个概念，人们每天都要接触各种各样的对象。

面向对象编程（OOP: object-oriented programming）

是一种通过对象的方式，把现实世界映射到计算机模型的一种编程方法。

面向对象与面向过程的区别

类与对象的主要区别

1. 类是对象的抽象，可以看成是一种对象的模板
2. 对象是具体的事物，看成该类的一个具体实例
3. 类：我们叫做class
4. 对象：我们叫做Object,instance(实例)。我们说某个类的对象，某个类的实例是一样的
5. 类是用于描述同一类型的对象的一个抽象概念，类中定义了这一类对象所应具有的共同的属性、方法

2. 类的结构

• 属性：对象数据的描述
• 方法：对象的行为（可以做哪些事）
• 构造方法：用于实例化对象
• 内部类：（inner class）即在类体中声明的类
• 块：分为静态块（static），实例块（局部代码块）

类的定义格式：

[public] [abstract|final] class 类名[extends 父类][implements 接口列表]{  
      属性声明及初始化；
      方法声明及方法体；
      构造方法（构造器）；
      代码块；
      内部类；
}

示例：

// 每一个源文件必须有且只有一个public class，并且类名和文件名保持一致！
public class Car { 
}
// 一个Java文件可以同时定义多个class
class Engine { 
}

上面的类定义好后，没有任何的其他信息，就跟我们拿到一张张图纸，但是纸上没有任何信息，这是一个空类，没有任何实际意义。所以，我们需要定义类的具体信息。
对于一个类来说，一般有三种常见的成员：

• 属性field
• 方法method
• 构造器constructor。

这三种成员都可以定义零个或多个。

属性 field

1. 属性用于定义该类或该类对象包含的数据或者说静态特征。
2. 属性作用范围是整个类体。
3. 在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。

属性定义格式及示例：

// 格式：[访问修饰符] [非访问修饰符] 属性类型  属性名 = [默认值] ;
// 示例
public class Car { 
    String color;
    // [访问修饰符] [非访问修饰符] 属性类型  属性名 = [默认值] ;
    private final int WHEEL = 4;
    public int seat;
    private Engine engine;
}
class Engine { 
}

方法 method

1. 方法用于定义该类或该类实例的行为特征和功能实现。
2. 方法是类和对象行为特征的抽象。
3. 方法很类似于面向过程中的函数。
4. 面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。
5. 面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。

方法的定义格式：

[访问修饰符] [非访问修饰符] 方法返回值类型 方法名(形参列表) {
    方法体;
    return 返回值;
}

可变参数 JDK1.5开始，Java支持传递同类型的可变参数给一个方法 在方法声明中，在指定参数类型后加一个省略号（…..） 在一个方法中只能指定一个可变参数，而且它必须是该方法的最后一个参数

示例：

public class Demo { 
    // [访问修饰符] [非访问修饰符] 方法返回值类型 方法名(形参列表) {
    public final int sum(int x, int y){
        // 方法体
        int sum = x + y;
        // 返回值
        return sum;
    }
    public void hello(){
        System.out.println("你好");
        // 因为返回值类型是 void，所以不必有return 语句。
    }
    // 可变参数
    public void print(String... args){
        // args 其实是一个数组
        for (String arg : args) {
            System.out.println(arg);
        }
    }
}

构造器 constructor

要学习Java语言，必须理解构造方法——构造器（ Constructor）。
构造方法是一种特殊的方法，利用构造方法能够初始化对象的属性。
构造方法的结构如下：

[修饰符]  类名（参数列表）{
        //方法体
}

构造方法的特点如下：

1. 具有与类相同的名称
2. 不含返回值类型
3. 不能在方法中用return语句返回一个值
4. 一般访问权限为public，但其他权限也是可以的

在一个类中，具有上述特征的方法就是构造方法。
注：Java中，每个类都至少要有一个构造方法，如果程序员没有在类里定义构造方法，系统会自动为这个类产生一个默认的访问权限为public且参数列表为空的构造方法。 一旦编程者为该类定义了构造方法，系统就不再提供默认的构造
构造方法和普通方法的区别如下：

1. 作用不同

构造方法是为了创建一个类的实例。这个过程只可以在创建一个对象的时候用到。普通方法的作用是为了完成一段业务功能。

1. 修饰符不同

和普通方法一样，构造方法可以有任何访问的修饰：public，protected，private或者没有修饰。不同于普通方法的是，构造方法不能有以下非访问性质的修饰：abstract，final， native，static或者synchronized。

1. 返回值不同

返回类型也是非常重要的。普通方法能返回任何类型的值或者无返回值（void），构造方法没有返回值，也不需要void。

1. 命名不同

构造方法使用和类相同的名字，而普通方法则不同。按照习惯，普通方法通常用小写字母开始，而构造方法通常用大写字母开始。
构造方法通常是一个名词，因为它和类名相同；而方法通常更接近动词，因为它说明一个操作

3. 方法的重载

重载定义

• 在 Java 中如果有多个同名但是不同参数 的方法就称为 “方法的重载”

• 编译器会根据调用时 传递的实际参数自动判断具体调用的是哪个重载方法

  重载的三大法则

• 方法名相同

• 参数不同
  1. 数量不同
  2. 数据类型不同
  3. 顺序不同
• 同一作用域

  注意：

  1. 当返回值不一样时，无法构成重载
  2. 必须要在同一个类当中，在不同的类当中，作用域不同，方法重载就无法生效

重载的运用

public class Demo{
    // 构造方法的重载
    // 无参构造方法
    public Demo(){
    }
    // 有参构造方法
    public Demo(String name){
        // do something...
    }
    // add方法的重载
    // 整数相加
    int add(int x,int y){
        return x + y;
    }
    // 浮点数相加
    float add(float x,float y) {
        return x + y;
    }
    // 长整形相加
    long add(long x, long y) {
        return x + y;
    }
}

4. 对象

对象创建

Java 通过 new 关键字调用构造方法创建对象。
创建对象的有两种方式

• 一部到位，声明对象并创建对象
• 分两步创建，先声明再创建 ```java /* 方式一：一步到位创建对象 格式： 类名 对象名 = new 构造器 / // 示例： Demo d1 = new Demo();

/* 方式二：分两步创建，先声明再创建 */ // 示例： Demo d2; d2 = new Demo();

<a name="zEFpj"></a>
#### 对象的使用
- 访问属性：对象名.属性
- 调用方法：对象名.方法名
示例:
```java
public class Demo {
    String name;
    public void setNewName(String newName){
        name = newName;
    }
    public Demo(String name){
        this.name = name;
    }
    /**
     * 方法执行结果：
     * demo-1
     * demo-new
     */
    public static void main(String[] args) {
        // 创建对象
        Demo demo = new Demo("demo-1");
        // 访问对象属性
        System.out.println(demo.name);
        // 调用对象方法
        demo.setNewName("demo-new");
        // 再访问对象属性
        System.out.println(demo.name);
    }
}

匿名对象

创建完对象，在调用该对象的方法时，也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫匿名对象，非匿名和匿名对象的对比如下：

public class Demo {
    public Demo(){
    }
    public void sayHello(){
        System.out.println("hello");
    }
    public static void main(String[] args) {
        // 非匿名对象
        Demo demo = new Demo();
        demo.sayHello();
        // 匿名对象
        new Demo().sayHello();
    }
}

如果对一个对象只需要进行一次方法调用，那就可以使用匿名对象。