【Java】韩顺平Java学习日志07——面向对象编程高级级部分——第一部分

类变量（静态变量static）

示例：

类变量可以通过对象名访问也可以通过类名来访问

内存布局

static变量是被同一个类的所有对象共享，不影响对多态的使用
static类变量是在类加载的时候就生成了

JDK8之前，静态变量存放在方法区的静态域，JDK8之后，类加载时在堆里生成一个对应的class对象，静态变量存放在此处的class对象实例的尾部

基本介绍

类变量也叫静态变量或静态属性，是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是相同的值，同样任何一个该类，同样任何一个该类的对象去修改它时，修改的也是同一个变量

访问修饰符 static 数据类型 变量名
static 访问修饰符 数据类型 变量名

访问类变量的方法：
1.类名.类变量名//不创建类对象实例也可以访问
2.对象名.类变量名

类变量的访问必须遵守相关的访问权限

使用细节

1.使用时机：当需要让某个类的多有对象都共享一个变量时，就可以考虑使用类变量
2.类变量和实例变量的区别：类变量是该类的所有对象共享的，而实例变量是每个对象独享的
3.有static称为类变量/静态变量，没有static称为实例变量/普通变量/非静态变量/非静态成员变量
4.实例变量（非静态字段） 不能通过类名.变量名的方式访问
5.类变量在类加载时就初始化了，也就是说，即使没有创建对象。只要类加载了，就可以使用类变量了
6.类变量的生命周期是随着类的加载开始，随着类消亡而销毁

类方法

基本介绍

类方法也叫静态方法

访问修饰符 static 数据返回类型 方法名（）{}
static 访问修饰符 数据返回类型 方法名（）{}

类方法的调用：
1.类名.类方法名
2.对象名.类方法名

当方法使用了static修饰后，该方法就是静态方法，静态方法可以访问静态属性/变量
类名也可以调用静态方法

经典使用场景

当方法中不涉及到任何和对象相关的成员，则可以将方法设计成静态方法，提高开发效率
如果希望不创建实例，也可以带哦用某个方法（即当作工具来使用），此时，把方法做成静态方法非常便捷
将通用方法设计成静态方法，这样不需要创建对象就可以使用该方法（用于开发自己的工具类，方便调用）

使用细节

1.类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区：类方法中无this的参数，普通方法隐含着this的参数
2.类方法可以通过类名调用，也可以通过对象名调用
3.普通方法和对象有关，需要通过对象名调用，不能通过类名调用
4.类方法不允许使用和对象有关的关键字，比如this和super，普通方法（成员方法）可以
5.类方法只能访问静态变量或静态方法
6.普通成员方法，既可以访问普通成员，也可以访问静态成员

总结：非静态方法可以访问所有的成员（静态成员和非静态成员），静态方法只能访问静态成员，同时必须遵循访问权限

main方法

语法说明

public static void main(String[] args){}

1.main方法是虚拟机调用
2.Java虚拟机需要调用类的main方法，所以该方法的访问权限必须是public
3.Java虚拟机在执行main（）方法是不必创建对象，所以该方法的访问权限必须是static
4.该方法接收String类型的数组参数，该数组保存执行Java命令时传递给所允许的类的参数
5.java 执行的程序 参数1 参数2 参数3

特别说明

1.在main方法中，我们可以直接调用main方法所在类的静态方法或静态属性
2.但是不能直接访问该类的非静态属性，必须创建该类的有关实例对象后，才能通过这个对象去访问类中的非静态成员

main多态传值

在main方法的args数组中传值

代码块

基本介绍

代码块又称为初始化块，属于类中的成员（属于类的一部分），类似于方法，将逻辑语句封装在方法体，通过{}包围起来
但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不通过对象或类显式调用，而是加载类，或创建对象时隐式调用

[修饰符]{//修饰符可写可省略
	代码
};

注意

1.修饰符可选，要写只能写static
2.代码块分为两类，使用static修饰的叫静态代码块，没有static修饰的，叫做普通代码块/非静态代码块
3.逻辑语句可以为任何逻辑语句（输入，输出，方法调用，训话，判断等）
4.分号；可以写也可以省略

好处

1.相当于另外一种形式的构造器（对构造器的补充机制，可以做初始化操作
2.如果多个构造器中都有重复语句，可以抽取到初始化块中，提高代码的重用性。当不管调用哪个构造器，创建对象，都会先调用代码块的内容
3.代码块调用顺序优先于构造器

使用细节

1.static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类加载而执行，并且只会执行一次，如果是普通代码块，每创建一个对象，就会执行
2.类什么时候被加载

• 创建对象实例时（new）
• 创建子类对象实例，父类也会被加载（先加载父类再加载子类）
• 使用类的静态成员时（静态属性，静态方法）

3.普通的代码块，在创建对象实例时，会被隐式的调用，被创建一次就会调用一次
如果只是使用类的静态成员，普通代码块并不会执行

4.创建一个对象时，在一个类调用顺序：

• 调用静态代码块和静态属性初始化

调用静态代码块和静态属性初始化（注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按照定义顺序调用

• 调用普通代码块和普通属性的初始化

调用普通代码块和普通属性的初始化（注意：普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通变量初始化，则按照定义顺序调用

• 调用构造方法

调用构造方法

5.构造方法（构造器）的最前面其实隐含了super（）和普通代码块，静态相关的代码块，属性初始化，在类加载时，就执行完毕，因此是优先于构造器和普通代码块执行的


先调用super到达父类，再调用父类的代码块，后父类的构造器，再调用子类的代码块，最后调用子类的构造器

6.创建一个子类对象时（继承关系），他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序：

• 父类的静态代码块和静态属性（优先级一样，按照定义顺序执行）
• 子类的静态代码块和静态属性（优先级一样，按照定义顺序执行）
• 父类的普通代码块和普通属性初始化（优先级一样，按照定义顺序执行）
• 父类的构造器
• 子类的普通代码块和普通属性初始化（优先级一样，按照定义顺序执行）
• 子类的构造器

注意：静态代码块只能直接调用静态成员（静态属性和静态方法），普通代码块可以调用任意成员

单例设计模式

设计模式

设计模式是在大量的实践中总结和理论化之后优选的代码结构，编程风格，以及解决问题的思考方式。
设计模式就像是经典的棋谱，不同的棋局，我们用不同的棋谱，免去我们自己再思考和摸索

单例模式

所谓类的单例设计模式，就是采用一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法

步骤：

1.构造器私有化——防止直接new创建新对象
2.类的内部创建对象，直接new，注意需要修饰为static
3.向外暴露一个静态的公共方法，返回创建的私有对象，实现私有对象的访问

饿汉式

步骤：

1.构造器私有化——防止直接new创建新对象
2.类的内部创建对象，直接new，注意需要修饰为static
3.向外暴露一个静态的公共方法，返回创建的私有对象，实现私有对象的访问

无论创建多少次，该静态对象保持不变，地址始终相同
只要类加载，该对象就创建，即使没有使用

饿汉式：即使尚未使用，仍然创建对象

懒汉式

步骤：

1.构造器私有化——防止直接new创建新对象
2.类的内部定义对象，只定义但不直接new，此时的构造器不会被调用，注意需要修饰为static
3.向外暴露一个静态的公共方法，返回创建的私有对象，实现私有对象的访问：进行if判断，是否有创建一个对象，位创建则先创建，而后再返回。

懒汉式，只有当调用getInstance方法时，才会返回cat对象，后面再次调用时，会发挥上次创建的cat对象，从而保证了单例设计模式

饿汉式VS懒汉式

1.二者最主要的区别在于创建对象的时机不同：饿汉式是在类加载就创建了对象实例，而懒汉式是在使用时才创建
2.饿汉式不存在线程安全问题，懒汉式存在线程安全问题
3.饿汉式存在浪费资源的可能，因为如果程序员应该对象实例都没有使用，你们饿汉式创建的对象就浪费了，懒汉式时使用时才创建，就不存在这个问题
4.JavaSE标准类中，java.lang.Runtime就是经典的单例模式

final关键字

基本介绍

final可以修饰类，属性，方法和局部变量

final的使用场景：

1.当不希望类被继承时，可以使用final修饰
2.当不希望父类的某个方法被子类覆盖/重写，可以使用final关键字修饰
3.当不希望类的某个属性值被修改，可以使用final修饰
4.当不希望某个局部变量被修改，可以使用final修饰（可称为局部常量）

使用细节

1.final修饰的属性又叫常量，一般 用XX_XX_XX来命名
2.final修饰的属性在定义时，必须赋初值，并且以后不能再修改，赋值可以在如下位置之一：定义时，在构造器中，在代码块中。
3.如果final修饰的属性时静态的，则初始化的位置只能是定义时或静态代码块中，不能在构造器中赋值（类加载了，但是构造器没有调用，造成无法赋初值）
4.final类不能继承，但是可以实例化对象
5.如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承
6.如果一个类已经是final类，就没有必要再将方法修饰成final方法（无法继承，自然无法重写）
7.final不能修饰构造器
8.final和static往往搭配使用，效率更高，不会导致类加载，底层编译器做了优化处理
9.包装类（Integer，Double，Float，Boolean等都是final类型），String也是final类

形参允许用final修饰

抽象类

当父类的某些方法需要声明，但是又不确定如何实现的时候，可以将其声明为抽象方法，那么这个类就是抽象类
所谓抽象方法就是没有实现的方法，就是指没有方法体

基本介绍

1.用abstract关键字来修饰一个类时，这个类就叫做抽象类

访问修饰符 abstract 类名{}

2.用abstract关键字来修饰一个方法时，这个方法就叫做抽象方法

访问修饰符 abstract 返回类型 方法名(参数列表){};//没有方法体

3.抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并且实现抽象类
4.抽象类与框架设计模式联系较为紧密

使用细节

1.抽象类不能被实例化
2.抽象类不一定要包含abstract方法，也就是抽象类可以没有abstract方法
3.一旦类包含了abstract方法，则这个类必须声明为abstract
4.abstract只能修饰类和方法，不能修饰属性和其他
5.抽象类可以有任意成员（抽象类还是类）（比如：非抽象方法，构造器，静态属性等等
6.抽象方法不能有主体，即不能实现
7.如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非他自己也声明为abstract抽象类
8.抽象方法不能使用private，final和static来修饰，因为这些关键字都与重写相违背

接口

基本介绍

接口就是给出有些没有实现的方法，封装到一起，到某个类要使用的时候，再根据具体情况把这些方法写出来

interface 接口名{
//属性
//方法:抽象方法，默认实现方法，静态方法
}
class 类名 implements 接口{
 自己属性
 自己方法
 必须实现的接口的抽象方法
 }

1.JDK7.0前，接口里的所有方法都没有方法体，即都是抽象方法
2.JDK8.0后接口可以有静态方法，默认方法，也就是说接口可以有方法的具体实现，但是需要使用default关键字修饰

default public void ok(){
System.out.println("ok....");
}

3.接口中的抽象方法的abstract可以省略

使用细节

1.接口不能被实例化
2.接口中所有的方法睡觉哦public方法，接口中的抽象方法可以不用abstract修饰
3.一个普通类实现接口，就必须将接口的所有方法都实现
4.抽象类实现接口，可以不用实现接口的方法
5.一个类同时可以实现多个接口
6.接口中的属性只能是final的，而且是public static final 修饰符

int a=1;//实际上是下面表示方式
public static final int a=1;//必须初始化

7.接口中属性的访问形式：接口名.属性名
8.接口不能继承其他类，但是可以继承多个别的接口
9.接口的修饰符只能是public和默认，这点和类的修饰符是一样的

接口VS继承

当子类继承了父类，就自动的拥有了父类的功能
如果子类需要扩展功能，可以通过实现接口的方式扩展
Java中只能单继承，不能多继承
可以理解实现接口是对Java单继承机制的一种补充

解决的问题不同

继承的价值主要是在于：解决代码的复用性和可维护性
接口的价值主要是在于：设计，设计好各种规范，让其他类去实现这些方法

接口比继承更加灵活

继承是满足is-a的关系，而接口只需要满足like-a的关系
接口在一定程度上实现代码解耦【即 接口的规范性+动态绑定】

多态特性

1.多态参数



2.多态数组

3.接口存在多态传递的现象

注意：
访问接口的变量使用接口名.变量
访问父类的变量使用super.变量