2、Java 面向对象思想

本栏目讲解Java语言相关语法、常用API、编程思想、IO流、集合框架、反射等知识

---

---

面向对象思想

1、简介

• 概述：面向对象是基于面向过程的编程思想。即对方法和属性进行封装成类，使用时先得到类，再使用对应的方法
• 特点
  • 把复杂的事件简单化
  • 从执行者变成指挥者
  • 更符合我们的思想习惯
• 特征：封装、继承、多态

2、封装

• 概述：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式
• 好处
  • 隐藏实现细节，提供公共的访问方式
  • 提高了代码的复用性
  • 提高安全性
• 原则
  • 将不需要对外提供的内容都隐藏起来
  • 把属性隐藏，提供公共方法对其访问

3、继承

• 概述：多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
• 格式：class 子类名 extends 父类名{}
• 好处
  • 提高代码的复用性
  • 提高代码的维护性
  • 让类与类之间产生关系，是多态的前提（但是这也提高了耦合性，而开发原则：低耦合，高内聚）
• 特点：只支持单继承，多层继承
• 注意事项
  • 子类只能继承父类所有非私有的成员
  • 子类不能继承父类的构造方法，但是可以通过 super 关键字访问
  • 不能为了部分功能去继承
  • 子类中所有的构造方法默认都会访问父类中空参数的构造方法，但是如果父类没有无参构造方法，子类要直接或间接调用父类构造方法，否则报错，每一个构造方法的第一条语句默认都是 super()
• 继承中成员变量间的关系：就近原则
• 什么时候使用继承：继承体现的是一种关系：“is a”

4、多态

• 概述：同一个对象，在不同时刻体现出来的不同状态
• 前提
  • 有继承关系
  • 有方法重写
  • 有父类的引用指向子类对象，即：父 f = new 子();
• 成员访问特点
  • 成员变量：编译看左边，运行看左边
  • 成员方法：编译看左边，运行看右边
  • 静态方法：编译看左边，运行看左边
  • 构造方法：创建子类对象的时候，先调用父类的构造方法进行初始化
• 好处
  • 提高程序的维护性（继承）
  • 提高程序的扩展性（多态）
• 弊端：不能访问子类的特有功能
• 多态的转型
  • 向上转型
  • 向下转型

---

类

1、类与对象的关系

• 类：是一组相关的成员变量和成员方法的集合。
• 对象：是该类事物的具体表现

2、类的初始化

• 一个类的初始化过程：成员变量的默认初始化， 然后显示初始化，接着构造方法初始化
• 子父类的初始化（分层初始化）：先进行父类初始化，然后进行子类初始化

3、类的组成

3.1 代码块

• 概述：在 Java 中，使用{}括起来的代码被称为代码块
• 分类
  • 局部代码块：局部位置，用于限定变量的生命周期
  • 构造代码块：在类中的成员位置，在构造方法之前执行，用于执行多个构造方法相同的代码
  • 静态代码块：在类中的成员位置，用 static 修饰，对类进行初始化，只加载一次
  • 同步代码块

3.2 构造方法

• 作用：给对象的数据进行初始化
• 格式：修饰符 类名(){}
• 注意事项
  • 如果你不提供构造方法，系统会给出默认构造方法
  • 如果你提供了构造方法，系统将不再提供
  • 构造方法也是可以重载的

3.3 成员方法

• 类型
  • 根据返回值
    • 有明确返回值方法
    • 返回 void 类型的方法
  • 根据形式参数
    • 无参方法
    • 带参方法
• 方法重写
  • 概述：子类中出现了和父类中一模一样的方法声明，也被称为方法覆盖，方法复写。
  • 应用：子类有自己特有内容时，可以重写父类中的方法（或用 super.方法() 在父类的基础上重写 ）
  • 注意事项
    • 父类中私有方法不能被重写
    • 子类重写父类方法时，访问权限不能更低
    • 父类静态方法，子类也必须通过静态方法进行重写

3.4 类中的变量

• 成员变量和局部变量的区别
  • 在类的位置不相同
  • 生命周期不同
  • 内存位置不同
  • 初始化值不同
• 静态变量和成员变量的区别
  • 所属不同
  • 内存中的位置不同
  • 内存出现的时间不同
  • 调用不同
• 形式参数问题
  • 基本类型：形式参数的改变不影响实际参数
  • 引用类型：形式参数的改变直接影响实际参数

3.5 匿名对象

• 概述：就是没有名字的对象
• 应用场景
  • 作为实际参数传递
  • 对象调用方法仅仅一次的时候

3.6 类中常见关键字

• private
  • 概述：是一个权限修饰符，可以修饰成员（成员变量和成员方法），被 private 修饰的成员只在本类中才能访问
  • 场景：把成员变量用 private 修饰，提供对应的 getXxx() / setXxx() 方法
• this
  • 概述：this 代表所有类的对象的引用
  • 注意：方法被那个对象调用了，this 就代表那个对象
  • 场景：局部变量隐藏成员变量
• static
  • 概述：可以修饰成员变量和成员方法，使被类的所有对象共享
  • 特点
    • 随着类的加载而加载
    • 优先于对象存在
    • 可以通过类名调用
  • 注意事项
    • 在静态方法中是没有this关键字的
    • 静态方法只能访问静态的成员变量和静态的成员方法
    • 非静态方法不仅能访问非静态成员，也能访问静态成员
• super
  • 概述：super代表父类存储空间的标识（可以理解为父类引用）
  • 用法
    • super.成员变量
    • super.成员方法
    • super(…)
• final
  • 概述：final 关键字是最终的意思，可以修饰类，成员变量，成员方法。
  • 作用
    • 修饰类，类不能被继承
    • 修饰变量，变量就变成了常量，只能被赋值一次
    • 修饰方法，方法不能被重写

3.7 权限修饰符

	public	protected	默认	private
同一类中	支持	支持	支持	支持
同一包的子类、其他类	支持	支持	支持
不同包	支持	支持
不同包的子类	支持

3.8 与类组成相关的修饰符

• 类
  • 权限修饰符：默认、public
  • 状态修饰符：final
  • 抽象修饰符：abstract
• 成员变量
  • 四种权限修饰符均可
  • 状态修饰符：final、static
• 构造方法：四种权限修饰符均可
• 成员方法
  • 四种权限修饰符均可
  • 状态修饰符：final、static
  • 抽象修饰符：abstract

---

抽象类

• 概述：对于一个不是具体对象的类，应该声明为抽象类
• 特点
  • 抽象类和抽象方法必须用 abstract 关键字修饰
  • 抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
  • 抽象类不能实例化（但可以通过多态实例化）
• 成员特点
  • 成员变量：可以是变量，也可以是常量
  • 构造方法：可以有构造方法，但不能实例化（用于子类访问父类的初始化）
  • 成员方法：可以是抽象，也可以是非抽象
• 抽象类的子类
  • 如果不想重写抽象方法，该子类是一个抽象类
  • 重写所有的抽象方法，该子类是一个具体类
• 使用 abstract 时的注意事项
  • private 关键字：冲突
  • final 关键字：冲突
  • static 关键字：无意义

---

内部类

1、简介

• 概述：把类定义在其他类的内部，这个类就被称为内部类
• 访问特点
  • 内部类可以直接访问外部类的成员，包括私有的
  • 外部类要访问内部类的成员，必须创建对象
• 类型
  • 成员内部类
  • 局部内部类
  • 匿名内部类

2、成员内部类

• 外界创建内部类对象格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
• 常见修饰符
  • private：为了保证数据的安全性（在外部类中提供一个方法，用于创建内部类对象）
  • static：为了让数据访问更方便（内部类里方法可以是静态或非静态，但方法中只能访问外部类的静态成员）
• 被静态修饰后创建内部类对象格式1：外部类名.内部类名 对象名 = new 外部类名.内部类名();
• 被静态修饰后创建内部类对象格式2：外部类名.内部类名.方法(); (适合于调用内部类的静态方法)
• 注意
  • 内部类和外部类之间没有继承关系
  • 通过外部类名限定 this 对象
• 案例

/**
 * 成员内部类基本使用测试
 */
public class MemberInnerTest {

    public static void main(String[] args) {
        // 创建内部类
        Outer1.Inner inner = new Outer1().new Inner();
        inner.show01();
        inner.show02();

        // 使用被private修饰的内部类
        new Outer2().invokeOperator();

        // 使用被static修饰的内部类
        Outer2.Inner2.show();
    }

}

//

/**
 * 外部类 - 内部类基本使用
 */
class Outer1 {

    private final int num = 10;

    /**
     * TIP1：外部内要创建内部对象才能访问内部成员
     */
    public void method1() {
        Inner inner = new Inner();
        inner.show01();
        inner.show02();
    }

    public void method2() {
        System.out.println("Method");
    }

    /**
     * 内部类
     */
    class Inner {

        private final String name = "Near";

        public void show01() {
            // TIP2：内部类使用外部类成员变量
            System.out.println("使用外部类的成员变量：" + num);
        }

        public void show02() {
            // TIP3：内部类使用外部类成员方法
            System.out.println("调用外部类的成员方法");
            method2();
        }
    }
}

//

/**
 * 内部类修饰符：private、static
 */
class Outer2 {

    private static int num = 10;

    /**
     * TIP4：private修饰内部类
     */
    private class Heart {

        public void operator() {
            System.out.println("心脏搭桥手术");
        }

    }

    /**
     * 使用内部类的方法
     */
    public void invokeOperator() {
        new Heart().operator();
    }

    /**
     * TIP5：static修饰内部类
     */
    public static class Inner2 {

        public static void show() {
            System.out.println("调用外部类的成员变量：" + num);
        }

    }

}

3、局部内部类

• 特点
  • 可以直接访问外部类的成员
  • 可以在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
• 注意事项：内部类调用的局部变量必须被final修饰，因为局部内部类随着方法的调用完毕而消失
• 案例

/**
 * 局部内部类测试
 */
public class LocalInnerTest {

    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.method();
    }

}

class Outer {

    private final int num = 10;

    public void method() {
        // 局部内部类
        class Inner {
            public void show() {
                System.out.println("使用外部类成员变量：" + num);
            }
        }

        // TIP1：使用局部内部类
        Inner inner = new Inner();
        inner.show();
    }

}

4、匿名内部类

• 前提：存在一个类或者接口
• 格式：new 类名或者接口名() {重写方法;}
• 本质：是一个继承了类或者实现了接口的子类的匿名对象
• 使用：可以用多态的方式，调用子类对象中的方法
• 案例

/**
 * 匿名内部类测试
 */
public class AnonymousInnerTest {

    public static void main(String[] args) {
        CommonClazz clazz = new CommonClazz();
        clazz.show(new AnonymousInterface() {
            public void method() {
                System.out.println("匿名内部类的方式实现接口...");
            }
        });
    }

}

/**
 * 匿名内部类接口
 */
interface AnonymousInterface {

    void method();
}

/**
 * 普通类
 */
class CommonClazz {

    public void show(AnonymousInterface ai) {
        ai.method();
    }

}

---

接口

• 概述： 用来进行额外功能的扩展
• 特点：接口没有构造方法，不能实例化
• 格式
  • 声明格式：interface 接口名 {}
  • 实现接口格式：class 类名 implements 接口名 {}
• 成员特点
  • 成员变量：只能是常量，默认修饰符：public static final
  • 成员方法：只能是抽象方法，默认修饰符：public abstract
  • 构造方法：接口没有构造方法，但是所有的类都继承自 Object

---

包

1、简介

• 概述：其实就是文件夹，用于对类进行分类管理
• 格式：package 包名;
• 注意事项
  • package 语句必须是程序的第一条可执行的代码，而且只能有一条
  • 如果没有 package 时，默认表示无包名

2、导包

• 原因：使用不同包下的类的时候，都需要加包的全路径。比较麻烦，所以在使用类之前就先把包导进去
• 格式：import 包名;