Java — 面向对象

目录

• 一、类和对象
• 二、方法
• 三、封装
• 四、继承
• 五、多态
• 六、final
• 七、static
• 八、抽象类
• 九、接口
• 十、内部类

一、类和对象

简介：类是对事物的一种描述，对象则为具体存在的事物。

类的定义：

public class 类名 {
    // 成员变量
    访问修饰符 数据类型 变量名；
    …
    // 成员方法
    访问修饰符 返回类型 方法名(参数列表) { 
        若干语句; 
        return 方法返回值; 
    }
    ...
}

创建对象：类名 对象名 = new 类名();

成员调用：对象名.成员变量;，对象名.成员方法(参数列表);

二、方法

定义：访问修饰符 返回值类型 方法名(参数列表) { 方法逻辑; return 方法返回值 }

调用：方法名(参数列表);

分类：无参数无返回值、无参数有返回值、有参数无返回值、有参数有返回值。

传值：

1. 基本类型：调用方值的复制，双方各自的后续修改互不影响。方法内部对参数变量做的任何操作都不会影响方法外部的变量。
2. 引用类型：调用方的变量和接收方的参数变量，内存地址指向同一个对象。双方任意一方修改该参数值都会影响对方。
3. 可变参数：当方法的参数列表有两个或多个参数时，可变参数需放在末尾。

进阶：

1. 类作为形参和返回值：方法的形参是类，需要该类的对象。方法的返回值是类，返回该类的对象。
2. 抽象类作为形参和返回值：方法的形参是抽象类，需要该抽象类子类对象。方法的返回值是抽象类，返回该抽象类的子类对象。
3. 接口作为形参和返回值：方法的形参是接口，需要该接口的实现类对象。方法的返回值是接口名，返回该类的实现类对象。

三、封装

简介：封装是面向对象编程语言对客观世界的模拟，客观世界里成员变量都隐藏在对象内部，外界无法直接操作。

原则：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

实现：

1. 使用 private 访问修饰符将对象的属性私有化。
2. 创建公开的 get / set 方法用于对属性的读写。
3. 在 get / set 方法中对属性的合法性进行判断。

private 关键字：

1. 是一个可以修饰成员信息的权限修饰符。
2. 被其修饰的成员只能在本类中访问，不能被其它类使用。
3. 被其修饰的成员提供公共的 get / set 方法，供其它类使用。

this 关键字：

1. 指向当前对象的引用（谁调用我就代表谁）。
2. 通过 this.成员变量 | 成员方法(参数列表) | (参数列表) 来访问本类的成员变量、方法，构造方法。
3. 使用时必须在方法体第一行，不能在静态方法中使用。

构造方法：

1. 格式：public class 类名 { 修饰符 类名(参数列表) }
2. 是一种特殊的方法，用于创建对象并完成对象的初始化。
3. 没有自定义构造方法，系统会提供一个默认的无参构造方法，若自定义了构造方法，系统不再提供默认的无参构造方法。

四、继承

由来：多个类中存在相同属性和行为时，将这些相同内容抽取到一个公共类中，则其它类中无需再定义这些属性和行为，只需继承公共类即可。

定义：就是子类继承父类的属性和行为，使得子类对象具有与父类对象相同的属性和行为，且子类可直接访问父类的非私有属性和行为。

格式：public class 子类名 extends 父类名 {...}

好处：提高代码的复用性，类与类之间产生了关系，是多态的前提。

特点：只支持单继承，不支持多继承，但支持多层继承。

方法重写：

1. 子类必须有和父类相同的方法名、参数列表和返回类型，且该父类方法没有被 final 或 static 修饰。
2. 子类的重写方法其访问修饰符的限定范围应大于等于父类方法，即 public > protected > default。
3. 子类不能重写父类构造方法，只能通过 super(参数列表) 调用。

访问修饰符：

1. public（公共的）：同类、同包、不同包的子类、不同包的非子类，均可访问。
2. protected（受保护的）：同类、同包、不同包的子类，均可访问。
3. default（默认的）：同类、同包，均可访问。
4. private（私有的）：同类，才可访问。

super 关键字：

1. 代表父类存储空间的标识，可理解为父类对象引用。
2. 子类通过 super.成员变量 | 成员方法(参数列表) | (参数列表) 来访问父类的成员变量、方法，构造方法。
3. 使用时必须在方法体第一行。

super 和 this 的区别：

1. 父类空间优先于子类对象产生，在每次创建子类对象时，先初始化父类空间再创建其子类对象本身。
   目的在于子类对象中包含了其对应的父类空间便可包含其父类成员。
2. super.成员变量 | 成员方法(参数列表) | (参数列表) 访问的是父类的成员变量、方法，构造方法。
3. this.成员变量 | 成员方法(参数列表) | (参数列表) 访问的是本类的成员变量、方法，构造方法。
4. super 和 this 不能同时使用，只能存在一个，并且都在方法体第一行。

成员访问特点：

1. 变量：子类局部范围找 > 子类成员范围找 > 父类成员范围找 > 若都没有则报错、不考虑父类的父类。
2. 方法：子类成员范围找 > 父类成员范围找 > 若都没有则报错、不考虑父类的父类。

五、多态

简介：同一对象在不同时刻表现出不同的形态。

特点：相同的消息给予不同的对象会引发不同的动态，也就是允许不同类的对象对同一消息做出不同的响应。

实现：满足继承(实现)关系、要有方法重写、父类引用指向子类对象。

访问：成员变量（编译看左边，执行看左边），成员方法（编译看左边，执行看右边）。

好处：定义方法时，使用父类型作为参数，将来调用时使用具体的子类型参与操作。

弊端：不能使用子类的特有方法。

转型：

1. 向上转型：又称自动转型、隐式转型，从子到父，子类对象赋值给父类对象，就是说父类引用指向子类实例。
   格式：父类名 对象名 = new 子类名(); ，此时该对象不能调用子类的特有方法。
2. 向下转型：又称强制转型，从父到子，父类对象赋值给子类对象，就是说子类引用指向父类实例。
   格式：子类名 对象名 = (子类名) 父类实例; ，此时该对象可以调用子类的特有方法，解决了多态的弊端。
3. instanceof：返回一个布尔值来确认某个对象，是否是某个特定类或该特定类子类的一个实例，就是看左边的对象是不是右边类的实例。
   格式：对象名 instanceof 类型 ，类型可以为类或接口。

六、final

简介：final 关键字是最终的意思，可以修饰类、成员方法、成员变量。

修饰类：

1. 格式：public final class 类名 {...}
2. 被 final 修饰的类叫做最终类，不能被其它类继承。
3. 类中的所有方法都被隐式设置为 final，但类中成员变量可以被定义为 final 或非 final。

修饰方法：

1. 格式：访问修饰符 final 返回值类型 方法名(参数列表) {...}
2. 被 final 修饰的方法叫做最终方法，不能被子类重写。

修饰变量：

1. 格式：访问修饰符 final 数据类型 变量名(大写) = 手动赋值;
2. 被 final 修饰的变量叫做常量，名称大写。
3. 成员变量具有默认值，被 final 修饰之后不再有默认值，需手动赋值。
4. 局部变量一次赋值终生不变。

七、static

简介：static 关键字是静态的意思，访问修饰成员方法、成员变量。

修饰方法：

1. 被 static 修饰的方法叫做静态方法，也称为类方法，可通过 类名.方法名 直接调用。
2. 静态成员方法只能访问静态的成员变量和方法。
3. 非静态成员方法可以访问非静态的成员变量和方法，也可以访问静态成员变量和方法。

修饰变量：

1. 静态变量：被 static 修饰的成员变量叫做静态变量，也称为类变量，静态变量属于这个类，而不是属于这个类的对象。
   静态变量通过 类名.变量名 直接调用。
2. 实例变量：没被 static 修饰的成员变量叫做实例变量，实例变量属于这个类的实例对象。
   实例变量必须先 new 一个对象之后，通过 对象名.变量名 调用。

八、抽象类

简介：在做子类共同功能抽取时，有些方法在父类中并没有具体的体现，此时就需要抽象类。

格式：public abstract class 类名 {...}

特点：

1. 抽象类和抽象方法必须使用 abstract 关键字修饰。
2. 抽象类中不一定有抽象方法，但有抽象方法的类一定是抽象类。
3. 抽象方法不能实例化，要想实例化可参照多态的方式，通过子类对象实例化，这叫做抽象类多态。
4. 抽象类的子类，要么重写抽象类中的所有抽象方法，要么子类也是抽象类。

内部：

1. 成员变量：既可以是变量也可以是常量。
2. 成员方法：既可以是普通方法也可以是抽象方法。
3. 构造方法：无参有参构造方法。

注意：

1. 与 abstract 不能共存的关键字：final、private、static。
2. final：被 final 修饰的类不能有子类，而被 abstract 修饰的类一定是个父类。
3. private：抽象类中私有的抽象方法，不被子类所知就无法重写，而抽象方法必须被重写。
4. static：若 static 可以修饰抽象方法，则不用 new 对象，直接类名调用即可，此时抽象方法没有意义。

九、接口

简介：接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。Java 中的接口更多的体现在对行为的抽象。

格式：public interface 接口名 {...}

特点：

1. 接口用 interface 关键字修饰。
2. 类实现接口用 implements 表示，例：public class 类名 implements 接口名 {...}
3. 接口不能实例化，要想实例化可参照多态的方式，通过子类对象实例化，这叫做接口多态。
4. 接口的子类要么重写接口中所有抽象方法，要么子类也是抽象类。

内部：

1. 成员变量：只能是常量，默认修饰符：public static final。
2. 成员方法：只能是抽象方法，默认修饰符：public abstract。
3. 构造方法：没有，接口主要是扩展功能而没有具体存在的。

抽象类与接口的区别：

1. 成员区别：抽象类有变量、常量、构造方法、普通方法、抽象方法，接口只有常量、抽象方法。
2. 关系区别：
   1. 类与类的关系：继承关系，只能单继承，支持多层继承。
   2. 类与接口的关系：实现关系，可以单实现，也支持多实现，还可以继承一个类的同时实现多个接口。
   3. 接口与接口的关系：继承关系，可以单继承，也支持多继承。
3. 设计理念：
   1. 抽象类：对类抽象，包括属性和行为。
   2. 接口：对行为抽象，主要对行为。

新特性：JDK8 之前，接口只有常量以及抽象方法。JDK8 时，接口增加了默认方法和静态方法。JDK9 时，接口增加了私有方法。

默认方法：

1. 格式：default 返回值类型 方法名(参数列表) {...}
2. 注意：默认方法不是抽象方法，也可以重写，重写时去掉 default 关键字。
3. 作用：对接口的升级不会影响到现有代码。

静态方法：

1. 格式：static 返回值类型 方法名(参数列表) {...}
2. 注意：静态方法只能通过接口名调用，不能通过实现类名或对象名调用。

私有方法：

1. 格式1：private 返回值类型 方法名(参数列表) {...}
2. 格式2：private static 返回值类型 方法名(参数列表) {...}
3. 注意：默认方法可以调用私有的静态方法和非静态方法，静态方法只能调用私有的静态方法。
4. 作用：提取默认方法和静态方法中相同的代码，提高代码的复用性。

十、内部类

简介：就是在一个类中定义一个类，例：在类 A 的内部定义类 B，类 B 就是内部类。

格式：public class 类名 { 访问修饰符 class 类名 }

特点：内部类可以直接访问外部类的成员(包括私有)，外部类要访问内部类的成员必须创建对象。

分类：

1. 成员内部类：在类的成员位置，外界访问通过 外部类名.内部类名 对象名 = new 外部类名().new 内部类名(); 。
   但一般都是私有化的，不会让外界直接访问，而是通过在外部类中定义一个方法，在该方法中实例化内部类，调用内部类方法。
   最终外界通过外部类的这个方法达到访问内部类的效果。
2. 局部内部类：在类的方法体中，外界无法直接访问，需在方法体中创建对象并使用，最终外界通过该方法达到访问局部内部类的效果。
3. 匿名内部类：局部内部类的简写形式，前提是继承类或实现接口，格式：new 类名() | 接口名() { 重写方法 } 。
   本质上是一个继承了该类或实现了该接口的子类匿名对象，就是说该类没有声名对象名。