面向对象编程

初识面向对象

面向过程 & 面向对象

• 面向过程思想

  • 步骤清晰简单，第一步做什么，第二步做什么.....

  • 面对过程适合处理一些较为简单的问题

• 面向对象思想

  • 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后才对某个分类下的细节进行面向过程的思索。

  • 面向对象适合处理复杂问题，适合处理需要多人协作的问题。

• 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统，。但是具体到微观操作，仍然需要面向过程的思路去处理。

什么是面向对象

• 面向对象的本质就是：以类的方式组织代码，以对象的的组织(封装)数据。

• 抽象

• 三大特性

• 封装

• 继承

• 多态

• 从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。

• 从代码运行角度考虑是先有类后有对象。类，是对象的模板。

类与对象的关系

类是一种抽象的数据类型，它是对某一类事物整体描述或定义，但是并不能代表某一个具体的事物。

• 动物，植物，手机，电脑.....

• Person类，Pet类，Car类等，这些类都是用来描述或定义某一类具体的事物应该具备的特点和行为。

对象是抽象概念的具体事例

• 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。

• 能够体现出特点，展现出功能的是具体实例，而不是一个抽象的概念。

return：结束一个方法，返回一个结果

创建与初始化对象

使用new关键字，创建对象

使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及类中构造器的调用。

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：

• 必须和类的名字相同。

• 一个类即使什么都不写，它也存在一个默认的构造方法。

• 必须必须没有返回类型，也不能写void。

构造器必须要掌握。

构造器

作用：

1. 实例化初始值

2. 使用new关键字，本质是在调用构造器。

注意点：一旦定义了有参构造，默认的无参构造调用必须重新定义。

Alt+insert 创建构造方法

this 代表当前类

创建对象内存分析

对象是通过引用操作的，指向堆中对象的地址

属性：字段、成员变量————默认初始化

对象的属性：对象名.属性名

对象的方法：对象名.方法名()

★面向对象的三大特性

封装

• 封装，数据的隐藏。

• 程序设计要追求"高内聚，低耦合"。高内聚就是类内部数据操作细节自己完成，不允许外部干涉；低藕合：仅暴露少量的方法给外部使用。

• 通常，应禁止直接访问一个对象中数据的实际表示。而应通过操作接口来访问，这称为信息的隐藏。

• 属性私有private， get/set

作用：

1. 提高程序程序安全性，保护数据。

2. 隐藏代码的实现细节。

3. 统一l接口。

4. 系统可维护性增加。

继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模

• extends大意思是"扩展"。子类是父类的扩展。

• Java中类只有单继承，没有多继承。

• 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。

• 继承关系的两个类，一个为子类(派生类),一个为父类(基类).子类继承父类,使用关键字extends来表示。

• 类和父类之间，从意义上讲应具有“is a”的关系。子类继承了父类，就会拥有父类的全部方法。

修饰符: public > protected > default > private

object类

Object类详解

在Java中所有的类.都默认直接或者间接继承Object。

super

super注意点:

• super调用父类的构造方法，必须要在构造方法的第一个.

• super必须只能出现在子类的方法或者构造方法中。

• super和this不能同时调用构造方法

super & this

1. 代表的对象不同。

   • this 本身调用者，这个对象

   • super 代表父类对象的应用。

2. 前提不同。

   • this 没有继承也可以使用。

   • super 只能在继承条件下才可以使用。

3. 调用的构造方法不同。

   • this() 本类的构造方法

   • super() 父类的构造方法

方法重写

重写:需要有继承关系,子类重写父类的方法。

• 方法名必须相同。

• 参数列表必须相同.

• 修饰符 : 范围可以扩大，但不能缩小。

• 抛出的异常 : 范围可以被缩小。但不能扩大。

重写,子类的方法和父类必须要一致，方法体不同。

重写的原因:

父类的功能子类不一定需要或者不一定满足。

重写都是方法的，重写和属性无关。

静态方法:

• 子类名 对象名 = new 子类名();

• 父类名 对象名 = new 子类名(); 父类的引用指向了子类。

静态的方法和非静态的方法区别很大。

方法的调用只和左边定义的数据类型有关。

非静态方法中，子类才能重写父类的方法。

Override 重写

多态

1. 动态编译 : 类型

2. 即同一方法，可以根据发送对象的不同而采用多种不同的行为类型。

3. 一个对象的实际类型是确定的,但可以指向对象的引用的类型有很多。

多态存在条件

• 有继承关系。

• 子类重写父类方法

• 父类引用指向子类对象。

不需要重写的方法:

static 方法,属于类，它不属于实例。

final 常量

private 方法

ClassCastException 类型转换异常

注意 :

• 多态是方法的多态,属性没有多态性。

• 一个对象的实际类型是确定的,可以指向的引用类型不确定。

• 父类指向子类时,子类重写了父类的方法,执行子类的方法;子类没有重写父类的方法，执行父类的方法。

• 对象能执行哪些方法,主要看对象左边的类型,和右边关系不大。

• 子类能调用的方法都是自己的，或者继承父类的。

• 父类可以指向子类,但是不能调用子类独有的方法。

强制转换

高------------------------------------------→低

父类名 对象名 = new 子类名();

((要转换的数据类型)对象名).方法名();

父类引用指向子类的对象时，把子类转换为父类，需要自动转换；父类转换为子类时，需要强制转换，但可能丢失方法。方便方法的调用，减少重复的代码，简洁。

static详解：

属性：

• 对象名.变量名;

• 类名.变量名(静态变量);

方法：

• 对象名.方法(非静态方法);

• 类名.方法(静态方法);

• 方法名();(类中调用，静态方法)

{
  //匿名代码块  
}
​
static{
    //静态代码块，只执行一次
}

同时有匿名代码块、静态代码块和构造器时，静态代码块第一个执行，其次是匿名代码块，最后才是构造方法。再执行一次，静态代码块不执行，匿名代码块第一个执行，最后是构造方法。

抽象类和接口

抽象类

• abstract 修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类的抽象类。

• 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。

• 抽象类不能使用 new 关键字来创建对象，它是用来让子类继承的。

• 子类继承抽象类，那么就必须要实现抽象类(重写抽象方法)。没有实现的抽象方法，否则该子类也要声明为抽象类。

抽象方法 ：只有方法名字，没有方法的实现。

接口

普通类，只有具体实现。抽象类，具体实现和规范(抽象方法)都有。接口，只有规范。

• 接口就是规范，定义的是一组规则

• 接口的本质是契约，就像法律一样，制定好后大家都需要遵守

• OO（面向对象）的精髓，是对对象的抽象，最能体现这一点的就是接口。之所以讨论设计模式，都只针对具备了抽象能力的语言(比如c++、 Java、c# )，就是因为设计模式所研究的，实际上就是如何合理的去抽象。

声明类的关键字是class，声明接口的关键字是interface。

接口中的所有定义其实都是抽象的。

实现接口

• 类通过implements实现一个或多个接口(逗号隔开)。

• 实现了接口中的类，就需要重写接口中的方法。

• 利用接口实现多继承。

接口中定义的一些方法，让不同的人实现。方法前默认有public abstract ，定义的常量前默认有public static final。

内部类

内部类就是在一个类的内部再定义一个类,比如A类中定义了一个B类，那么B类相对于A类来说就称为内部类，而A类相对B类来说就是外部类。

一个Java类中可以有多个class类，但是只能有一个Public class

• 成员内部类：

  通过外部类实例化内部类。

  外部类名.内部类名 内部对象名 = 外部对象名.new 内部类名()；

  内部类可以获得外部类的私有属性私有方法。

• 静态内部类 ：成员内部类加上static

• 局部内部类：方法里定义类

• 匿名内部类 ：没有名字初始化类。不用将实例保存到变量中。

异常机制

异常的定义

• 实际工作中遇到的情况，不可能是非常完美的。比如写的某个模块，用户输入不一定符合你的要求；你的程序要打开某个文件，这个文件可能不存在，或者文件格式不对；你要读取数据库的数据，数据可能是空的；程序在运行，内存或硬盘可能满了等等。

• 文件程序在运行过程中非常可能遇到这些异常问题。异常，英文是Exception，意思是例外，这些例外情况或者异常。需要写的程序做出合理的处理，而不至于使程序崩溃。

• 异常指程序运行中出现的不期而至的各种状况，如文件找不到、网络连接失败、非法参数等。

• 异常发生在程序运行期间，它影响了正常的程序执行流程。

异常分类

• 检查性异常 ：最具代表的检查性异常是用户错误或问题引起异常。，这是程序员无法预见的。例如要打开一个不存在的文件时，一个异常就发生了，这些异常在编译时不能被简单的忽略。

• 运行时异常 ：运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。

• 错误 ：错误不是异常，而是脱离程序员控制的问题。错误在代码中中常被忽略。例如当栈溢出时，一个错误就发生了，它们在编译也检查不到。

异常体系结构

• Java把异常当作对象来处理，并定义一个基类Java.Lang.Throwable作为异常的超类

• 在Java API中已经定义了许多异常类，这些异常类分为两大类。错误Error和异常Exception

  

Error

• Error类对象由Java虚拟机生成并抛出。大多数错误与代码编写者所执行的操作无关。

• Java虚拟机运行错误，当 JVM不再继续执行操作所需的内存资源时，当出现OutOfMemoryError。这些异常发生时，Java虚拟机一般会选择线程终止。

• 还有发生在虚拟机试图执行应用时，如类定义错误(NoClassDefFoundError)、链接错误(LinkAge Error)。这些错误是不可查的，因为他们在应用程序的控制和处理能力之外。而且绝大多数是程序运行时不允许出现的状况。

Exception

• 在Exception分支中有一个重要的子类Runtime Exception(运行时异常）。

  • Array Index Out Of Bounds Exception数组下标越界

  • Null Pointer Exception空指针异常

  • Arithmetic Exception算术异常

  • Missing Resource Exception丢失资源

  • Class Not Found Exception找不到类

• 这些异常一般是由程序逻辑错误引起的,程序应从逻辑角度尽可能避免这类异常的发生。

• Error和Exception的区别 : Error 通常是灾难性的致命错误,是程序无法控制和处理的,当出现这些异常时 , Java虚拟机一般会选择终止线程;Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。

Java异常处理

• 抛出异常

• 捕获异常

异常处理关键字：try、catch、finally、throw、throws

快捷键 Ctrl +Alt + T

自定义异常

• 使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常，用户自定义异常类只需继承Exception类即可。

• 在程序中使用自定义异常类，大体可分为以下几个步骤：

  1. 创建自定义异常类

  2. 在方法中，通过throw关键字抛出异常对象。

  3. 如果在当前抛出异常的方法中处理异常可以使用try---catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。

  4. 在出现异常方法的调用者中捕获并处理异常。

异常总结:

• 处理运行异常时，采用逻辑去合理规避，同时辅助try----catch处理。

• 在多重catch块后面，可以加一个catch (exception）来处理可能会被遗漏的异常。

• 对于不确定的代码，也可以加上try---catch，处理潜在的异常。

• 尽量去处理异常，切忌只是简单的调用PrintStackTrace()去打印输出。

• 具体如何处理异常，要根据不同的业务需求和异常类型去决定。

• 尽量添加finally语句块，去释放占用的资源。