【Java SE】面向对象高级特性

来源：互联网发布：网络教育概念股编辑：程序博客网时间：2024/05/18 03:08

继承(extends)
- A类直接使用B类的属性和方法(私有属性和构造方法除外)，即称为A类继承于B类
  - B类：被继承的类，称为父类(超类、基类)
  - A类：称为子类(派生类)
  - 子类继承父类的所有属性和方法(私有属性和构造方法除外)，同时可以增加自己的属性和方法
- Java中只能单继承：每个类只能有一个直接父类，一个父类可以有多个子类
- 语法：[访问控制符] [修饰符] class 子类名 extends 父类名
```
Class Employee{    String name;    String birth;    double salary;    void getDetail(){    }double getSalary(){}getArea(int l,int w){}getArea(int r){}e.getArea(1,2);}
Class Worker extends Employee{}
```
- 优点：
  1. 使编码更高效
  2. 易维护
  3. 代码的重用
super关键字
- 代表父类对象本身的引用
- 在所有方法中使用，引用父类对象的属性和方法
  - this.成员变量名：引用父类对象的属性(多用于变量名出现重名的时候)
  - this.方法名(参数列表)：引用父类对象的方法
- 只在构造方法中使用，用于调用父类的构造方法
  - super(参数列表)
    - 只能写在方法体内第一行
    - 只能使用一次
    - 参数列表要与被调用的父类构造方法的参数列表一致
  - 在同一个构造器中super()和this()不能同时出现
子类实例化的过程
- 使用默认的构造器
- 使用子类中创建的构造器
  - 在子类中创建构造器时，必须调用父类的构造器
  - 子类可以在自己的构造器中使用super()调用父类的构造器
    - 如果调用的是父类的无参构造器，则可以不写super()
    - 如果调用父类的无参构造器，那么父类中必须有无参构造器，否则系统编译时会出错
包
- 用途：
  - 包允许将类组合成较小的单元
  - 有助于避免命名冲突
  - 包允许在更广的范围内保护类、数据和方法
- 包可以是类、接口和子包的集合
- 将类放入包中：package 包名;
  - 在Java中位于包中的类，在文件系统中的存放位置，必须有与包名层次相对应的目录结构
  - package语句要作为Java源文件中的第一条语句
  - 每个源文件只能声明一个包
  - 如果没有package语句，则默认为无名包
- Java类库中常用的包
  - java.lang：Java语言包，任何程序中，该包都被自动导入
  - java.awt：图形用户界面包
  - java.awt.event：图形用户界面事件处理包
  - java.swing：跨平台轻量级组件包
  - java.sql：数据库访问包
  - java.io：由对输入/输出操作有用的类组成的包
  - java.util：提供了许多创建如:list、calendar、date等所需要的类和接口
  - java.net：提供了许多进行TCP/IP网络编程的类和接口
- 导入包中的类
  - 包名.类名
```
package test;class Cat extends p08.Animal{}
```
  - 使用import关键字引入其他包中的类
```
package test;import p08.Animal;class Cat extends Animal{}
```
    - 导入包中所有的类：import 包名.*;
    - 导入子包中所有的类：import 包名.子包名.*;
    - 导入包中的某个类：import 包名.子包名.类名;
  - 位于同一包中的类可以直接访问
权限访问操作符
权限访问操作符：public、protected、private和默认(什么都不写)
- 封装：
  - 使用访问权限修饰符对类的成员进行控制
  - 封装并不等同于private，即封装并不是不能访问成员
  - 对成员访问权限的任何控制(包括public)都可以称为封装机制
  - 作用：
    - 隐藏类的实现细节
    - 让使用者只能通过事先定制好
- 访问权限大小：public>protected>默认>private
- 类成员的访问权限修饰符：public、protected、默认、private
- 类的访问权限修饰符：public、默认
方法的覆盖(重写)
- 在子类继承父类时，发生的对从父类中继承来的方法进行改造的行为
- 在子类中的覆盖方法与父类中被覆盖的方法应具有：
  - 相同的方法名
  - 相同的参数列表：参数数量、参数类型、参数顺序都相同
  - 相同的返回值类型
  - 子类覆盖方法的访问权限要不小于父类中被覆盖方法的访问权限(通常设置相同的访问权限)
```
class A {    int method(int a,double b){        return 0;    }}
class B extends A {    int method(int a,double b){        return 1;    }}
```
引用数据类型的转换
- 上溯造型(向上转型)
  - 子类转换为父类，自动转换
  - 向上转型损失了子类新扩展的属性和方法，仅可以使用从父类中继承的属性和方法
- 下溯造型(向下转型)
  - 将父类对象显示的转换成子类类型，强制转换
  - 只有曾经向上转换过的对象，才能再向下转换
```
Animal a = new Cat(); //向上转型Cat c = (Cat)a; //向下转型
```
instanceof运算符
- 判断一个类是否实现了某个接口：对象 instanceof 接口;
- 判断一个实例对象是否属于一个类：对象 instanceof 类;
- instanceof运算符的返回值是boolean型的
多态
- 不同的对象对同一行为做出的不同相应
- 多态存在的三个必要条件：
  - 要有继承或实现关系
  - 要有重写
  - 父类引用指向子类对象
- 一旦满足多态存在的三个必要条件，当调用父类中被重写的方法后，运行时创建的是哪个子类的对象，就调用该子类中重写的那个方法
- 优点：
  - 简化代码
  - 改善代码的组织性和可读性
  - 易于扩展
static关键字
- static可以修饰属性、方法、代码块
- static只能修饰类成员，不能修饰局部变量
- 静态变量
  - static修饰的变量称为静态变量，也叫类变量
  - 静态变量被所有对象共享，它们在类被载入时创建，只要类存在，静态变量就存在
  - 访问方式：
    - 直接访问：类名.属性;
    - 实例化后访问：对象名.属性;
- 静态方法
  - static修饰的方法称为静态方法，也叫类方法
  - 访问方式：
    - 直接访问：类名.方法名();
    - 实例化后访问：对象名.方法名();
  - 作用：
    - 简化方法的使用
    - 便于访问静态属性
  - 静态方法里只能直接访问静态成员，而不能直接访问类中的非静态成员
  - 静态方法中布恩那个使用this、super关键字
  - 静态方法不能被非静态方法覆盖，静态方法不能修饰构造器
- 静态代码块
  - 类中由static修饰的不包含在任何方法体中的代码块
  - 当类被载入时，静态代码块被执行，其只能被执行一次
  - 静态代码块常用来进行类属性的初始化
```
class Chinese {    String name;    static String country; //静态变量    String age;         //静态代码块    static {System.out.println("你好！");    }         //静态方法    static void sing(){        System.out.println("北京欢迎你！");    }}
```

单例模式

保证一个类仅能创建一个实例，并提供一个访问它的全局访问点

实现：

public class Singleton {    //提供一个自身静态私有的成员变量    //在自己内部定义自己的一个实例，只供内部调用    private static Singleton instance = new Singleton();    //拥有一个私有构造器    private Singleton(){    }         //提供一个公有的静态方法，以供外部直接访问，获取唯一实例    public static Singleton getInstance(){        return instance;    }}

final关键字
- final可以修饰：
  - 类：不能被继承
  - 变量(属性和局部变量)：不能被重新赋值
    - 在声明时赋值，或在构造器中赋值
    - 系统不会对final属性默认的赋初始值
  - 方法：不能在子类中被覆盖
- 常量：在程序中经常使用而不需要频繁修改的变量，如圆周率
  1. 设置为static，多个实例共享该常量，没有必要每个对象保存一份
  2. 设置为final，赋值以后不能改变
  3. 所有字母大写，单词之间用下划线连接
抽象类
- 抽象类是抽象方法和非抽象方法的集合
  - 抽象方法：只有方法声明，没有方法实现
    - [访问权限修饰符] abstract 返回值类型方法名(参数列表);
  - 抽象方法和非抽象方法都有
  - 全部是抽象方法
  - 全部是非抽象方法
- 语法格式：[访问权限修饰符] abstract class 类名{}
```
abstract class A{    String name;    abstract int method(int a,int b);    void sayHi(){        System.out.println("Hello!");    }}
```
- 抽象类不能被实例化，只能被继承
- 抽象类包含的抽象方法必须在其子类中被继承，否则该子类也要声明为abstract
- 抽象方法不能为static
接口
- 接口中只包含常量和抽象方法，而没有变量和方法的实现(全部是抽象方法的抽象类可以被定义成接口)
- 接口是对类的一种规范
- 接口不是类，没有构造器，不能被实例化
- 语法格式：[访问权限修饰符] interface 接口名{//常量、抽象方法}
  - 接口成员默认修饰符：
    - 常量：public abstract final
    - 抽象方法：public abstract
```
interface Runnable {    public abstract void run();}
```
类之间是单继承，类与接口之间是多实现，接口之间是多继承
接口可以使方法的定义和实现分离，降低模块间或系统间的耦合性
针对接口编程可以屏蔽不同实现间的差异，看到的只是实现好的功能
implements：用类实现接口
- 多个无关的类可以实现一个接口，一个类可以实现多个无关的接口
- 一个类可以在继承一个父类的同时，实现一个或多个接口
内部类
- 内部类就是定义类在另一个类内部的类
- 特性：内部类对于同一包中的其他类来说，内部类能够隐藏起来，实现隐藏实现细节的功能
- 内部类可以访问其外部类中所有的属性和方法(局部内部类只能所在方法中的final类型的局部变量)
- 无需创建外部类的对象，即可从内部类访问外部类的变量和方法
- 必须创建内部类的对象，否则无法从外部类访问内部类的变量和方法
- 如果内部类中有和外部类同名的变量或方法，则内部类的变量和方法将获得比外部类的变量和方法更高的优先级
- 不能定义static变量
- 内部类的访问
  - 在其外部类中访问内部类：Inner in = new Inner();
  - 在其他类访问内部类：
    1. 实例化外部类：Outer o = new Outer();
    2. 实例化内部类：Outer.Inner oi = o.new Inner();
- 非静态内部类只能定义非静态成员，而静态内部类可以定义静态成员和非静态成员
- 使用“Outer.Inner inn = new Outer.Inner();”方式实例化静态内部类