笔记6.4

第七章：面向对象

一、编程思想

1. 面向过程：

}

for(int i=0;i<a.length;i++){

System.out.print(a[i]+"\t");

}

(2) 第二种：借助工具类

java.util.Arrays.sort( 数组名 );

(1) 面向过程：将问题分为第一步、第二步、第三

步 ... 直到问题解决

(2) 问题：解决小业务相对比较简单，但是面对复

杂业务时，相对不好处理 2. 面向对象：

二、对象

1. 对象：计算机中的对象：复杂的客观事物在 Java

程序中的一种表现形式

2. 对象的组成部分：

(1) 面向对象：将一些业务过程看成一个整体，利

用对象之间关系，解决问题

(2) 好处：解决业务复杂问题时，相对简单

一切皆对象

(1) 对象的属性：代表对象有什么特征，对应静态

数据部分

(2) 对象的方法：代表对象能做什么，对应动态的

行为和功能 3. 类：

三、类的组成

1. 类名：望文生义，每个单词首字母大写

2. 类的组成：

3. 属性：

(1) 计算机中，使用类进行区分不同类别对象，用

于描述该类对象有哪些属性和哪些方法

(2) 类和对象的关系：

  类是对象的模板

  对象是类的实例

  注意：一个类可以创建多个对象

class 类名 {

  // 1. 属性

  // 2. 方法

} (1) 属性：也称为成员变量

(2) 位置：定义类以内，方法以外

(3) 语法：数据类型 变量名 ;

        数据类型 变量名 = 值 ;

(4) 成员变量具有默认值：

  整数类型： 0

  小数类型： 0.0

  布尔类型： false

  字符类型：空字符

  对象类型： null

   

(5) 成员变量的作用范围：至少在本类中有效

(6) 一个类中不允许成员变量命名相同，但是成员

变量可以和局部变量命名冲突；局部变量在方法中

被优先使用 4. 方法：

(1) 方法：也称为成员方法

(2) 位置：定义在类以内，其他的方法以外

(3) 语法：

  public 返回值类型 方法名 ( 形参 ){

      // 方法体

  }

(4) 方法的定义分为方法的声明和方法实现：

  a. 方法的声明：

      修饰符 返回值类型 方法名 ( 形参 ) 异常

     

      注意：一个方法的修饰符可以有 0~n 个

  b. 方法的实现： {}

5. 创建对象：

(1) 类名 对象名 = new 类名 ();

(2) 使用：

  对象名 . 属性名

  对象名 . 方法名 ( 实参 ); 四、方法的重载 (overload) 【开发 + 面试 + 考试】

1. 理解：一个类中可以定义多个同名的方法，但是

参数列表不同

2. 要求：

3. 使用：根据调用时，传递的实际参数决定调用哪

一个方法

五、构造方法

1. 构造方法：是一种特殊的方法，也被称为构造器

2. 定义位置：定义类以内，方法以外

3. 特点 ( 要求 )

(1) 方法名相同

(2) 形参列表不同 ( 数据类型、个数、顺序 )

(3) 返回值类型、修饰符、异常没有要求 (1) 构造方法的方法名必须和类名一致

(2) 构造方法没有返回值类型 ( 连 void 都没有 )

(3) 语法：

  修饰符 类名 ( 形参 ){}

(4) 构造方法允许重载

  ( 一个类中可以定义多个构造方法，但是无参

数的构造方法只能一个，可以同时定义多个有参数

的构造方法 )

(5) 构造方法不能手动调用，在创建对象时，被调

用

4. 使用：

(1) 在创建对象时，根据传递的实际参数，决定具

体调用哪一个构造方法完成对象的创建

(2) 如果一个类中没有提供任何的构造方法时，

jvm 默认提供一个公开的无参数的构造方法；当类

中提供了有参数的构造方法，则默认的构造方法不

再提供 ( 可以自定义写出 )

5. 构造方法的作用： 6. 开发应用技巧：

六、 this 的应用

1. this.

(1) 用于创建对象

(2) 借助构造方法给属性赋值

实际开发一个类中通常提供两个构造方法：

(1) 一个无参数的构造方法

(2) 一个有参数的构造方法 ( 参数取决于属性的个

数、类型、顺序 )

(1) this 代表当前对象，用于调用本类中属性或

是方法

(2) this. 属性名

  this. 方法名 ( 实参 );

(3) this. 通常可以省略，但是当成员变量和局部

变量命名冲突时，可以使用 this. 区分成员变

量   2. this()

七、引用

1. 引用：对象类型的变量

2. 引用存储对象在堆空间中首地址

3. 每个对象在堆空间是相互独立，操作一个对象不

会影响其他对象

(1) this() 只能应用在构造方法中，调用本类其

他构造方法

(2) this() 只能应用在构造方法中的第一行有效

语句

java 是一种强类型的语言，对应类型的数据需要

存储在对应类型的变量中：

  类名 引用名 = new 类名 ( 实参 );

  // 引用         对象

  // 引用类型     对象的类型

注意：引用的类型必须和对象的类型一致 4. 可以单独的声明引用： 类名 引用名 ;

5. 相同类型的引用之间可以相互赋值，传递的是对

象在堆空间中首地址

6. 可以利用 null 作为引用的初始化数据，代表空地

址，但是如果使用存储 null 引用调用属性或是方

法，编译通过，但是运行报错，错误信息为：

java.lang.NullPointerException( 空指针异常 )

7. 引用的应用场景：

(1) 引用应用在形式参数上：该类型的对象和引用

都可以作为实际参数进行传递

(2) 引用应用在返回值类型上：该类型的对象或是

引用都可以作为返回值进行返回 第八章：面向对象的三大特性 ( 封装、继

承、多态 )

一、封装

1. 目前的程序无法保证数据的安全性、容易造成业

务数据的错误

2. private ：私有的，被 private 修饰的内容只能在

本类中访问

3. 为私有化的属性提供公开的 get 和 set 方法： 二、继承

（ 1 ） get 方法，获取私有化属性的值：

    public 返回值类型 get 属性名 (){

        return 属性名 ;

    }

    注意：返回值类型取决于获取属性的类型

        方法名： get+ 属性名首字母大写

(2) set 方法，为私有化属性赋值：

  public void set 属性名 ( 数据类型 变量

名 ){

      this. 属性名 = 变量名

  }

  注意： () 中的数据类型取决于属性类型

        方法名： set+ 属性名首字母大写 碳素笔 是一种   笔

水杯   是一种 容器

狗     是一种 动物

A     is a   B

如果 A is-a B 关系成立， A 和 B 之间具有继承关

系

A- 子类   继承   B- 父类

      extends

1. 理解：

(1) 继承体现的是类之间的一种 “is-a” 关系。

      A   is a   B

      子类         父类

      子类   继承   父类

          extends

(2) 语法：

  class 子类类名 extends 父类类名 {}

(3) 通过继承关系，子类型可以直接使用父类中定

义的属性和方法

2. 继承体现了程序的复用性和可扩展性 3. 方法的覆盖【也被称为方法的重写 - override 】

(1) 方法的覆盖：子类中定义和父类中相同的方法

(2) 方法的覆盖要求：

a. 子类的方法名、形参列表、返回值类型必须和

父类一致

b. 子类的访问修饰符，和父类相同或是比父类更

宽

(3) 如果子类覆盖了父类中方法，则优先使用子类

覆盖后的

(4) 注意：如果子类定义了和父类方法名、形参列

表相同，但是返回值类型不同的方法，则编译报错

(5) 如果子类定义了和父类方法名相同、形参列表

不同的方法，则编译通过，运行也 ok ，这构成了方

法的重载

4. Java 中继承特点： (1) 一个父类可以有多个直接的子类

    class Animal{}

    class Dog extends Animal{}

    class Cat extends Animal{}

(2) 一个子类只能有一个直接的父类，但是可以有

多个间接的父类 ( 多级继承 ) ， java 中的类之间是单

继承

5. java 中的访问修饰符：

(1) 访问修饰符代表一种访问权限

(2) java 中有 4 个访问修饰符：

  private ：私有的

  default ：默认的

  protected ：受保护的

  public ：公开的

(3) 访问修饰符的访问权限：

          本类   同包   非同包的子类  

其他  

private     ok

default     ok     ok

protected   ok     ok       ok public ：   ok     ok         ok      

ok

(4) 访问修饰符修饰内容的继承性：

  private 修饰的属性和方法，不能被继承

  default 修饰的属性和方法，同包子类允许

继承

  protected 修饰的属性和方法，同包 + 非同

包子类继承

  public 修饰的属性和方法，所有子类都可以

继承

6. super 的应用： 三、多态

1. 理解：

(1) 第一种用法： super.

  a. super. 引用在子类的方法中，代表访问

父类中属性或是成员方法

   

  b. super. 属性名

      super. 成员方法名 ( 实参 );

     

(2) 第二种用法： super()

  a. 创建子类对象时， jvm 默认创建一个父类

对象，而且默认使用父类中无参数的构造方法完成

父类对象的创建

  b. super()/super( 实参 ): 应用在子类的

构造方法的第一行有效语句中，代表创建子类对象

时，告知 jvm 完成父类对象创建时采用哪一个构造

方法完成对象的创建

  c. 如果子类的构造方法第一行没有指定

super()/super( 实参 ) ，则默认添加 super() (1) 多态：父类型的引用存储不同子类型的对象

        父类类名 引用名 = new 子类类名

();

            引用           对象

          父类型         子类型

(2) 使用父类型的引用调用属性或是方法，只能调

用父类中定义的属性和方法

(3) 如果子类覆盖了父类中方法，则优先使用子类

覆盖后的方法

2. 引用之间的转换： (1) 父类型的引用赋值给子类型的引用，需要强制

类型转换

      大类型     小类型

  a. 子类类名 引用名 = ( 子类类名 ) 父类型

的引用名 ;

  b. 强制类型转换的结果：

      i. 实际存储的对象类型和要转换类型一

致，编译 + 运行通过

      ii. 实际存储的对象类型和要转换的类型

不一致，编译通过，运行报错，错误信息为：

java.lang.ClassCastException( 类型转换异

常 )

     

(2) 子类型的引用 赋值给父类型的引用，无需强

转，直接赋值，体现多态

(3) 没有继承关系双方，不允许相互赋值，强制类

型转换也不允许

3. instanceof 避免类型转换异常： (1) 语法：引用名 instanceof 类名

(2) 执行：判断引用中存储的实际对象类型是否兼

容于后面的类型 ( 是否为后面类型的一种 ) ，兼容 -

true ，不兼容 -false

(3) 作用：可以在程序设计中避免类型转换异常

直接使用案例中的 Animal 、 Dog 、 Cat 类即可，

在 main 函数中完成以下功能：

public static void main(String[]

arsg){

  Animal a = null;

  /*

  利用 Scanner 输入一个整数 n ， n 是偶数

则存储 Dog,

  否则存储 Cat

  */

   

  /*

  判断：如果 a 中存储的是 Cat ，打印输

出 " 我是猫 " ，

      否则打印输出 " 我不是猫 " 4. 多态的应用：

第九章：三个修饰符

一、 abstract[ 抽象的 ]

1. abstract 可以修饰类：

  */

   

}

(1) 多态应用在形式参数上：本类型 + 所有的子类

型对象、引用都可以作为实际参数进行传递

(2) 多态应用在返回值上：本类型 + 所有子类型的

对象、引用都可以作为返回值进行返回 (1) 被 abstract 修饰的类称为抽象类

(2) 语法：

  abstract class 类名 {}

(3) 特点：抽象类只能声明引用，不能创建对象

(4) 抽象类中可以定义属性和成员方法、构造方法

2. asbtract 可以修饰方法：

(1) 被 asbtract 修饰的方法称为抽象方法

(2) 语法：

  访问修饰符 abstract 返回值类型 方法名

( 形参 );

  注意：访问修饰符和 abstract 没有先后顺序

(3) 特点：抽象方法只有声明部分，没有方法的实

现

(4) 注意：抽象方法只能定义在抽象类中

3. 抽象可以定义子类

(1) 语法： class 类名 extends 抽象类类名 {}

(2) 特点：子类不想成为抽象类，则必须覆盖父类

中所有的抽象方法 二、 static[ 静态的 ]

1. 可以修饰属性：

2.

3. 可以修饰方法：

(1) 被 static 修饰的属性称为静态属性、静态变

量、类变量

(2) 语法： static 数据类型 变量名 ;

        static 数据类型 变量名 = 值 ;

(3) 特点：静态变量基于类存在，被所有对象共

享，和创建对象的多少无关

(4) 使用：

    a. 可以通过 对象 . 静态属性名

    b. 可以直接通过 类名 . 静态属性名 -> 建

议 (1) 被 static 修饰的方法称为静态方法

(2) 语法：

  访问修饰符 static 返回值类型 方法名 ( 形

参 ){}

(3) 使用：直接通过 类名 . 静态方法名 ( 实参 );

(4) 注意：静态方法中只能访问本类的静态成员，

不能直接访问本类的非静态成员

(5) 静态方法中不能使用 this 和 super 关键字

4. 可以代码块 (1) 被 static 修饰的代码称为静态代码块

(2) 位置：定义在类以内，方法以外，被 static

修饰的 {}

(3) 语法：

      class 类名 {

          static{}

      }

(4) 作用：在类加载的时候，静态代码块按照和属

性定义的先后顺序完成对静态属性的初始化工作

(5) 类加载：当 jvm 第一次使用一个类的时候，通

过 classpath 找到类对应的 .class 文件，对文件

进行读取 , 读取该类的包名、类名、父类、属性、构

造方法等信息，并将读取的信息保存到 jvm 内存

中，一个类进行一次类加载。

(6) jvm 类加载的时机 ( 什么叫第一次使用一个

类 ) ：

  a. 第一次访问该类的静态成员

  b. 第一次创建该类对象：

      先进行类加载，再完成对象的创建

  c. 子类类加载，先导致其父类类加载     三、 final[ 最终的、最后的 ]

1. final 可以修饰变量：

2. final 可以修饰方法：允许子类继承，但是不允许

覆盖

3. final 可以修饰类：被 final 修饰的类不允许被继

承，没有子类，例如： System 、 Math

第十章：接口

(1) 被 final 修饰的变量作用范围内的常量

(2) final 数据类型 变量名 ;

(3) 特点：只允许一次赋值，不允许修改

(4) 注意：引用一旦被 final 修饰，代表引用中存

储的对象不能更换

思考： System.out.println(); 实现原理？

    System -> 类

    out -> 静态 属性 - 》对象类型

    println() -> 方法 一、接口

1. 接口：是一种标准，接口的实现者和使用者都必

须遵循的约定。

2. 接口的语法：

二、接口的实现类

1. 语法：

(1) 接口的关键字： interface

(2) 语法：

    interface 接口名 {}

(3) 接口不能创建对象，但是可以声明引用

(4) 接口中不能定义构造方法

(5) 接口中所有属性为公开、静态、常量 ( 默认被

public static final 修饰 )

(6) 接口中所有方法位公开抽象方法 ( 默认被

public asbtract 修饰 )

class 类名 implements 接口名 {} 2. 注意：

(1) 如果实现类不想成为抽象类，需要覆盖接口中

所有的方法

(2) 实现类覆盖接口中方法时，访问权限必须是

public

3. 使用：

接口名 引用名 = new 实现类类名 ();

// 父类型       子类型

// 接口         实现类   - 》 体现多态