面向对象基本概念

面向对象编程的概念

• 万物皆对象。
• 面向对象指以属性和行为的观点去分析现实生活中的事物。
• 面向对象编程指先以面向对象的思想进行分析，然后使用面向对象的编程语言 进行表达的过程。
• 面向对象编程是软件产业化发展的需求。
• 理解面向对象的思想精髓(封装、继承、多态)，

类和对象

• 对象主要指现实生活中客观存在的实体，在Java语言中对象体现为内存空间中的一块存储区域。
• 类简单来就是“分类” ，是对具有相同特征和行为的多个对象共性的抽象描述，在Java语言中体现为一种引用数据类型，里面包含了描述特征/属性 的成员变量以及描述行为的成员方法。
• 类是用于构建对象的模板，对象的数据结构由定义它的类来决定。

封装

封装的概念

• 通常情况下可以在测试类给成员变量赋值一些合法但不合理的数值，无论是编译阶段还是运行阶段都不会报错或者给出提示，此时与现实生活不符。
• 为了避免上述错误的发生，就需要对成员变量进行密封包装处理，来隐 藏成员变量的细节以及保证成员变量数值的合理性，该机制就叫做封装。

封装的实现流程

• 私有化成员变量，使用private关键字修饰。
• 提供公有的get和set方法，并在方法体中进行合理值的判断。
• 在构造方法中调用set方法进行合理值的判断。

构造方法

构造方法的基本概念

构造方法名与类名完全相同并且没有返回值类型，连void都不许有。

class 类名 {
    类名(形参列表) {
         构造方法体;
    }
}
class Person {
    Person() { 
        // Person类中的构造方法
    }
} 

默认构造方法

• 当一个类中没有定义任何构造方法时，编译器会自动添加一个无参空构 造构造方法，叫做默认/缺省构造方法，如：Person(){}
• 若类中出现了构造方法，则编译器不再提供任何形式的构造方法。

构造方法的作用

使用new关键字创建对象时会自动调用构造方法实现成员变量初始化工作。

方法重载

方法重载的概念

若方法名称相同，参数列表不同，这样的方法之间构成重载关系 (Overload)。

重载的体现形式

• 方法重载的主要形式体现在：参数的个数不同、参数的类型不同、参数 的顺序不同，与返回值类型和形参变量名无关，但建议返回值类型最好 相同。
• 判断方法能否构成重载的核心：调用方法时能否加以区分。

重载的实际意义

• 方法重载的实际意义在于调用者只需要记住一个方法名就可以调用各种 不同的版本，来实现各种不同的功能。
• 如：java.io.PrintStream类中的println方法。

this关键字

this的基本概念

• 若在构造方法中出现了this关键字，则代表当前正在构造的对象。
• 若在成员方法中出现了this关键字，则代表当前正在调用的对象。
• this关键字本质上就是当前类类型的引用变量。

工作原理

在构造方法中和成员方法中访问成员变量时，编译器会加上this.的前缀， 而this.相当于汉语中"我的"，当不同的对象调用同一个方法时，由于调用 方法的对象不同导致this关键字不同，从而this.方式访问的结果也就随之 不同。

使用方式

• 当局部变量名与成员变量名相同时，在方法体中会优先使用局部变量(就近原则)，若希望使用成员变量，则需要在成员变量的前面加上this.的前 缀，明确要求该变量是成员变量（重中之重）。
• this关键字除了可以通过this.的方式调用成员变量和成员方法外，还可以 作为方法的返回值（重点）。
• 在构造方法的第一行可以使用this()的方式来调用本类中的其它构造方法 （了解）。

注意事项

• 引用类型变量用于存放对象的地址，可以给引用类型赋值为null表示不指向任何对象。
• 当某个引用类型变量为null时无法对对象实施访问（因为它没有指向任何 对象）。此时，如果通过引用访问成员变量或调用方法，会产生 NullPointerException 异常。

继承

继承的概念

当多个类之间有相同的特征和行为时，可以将相同的内容提取出来组成 一个公共类，让多个类吸收公共类中已有特征和行为而在多个类型只需要编写自己独有特征和行为的机制，叫做继承。

在Java语言中使用extends(扩展)关键字来表示继承关系。

如： public class Worker extends Person{} - 表示Worker类继承自Person类 其中Person类叫做超类、父类、基类。 其中Worker类叫做派生类、子类、孩子类。

使用继承提高了代码的复用性，可维护性及扩展性，是多态的前提条件。

继承的特点

• 子类不能继承父类的构造方法和私有方法，但私有成员变量可以被继承只是不能直接访问。
• 无论使用何种方式构造子类的对象时都会自动调用父类的无参构造方法， 来初始化从父类中继承的成员变量，相当于在构造方法的第一行增加代 码super()的效果。
• 使用继承必须满足逻辑关系：子类 is a 父类，也就是不能滥用继承。
• Java语言中只支持单继承不支持多继承，也就是说一个子类只能有一个父 类，但一个父类可以有多个子类。

方法重写的概念

从父类中继承下来的方法不满足子类的需求时，就需要在子类中重新写 一个和父类一样的方法来覆盖从父类中继承下来的版本，该方式就叫做 方法的重写（Override）。

方法重写的原则

• 要求方法名相同、参数列表相同以及返回值类型相同，从Java5开始允许返回子类类型。
• 要求方法的访问权限不能变小，可以相同或者变大。
• 要求方法不能抛出更大的异常(异常机制)。

访问控制

常用的访问控制符

修饰符	本类	同一个包中的类	子类	其他类
public	可以访问	可以访问	可以访问	可以访问
protected	可以访问	可以访问	可以访问	不能访问
默认	可以访问	可以访问	不能访问	不能访问
private	可以访问	不能访问	不能访问	不能访问

注意事项

• public修饰的成员可以在任意位置使用。
• private修饰的成员只能在本类内部使用。
• 通常情况下，成员方法都使用public关键字修饰，成员变量都使用private 关键字修饰。

final关键字

基本概念

final本意为"最终的、不可改变的"，可以修饰类、成员方法以及成员变量。

使用方式

• final关键字修饰类体现在该类不能被继承。 - 主要用于防止滥用继承，如：java.lang.String类等。
• final关键字修饰成员方法体现在该方法不能被重写但可以被继承。 - 主要用于防止不经意间造成重写，如：java.text.Dateformat类中format方法等。
• final关键字修饰成员变量体现在该变量必须初始化且不能改变。 - 主要用于防止不经意间造成改变，如：java.lang.Thread类中MAX_PRIORITY等。（初始化方式：直接初始化，构造块中初始化，构造方法体中初始化）

常量的概念

• 在以后的开发中很少单独使用final关键字来修饰成员变量，通常使用 public static final关键字共同修饰成员变量来表达常量的含义，常量的命名规范要求是所有字母都要大写，不同的单词之间采用下划线连接。
• • public static final double PI = 3.14;

多态

多态的概念

• 多态主要指同一种事物表现出来的多种形态。

• 饮料：可乐、雪碧、红牛、脉动、...

多态的语法格式

父类类型 引用变量名 = new 子类类型(); 如： Shape sr = new Rect(); sr.show();

多态的特点

• 当父类类型的引用指向子类类型的对象时，父类类型的引用可以直接调用父类独有的方法。
• 当父类类型的引用指向子类类型的对象时，父类类型的引用不可以直接调用子类独有的方法。
• 对于父子类都有的非静态方法来说，编译阶段调用父类版本，运行阶段调用子类重写的版本（动态绑定）。
• 对于父子类都有的静态方法来说，编译和运行阶段都调用父类版本。

引用数据类型之间的转换

• 引用数据类型之间的转换方式有两种：自动类型转换 和 强制类型转换。
• 自动类型转换主要指小类型向大类型的转换，也就是子类转为父类，也 叫做向上转型。
• 强制类型转换主要指大类型向小类型的转换，也就是父类转为子类，也 叫做向下转型或显式类型转换。
• 引用数据类型之间的转换必须发生在父子类之间，否则编译报错。
• 若强转的目标类型并不是该引用真正指向的数据类型时则编译通过，运行阶段发生类型转换异常。 (ClassCastException 类型转换异常)
• 为了避免上述错误的发生，应该在强转之前进行判断，格式如下： if(引用变量 instanceof 数据类型) 判断引用变量指向的对象是否为后面的数据类型

多态的实际意义

多态的实际意义在于屏蔽不同子类的差异性实现通用的编程带来不同的效果。

多态的使用场合

• 通过方法的参数传递形成多态； public static void draw(Shape s){ s.show(); } draw(new Rect(1, 2, 3, 4));
• 在方法体中直接使用多态的语法格式 Account acc = new FixedAccount();
• 通过方法的返回值类型形成多态 Calender getInstance(){ return new GregorianCalendar(zone, aLocale); }

抽象类

抽象方法的概念

• 抽象方法主要指不能具体实现的方法并且使用abstract关键字修饰，也就 是没有方法体。（abstract 不能和final，static同时使用）
• 具体格式如下： 访问权限 abstract 返回值类型 方法名(形参列表); public abstract void cry();
• 抽象类主要指不能具体实例化的类并且使用abstract关键字修饰，也就是不能创建对象。

抽象类和抽象方法的关系

• 抽象类中可以有成员变量、构造方法、成员方法；
• 抽象类中可以没有抽象方法，也可以有抽象方法；
• 拥有抽象方法的类必须是抽象类，因此真正意义上的抽象类应该是具有 抽象方法并且使用abstract关键字修饰的类。

抽象类的实际意义

• 抽象类的实际意义不在于创建对象而在于被继承。
• 当一个类继承抽象类后必须重写抽象方法，否则该类也变成抽象类，也 就是抽象类对子类具有强制性和规范性，因此叫做模板设计模式。

开发经验分享

• 在以后的开发中推荐使用多态的格式，此时父类类型引用直接调用的所 有方法一定是父类中拥有的方法，若以后更换子类时，只需要将new关键 字后面的子类类型修改而其它地方无需改变就可以立即生效，从而提高 了代码的可维护性和可扩展型。
• 该方式的缺点就是：父类引用不能直接调用子类独有的方法，若调用则 需要强制类型转换。

接口

接口的基本概念

• 接口就是一种比抽象类还抽象的类，体现在所有方法都为抽象方法。
• 定义类的关键字是class，而定义接口的关键字是interface。

类和接口之间的关系

名称	关键字	关系
类和类之间的关系	使用extends关键字表达继承关系	支持单继承
类和接口之间的关系	使用implements关键字表达实现关系	支持多实现
接口和接口之间的关系	使用extends关键字表达继承关系	支持多继承

抽象类和接口的主要区别

• 定义抽象类的关键字是abstract class，而定义接口的关键字是interface。
• 继承抽象类的关键字是extends，而实现接口的关键字是implements。
• 继承抽象类支持单继承，而实现接口支持多实现。
• 抽象类中可以有构造方法，而接口中不可以有构造方法。
• 抽象类中可以有成员变量，而接口中只可以有常量。
• 抽象类中可以有成员方法，而接口中只可以有抽象方法。
• 抽象类中增加方法时子类可以不用重写，而接口中增加方法时实现类需 要重写（Java8以前的版本）。
• 从Java8开始增加新特性，接口中允许出现非抽象方法和静态方法，但非 抽象方法需要使用default关键字修饰。
• 从Java9开始增加新特性，接口中允许出现私有方法。

static关键字

基本概念

• 使用static关键字修饰成员变量表示静态的含义，此时成员变量由对象层级提升为类层级，也就是整个类只有一份并被所有对象共享，该成员变量随着类的加载准备就绪，与是否创建对象无关。
• static关键字修饰的成员可以使用引用.的方式访问，但推荐类名.的方式。

使用方式

• 在非静态成员方法中既能访问非静态的成员又能访问静态的成员。 (成员：成员变量 + 成员方法， 静态成员被所有对象共享)
• 在静态成员方法中只能访问静态成员不能访问非静态成员(不能使用this关键字)。 (成员：成员变量 + 成员方法， 因为此时可能还没有创建对象)
• 在以后的开发中只有隶属于类层级并被所有对象共享的内容才可以使用 static关键字修饰。(不能滥用static关键字)

构造块和静态代码块（熟悉）

• 构造块：在类体中直接使用{}括起来的代码块。
• 每创建一个对象都会执行一次构造块。
• 静态代码块：使用static关键字修饰的构造块。
• 静态代码块随着类加载时执行一次。

public class SuperTest {
    {
        System.out.println("SuperTest中的构造块");  // step3
    }
    static {
        System.out.println("SuperTest中的静态构造块"); // step1
    }
    public SuperTest(){
        System.out.println("SuperTest中的构造方法体");// step4
    }

    public static void main(String[] args) {
        SuperTest superTest=new SuperTest();

    }
}
public class SubSuperTest extends SuperTest {
    {
        System.out.println("=====SubSuperTest中的构造块");  // step5
    }
    static {
        System.out.println("=====SubSuperTest中的静态构造块"); // step2
    }
    public SubSuperTest(){
        System.out.println("=====SubSuperTest中的构造方法体");// step6
    }

    public static void main(String[] args) {
        SubSuperTest test=new SubSuperTest();
    }
}
//SuperTest中的静态构造块
//=====SubSuperTest中的静态构造块
//SuperTest中的构造块
//SuperTest中的构造方法体
//=====SubSuperTest中的构造块
//=====SubSuperTest中的构造方法体
- 先执行父类的静态代码块，再执行子类的静态代码块。 
- 执行父类的构造块，执行父类的构造方法体。 
- 执行子类的构造块，执行子类的构造方法体。