JAVA 面向对象编程（高级）面向对象编程（高级）

68 阅读 0 评论 45 点赞

我是靠谱客的博主整齐机器猫，最近开发中收集的这篇文章主要介绍JAVA 面向对象编程（高级）面向对象编程（高级），觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

面向对象编程（高级）

类变量和类方法

类变量的提出
- 其它地方访问很麻烦
- 成员变量不是类变量，类变量是属于类名的，不是单单某一个实例的
类变量的内存布局
- static变量是同一个类的所有对象共享的
- 类变量也就是static变量是在类加载的时候就生成了
类变量的定义
- 定义语法
  - 访问修饰符 static 数据类型变量名
  - or static 访问修饰符数据类型变量名
如何访问
- 对象名.类变量名
- 类名.类变量名
类变量的使用细节
1. 什么时候需要使用类变量
  1. 某个类的所有对象都共享一个属性时，可以使用类变量：定义学生类
2. 类变量和实例对象的区别
  1. 实例对象就是成员变量
3. 加上 static 就是类变量或静态变量，否则就是实例变量，普通变量，非静态变量
4. 类变量可以通过类名.类变量名或者对象名.类变量名来访问
5. 实例变量不能通过类名.变量名来访问
6. 类变量在类加载时就创建了，没有实例也可以访问
7. 类变量的声明周期是随着类的加载而开始，随着类的消亡而销毁
类方法
- 访问形式
  - 访问修饰符 static 数据返回类型方法名() {} 推荐
  - static 访问修饰符数据返回类型方法名() {}
- 类方法的调用
  - 类名.类方法名
  - 对象名.类方法名
- 类方法的经典使用场景
  - 当方法中不涉及和对象相关的成员，可以将方法设置为静态方法，提高开发效率
  - 不创建实例，也可以调用某个方法，即当作工具来使用
  - 将方法做成静态方法非常适合
- 类方法的注意事项
  1. 类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区：类方法中无this参数，而普通方法中隐含着this参数
  2. 类方法可以通过类名调用，也可以通过对象名调用
  3. 普通方法和对象有关，需要通过对象名调用
  4. 类方法中不允许使用和对象有关的关键字，比如this和super。普通方法中可以使用
  5. 类方法只能访问静态方法和静态变量
  6. 普通静态方法，可以访问非静态成员，也可以访问静态成员
- 练习
  - 小结：记住两句话（1）静态方法只能访问静态方法（2）非静态方法，可以访问所有的成员（3）在编写代码时，仍然要遵守访问权限规则
- 理解main方法语法
  1. main方法是虚拟机调用，因此必须是public
  2. 为什么是 static 调用时不用创建对象，因此方法必须是static
  3. 该方法接收String类型的数组参数，该数组中保存执行java时传给所运行的类的参数 main方法是入口
- main()方法中，可以直接调用静态方法或者静态属性
- 但是，不能直接访问类中的非静态成员，必须创建该类的一个实例对象后，才能通过对象访问非静态成员
- main方法的动态传值，如何在idea中动态传递参数

理解main方法语句 static

代码块

基本介绍
- 初始化块，也是类中的成员之一，类于方法，将逻辑语句封装在方法体中，通过{}包围
- 和方法不同没有方法名，加载类，或创建对象时隐式调用
基本句法
- [修饰符号] {
  - 代码
- };
- 修饰符要么不写，要么写static
- 代码块分两种，static修饰的叫静态代码块，没有static修饰的，叫普通代码块
- ；可以写也可以省略
代码块的好处
1. 相当于另一种形式的构造器，做初始化操作
2. 如果多个构造器都有重复语句，可以抽取到初始化块中，提高复用性代码块的优先级先于构造器
使用注意事项和细节讨论 CodeBlockDetail01
1. static 代码块，随着类的加载执行，且只执行一次。如果时普通代码块，每创建一个对象，就执行
2. 类在什么时候被加载
  1. 创建对象实例时（new）
  2. 创建子类对象实例，父类也被架子啊
  3. 直接使用类的静态成员（静态属性，静态方法）
3. 普通代码块，在创建对象实例时，会被隐式调用。被创建一次，就会调用一次。如果只是使用类的静态成员，普通代码并不会被执行
  
  小结：1.static代码块是类加载时调用，只会执行一次 2.普通代码块在创建对象时调用，创建一次调用一次 3.类加载的三种情况需要记住
4. 创建一个对象时，一个类的调用顺序时
  1. 调用静态代码块和静态属性初始化。两者优先级相同，按定义顺序调用
  2. 调用普通代码块和普通属性的初始化。两者优先级相同，按定义顺序相同
  3. 调用构造方法
5. 构造器的最前面隐藏了super()和调用普通代码块，静态相关的代码块，属性初始化，在类加载时，就执行完毕，优于构造器和普通代码块执行
  1. ```
  class A {
      public A() {
          // 隐藏语句
          super(); // 1
          // 调用普通代码块
          System.out.println("ok");
      }
  }
```
6. 创建一个子类时，他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下（先加载类信息，也就是静态代码块和静态属性的初始化）
  1. 父类的静态代码块和静态属性（优先级一样，定义顺序执行）
  2. 子类的静态代码块和静态属性。。。
  3. 父类的代码块和普通属性初始化（优先级。。。
  4. 父类的构造方法
  5. 子类的普通代码块和普通属性初始化了（优先级一样，按定义顺序执行
  6. 子类的构造方法
7. 静态代码块只能调用静态成员，普通代码块可以调用任意成员
代码块练习

设计模式

什么是设计模式
1. 静态方法和属性的经典使用
2. 解决问题的思考方式，代码结构，编程风格。棋谱，免去思考和摸索。
什么是单例模式
1. 所谓的单例设计模式，是采取一定的方法保证在整个软件系统中，对某个类只存在一个对象实例，并且该类只提供一个取得其对象实例的方法
2. 单例设计模式有两种方式 1）饿汉式 2）懒汉式
饿汉式
1. 构造器私有化 => 防止直接new
2. 类的内部创建对象
3. 向外暴露一个静态的公共方法。getInstance
4. 代码实现
懒汉式
1. 两者的区别在于创建对象的时机不同，饿汉式在类加载时创建对象实例，懒汉式在使用时创建
2. 懒汉式不存在线程安全问题，饿汉式存在线程安全问题。
3. 饿汉式存在浪费资源的可能。
4. javaSE中，java.lang.Runtime就是经典的单例模式
小结
1. 单例模式的两种实现方式
  1. 饿汉式
  2. 懒汉式
2. 饿汉式的问题：在类加载时就创建，可能存在资源浪费问题
3. 懒汉式的问题：存在线程安全问题，在学了线程后，进行完善

final关键字

基本介绍
- 修饰类，属性，方法，局部变量
使用情况
1. 不希望类被继承 final
2. 不希望父类的某个方法被子类覆盖 override
3. 不希望类的某个属性被修改
4. 不希望某个局部变量被修改，使用final修饰符
使用注意事项和细节讨论
1. final修饰的属性又叫常量，一般用 XX_XX_XX 命名
2. final修饰的属性定义时赋值，以后不再修改，在三种地方可以赋值
  1. 定义时
  2. 在构造器中
  3. 在代码块中
3. 如果final修饰的属性是静态的，则初始化的位置只能是
  1. 定义时
  2. 在静态代码块，不能在构造器中赋值
4. final类不可以继承，但是可以实例化
5. 如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承，如果类已经是final类了，不必再将方法设定为final
6. final不能修饰构造方法
7. final和static搭配使用，效率更高。不会导致类的加载。单独使用属性，不会导致类的加载。
8. 包装类（Interger， String）等都是final类，不能被继承

抽象类

问题
- 当父类的某些方法，需要声明，但是又不明确如何实现时，可以将其声明为抽象方法，这个类就是抽象类—-》抽象方法就是没有实现的方法，也就是说没有方法体
介绍
1. 用abstract关键字修饰一个类，这个类就是抽象类
  1. 访问修饰符 abstract 类名 {}
2. 用 abstract 关键字来修饰一个方法时，这个方法就是抽象方法
  1. 访问修饰符 abstract 返回类型方法名(参数列表)；没有方法体
3. 抽象类的价值在于设计，让设计者设计好后，让子类继承并实现抽象类
4. 框架和设计模式使用较多
使用细节和注意事项
1. 抽象类无法被实例化
2. 抽象类不一定要