3.Java面向对象进阶（上篇）

最新推荐文章于 2024-10-01 18:51:18 发布

Zd08

最新推荐文章于 2024-10-01 18:51:18 发布

阅读量934

点赞数 11

分类专栏： Java基础文章标签： java

本文链接：https://blog.csdn.net/weixin_60437068/article/details/141317291

版权

Java基础专栏收录该内容

27 篇文章 0 订阅

订阅专栏

目录

1.static

2.面向对象三大特性—继承

3.面向对象三大特性—多态

4.包与权限修饰符

5.final

6.抽象类

7.接口

8.内部类

9.枚举
1.static
- 1.1static：修饰成员变量及内存原理
  - 成员变量分为两种：
    - 静态成员变量(有static修饰，属于类，内存中加载一次)：常表示如在线人数等信息，可以被共享访问。(类名.静态变量)
      访问方法：类名.静态成员变量
    - 实例成员变量(无static修饰，存在于每个对象中)：常表示姓名name、年龄age、等属于每个对象的信息。(实例对象.变量)
      访问方法：对象.实例成员变量
  - Static修饰成员变量的内存原理
- 1.2static：修饰成员方法及内存机制
  - 成员方法分为两种：
    - 静态成员方法（有static修饰，归属于类），建议用类名访问，也可以用对象访问。
    - 实例成员方法（无static修饰，归属于对象），只能用对象触发访问。
  - 使用场景：
    - 表示对像自己的行为的，且方法中需要访问实例成员的，则该方法必须申明成实例方法。
    - 如果该方法是以执行一个共用功能为目的，则可以申明成静态方法。
  - Static修饰成员方法的内存原理
- 1.3static：访问注意事项
  - 静态方法只能访问静态的成员，不可以直接访问实例成员。
  - 实例方法可以访问静态的成员，也可以访问实例成员。
  - 静态方法中是不可以出现this关键字的。
  - 存储于一块固定的内存区域（静态区），它优先于对象存在
- 1.4static：应用知识-工具类
  - 类中都是一些静态方法，每个方法都是以完成一个共用的功能为目的，这个类用来给系统开发人员共同使用。（其中将构造器私有化）
- 1.5static：应用知识-代码块
  在Java类下，使用{ }括起来的代码被称为代码块。
  - 代码块是类的五大成分之一（成员变量、构造器、方法、代码块、内部类），定义在类中方法外。
  - 静态代码块：
    - 格式：static{ }
    - 特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发，只执行一次
    - 使用场景：在类加载的时候做一些静态数据初始化的操作，以便后续使用
  - 构造代码块(实例代码块)（了解，见得少）：
    - 格式：{ }
    - 特点：每次创建对象，调用构造器执行时，都会执行该代码块的代码，并且在构造器执行前执行
    - 使用场景：初始化实例资源
  - static：应用知识：单例模式
2.面向对象三大特性—继承
- 2.1继承特点：
  - 子类可以继承父类的属性和行为，但是子类不能继承父类的构造器
  - Java是单继承模式
  - 支持多层继承
  - Java中所有的类都是Object类的子类
- 2.2子类是否可以继承父类的静态成员：
  - 子类可以直接使用父类的静态成员（通过共享访问），但并非继承
- 2.3在子类方法中访问成员（成员变量、成员方法）满足：就近原则
  - 先子类局部范围找
  - 然后子类成员范围找
  - 然后父类成员范围找，如果父类范围还没有找到则报错
- 2.4方法重写：
  - @ override ：用于重写父类的不满足自己的需求的方法
  - 注意事项：
    - 重写方法的名称，形参列表必须与重写方法的名称和参数列表一致
    - 私有方法不能被重写。
    - 子类重写父类方法时，访问权限必须大于或者等于父类（默认< protected < public）
    - 子类不能重写父类的静态方法
- 2.5继承后构造器的特点：
  - 子类中所有的构造器默认都会先访问父类中无参的构造器，再执行自己。
  - 子类构造器的第一行默认都是：super()，不写也存在。
  - 子类初始化之前，一定要调用父类构造器先完成父类数据空间的初始化。
  - 在默认条件下，如果父类中没有无参数构造器，只有有参构造器，会报错。
- 2.6this和super的使用总结
  - 使用总结
  - this（）访问本类构造器
    
    在创建对象的时候，第一个参数是姓名，第二个是学校（如不填就会调用第一个构造器）
  - this（...）与super（...）不能同时存在同一个构造器之中
3.面向对象三大特性—多态
- 3.1定义：
  - 同类型的对象，执行同一个行为，会表现出不同的行为特征。
- 3.2多态的常见形式：
  - 父类类型对象名称 = new 子类构造器
  - 接口对象名称 = new 实现类构造器
- 3.3多态的前提：
  - 有继承/实现关系；有父类引用指向子类对象（new）；有方法重写【意义体现：不重写，无意义】
- 3.4多态成员的访问特点：
  - 方法调用：编译看左边，运行看右边（方法运行调用子类）
  - 变量调用：编译看左边，运行也看左边（多态侧重行为多态，属性运行调用父类）
- 3.5多态的优势：
  - 在多态的形势下，右边对象可以实现解耦合，便于扩展和维护。
    定义方法的时候，使用父类类型作为参数，该方法就可以接受这个父类的一切子类对象，体现出多态的扩展性与便利。
- 3.6多态的弊端：
  多态下不能使用子类的独有功能，只能使用通用功能（就是子类中没有重写的方法）
  - 自动化类型转换（从子到父）：子类对象赋值给父类类型的变量指向
  - 强制类型转换（从父到子类）：
  - 此时必须进行强制类型转换：子类对象变量 = (子类)父类类型的变量
  - 作用：可以解决多态下的劣势，可以实现调用子类独有的功能
  - 注意：如果转型后的类型和对象真实类型不是同一种类型，那么在转换的时候就会出现ClassCastException错误
  - 变量名 instanceof 真实类型：判断关键字左边的变量是否是右边的类型
4.包与权限修饰符
- 4.1包
  - 包是用来分门别类的管理各种不同类的，类似于文件夹，建包有利于程序的管理和维护。
  - 建包的语法格式：package公司域名倒写.技术名称。包名建议全部英文小写
  - 如果这个类使用不同包下的相同的类名，此时默认只能导入一个类的包，另一个类需要使用全名访问。
- 4.2权限修饰符
  - 可以修饰成员变量，方法，构造器，内部类，不同权限修饰符修饰的成员能够被访问的范围将受到限制。
    
    缺省就是不写，default用于JDK8以后的接口中的新增默认方法，必须用default修饰
  - 成员变量使用private ，隐藏细节。
  - 构造方法使用public ，方便创建对象。
  - 成员方法使用public ，方便调用方法。
5.final
- 5.1final：作用
  - final关键字是最终的意思，可以修饰（类、方法、变量）
  - 修饰类：表示该类是最终类，不能被继承
  - 修饰方法：表明该方法是最终方法，不能被重写
  - 修饰变量：表明该变量第一次赋值后，不能再次被赋值（有且仅能赋值一次）
- 5.2final：修饰变量的注意事项
  - final修饰的变量是基本类型：那么变量存储的数据值不能发生改变。
  - final修饰的变量是引用类型：那么变量存储的地址值不能发生改变，但是地址指向的对象内容是可以发生变化的。
  - final修饰实例成员变量，几乎不用，会导致每个对象都是一样的值且不能修改
  - final修饰的静态成员变量也称为常量
    public static final String userName = "mochu7";
  - 常量：
    - 常量定义：
      - public static final修饰的成员变量，必须有初始化值，而且执行的过程中其值不能被改变。
      - 常量命名规范：英文单词全部大写，多个单词下划线连接起来。
    - 常量的执行原理：
      - 在编译阶段会进行“宏替换”，把使用常量的地方全部替换成真实的字面量。
      - 这样做的好处是让使用常量的程序的执行性能与直接使用字面量是一样的。
6.抽象类
- 6.1定义：
  - abstract修饰类，这个类就是抽象类；修饰方法，这个方法就是抽象方法。
    - 修饰符 abstract class 类名{
    - 修饰符 abstract 返回值类型方法名称(形参列表);
    - }
    - public abstract class Animal{
    - public abstract void run();
    - }
  - 注意事项：
    - 抽象方法不能申明方法体
    - 一个类中如果定义了抽象方法，这个类必须声明抽象类，否则报错
- 6.2抽象的使用场景：
  - 抽象类可以理解成不完整的设计图，一般作为父类，让子类来继承。
  - 当父类知道子类一定要完成某些行为，但是每个子类该行为的实现又不同，于是该父类就把该行为定义成抽象方法的形式，具体实现交给子类去完成。此时这个类就可以声明成抽象类。
- 6.3抽象类的特征和注意事项：
  - 类有的成员（成员变量，方法，构造器）抽象类都具备
    但是抽象类失去了创建对象的能力
  - 一个类继承了抽象类必须重写完抽象类的全部抽象方法，否则这个类也必须定义为抽象类，不然报错
  - 不能用abstract修饰变量、代码块、构造器
  - 类中有抽象方法，则此类一定是抽象类，并且此类就失去了创建对象的能力（抽象类不能创建对象）
  - final和abstract是互斥关系（final：不能被继承；abstract：必须被继承）
- 6.4模板方法模式实现步骤：
  - 把功能定义成一个所谓的模板方法（建议用final修饰，直接给子类使用，不让子类重写），放在抽象类中，模板方法（抽象类中的非抽象方法，共享功能）中只定义通用且能确定的代码。
  - 模板方法中不能决定的功能定义成抽象方法让具体子类去实现
7.接口
- 7.1接口的定义与特点：
  - /**
  - * 声明了一个接口：体现了一种规范，规范一定是公开的
  - */
  - public interface InterfaceDemo {
  - // jdk 1.8之前，接口中只能有抽象方法和常量
  - // // 注意：代码层面，public static final可以省略不写。
  - // public static final String USER_NAME = "MOCHU7";
  - String USER_NAME = "MOCHU7";
  - // 抽象方法
  - // 注意：规范默认都是公开的，所以代码层面，public abstract可以省略不写。
  - // public abstract void run();
  - void run();
  - // public abstract void eat();
  - void eat();
  - --------------------------------------------方法用public abstract ，属性用public static final---------------------------------------
  - }
- 7.2实现：
  - 接口是用来被类实现(implements)的，实现接口的类称为实现类。实现类可以理解成所谓的子类。
  - 修饰符 class 实现类 implements 接口1, 接口2, 接口3, ...{//可以多实现
  - }
  - 实现关键字：implements
- 7.3接口新增方法：
  - public interface SportMan {
  - /**
  - * 默认方法：
  - * JDK8开始新增了默认方法(实例方法)，必须default修饰，默认public修饰（可以省略public）
  - * 接口不能创建对象，这个方法只能由实现类对象调用
  - */
  - default public void run(){
  - System.out.println("润~");
  - // 内部调用work()
  - work();
  - }
  - /**
  - * 静态方法：
  - * 必须使用static修饰，默认使用public修饰（可以省略public）
  - * 接口的静态方法，必须接口名调用
  - */
  - static public void study() {
  - System.out.println("学~");
  - }
  - /**
  - * 私有方法(实例方法)：
  - * JDK9开始新增的，必须在接口内部才能被访问
  - */
  - private void work() {
  - System.out.println("做~");
  - }
  - }
  - class PingPongMan implements SportMan {
  - }
  - class Test {
  - public static void main(String[] args) {
  - PingPongMan ppm = new PingPongMan();
  - ppm.run();
  - SportMan.study();
  - }
  - }
- 7.4注意事项：
  - 接口实现的注意事项：
    - 一个类实现接口，必须重写完全部接口的全部抽象方法，否则这个类需要定义成抽象类
    - 类和类的关系：单继承
    - 类和接口的关系：多实现
    - 接口和接口的关系：多继承，一个接口可以同时继承多个接口。
    - 接口多继承的作用：规范合并，整合多个接口为同一个接口，便于子类实现
  - 接口使用注意事项：
    - 接口不能创建对象(接口更加彻底的抽象)
    - 一个类实现多个接口，多个接口中有同样的静态方法不冲突。
    - 一个类实现了多个接口，多个接口中存在同名的默认方法，不冲突，这个类重写该方法即可。
    - 父类和接口中有同名方法，默认用父类的。
    - 一个接口继承多个接口，是没有问题的，如果多个接口存在规范冲突则不能多继承。
8.内部类
- 将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。可以把内部类理解成寄生，外部类理解成宿主。
- 8.1什么时候使用内部类
  - 一个事物内部还有一个独立的事物，内部的事物脱离外部的事物无法独立使用。如人的心脏，汽车内部有一个发动机
- 8.2内部类的分类
  按定义的位置来分
  - 成员内部内，类定义在了成员位置 (类中方法外称为成员位置，无static修饰的内部类)
  - 静态内部类，类定义在了成员位置 (类中方法外称为成员位置，有static修饰的内部类)
  - 局部内部类，类定义在方法内
  - 匿名内部类，没有名字的内部类，可以在方法中，也可以在类中方法外。
- 8.3成员内部类
  - 使用格式：外部类.内部类 // 访问内部类的类型都是用外部类.内部类
  - 获取内部类对象的两种方式：
    - 方式一：外部直接创建成员内部类的对象
      - 外部类.内部类变量 = new 外部类（）.new 内部类（）;
    - 方式二：在外部类中定义一个方法提供内部类的对象
      - public Inner getInstance(){
      - return new Inner();
      - }
  - 注意：内部类访问外部类对象的格式是：外部类名.this
  - 内存图
- 8.4静态内部类
  - 创建对象格式：外部类.内部类变量 = new 外部类.内部类构造器;
  - 调用方法的格式：
    - 调用非静态方法的格式：先创建对象，用对象调用
    - 调用静态方法的格式：外部类名.内部类名.方法名();
  - 静态内部类的特点：
    - 静态内部类是一种特殊的成员内部类。
    - 有static修饰，属于外部类本身的。
    - 总结：静态内部类与其他类的用法完全一样。只是访问的时候需要加上外部类.内部类。
    - 拓展1:静态内部类可以直接访问外部类的静态成员。
    - 拓展2:静态内部类不可以直接访问外部类的非静态成员，如果要访问需要创建外部类的对象。
    - 拓展3:静态内部类中没有隐含的Outer.this。
- 8.5局部内部类
  - 定义格式：
  - class 外部类名 {
  - 数据类型变量名;
  - 修饰符返回值类型方法名(参数列表) {
  - // …
  - class 内部类 {
  - // 成员变量
  - //成员方法
  - }
  - }
  - }
- 8.6匿名内部类【重点】
  如果我们希望定义一个只要使用一次的类，就可考虑使用匿名内部类。匿名内部类的本质作用
  是为了简化代码。
  - 格式：
    包含了：继承或者实现关系，方法重写，创建对象
    所以从语法上来讲，这个整体其实是匿名内部类对象
    - new 类名或者接口名() {
    - 重写方法;
    - };
  - 前提：匿名内部类必须继承一个父类或者实现一个父接口。
  - 特点：
    - 定义一个没有名字的内部类
    - 这个类实现了父类，或者父接口
    - 匿名内部类会创建这个没有名字的类的对象
  - 使用场景：通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。
9.枚举
- 9.1枚举的概述
  - 枚举是Java的一种特殊类型
  - 枚举的作用：“是为了做信息的标志和信息的分类”
- 9.2代码演示：
  - 修饰符 enum 枚举名称{
  - 第一行都是罗列枚举类实例的名称
  - }
  - enum Season{
  - SPRING, SUMMER, AUTUMN, WINTER;
  - }
- 9.3注意事项：
  - 枚举类都是继承了枚举类型：java.lang.Enum
  - 枚举类都是最终类，不可以被继承
  - 构造器的构造器都是私有的，枚举对外不能创建对象
  - 枚举类的第一行默认都是罗列枚举对象的名称的
  - 枚举相当于多例模式