Java 面向对象程序设计

标签：use   方法返回值   允许   分析   import   jdk   html   user   计算机   

第一章 类和对象

假设要编程解决一个很大的问题，需要写几万行代码，如果按照以前的做法，将这些代码放一个Java文件中，可以想象这个文件会非常冗长，而且很难维护。

因此，出现了面向对象的设计。

面向对象程序设计，英语缩写为 OOP。面向对象程序设计是一个里程碑，Alan Kay 因为设计了世界上第一个面向对象语言 Smalltalk 而获得图灵奖。

Java之父 James Gosling 结合 Internet 背景设计了完全面向对象的Java 语言。

1、对象

现实世界中客观存在的事物就称为对象。在Java的世界中，“万物皆对象”。

对象可以是有形的，如一辆汽车；也可以是无形的，如一项计划。

Java是一种面向对象的编程语言（Object Oriented Programming Language, OOPL）,因此，我们要学会用面向对象的思想考虑问题和编写程序。在面向对象中，对象是用来描述客观事物的一个实体，用面向对象的方法解决问题时，首先要对现实中的对象进行分析与归纳，找出哪些对象与要解决的问题是相关的。

每一个对象都有自己的特征，包括静态特征和动态特征。静态特征是可以用某些数据来描述的特征，如人的姓名、年龄等。动态特征是对象所表现的行为或对象所具有的功能，如购物、收款等。

1.1、对象的属性和方法

在面向对象的编程思想中，把对象的静态特征和动态特征分别称为对象的属性和方法，它们是构成对象的两个主要因素。其中属性是用来描述对象静态特征的一个数据项，该数据项的值即是属性值。

解释：对象：用来描述客观事物的一个实体，由一组属性和方法构成。

1.2、封装

封装（Encapsulation）就是把一个事物包装起来，并尽可能隐藏内部细节。

对象的属性和方法是相辅相成、不可分割的，它们共同组成了实体对象。因此，对象具有封装性。

2、类

类定义了对象将会拥有的特征（属性）和行为（方法）。

类的属性：对象所拥有的静态特征在类中表示时称为类的属性。

类的方法：对象执行的操作称为类的方法。

2.1、类和对象的关系

在Java面向对象编程中，就用这个类创建出类的一个实例，即创建类的一个对象。

一个类为它的全部对象给出了一个统一的定义，而它的每个对象则是符合这种定义的一个实体。因此类和对象的关系就是抽象和具体的关系。

类时多个对象进行综合抽象的结果，是实体对象的概念模型，而一个对象是一个类的实例。

类是对象的类型。

3、Java是面向对象的语言

在面向对象程序设计中，类是程序的基本单元。Java是完全面向对象的编程语言，所有程序都是以类为组织单元的。

命名规则：

Camel （骆驼）命名法：方法或者变量的第一个单词的首字母小写，后面每个单词的首字母大写，如 showCenter、userName等。

Pascal (帕斯卡) 命名法：每一个单词的首字母都大写，如类名School等。

在Java中，定义类的属性和方法使用骆驼命名法，定义类使用帕斯卡命名法。

3.1、创建和使用对象

类的用作就是创建对象。由类生成对象，称为类的实例化过程。一个实例也就是一个对象，一个类可以生成多个对象。

语法： 类名  对象名 = new 类名();

面向对象的优点：

（1）与人类的思维习惯一致：面向对象的思维方式从人类考虑问题的角度出发，把人类解决问题的思维过程转变为程序能够理解的过程。面向对象程序设计能够让我们使用“类”来模拟现实世界中的抽取概念，用“对象”来模拟现实世界中的实体，从而计算机解决现实问题。

（2）信息隐藏，提高了程序的可维护性和安全性：封装实现了模块化和信息隐藏，即将类的属性和行为封装在类中，这保证了对它们的修改不会影响到其他对象，有利于维护。同时封装使得在对象外部不能随意访问对象的属性和方法，避免了外部错误对它的影响，提高了安全性。

（3）提高了程序的可重用性：一个类可以创建多个对象实例，增加了重用性。

本章总结：

• 对象是用来描述客观事物的一个实体，由一组属性和方法构成。
• 类定义了对象将会拥有的特征（属性）和行为（方法）。
• 类和对象的关系是抽象和具体的关系。类是对象的类型，对象是类的实例。
• 对象的属性和方法被共同封装在类中，相辅相成，不可分割。
• 面向对象程序设计的优点如下：
  • 与人类的思维习惯一致
  • 隐藏信息，提高了程序的可维护性和安全性。
  • 提高了程序的可重用性

第二章 类的无参、带参方法

 1、成员变量和局部变量

成员部门：在类中定义的变量称为类的成员变量。如果其它类的方法要访问它，必须首先创建该类的对象，然后才能通过操作符 “.” 来引用。

局部变量：在方法中定义的变量称为局部变量。它的作用域仅仅在定义该变量的方法内，因此只有在这个方法中能够使用。

局部变量可以和成员变量同名，并且在使用时，局部变量具有更高的优先级。

2、JavaDoc注释

/**
 * <p>Title: ESPModelConvert</p>
 * <p>Description: 模型转换</p>
 * @author liyh
 * @version 1.0
 */
称为JavaDoc注释

@parameter

3、在定义方法和调用方法时，把参数分别称为形式参数和实际参数，简称形参和实参。

形参是在定义方法时对参数的称呼，目的是定义方法需要传入的参数个数和类型。

实参是调用方法时传递给方法处理的实际的值。

调用方法时，需要注意以下两点：

• 先实例化对象，再调用方法。
• 实参的类型、数量、顺序都要与形参一一对应。

4、深入理解带参方法

数组作为参数的方法

对象作为参数的方法

5、包名

package 包名；

5.1、导入包

import 包名.类名；

第三章 对象和封装

面向过程的核心是函数，以功能为中心，实现了函数级别的代码重用。

面向对象的核心是封装了属性和方法（行为）的类，以数据为中心，实现了类级别的代码重用，面向对象因为采用了类，所以具有继承和多态特性，可以进一步重用代码和简化编程，而面向过程中没有继承和多态特性。

1、构造方法及其重载

构造方法的名称和类名相同，没有返回值类型。构造方法的主要作用就是在创建对象时执行一些初始化操作，如给成员属性赋值。

重载：方法名相同、参数列表不同，称为构造方法的重载。

如果同一个类中包含了两个或两个以上的方法，他们的方法名相同，方法参数的个数或者参数类型不同，则称为方法被重载了，这个过程称为方法重载。

成员方法和构造方法都可以进行重载。

注意：方法重载的判断依据如下：

• 必须在同一个类里。
• 方法名相同。
• 参数列表（方法参数的个数或参数类型）不同。
• 与方法返回值和方法修饰符没有任何关系。

在使用 this 调用 自身的其他构造方法时，只能作为第一条语句。

2、static 修饰符

static 可以用来修饰属性、方法和代码块。static修饰的变量属于这个类所有，即由这个类创建的所有对象共用同一个static 变量。通常把static 修饰符的属性和方法称为类属性（类变量）和类方法。

不使用static修饰的属性和方法属于单个对象，通常称为实例属性（实例变量）和实例方法。

注意:

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

在方法中不可以定义static变量，也就是说，类变量不能是局部变量。

结论：构造方法没有返回值类型，如果有，则不是构造方法，而是和构造方法同名的成员方法。

成员变量和局部变量同名时，必须使用 this。

this.name = name;

注意：this不能调用类变量和类方法，也不能调用局部变量。

3、封装

封装的具体步骤：修改属性的可见性来限制对属性的访问；为每一个属性创建一对赋值（setter）方法和取值（getter）方法，用于对这些属性的存取；在赋值方法中，加入对属性的存取控制语句。

封装的好处：隐藏类的实现细节；让使用者只能通过程序规定的方法来访问数据；可以方便地加入存取控制语句，限制不合理的操作。

封装时会用到多个权限控制符来修改成员变量和方法，区别如下。

• private：成员变量和方法只能在其定义的类中被访问，具有类可见性。
• 默认：成员变量和方法只能被同一个包里的类访问，具有包可见性。
• protected：可以被同一个包中的类访问，被同一个项目中不同包中的子类访问。
• public：可以被同一个项目中的所有类访问，具有项目可见性，这是最大的访问权限。

 第四章 继承

1、语法

修饰符 SubClass extend SuperClass {

　　// 类定义部分

}

继承是面向对象的三大特性之一，是Java中实现代码重用的重要手段之一。Java中支持单继承，即每个类智能有一个直接父类。继承表达的是is a的关系，或者说是一种特殊和一般的关系。

在Java中，子类可以从父类中继承到哪些“财产”呢？

• 继承public 和 protected 修饰的属性和方法，无论子类和父类是否在同一个包里。
• 继承默认权限修饰符修饰的属性和方法，但是子类和父类必须在同一个包里。
• 无法继承private 修饰的属性和方法。
• 无法继承父类的构造方法。

2、重写和继承关系中的构造方法

在子类中可以根据需求对从父类继承的方法进行重新编写，称为方法的重写或者方法的覆盖（overriding）.

方法重写必须满足如下要求：

• 重写方法和被重写方法必须具有相同的方法名。
• 重写方法和被重写方法必须具有相同的参数列表。
• 重写方法的返回值类型和被重写方法的返回值类型相同或者是其子类。
• 重写方法不能缩小被重写方法的访问权限。

2.1、Object 类的重写

Object 类是所有类的父类。是所有Java类的祖先。

Object类中的equals() 方法用来比较两个对象是否是同一对象，若是，返回true。

而字符串对象的equals() 方法用来比较两个字符串的值是否相等。java.lang.String类重写了Object类中的equals()方法。

继承条件下构造方法的调用规则如下：

• 如果子类的构造方法中没有通过super显式调用父类的有参构造方法，也没有通过this显式调用自身的其他构造方法，则系统会默认先调用父类的无参构造方法。在这种情况下，有没有“super();” 语句，效果都是一样。
• 如果子类的构造方法中通过super显式调用父类的有参构造方法，则将执行父类相应的构造方法，而不执行父类无参构造方法。
• 如果子类的构造方法中通过this 显式调用自身的其他构造方法，则在相应构造方法中应用以上两条规则。
• 需特别注意是，如果存在多级继承关系，则在创建一个子类对象时，以上规则会多次向更高一级父类应用，一直到执行顶级Object 类的无参构造方法为止。

3、抽象类

3.1、抽象类和抽象方法

可以使用Java中的抽象类来实现，用abstract 来修饰类，抽象类不能通过new 实例化。

用abstract来修饰print() 方法，则子类必须重写该方法。

抽象类和抽象方法的特点如下：

• 抽象类和抽象方法都通过abstract关键字来修饰。
• 抽象类不能实例化。抽象类中可以没有、有一个或多个抽象方法，甚至全部方法都可以是抽象方法。
• 抽象方法只有方法声明，没有方法实现。有抽象方法的类必须声明为抽象类。子类必须重写所有的抽象方法才能实例化，否则子类还是一个抽象类。

注意：abstract可以用来修饰类和方法，但不能用来修饰属性和构造方法。

4、final 修饰符

 　　用final 修饰的变量（包括成员变量和局部变量）将变成常亮，只能赋值一次。

注意：

• final 和abstract 是功能相反的两个关键字。可以形成对比记忆。
• abstract 可以用来修饰类和方法，不能用来修饰属性和构造方法。final 可以用来修饰类、方法和属性，不能修饰构造方法。
• Java提供很多类都是final 类，如String 类、Math类，他们不能再有子类。Object类中一些方法，如getClass()、notify()、都是final方法，只能被子类继承而不能被重写，但是hashCode()、toString()、equals(Object obj) 不是final方法，可以被重写。

一定要区分对象的引用值和对象的属性值两个概念。使用final 修饰引用型变量，变量不可以再指向另外的对象，但是所指对象的内容却是可以改变的。

结论：

使用final修饰引用型变量时，变量的值是固定不变的，而变量所指向的对象的属性值是可变的。

abstract 不能和private 同时修饰一个方法。

abstract 不能和static 同时修饰一个方法。

abstract 不能和final 同时修饰一个方法或类。

本章总结：

• 继承是Java 中实现代码重用的重要手段之一。Java中只支持单继承，即一个类只能有一个直接父类。java.lang.Object 类是所有Java类的祖先。
• 在子类中可以根据实际需求对从父类继承的方法进行重新编写，称为方法的重写或覆盖。
• 子类中重写的方法和父类中被重写的方法必须具有相同的方法名，参数列表，返回值类型必须和被重写方法的返回值类型相同或是其子类。
• 如果子类的构造方法中没有通过super显式调用父类的有参构造方法，也没有通过this 显式调用自身的其他构造方法，则系统会默认先调用父类的无参构造方法。
• 抽象类不能实例化。抽象类中可以有零到多个抽象方法。非抽象类若继承抽象类，则必须重写父类的所有抽象方法。
• 子类必须重写父类所有的抽象方法才能实例化，否则子类还是一个抽象类。
• 用final 修饰的类，不能再被继承。用final 修饰的方法，不能被子类重写。用final 修饰的变量将变成常亮，只能在初始化时进行赋值，不能再其他地方修改。

第五章 多态

　　简单来说，多态(Polymorphism) 是具有表现多种形态能力的特征。更专业化的说法，同一个实现接口，使用不同的实例而执行不同的操作。

　　1、子类到父类的转换（向上转型）

• 将一个父类的引用指向一个子类对象，称为向上转型（upcasting）,自动进行类型转换。
• 此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法。
• 此时通过父类引用变量无法调用子类特有的方法。

1.1、使用父类作为方法形参实现多态

使用父类作为方法的形参，是Java中实现和使用多态的主要方式之一。

1.2、使用父类作为方法返回值实现多态

使用父类作为方法的返回值，是Java中实现和使用多态的另一种方式。

总结：总结出实现多态的三个条件

• 继承的存在（继承是多态的继承，没有继承就没有多态）。
• 子类重写父类的方法（多态下调用子类重写后的方法）。
• 父类引用变量指向子类对象（子类到父类的类型转换）。

2、父类到子类的转换（向下转型）

将一个指向子类对象的父类引用赋给一个子类的引用，称为向下转型，此时必须进行进行强制类型转换。

3、instanceof 运算符

进行向下转型时，如果没有转换为真是子类类型，就会出现类型转换异常。如何有效避免出现这种异常？Java提供了instanceof 运算符来进行类型的判断。

语法： 对象 instanceof 类或接口

该运算符用来判断一个对象是否属于一个类或者实现了一个接口。结果为true 或 false。 在强制类型转换之前通过instanceof 运算符检查对象的真实类型，再进行相应的强制类型转换，这样就可以避免类型转换异常，从而提高代码的健壮性。

资料：

• 使用instanceof 运算符时，对象的类型必须和 instanceof 的第二个参数所指定的类或接口在继承树上有上下级关系，否则会出现编译错误。
• instanceof 通常和强制类型转换结合使用。

本章总结

• 通过多态可以减少类中的代码量，可以提高代码的可扩展性和可维护性。继承是多态的基础，没有继承就没有多态。
• 把子类转换为父类称为向上转型，自动进行类型转换。把父类转换为子类称为向下转型，必须进行强制类型转换。
• 向上转型后通过父类引用变量调用的方法是子类覆盖或继承父类的方法，通过父类引用变量无法调用子类特有的方法。
• 向下转型后可以访问子类特有的方法。必须转换为父类指向的真实子类类型，否则将出现；类型转换异常 ClassCastExceptio。.
• instanceof 运算符用于判断一个对象是否属于一个类或实现了一个接口。
• instanceof 运算符通常和强制类型转换结合使用，先通过instanceof 进行类型判断，再进行相应的强制类型转换。
• 使用父类作为方法形参和使用父类作为返回值类型是使用多态的常用方式。

第六章 接口

·1、语法（定义接口类）

[修饰符] interface 接口名 extends 父接口1，父接口2，...{

　　// 敞亮定义

　　// 方法定义

}

class 类名 extends 父类名 implements 接口1，接口与2，...{

　　//类成员

}

说明：

• 接口的命名规则与类相同。如果修饰符是public，则该接口在整个项目中可见；如果省略修饰符，则该接口只在当前包可见。
• 接口中可以定义常量，不能定义变量。接口中的属性都会自动用public static final 修饰，即接口中的属性都是全局静态常量。接口中的常量必须在定义时指定初始值。

　　public static final int PI = 3.14;  

　　int PI = 3.14； // 在接口中，这两个定义语句效果完全相同

　　int PI；// 错误！在接口中必须指定初始值，在类中会有默认值

• 接口中所有方法都是抽象方法。在接口中方法都会自动用public abstract 修饰，即接口中只有全局抽象方法。
• 和抽象类一样，接口也不能实例化，接口中不能有构造方法。
• 接口之间可以通过extends 实现继承关系，一个接口可以继承多个接口，但接口不能继承。
• 接口的实现类必须实现接口的全部方法，否则必须定义为抽象类。

一个类只能有一个直接父类，但可以通过implements 实现多个接口。当类在继承父类的同时又实现了多个接口时，extends 关键字必须位于implements 关键字之前。

 本章总结：

• 接口中的属性都是全局静态常量，接口中的方法都是全局抽象方法，接口中没有构造方法。
• 类中能继承一个父类，但可以实现多个接口。一个类如果实现了一个接口，则必须实现接口中的全部方法，否则必须将其定义为抽象类。Java通过实现接口达到了多重继承的效果。
• 接口表示一种约定，接口表示一种能力。接口体现了约定和实现相分离的原则。
• 抽象类利于代码复用，接口利于代码维护。
• 通过面向接口编程，开发系统时，主题架构使用接口，接口构成系统的骨架，这样就可以通过更换实现接口的类来实现更换系统。

第七章 异常

目前流行的用于记录日志的开源框架——log4j 并使用 log4j 记录异常日志。

Java的异常处理是通过五个关键字——try、catch、finally、throw、throws来实现的。

1、在try——catch 语句块后加入finally 块，把该语句放入finally 块。无论是否发生异常，finally 块中的代码总能被执行。

try——catch——finally 结构中try块是必需的，catch和finally块为可选，但两者至少须出现其中之一。

需要特别注意的是，即使在try块和catch块中存在return语句，finally块中语句也会被执行。发生异常时的执行顺序，执行try块或catch中return之前的语句，执行finally块中的语句，执行try块或catch中return语句退出。

finally块中语句不被执行的唯一情况：在异常处理代码中执行System.exit(1) ，将退出Java虚拟机。

例如：在catch块中执行System.exit(1); //finally块中语句不被执行的唯一情况

2、多个catch块

当运行时，系统从上到下分别对每个catch语句块语句处理的异常类型进行检测，并执行第一个与异常类型匹配的catch 语句。执行其中的一条catch语句之后，其后的catch语句都将被忽略。

注意：在使用多重catch块时，catch块排列顺序必须是子类到父类，最后一个一般都是Exception 类。

3、声明异常——throws

通过throws继续声明异常，如果调用者不打算处理该异常，则可以继续通过throws声明异常，让上一级调用者处理异常。

4、抛出异常——throw

在方法内通过throw抛出异常，把问题交给调用者去解决。

对比：throw 和 throws 的区别表现在以下三个方面

• 作用不同：throw 用于在程序中抛出异常；throws用于声明在该方法内抛出了异常。
• 使用位置不同：throw 位于方法体内部，可以作为单位语句使用；throws 必须跟在方法参数列表的后面，不能单独使用。
• 内容不同：throw 抛出一个异常对象，而且只能是一个；throws后面跟异常类，而且可以跟多个异常类。

5、开源日志记录工具 log4j

创建log4j.properties 文件。使用log4j 需要创建log4j.properties 文件，该文件专门用来配置日志信息。如输出级别、输出目的地、输出格式等。

### 设置Logger 输出级别和输出目的地 ###

log4j.rootLogger = debug, stdout,logfile

### 把日志信息输出到控制台 ###

log4j.appender.stdout = org.apache.log4j.ConsoleAppender

log4j.appender.stdout.Target = System.err

log4j.appender.stdout.layout = org.apache.log4jSimpleLayout 

### 把日志信息输出到文件：jbit.log ###

log4j.appender.logfile = org.apache.log4j.FileAppender

log4j.appender.logfile.File = jbit.log

log4j.appender.logfile.layout = org.apache.log4j.PatternLayout

log4j.appender.logfile.layout.ConversionPattern = %d{yyyy-MM-dd HH:mm:ss} %1 %F%p %m%n

5.1、输出级别

log4j.rootLogger = debug, stdout,logfile

其中，debug指的是日志记录器（Logger）的输出级别，主要输出级别及含义如下。

• fatal：指出严重的错误事件将会导致应用程序的退出。
• error：指出虽然发生错误事件，但仍然不影响系统的继续运行。
• warn：表明会出现潜在的错误的情形。
• info：在粗粒度级别上指明消息，强调应用程序的运行过程。
• debug：指出细粒度信息事件，对调式应用程序是非常有帮助的。

各个输出级别优先级：

fatal > error > warn > info > debug

日志记录器（Logger） 将只输出那些级别高于或等于它的信息。例如，级别为debug，将输出fatal、error、warn、info、debug级别的日志信息；而级别为error，将只输出fatal、error级别的日志信息。

5.2、日志输出目的地 Appender

log4j.rootLogger = debug, stdout,logfile

其中，stdout、logfile 指的是日志输出目的地的名字。

log4j允许记录日志到多个输出目的地，一个输出目的地被称为一个Appender。log4j中最常用的Appender有以下两种。

• ConsoleAppender：输出日志事件到控制台。通过Target 属性配置输出到System.out 或 System.err，默认的目标是System.out。
• FilAppender：输出日志事件到一个文件。通过File 属性配置文件的路径及名称。
• 示例中共有两个Appender ,第一个命名为stdout，使用了ConsoleAppender，通过配置Target属性，把日志信息写到控制台System.err；第二个 Appender 命名为logfile，使用了FileAppender，通过配置File属性，把日志信息写到指定的文件jbit.log中。

5.3 日志布局类型Layout

Appender 必须使用一个与之相关联的布局类型 Layout，用来指定它的输出样式。log4j 中最常用的 Layout 有以下三种。

• HTMLLayout：格式化日志输出为HTML表格。
• SimpleLayout：以一种非常简单的方式格式化日志输出，它输出级别Level，然后跟着一个破折号“——”，最后是日志消息。
• PatternLayout：根据指定的转换模式格式化日志输出，从而支持丰富多样的输出格式。需要配置layout.ConversionPattern 属性，若没有配置该属性，则使用默认的转换模式。

示例中的第一个Appender 是stdout，使用了SimpleLayout；第二个Appender 是logfile,使用了PatternLayout，需要配置layout.ConversionPattern 属性来自定义输出格式。

5.4 转换模式 ConversionPattern

对于PatternLayout，需要配置layout.ConversionPattern属性，常用的配置参数及含义如下。

• %d：用来设置输出日志的日期和时间，默认格式为ISO8601。野结衣在其后指定格式，比如%d{yyyy-MM-dd HH:mm:ss}，输出格式类似于2020-11-23 11:15:59。
• %m：用来输出代码中指定的消息。
• %n：用来输出一个回车换行符。
• %l：用来输出日志事件的发生位置，包括类名、发生的线程，以及在代码中的行数。例如，如果输出为cn.jbit.log.Test11.main(Test11.java:21)，则说明日志事件发生在cn.jbit.log包下的Test11类的main线程中，在代码中的行数为第21行。
• %p：用来输出优先级，即debug、info、warn、error、fatal等。
• %F：用来输出文件名。
• %M：用来输出方法名。

本章总结：

• 异常是由Java应用程序抛出和处理的非常严重错误，它可以分为Checked异常和运行时异常两大类。
• Checked异常必须捕捉或者声明抛出，否则无法通过编译。运行时异常不要求必须捕捉或者声明抛出。
• Java的异常处理是通过五个关键字来实现的：try、catch、finally、throws 和 throw。
• 即使在try块、catch块中存在return语句，finally块中语句也会被执行。finally块中语句不被执行的唯一情况是，在异常处理代码中执行System.exit(1);
• 可以在一个try语句块后面跟多个catch语句块，分别处理不同的异常。但排列顺序必须是从特殊到一般，最后一个一般为Exception类。
• 自定义异常类，一般需要继承Exception 或者 RuntimeException。
• log4j是一个优秀的日志记录工具，常用使用方式是配置log4j.properties 文件，从而控制日志输出级别、目的地和输出格式。

本文为课程书本知识记录，如有遗漏错误，请大佬指出，谢谢谢谢。

Java 面向对象程序设计

标签：use   方法返回值   允许   分析   import   jdk   html   user   计算机   

原文地址：https://www.cnblogs.com/liyh321/p/13999453.html