面向对象(下)学习笔记一

一、关键字：static

static关键字的使用

  • static可以用来修饰：属性、方法、代码块、内部类。

  • 使用static修饰属性：静态变量（类变量）

    • 属性：按是否使用static修饰，又分为：静态属性 vs 非静态属性（实例变量）

      • 实例变量：我们创建了类的多个的对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。
      • 我们创建了类的多个的对象，每个对象都共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。

    • static修饰属性的其他说明

      • 静态变量随着类的加载而加载。可以通过”类名.静态变量”的方式进行调用。

      • 静态变量的加载要早于对象的创建。

      • 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。

        1.     类变量        实例变量

类 yes no

对象 yes yes

  • 静态属性举例：System.out; Math.PI

  • day14_java面向对象(下)学习笔记1 - 图1

  • 使用static修饰方法：静态方法

    • 随着类的加载而加载，可以通过”类.静态方法”的方式调用

      1.     静态方法       非静态方法

类 yes no

对象 yes yes

  • 静态方法中，只能调用静态的方法和属性。非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法和属性。

  • static注意点：

    • 在静态的方法中，不能使用this关键字，super关键字。
    • 关于静态属性和静态方法的使用，都从生命周期的角度去理解。
    • static修饰的方法不能被重写
  • 开发中，如何确定一个属性是否要声明为static的？

    属性是可以被多个对象所共享的，不会随着对象的不同而不同。

  • 开发中如何确定一个方法是否声明为staticc的？

    操作静态属性的方法，通常设置为static的。工具类中的方法，习惯上声明为static的。比如，Math、Arrays、Collections

单例(Singleton)设计模式

  • 定义：所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。并且该类只提供一个取得其对象实例的方法。 如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象， 静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象 的变量也必须定义成静态的

  • 如何实现？

    • 饿汉式：例如java.lang.Runtime

      1. public class SingletonTest1 {
      2.    public static void main(String[] args) {
      3. //        Bank bank1 = new Bank();
      4. //        Bank bank2 = new Bank();
      6.        Bank bank1 = Bank.getInstance();
      7.        Bank bank2 = Bank.getInstance();
      9.        System.out.println(bank1 == bank2);
      10.    }
      11. }
      13. //饿汉式
      14. class Bank{
      16.    //1.私有化类的构造器
      17.    private Bank(){
      19.    }
      21.    //2.内部创建类的对象
      22.    //4.要求此对象也必须声明为静态的
      23.    private static Bank instance = new Bank();
      25.    //3.提供公共的静态的方法，返回类的对象
      26.    public static Bank getInstance(){
      27.        return instance;
      28.    }
      29. }

  • 懒汉式 ```java /*

    • 单例模式的懒汉式实现

    • */ public class SingletonTest2 { public static void main(String[] args) {

      1.  Order order1 = Order.getInstance();
      2.  Order order2 = Order.getInstance();
      4.  System.out.println(order1 == order2);

      } }

  1. class Order{
  3.     //1.私有化类的构造器
  4.     private Order(){
  6.     }
  8.     //2.声明当前类对象，没有初始化
  9.     //4.此对象也必须声明为static的
  10.     private static Order instance = null;
  12.     //3.声明public、static的返回当前类对象的方法
  13.     public static Order getInstance(){
  15.         if(instance == null){
  17.             instance = new Order();
  19.         }
  20.         return instance;
  21.     }

} ```

  • 饿汉式和懒汉式的区别

    饿汉式：坏处：对象加载时间过长

懒汉式：好处：延迟对象的创建。目前坏处：线程不安全。—->到多线程内容时，再修改

  • 单例模式的优点

    由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时产生一个单例对象，然后永久驻留内存的方式来解决。

  • 单例设计模式的应用场景

    • 网站的计数器
    • 数据库连接池
    • 项目中读取配置文件的类，一般只有一个对象，没必要每次使用配置文件数据时，都去生成一个对象。

二、理解main()方法的语法

  • main方法的使用说明：

    • main方法作为程序的入口出现
    • main()方法也是一个普通的静态方法
    • main()方法也可以作为与控制台交互的方式
    • 注意：main方法虽然是程序的入口，但不一定是最先执行的，如果类中有静态结构（例如静态代码块），则先执行完静态结构再执行main方法。

day14_java面向对象(下)学习笔记1 - 图2

三、代码块(初始化块)

  • 代码块的作用：用来初始化类、对象

  • 代码块如果有修饰的话，只能使用static

  • 分类：静态代码块 VS 非静态代码块

  • 静态代码块

    • 内部可以有输出语句

    • 随着类的加载而执行，而且只执行一次

    • 作用：初始化类的信息

    • 如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行

    • 静态代码块的执行要优先于非静态代码块的执行。

    • 静态代码块内只能调用静态的属性和静态的方法，不能调用非静态的结构

  • 非静态代码块

  • 内部可以有输出语句。

  • 随着对象的创建而执行。

  • 每创建一个对象，就执行一次非静态代码块。

  • 作用：可以在创建对象时，对对象的属性进行初始化。

  • 如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行

  • 非静态代码块内可以调用静态的属性、静态的方法、或非静态的属性 、非静态的方法。

  • 创建对象的时候非静态代码优先于构造器执行

  • 对象可以赋值的位置

    • (1)默认初始化
    • (2)显示初始化
    • (3)构造器初始化
    • (4)有了对象以后、可以通过“对象.属性”或“对象.方法”的方式，进行赋值。
    • (5)在代码块中赋值

赋值的顺序：(1)—>(2)/(5)—>(3)—>(4)

  • 实例化子类对象时，涉及父类、子类中静态代码块、非静态代码块、构造器的加载顺序：由父及子，静态先行。通俗来说就是父类静态代码块—>子类静态代码块—>父类非静态代码块—>父类构造器—->子类非静态代码块—->子类构造器。对应的练习：LeafTest.java Son.java

四、关键字final

  • final：最终的

  • final可以用来修饰的结构：类、方法、变量

  • final 用来修饰一个类：不能被其他类所继承。比如：String类、StringBuffer类、System类。

  • final修饰一个方法：表明此方法不可以被重写。比如：Object类中的getClass()；

  • final用来修饰变量：此时的“变量”就称为一个常量。

    • final修饰属性（成员变量）：可以考虑赋值的位置有：显示初始化、代码块初始化、构造器中初始化、
    • final修饰属性（成员变量）时，该属性不会被系统默认初始化赋值，必须自己进行赋值，可以显示初始化赋值、代码块初始化赋值、构造器中赋值、最晚要在构造器执行完之前赋值完成，因为构造器执行完成之后，类的对象就产生了，对象一出生相应的在堆空间中属性就加载了，这时候就属性就必须有值了。总结就是final标记的成员变量必须在声明时或在每个构造器中或代码块中显式赋 值，然后才能使用。

    • final修饰局部变量

      • 尤其是使用fianl修饰形参是、声明此形参是一个常量。当我们调用此方法时，给常量形参赋值一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。
    • static final用来修饰属性：表示是全局常量。