Java面向对象

叁歲伎倆 2022-04-02 11:13 309阅读 0赞

## 1.1. 面向对象概念 ##

Ø 什么是面向对象 面向对象(Object Oriented)是一种思想，90年代以后软件开发的主流思想。

由于现实社会是由各种各样的事物所组成的，而我们编程又是在模拟现实社会，那么在程序也要用一些东西来表示现实社会中的事物，这些东西就是程序中的对象。我们在程序中使用这些对象，对其特征和行为进行操作进行编程，这就是面向对象编程。

在使用面向对象编程思想之前，我们通常用面向过程的思想编程，先分析出解决问题的步骤，然后按照步骤一步一步实现。

Ø 面向对象编程的优点

提高代码复用性。

使用者无需关心具体细节。

转变程序员角色，更加符合人的思维习惯。

## 1.2. 类与对象 ##

Ø 什么是类

类是用来描述对象的。由于对象是虚拟出来的东西，是看不见摸不着的，我们需要在程序中使用对象，就需要用一种方式来描述对象，然后根据这个描述来创建对象。

Ø 类和对象的关系

对象是类的实例，类是对象的抽象。

Ø 怎么定义类

将一系列特征相似的对象的共同特征及行为抽取出来进行描述，写在一个class中，用成员变量描述对象的特征，用成员方法来描述对象的行为。

class Person \{

String name;

int age;

void speak()\{

System.out.println("My name is " + name);

System.out.println("I am " + age + " years of age");

Ø 怎么使用类创建对象

使用new关键字和指定类名来创建一个对象。

Ø 对象的产生

Person p = new Person();

这句话先在堆内存中创建了一个对象，然后栈内存中创建一个变量引用了对象的地址。

Ø 成员变量初始化

当一个对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值。基本数据类型初始化值为0，引用数据类型初始化值为null。

Ø 对象的使用

当我们创建对象之后可以使用点语法来访问对象的属性和方法。例如：

Person p = new Person();

p.name = "张三"; // 访问属性(成员变量)

p.age = 20;

p.speak(); // 访问方法

Ø 对象的生命周期

对象的生命周期从new关键字创建时开始，到没有任何引用到达对象时结束(成为垃圾)。

Ø 匿名对象

我们可以不定义变量引用对象，使用new关键字创建对象后直接使用，这样的对象没有名字，所以叫匿名对象。

匿名对象因为没有任何引用到达，在使用一次之后即成为垃圾。

通常我们需要使用一个对象且只使用一次的时候，就可以使用匿名对象。比如将对象作为一个参数传递给另外一个函数。

## 1.3. 封装（Encapsulation） ##

Ø 什么是封装

封装是指隐藏对象的属性和一些实现细节，仅对外提供必须的访问方式。

Ø 怎么封装

将所有属性隐藏，提供公有方法对其访问。

将不需要对外提供的方法隐藏。

Ø 封装的优点

提高安全性：在访问对象的属性时候通过方法实现，在方法中可以进行校验。隐藏不必要提供的方法避免错误的调用。

简化编程：使用者无需关心对象内部具体实现细节，只要根据对象功能调用指定方法。

## 1.4. 构造函数（Constructor） ##

Ø 什么是构造函数

构造函数（Constructor）是一个特殊的函数。

函数名和类名相同。

没有返回值类型。注意：没有返回值类型不等同于void，void也是一种返回值类型。不能使用return关键字返回任何值。

在使用new关键字创建对象之后自动调用。

Ø 构造函数的重载

构造函数的重载和普通函数相同，函数名相同，参数列表不同即可。

Ø 构造函数的调用

构造函数在new关键字创建对象时调用。

构造函数可以在该类其他构造函数的第一个语句使用this关键字调用。

Ø 所有类都有构造函数

每一个类都有构造函数，即使我们没有显式定义构造函数，也会生成一个默认无参的构造函数，其中没有任何内容。

注意：这个自动生成的构造函数只在未定义任何构造函数时生成，如果我们定义了一个有参的构造函数，那么就不会生成无参的了。

Ø 构造函数的访问权限

在定义构造函数时，如无特殊需要，应使用public关键字修饰构造函数。

在一些特定情况下，我们不想让别人创建该类对象，那么可以使用private修饰构造函数，例如单态设计模式。

## 1.5. this关键字 ##

this关键字除了在构造函数中调用其他构造函数以外，还可以当做一个引用使用。其用于方法中，哪个对象调用该方法，this就引用哪个对象。例如：

方法中局部变量和成员变量重名，我们想调用成员变量时就可以使用this.变量名形式访问成员变量。

在方法中要将调用该方法的对象作为参数传递给另一个方法时，可以将this作为实参传给该方法。

在内部类中访问外部类的成员时，需要使用外部类名.this.成员名形式访问。

## 1.6. 函数的参数传递 ##

基本数据类型的变量作为实参传入函数之后，在函数中将形参改变，调用处的实参不变。

因为基本数据类型的值是直接存在变量中，传入函数之后函数中的形参也同样存了一个值，这两个值是没有联系的，所以函数中将形参改变时修改的只是函数中的变量的值，和调用处的实参无关。

引用数据类型的变量作为实参传入函数之后，在函数中将形参改变，调用处的实参改变。

因为引用数据类型变量中存储的是地址，传入函数之后函数中的形参存储的也是同样一个地址，函数中将这个形参改变时改变的都是同一个地址上的对象，所以一边改变两边都变。

## 1.7. static关键字 ##

static关键字用来修饰类的成员，被这个关键字修饰的成员都和类加载有关。

JVM运行时不会将所有类加载到内存，因为无法确定程序中要使用哪些。类在第一次使用时加载，只加载一次。

Ø 静态变量

用static修饰的变量就是静态变量。

静态变量在类加载后就初始化。

静态变量被类的所有实例所共享。

静态变量可以使用 类名.变量名 形式访问。

如果在定义一个类的时候，发现一个成员变量需要被所有实例所共享，那么这个成员变量就需要定义为static的。

Ø 静态方法

用static修饰的方法就是静态方法。

静态方法在类加载后就可以使用。

静态方法可以使用 类名.方法名 形式访问。

静态方法不能直接访问外部非静态成员。

因为外部非静态成员必须在类创建对象之后才能使用，而静态方法可以在没创建对象时就使用。

如果要在静态方法内部访问外部非静态成员，需要先创建该类对象，通过对象访问。

静态方法中不能使用this关键字。

因为this是个引用，哪个对象调用方法就引用哪个对象。 而静态方法有可能不是被对象调用的，this无从引用。

如果一个方法不用访问对象的非静态成员，那么就可以定义为静态的，这样使用者就不需要创建对象，直接用类名调用。

静态方法通常是作为工具方法或者一个可以产生对象的方法被声明，目的是为了让调用者更方便的使用，不必创建对象。

Ø 静态代码块

用static修饰的代码块就是静态代码块。

静态代码块在类加载后执行。

静态代码块和静态方法相同，不能使用外部非静态成员。

静态代码块执行和静态变量的初始化顺序由代码从上到下顺序决定。

Ø 静态内部类

用static修饰的内部类就是静态内部类。

静态内部类在类加载后就可以创建对象，无需创建外部类对象。

具体内容详见3.18内部类

## 1.8. 垃圾回收 ##

对象在没有任何引用可以到达时，生命周期结束，成为垃圾。

所有对象在被回收之前都会自动调用finalize()方法。

一个对象在成为垃圾之后不会被马上回收，JVM会检测内存中的垃圾堆积到一定程度时才会回收，如果我们不想等到这个时候才回收，可以使用System.gc()方法来通知虚拟机回收垃圾。调用该方法之后JVM会开启新线程做处理垃圾的工作，这需要一定时间。

## 1.9. 单态设计模式（SingletonPattern） ##

Ø 什么是设计模式

在编程过程中我们经常会遇到一些典型的问题或需要完成某种特定需求，而这些问题和需求前人也曾经遇到过，他们经过大量理论总结和实践验证之后优选出的代码结构、编程风格、以及解决问题的思考方式，这就是设计模式（Design pattern）。设计模式就像是经典的棋谱，不同的棋局，我们用不同的棋谱，免得我们自己再去思考和摸索。

Ø 单态（单例）设计模式

单态设计模式（Singleton pattern）就是要保证在整个程序中某个类只能存在一个对象，这个类不能再创建第二个对象。

Ø 单态设计模式的写法

私有化构造函数，阻止创建新对象。

由于需要返回一个对象，那么我们就需要在类内部自己创建一个对象，并使用成员变量记住它。

由于该类不能创建对象，所以这个成员变量不能是普通的成员变量，需要静态，这样在类加载之后就可以创建一个唯一的对象了。

我们不希望其他类修改这个成员变量，所以将其私有。

提供一个公有的方法用来获取唯一的一个对象。

这个方法由于需要在不创建对象的情况下使用，所以需要静态。

## 1.10. 继承（Inherit） ##

Ø 什么是继承

在程序中，可以使用extends关键字可以让一个类继承另外一个类。

继承的类为子类(派生类)，被继承的类为父类(超类, 基类)。

子类会自动继承父类所有的方法和属性。

Ø 为什么要使用继承

当我们发现一个类的功能不行，方法不够用时，就可以派生子类，增加方法。

当我们需要定义一个能实现某项特殊功能的类时，就可以使用继承。

最终还是为了一个目的，实现代码的复用性。

当我们定义一个类时，发现另一个类的功能这个类都需要，而这个类又要增加一些新功能时，就可以使用extends关键字继承那个类，这样那个被继承类的功能就都有了，不必重写编写代码。这时只要在新的类中编写新的功能即可，原有代码就被复用了。

Ø 继承的特点

Java只支持单继承，不支持多继承，但是可以多重继承

因为如果一个类继承多个类，多个类中有相同的方法，子类调用该方法时就不知道该调用哪一个类中的方法了。

子类中可以使用super调用父类成员

super用法和this类似，this是谁调用该方法就引用谁，super是调用该方法的对象的父类对象。

Ø 向上转型

把一个子类当做父类来用是可以的，因为父类有的子类都有

把一个父类当做子类来用就不可以了，因为子类有的父类不一定有

可以定义一个父类类型的变量来记住子类对象，这在程序中称之为向上转型

Ø 强制类型转换

把一个子类当做父类来用的时候，不能调用子类特有方法。

因为编译时编译器会做语法检查，看到变量是父类类型那么就会到父类中查找是否有该方法，没有则报错。

这种情况下，就需要强制类型转换，将父类类型强转成子类类型。

以(子类名)变量名形式进行强制类型转换

强制类型转换时，无论类型是否匹配编译都不会报错，但如果类型不匹配运行会报错，我们可以使用instanceof进行判断，编译时预知错误。

在子类当做父类来用时，不能调用特有方法，如果一定要调用，就需要强制类型转换回子类。在做转换时最好instanceof判断一下类型是否匹配。

Ø 子类覆盖（Override）父类方法

覆盖方法必须和被覆盖方法具有相同的方法名称、参数列表和返回值类型。

子类的方法返回值类型可以是父类方法返回值类型的子类。

如果在子类中想调用父类中的那个被覆盖的方法，我们可以用super.方法的格式。

如果直接调用方法，是在当前子类中先查找，如果子类有会调用子类的。使用super形式只在父类中查找，子类有没有都不调用。

覆盖方法时，不能使用比父类中被覆盖的方法更严格的访问权限。

因为有可能将子类对象当做父类对象来使用，那么能获取到的父类对象中的方法在子类中必须都能获取到。

覆盖方法时，不能比父类抛出更多的异常。

子类只能比父类强，不能比父类弱。

重载（Overload）和重写（Override）的区别：

重载是方法名相同，参数列表不同，和返回值类型无关。

重写是方法名、参数列表、返回值类型全相同。

@Override 注解，可以检查覆盖是否成功

Ø 子类当做父类使用时需要注意

当我们在调用某个类的一个方法时，此方法声明需要一个父类对象，这时我们可以将一个子类对象作为实参传递过去，注意此时方法定义的形参为父类，在方法中使用父类变量调用方法时，其实是调用子类的方法。

思考：上述情形下，在方法中用父类变量访问属性，访问的是子类还是父类的属性 ?

在把子类当做父类来用时，使用父类变量访问方法，访问的是子类的方法，因为虚拟机会找到变量引用的地址，根据这个地址来访问方法，这叫动态分配。

这种机制没有被使用到类的成员变量上，如果用父类变量访问属性，那么会直接找到父类的属性，不会看地址是哪个对象。

Ø 继承的应用细节

子类不继承父类私有成员

父类中私有成员对外不可见，子类对象中无法访问这些成员。

构造函数不被继承

构造函数通常用来初始化类的成员变量，父类和子类的成员变量不同，初始化方式也不同，构造函数的名字也不同。

为什么只支持单继承

如果一个类继承多个类，那么多个类中有相同的方法，调用时会引起歧义。

Ø 子类对象实例化过程

子类构造函数中可以使用super关键字调用父类构造函数。

在子类创建对象时一定会调用父类构造函数。即使没有显式调用，也会默认调用父类无参构造函数。

在子类中第一行用this关键字去调其他的构造方法，这时系统将不再自动调父类的。但其他构造函数中会调用父类构造函数。

在构造方法中this和super关键字只能出现一次，而且必须是第一个语句。

以后在设计类的时候，最好定义一个无参的构造方法，不然子类实例化的时候就容易出错。

## 1.11. 对象的比较 ##

在我们使用运算符“==”来比较两个对象时，其实比较的是两个对象的地址。如果运算符两边是同一个对象，地址相同则会等到true，只要是不同对象地址就会不同，返回false。

我们在编程过程中经常会比较两个对象的属性，这时我们就无法用“==”来比较了，因为即使两个对象所有属性都相同但不是同一个对象“==”号比较后也会得到false。这种情况下我们一般会定义一个equals（）方法来进行比较。

## 1.12. 文档注释 ##

文档注释以“/\*\*”开始，以“\*/”标志结束，相应的信息和批注所对应的位置很重要！ 类的说明应在类定义之前，方法的说明应在方法的定义之前。

使用文档注释修饰一个类的源代码之后可以通过javadoc.exe来生成帮助文档。

生成文档的命令：

javadoc -d (目录) -version –author (源文件)

批注参数来标记一些特殊的属性及其相应的说明 。

@author<作者姓名>

@version<版本信息>

@param<参数名称><参数说明>

@return<返回值说明>

## 1.13. 组合设计模式(CompositePattern) ##

Ø 什么时候用组合

组合是一种实现代码复用的方式，当我们在定义一个类的时候需要用到另外一个类的方法时，就可以用组合。

Ø 怎么用组合

定义一个所需要的类类型的成员变量

通过构造函数进行装配，接收一个该类类型的对象，用成员变量引用

在需要使用另一个类的方法时通过成员变量访问

Ø 组合的优点

如果两个类没有父子关系，不合适用继承。

Java只支持单继承，组合不占用继承位置。

## 1.14. 多态(Polymorphism) ##

Ø 什么是多态

多态字面上的意思就是多种形态。在面向对象语言中，我们可以将函数的形参定义为一个父类类型，而在真正调用该函数时这个父类类型的所有子类对象都可以传入，根据传入的子类对象不同函数可以运行处多种形态。

Ø 多态的特点

应用程序不必为每一个派生类（子类）编写功能调用，只需要对抽象基类进行处理即可。这一招叫“以不变应万变”，可以大大提高程序的可复用性。

派生类的功能可以被基类的引用变量引用，这叫向后兼容，可以提高程序的可扩充性和可维护性。现在写的程序可以调用将来写的程序不足为奇 。

## 1.15. 抽象类 ##

Ø 什么是抽象类

使用abstract关键字修饰的类就是抽象类，抽象类不能new对象，原因在于抽象类含有抽象方法，不能被调用。

没有方法体的方法为抽象方法，使用abstract关键字修饰。

有抽象方法的类必须声明为抽象类，抽象类不一定含有抽象方法。

Ø 为什么要定义抽象类

如果有多个类具有相同的方法声明，而方法的实现不一样，这时就可以抽象出父类，将方法在父类中声明

别人在学习我们的软件时，只需要学习父类就知道子类有什么方法

在设计软件时，要尽力抽象父类，继承关系以3~4层为宜

## 1.16. final关键字 ##

final标记的类不能被继承。

final标记的方法不能被子类重写。

final标记的变量即为常量，只能赋值一次。注意引用数据类型和基本数据类型的区别。

使用public static final共同修饰的常量就是全局常量。通常全部字母大写。

## 1.17. 模板设计模式(TemplatePattern) ##

Ø 为什么要使用模板方法设计模式

在解决一些问题或者设计一个软件的时候，需要先定义一个模板，就相当于一种事先定义好的协议。

以后要做这系列的事情都按照这个模板来做。这样就实现统一化管理。

Ø 如何实现模板方法设计模式

定义一个抽象的父类做为模板，定义所有需要的方法

在父类中实现供外界调用的主方法，将方法声明为final

根据不同业务需求定义子类实现父类的抽象方法

## 1.18. 内部类（InnerClass） ##

Ø 类中的内部类

在类里面定义的类称之为内部类（Inner Class），内部类是外部类的一个成员。

内部类必须创建外部类对象才能使用。

创建内部类对象时必须先创建一个外部类对象，通过一个外部类对象才能创建内部类对象。

外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

内部类可以直接访问外部类的成员，而外部类不能直接访问内部类的成员。访问方式：外部类名.this.成员名

内部类可以访问外部类成员，因为在使用内部类时一定会有外部类对象，且只对应一个。

外部类不能访问内部类成员，因为在使用外部类时有可能还没有创建内部类对象。

如果一定要在外部类中使用内部类成员，那么需要创建内部类对象，通过对象来访问。

内部类中不能定义静态成员。

因为内部类需要创建外部类对象才能使用，static的本意是不创建对象就能使用，这是矛盾的。

内部类的class文件名为：外部类名.内部类名.class

Ø 方法中的内部类

一个类如果只在某个方法中使用，那么可以在方法中定义。

定义在方法中的类只能在方法中使用，而且使用的代码只能在声明的代码下面。

方法中的内部类只有在运行到类定义之后才能使用。

方法中定义的内部类不能访问方法中定义的局部变量，除非这个局部变量被声明为final的。

在方法中定义的局部变量在方法运行结束之后生命周期结束，不能再被访问。

方法中的内部类创建的对象有可能生命周期比这个局部变量长，例如这个对象被作为返回值返回，那么方法运行结束之后还可以访问这个对象。

这时变量被销毁了，对象还在，如果在对象的某个方法内访问这个变量就访问不到了。

我们需要使用final修饰这个变量，被final修饰的变量会一直存储在内存中，方法运行结束之后不被销毁。

方法中的内部类class文件名为：外部类名$.编号内部类名.class

Ø 匿名内部类

如果一个类只使用一次，那么可以定义为匿名内部类。

使用 new 父类名()\{ 类定义\} 形式声明，先创建一个指定类的子类，然后根据这个类创建一个对象。

匿名内部类的class文件名为：外部类名$编号.class

Ø 静态内部类

可以使用static修饰一个类中的内部类。

静态内部类不用创建外部类对象就可以直接创建对象。

外部类名.内部类名 变量名 = new 外部类名.内部类名();

静态内部类可以定义静态成员。

因为静态内部类可以直接使用，无需创建外部类对象。

静态内部类中不能访问外部非静态成员。

因为创建静态内部类不需要外部类对象，也就是有可能没有创建外部类对象，使用外部类成员必须有外部类对象。

## 1.19. 接口 ##

Ø 什么是接口

Ÿ 接口是一种特殊的抽象类，接口中声明的所有方法都是抽象的

Ÿ 使用interface关键字修饰一个接口

Ø 接口的用法

Ÿ 我们可以定义一个类来实现接口，使用implements关键字

Ÿ 实现一个接口需要实现接口中所有的方法，抽象类除外

Ÿ 通常使用匿名内部类来实现一个接口

Ÿ 接口可以继承接口，使用extends关键字。 接口不能继承抽象类，因为抽象类中可能有不抽象的方法。

Ÿ 一个类可以实现多个接口，为了实现多态

Ø 接口中的方法和变量

Ÿ 接口中定义的方法默认是公有的抽象的，被public abstract修饰

Ÿ 接口中定义的变量默认为全局常量，使用public static final修饰

Ø abstract class和interface的区别

Ÿ 抽象类中可以有不抽象的方法，接口中全是抽象的方法

Ÿ 抽象类用extends继承，接口用implements实现

Ÿ 抽象类中的变量和方法没有默认修饰符，接口中的变量默认为public static final的，接口中的方法默认为public abstract

Ÿ 一个类只能继承一个抽象类，一个类可以实现多个接口

Ø 什么时候用抽象类，什么时候用接口

Ÿ 如果能用接口，就不用抽象类，因为别人实现接口可以不占用继承的位置。

Ÿ 如果定义一个抽象的父类，其中所有方法都是抽象的，那么就定义为接口。

Ÿ 如果定义一个抽象的父类的时候，需要有不抽象的方法，那么只能定义为抽象类。

## 1.20. 异常 ##

Ø 什么是异常

Ÿ 异常就是Java程序在运行过程中出现的错误。如程序要打开一个不存的文件、网络连接中断、操作数组越界、装载一个不存在的类等。

Ø Throwable

Ÿ Throwable表示Java中可被抛出的对象，它是所有错误和异常的父类

Ÿ Throwable有两个子类：Error、Exception

Ÿ Error表示错误

Ÿ Exception表示异常

Ÿ RuntimeException表示运行时异常，是Exception的子类

Ø 异常的分类

Ÿ Error(错误)

由Java虚拟机生成并抛出，包括动态链接失败、虚拟机错误等，程序对其不进行处理

Ÿ Exception(异常)

所有异常类的父类，子类定义了各种各样可能出现的异常事件，一般需要用户显式地声明向外抛出或捕获。

Ÿ Runtime Exception(运行时异常)

一类特殊的异常，如被0除、数组角标越界等。产生比较频繁，处理麻烦，如果每次都处理，会对程序可读性和运行效率影响比较大，因此由系统检测并将它们交给缺省的异常处理程序，用户不必对其进行处理。这类异常不处理，编译时不会报错，只是在运行时出现错误时才报告异常，所以我们称之为运行时异常，所有RuntimeException的子类都是运行时异常。我们也可以对运行时异常进行处理。

Ÿ 编译时异常

Exception中除了RuntimeException的子类，其他异常都是必须要处理的，如果不处理，编译时会报错，这些异常我们称之为编译时异常。

Ø 异常的用法

Ÿ 处理异常

在程序中可以在方法后面使用throws关键字声明向外抛出异常

对于编译时异常，通常我们需要使用try……catch语句进行捕获

finally可以结合try……catch使用，出现异常，finally里面的代码也会执行

Ÿ 异常的一些细节

如果父类方法中声明抛出多个异常，那么重写（覆盖）该方法只能抛出那些异常的一个子集，也就是说子类不能比父类抛出更多的异常。

如何处理多个异常

try语句与finally的嵌套使用

Ÿ 自定义异常