面向对象(下)

一、关键字：static

使用范围： 在Java类中，可用static修饰属性、方法、代码块、内部类

被修饰后的成员具备以下特点：

1.随着类的加载而加载

2.优先于对象存在

3.修饰的成员，被所有对象所共享

4.访问权限允许时，可不创建对象，直接被类调用

static关键字的使用

*

* 1.static：静态的

* 2.static可以用来修饰：属性、方法、代码块、内部类

*

* 3.使用statci修饰属性：静态变量(类变量)

*         3.1属性：按是否使用static修饰，又分为：静态变量 vs 非静态变量(实例变量)

*         实例变量：当我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性

*                 当修改其中一个对象中的非静态属性时，不会导致其他对象中同意的属性值修改

*        静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量，当通过每一个对象修改静态变量时，会导致

*                 其他对象调用此静态变量时，是修改过了的

*        3.2 static修饰属性的其他说明：

*            ① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用

*            ② 静态变量的加载要早于对象的创建

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

*    

*            ④          静态变量     实例变量

*            类           yes          no

*            对象           yes        yes

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

*    

* 4.使用static修饰方法：

*         ① 随着类的加载而加载，可以通过“类.方法”的方式进行调用

*         ②                静态方法        非静态方法

*                 类        yes            no

*                 对象        yes            yes

*         ③ 静态方法中：只能调用静态的方法或属性

*           非静态方法中：既可以调用非静态的方法或属性，也可以调用静态的方法或属性

*

* 5.static注意点：

*         5.1静态的方法内，不能使用this、super关键字

*         5.2关于静态属性和静态方法的使用，大家都从生命周期的角度去理解

*

* 6.开发中，如何确定一个属性是否声明为static的？

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

*         >类中的常量也常常声明为static

*

*   开发中，如何确定一个方法是是否声明为static的        

*

*         >操作静态属性的方法，通常设置为静态的

*         >工具类中的方法，习惯上声明static的。比如：Math、Arrays、Collections

二、单例模式

* 单例设计模式

* 1. 所谓类的单例模式，就是采取一定的方法保证在整个软件系统中，对某个类只存在一个对象实例

*

* 2. 如何实现？

*         饿汉式 vs 懒汉式

*

* 3. 区分饿汉式 和 懒汉式

*       饿汉式：

*             坏处：对象加载时间过长

*             好处：饿汉式是线程安全的

*

*       懒汉式：好处：延迟对象的创建

*              目前的写法坏处：线程不安全--->到多线程内容时再修改

*

①饿汉式

//饿汉式
class Bank{
  //1.私有化类的构造器
  private Bank() {
  }
  //2.内部创建类的对象
  //4.要求此对象也必须为静态的
  private static Bank instance = new Bank();
  //3.提供公共的静态方法，返回类的对象
  public static Bank getInstance() {
  return instance;
  }
}

②懒汉式

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

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

* main()方法的使用说明

* 1. main()方法作为程序的入口

* 2. main()方法也是一个普通的静态方法

* 3. main()方法也可以作为我们与控制台交互的方式。(之前，使用Scanner)

*

三、类的成员之四：代码块

* 1. 代码块的作用：用来初始化类、对象

* 2. 代码块如果有修饰的话,只能使用static

* 3. 分类： 静态代码块 vs 非静态代码块

*

* 4. 静态代码块

*         >内部可以有输出语句

*         >随着类的加载而执行,而且只执行一次

*         >作用：初始化类的信息

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

*         >静态代码块的执行要优先于非静态的代码块    

*         >静态代码块内只能调用静态的属性、静态的方法、不能调用非静态的结构

*

* 5. 非静态代码块

*         >内部可以用输出语句

*         >随着对象的创建而执行

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

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

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

*         >非静态的代码块可以调用静态的属性、方法，或非静态的属性、方法

四、关键字：final

* final:最终的

*

* 1. final可以修饰的结构：类、方法、变量

*

* 2. final用来修饰一个类:此类不能被其他类继承    

*             比如：String类、Systenm类、StringBuffer类

*

* 3. final用来修饰方法：表面此方法不可以被重写

*             比如：Object类中getClass()；

*

* 4. final用来修饰变量：此时的“变量”称为是一个常量

*             4.1 final修饰属性：可以考虑赋值的位置有：显示初始化、代码块中初始化、构造器中初始化

*             4.2 final修饰局部变量：

*                 尤其是用final修饰形参时，表明此形参是一个常量，当我们调用此方法是，给常量形参赋一个实参，一旦赋值以后

*                 就只能在方法体内使用此形参，但不能进行重新赋值

*

* static final:用来修饰属性：全局常量

五、抽象类与抽象方法

* abstract关键字的使用

* 1. abstract：抽象的

* 2. abstract可以用来修饰的结构：类、方法

*

* 3. abstract修饰类：抽象类

*         >此类不可实例化

*      >抽象类中一定有构造器，便于子类实例化调用(涉及：子类对象实例化的全过程)

*      >开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作

*

* 4. abstract修饰方法：抽象方法

*         >抽象方法只有方法的声明，没有方法体

*         >包含抽象方法的类，一定是个抽象类，反之抽象类中是可以没有抽象方法的

*         >若子类重写了父类中所有的抽象方法后，此子类可实例化

*             若子类没有重写父类中所有的抽象方法，则此子类也是一个抽象类

六、接口

* 接口的使用

* 1.接口使用interface来定义

* 2.在Java中，接口和类是并列的两个结构

* 3.如何定义接口：定义结构中的成员

*            

*             3.1    JDK7及以前：只能定义全局常量和抽象方法

*                 >全局常量：public static final的:但是书写时可以省略不写

*                 >抽象方法：public abstract                

*

*             3.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法(略)

*

* 4.接口中不能定义构造器的！意味着结构不可实例化

*

* 5.Java开发中，接口都通过让类去实现的方式去实现(implements)的方式来使用

*      如果实现类覆盖了接口中的所有的抽象方法，则此实现类可以实例化

*   如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类

*

* 6.Java类可以实现多个接口 --->弥补了Java单继承性的局限性

*      格式：class AA extends BB implements CC,DD,EE

*  

* 7.接口与接口之间可以继承，而且可以多继承

*

* *******************************************

*

* 8.接口具体的使用，体现多态性

* 9.接口，实际上可以看做是一种规范

七、类的成员之五：内部类

* 接口的使用

* 1.接口使用interface来定义

* 2.在Java中，接口和类是并列的两个结构

* 3.如何定义接口：定义结构中的成员

*            

*             3.1    JDK7及以前：只能定义全局常量和抽象方法

*                 >全局常量：public static final的:但是书写时可以省略不写

*                 >抽象方法：public abstract                

*

*             3.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法(略)

*

* 4.接口中不能定义构造器的！意味着结构不可实例化

*

* 5.Java开发中，接口都通过让类去实现的方式去实现(implements)的方式来使用

*      如果实现类覆盖了接口中的所有的抽象方法，则此实现类可以实例化

*   如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类

*

* 6.Java类可以实现多个接口 --->弥补了Java单继承性的局限性

*      格式：class AA extends BB implements CC,DD,EE

*  

* 7.接口与接口之间可以继承，而且可以多继承

*

* *******************************************

*

* 8.接口具体的使用，体现多态性

* 9.接口，实际上可以看做是一种规范

【注意】 1. 非static的成员内部类中的成员不能声明为static的，只有在外部类或static的成员 内部类中才可声明static成员。 2. 外部类访问成员内部类的成员，需要“内部类.成员”或“内部类对象.成员”的方式 3. 成员内部类可以直接使用外部类的所有成员，包括私有的数据 4. 当想要在外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态的