面向对象高级——韩顺平0基础学java（笔记）

面向对象高级

类变量和类方法

传统的方法来解决

静态变量

static变量是所有对象共享的 在类加载的时候就生成了

权限 static 类型名 变量名

可以使用类名来访问

类变量内存布局

有些书说static是在方法区中

什么是类变量？

类变量也叫静态变量/静态属性，是该类的所有对象共享的变量，任何一个该类的对象去访问它是，取到的都是相同的值，同样一个该类的对象去修改它是，修改的也是同一个变量，这个从前面的图也可以看出来。

如何定义类变量

定义语法：

访问修饰符 static 数据类型 变量名；【推荐】

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

如何访问类变量

类变量使用注意事项和细节讨论

1、什么时候需要类变量

当我们需要让某个类的所有对象都共享一个变量是，就可以考虑使用类变量（静态变量）：比如：定义学生类，统计所有学生共交多少钱。Student(name，staticfee)

2、类变量与实际变量（普通属性）区别

类变量是该类的所有对象共享的，而实例变量是每个对象独享的。

3、加上static称为类变量或静态变量，否则称为实例变量/不同变量/非静态变量

4、类变量可以通过 类名.变量名 或者 对象名.变量名 来访问，但java设计师推荐我们使用 类名.类变量名方式访问 【前提是 满足访问修饰符的访问权限和范围】

5、实例变量不能通过 类名.类变量名 方式访问。

6、类变量是类加载时就初始化了，也就是说，即使你没有创建对象，只要类加载了，就可以使用类变量。

类变量的生命周期是随类加载开始，随着类消亡而销毁。

类方法基本介绍

类方法的调用

静态方法只能访问静态变量

类方法经典的使用场景

当方法中不涉及到任何的对象相关的成员，则可以将方法设计成静态方法，提高开发效率

比如：工具类中的方法utils

Math类，Array类、Collections集合类看下源代码：

小结

在程序员实际开发过程中，往往会将一些通用的方法，设计成静态方法，这样我们不需要创建对象就可以使用了，比如打印一维数组，冒泡排序，完成某个计算任务 等```

类方法使用注意事项和细节讨论

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

小结：静态方法，只能访问静态的成员，非静态的方法，可以访问静态成员和非静态成员

理解main方法语句

深入理解main方法

解释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. 但是，不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员，

代码块

基本介绍

代码块又称为初始化块，术语类中的成员【即是类的一部分】，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来。

但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显示调用，而是加载类是，或创建对象时隐式调用。

基本语句

[修饰符]{代码};

说明注意：

1. 修饰符 可选，要写的话，也只能写static
2. 代码块分为两类，使用static修饰的叫静态代码块，没有static修饰的，叫普通代码块/非静态代码块。
3. 逻辑语句可以为任何逻辑语句（输入、输出、方法调用、循环、判断等）
4. ;号可以写上，也可以省略
5. 相当于另一种形式的构造器（对构造器有补充机制），可以做初始化操作
6. 场景：如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的复用性

创建一个对象时，在一个类调用顺序是：（重点，难点）：

• 1. 调用静态代码块和静态属性初始化（注意：静态代码块和静态属性初始化的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用）
  2. 调用普通代码块和普通属性的初始化（注意：普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化）
  3. 调用构造方法

静态变量不能调用非静态函数赋值

构造器 的前面起始隐含了 super()和 调用普通代码块，静态相关的代码块，属性初始化，在类加载时，就执行完毕，因此是优先于构造器和普通代码块执行的

静态变量初始化==静态代码块>代码块==普通变量初始化>构造函数

1. 我们看一下创建一个子类对象时（继承关系），他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下：
   1. 父类的静态代码块和静态属性（优先级一样，按定义顺序执行）
   2. 子类的静态代码块和静态属性（优先级一样，按定义顺序执行）
   3. 父类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）
   4. 父类的构造方法
   5. 子类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）
   6. 子类的构造方法//面试题

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

单例设计模式

什么是设计模式

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

什么是单例模式

单例（单个的实例）

1. 所谓类的单例模式，就是才去一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法
2. 单例模式有两种方式：1、饿汉式2、懒汉式

单例模式应用实例

public class text01 {
public static void main(String[] args) {
GirlFriend gf1 = GirlFriend.getInstance();
System.out.println(gf1);

GirlFriend gf2 = GirlFriend.getInstance();
System.out.println(gf2);
System.out.println(gf1 == gf2);
}
}

class GirlFriend {
private static String name;
private static GirlFriend gf = new GirlFriend("小红红");

private GirlFriend(String name) {
GirlFriend.name = name;
System.out.println("我是一个初始化的对象");
}


public static GirlFriend getInstance() {
return gf;
}
@Override
public String toString() {
return "GirlFriend{" +
"name='" + name + '\'' +
'}';
}
}

懒汉式

public class text02 {
public static void main(String[] args) {
System.out.println(Cat.n1);
Cat 小红 = Cat.getInstance("小红");
System.out.println(小红);
Cat 小红2 = Cat.getInstance("小红2");
System.out.println(小红2);
System.out.println(小红 == 小红2);

}
}

class Cat {
public static int n1 = 999;
private String name;
private static Cat cat;

private Cat(String name) {
this.name = name;
System.out.println("调用了 Cat 的构造方法");
}

public static Cat getInstance(String name) {
if (cat == null) {
cat = new Cat(name);
System.out.println("调用了 Cat 的静态方法");
}
return cat;
}

@Override
public String toString() {
return "Cat{" +
"name='" + name + '\'' +
'}';
}
}

饿汉式VS懒汉式

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

final关键字

基本介绍

final 中文意识：最后的，最终的。

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

在某些情况下，程序员可能有一下去修，就会使用到final：

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

final注意事项和细节讨论

1. final修饰的属性又叫常量，一般 用XX_XX_XX 来命名
2. final修饰的舒心在定义时，必须赋初值，并且以后不能再修改，赋值可以在如下位置之一{选择一个位置赋初值即可}；
   1. 在定义时：如public final double TAX_RATE=0.08;
   2. 在构造器中。
   3. 在代码块中。
3. 如果在final修饰的属性是静态的，则初始化的位置只能是
   1. 在定义时
   2. 在静态代码块 不能在构造器中赋值
4. Final类不能继承，但是可以实例化对象。
5. 如果类不是final类，但是还有final方法，则该方法虽然不能重写，但是可以被继承
6. 一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法。
7. Final不能修饰构造方法（即构造器）
8. Final和static往往搭配使用，效率更高，不会导致类加载.底层编译器做了优化处理。
   1. 
9. 

抽象类

抽象类的介绍

1. 用abstract关键字来修饰一个类是，这个类就叫抽象类
   1. 访问修饰符 abstract 类名{

}

1. 用abstract关键字来修饰一个方法时，这个方法就是抽象方法
   1. 访问修饰符abstract 返回类型 方法名(参数列表);//没有方法体
2. 先后向雷的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现抽象类()
3. 抽象类，是考官比较爱问的知识点，在框架和设计模式使用较多

抽象类使用的注意事项和细节讨论

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

抽象类最佳实践——模板设计模式

基本介绍

抽象类体现的就是一种模板的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象的行为方式。

模板设计模式能解决得问题

1、当功能内部一部分显示是确定，一部分实现是不确定的。这时可以吧不确定的部分保留出去，让子类去实现。

2、编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其他子类实现，就是一种模板模式。

最佳实践

1. 有多个类，完成不同的job
2. 要求统计得到鸽子完成任务的时间

接口

为什么有接口

usb插槽就是现实中的接口。

你可以把手机，相机，u盘都插在usb插槽上，而不用担心那个插槽是专门插哪个的，原因是做usb插槽的厂家和做各种设备的厂家都遵守了统一的规定包括尺寸，排线等等。

基本介绍

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

interface 接口名{

//属性

//抽象方法、默认实现方法，静态方法

}

class 类名 implements 接口{

自己属性

自己方法

必须实现的接口的抽象方法

}

小结：接口是更加抽象的抽象的类，抽象类里的方法体可以有方法体，接口里的所有方法都没有方法体【jdk7.0】。接口体现了程序设计的多态和高内聚低耦合的设计思想。

特别说明：jdk8.0以后接口类可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现

代码：

interface B {
//写属性
public int n1 = 10;

//在方法，在接口中，抽象方法，可以省略abstract关键字
public void temp();
//在jdk8后，可以有默认实现方法，需要使用default关键字修饰
default public void ok(){
System.out.println("ok ...");
}
//jdk8以后也可以有静态方法
public static void cry() {
System.out.println("cry ...");
}
}

注意事项和细节

1. 接口不能被实例化
2. 接口中所有的方法都是public方法，接口中抽象方法，可以不用abstract修饰
3. 一个普通类实现接口，就必须将该类接口的所有方法都实现，可以用alt+enter来解决
4. 抽象类实现接口，可以不用实现接口的抽象方法。
5. 一个类同时可以实现多个接口
6. 接口中的属性，只能是final的，而且是public static final 修饰符。
   1. 比如：int a=1；实际上是public static final int a=1；（必须初始化）
7. 接口中的属性的访问形式：接口类.属性名
8. 接口不能继承其他的类，但是可以继承多个别的接口
9. 接口的徐师傅 只能是public和默认，这点和类的修饰符是一样的

实现接口vs继承类

接口和继承解决的问题不同

继承的价值主要在于：解决代码的复用性和可维护性

接口的价值主要在于：设计，设计好各种规范（方法），让其他类去实现这些方法。即更加的灵活

接口比继承更加灵活

接口比继承更加灵活，继承是满足is-a的关系，而接口只需要满足like-a的关系。

接口在一定程度上实现代码解耦【即：接口规范性+动态绑定机制】

接口的多态特性

1. 多态参数
   1. 在前面的Usb接口案例，既可以接受手机对象，又可以接受相机对象，就体现了接口的多态（接口引用可以指向实现了接口的类的对象）
2. 多态数组
3. 接口存在多态传递现象

interface A {
int x = 0;
}

class B {
int x = 1;
}

class C extends B implements A {
public void pX() {
System.out.println("C pX");
System.out.println("C x = "+x);
}
}

内部类

如果定义在类内局部位置（方法中/代码块）：（1）局部内部类（2）匿名内部类

如果定义在成员位置（1）成员内部类（2）静态内部类

基本介绍

一个类的内部有完整的嵌套了另一个类结构。被嵌套的内称为内部类（inner class），嵌套其他类的类称为外部类（outer class）。使我们类的无法成员【思考：类的五大成员是哪些？[属性，方法，构造器，代码块，内部类]】，内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系，注意：内部类是学习的难点，同时也是重点，源码里有大量的内部类

基本语法

内部类的分类

定义在外部类局部位置上（比如方法内）：

1. 局部内部类（有类名）
2. 匿名内部类（没有类名）

定义在外部类的成员位置上：

1. 成员内部类（没用static修饰）
2. 静态内部类（使用static修饰）

局部内部类的使用

说明：局部内部类是定义外部类的局部位置，比如方法中，并且有类名。

1. 可以直接访问外部类的所有成员，包含私有的
2. 不能添加访问修饰符，因为他的地位就是一个局部变量，局部变量是不能使用修饰符的。但是可以使用final修饰，因为局部变量也可以使用final
3. 作用域：仅仅在定义它的方法或代码块中。
4. 局部内部类—访问-🡪外部类的成员【访问方式：直接访问】
5. 外部类---访问-🡪局部内部类的成员
   1. 访问方式：创建对象，在访问（注意：必须在作用域内）

记住：（1）局部内部类定义在方法中/代码块

（2）作用域在方法体或代码块中

（3）本质仍然是一个类

6、外部其他类---不能访问-🡪局部内部类（因为 局部内部类地位是一个局部变量）

7、如果外部类和局部内部类的成员重名时，默认遵循究竟原则，如果想访问外部类成员，则可以使用（外部类名.this.成员）去访问 【演示】System.out.printfln(“外部类的n2=” + 外部类名.this.n2);

匿名内部类的使用

1. 本质是类
2. 内部类
3. 该类没有名字
4. 同时还是一个对象

说明：匿名内部类是定义在外部类的局部位置，比如方法体中，并且没有类名

1. 匿名内部类的基本语法

New 类或接口（参数列表）{

类体

}

1. 匿名内部类的语法比较奇特，请大家注意，因为匿名内部类既是一个类的定义同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征，对前面代码分析可以看出这个特点，因此可以调用匿名内部类方法。
2. 可以直接访问外部类的所有成员，包含私有的
3. 不能添加访问修饰符，因为它的地位就是一个局部变量
4. 作用域：仅仅在定义它的方法或代码块中
5. 匿名内部类---访问-🡪外部类成员【访问方式：直接访问】
6. 外部其他类—不能访问-🡪匿名内部类【因为 匿名内部类的地位是一个局部变量】
7. 如果外部类和匿名内部类的成员重名是，匿名内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员） 去访问

成员内部类的使用

说明：成员内部类是定义在外部类的成员位置，并没有static修饰

1. 可以直接访问外部类的所有成员，包含私有的
   1. 
2. 可以添加任意访问修饰符（public、protected、默认、private），因为他的地位就是一个成员。
3. 作用域和外部类的其他成员一样，为整个类体，比如前面案例，在外部类的成员方法中创建成员内部类对象，再调用方法。
4. 成员内部类---访问--🡪外部类成员（比如：属性）（访问方式：直接访问）（说明）
5. 外部类---访问-🡪成员内部类（说明）
   1. 访问方式：创建对象，再访问
6. 外部其他类---访问-🡪成员内部类
7. 如果外部类和内部类重名是，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问

外部类访问成员内部类的三种方法：

先实例化外部类

外部类.成员内部类 对象名 = 外部类对象.new 成员内部类

静态内部类的使用

说明：静态内部类是定义在外部类的成员位置，并且有static修饰

1. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
2. 可以添加任意访问修饰符（public、protected、默认、private），因为他的地位就是一个成员
3. 作用域：同其他的成员，为整个类体
4. 静态内部类---访问-🡪外部类（比如：静态属性）【访问方式：直接访问所有静态成员】
5. 外部类---访问--🡪静态内部类 访问方式：创建对象，再访问
6. 外部其它类---访问--🡪静态内部类
7. 如果外部类和静态内部类的成员重名是，静态内部类访问的时候，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.成员）去访问

如果不想创建外部类，可以把这个方法写成静态方法