🌹作者:云小逸
📝个人主页: 云小逸的主页
📝Github: 云小逸的Github
🤟motto:要敢于一个人默默的面对自己， ==强大自己才是核心==。不要等到什么都没有了，才下定决心去做。种一颗树，最好的时间是十年前，其次就是现在！学会自己和解，与过去和解，努力爱自己。==希望春天来之前，我们一起面朝大海，春暖花开！==🤟
👏专栏：C++👏 👏专栏：Java语言👏
👏专栏：C语言初阶👏👏专栏：数据结构👏

@TOC

前言

——————————————————————————————
首先先摘抄上罗老师的几句话：献给坚持创作的我和点开这篇文章希望进步的你：
1、你没必要和别人杠，由于知识的贫穷，他只活在自己的世界里，只认自己的那个想法，你很难改变他

2、一个知识越贫乏的人，越是拥有一种莫名奇怪的勇气和一种莫名奇怪的自豪感。因为知识越贫乏，他所相信的东西就越绝对，因为他根本没有听过与此相对立的观点。夜郎自大是无知者，和好辩者的天性。

3、你太狂妄了，你以前居然把很多很多命运对你的帮助，命运对你的加持，看成是你所配的，于是你就仔细去回想，去回想你这一生中所遇到的很多经历，很多重要时刻，你才恍然大悟，原来你就是一个很渺小的人，离开了他人的帮助，他人的祝福，命运的加持，你什么都不是……

—————————————————————————————————

这篇文章开始我们就要进入了Java语言的学习了，加油！！！
本Java专栏不会把Java的所有的知识点全部讲到，比如与C语言类似的语法本专栏就不会再赘述，本专栏如有讲的不够好的地方，希望各位读者大大多多包涵。

​

1.static静态关键字

a.static是什么？

static是==静态的意思==，可以用来修饰成员变量、成员方法。

b.static修饰成员变量

static修饰成员变量之后称为静态成员变量（类变量）
由此我们可以得出成员变量分为==两类==：

（1）静态成员变量：

有static修饰，属于类，只会加载一次，内存中只有一份
访问它有两种格式：

类名.静态成员变量(推荐)
对象.静态成员变量(不推荐)。

（2）实例成员变量：

无static修饰，属于对象，访问格式只有一种：

对象.实例成员变量。

（3）两变量的使用场景：

**静态成员变量：表示在线人数等需要被类的所有对象共享的信息时。
实例成员变量：属于每个对象，且每个对象的该信息不同时（如：name,age,money…）**

（4）成员变量的内存原理：

**静态变量 是属于类的，存储在方法区，随着的类加载而加载，
实例成员变量 属于对象，存储在 堆中，随着对象的创建而创建**

c.static修饰成员方法：

static修饰成员方法与其修饰成员变量极其类似：

静态成员方法（有static修饰，归属于类），建议用==类名访问==，也可以用对象访问。
实例成员方法（无static修饰，归属于对象），只能用对象触发访问。

d.注意事项：

**静态方法只能访问静态的成员，不可以直接访问实例成员。
实例方法可以访问静态的成员，也可以访问实例成员。
静态方法中是不可以出现this关键字的。**

e.static应用知识：工具类

（1）是什么？

**内部都是一些静态方法，每个方法完成一个功能
一次编写，处处可用，提高代码的重用性。**

（2）有什么要求？

由于工具里面都是静态方法，直接用类名即可访问，因此，工具类无需创建对象，建议将工具类的构造器进行私有。

f.static应用知识：代码类：

**代码块是类的5大成分之一（成员变量、构造器，方法，代码块，内部类），定义在类中方法外。
在Java类下，使用 { } 括起来的代码被称为代码块 。**

（1）静态代码块:

**格式：static{}
特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发、只执行一次
使用场景：在类加载的时候做一些静态数据初始化的操作，以便后续使用**

（2）构造代码块（了解，见的少）：

**格式：{}
特点：每次创建对象，调用构造器执行时，都会执行该代码块中的代码，并且在构造器执行前执行
使用场景：初始化实例资源。**

g.static应用知识：单例设计模式

（1）什么是设计模式（Design pattern）

开发中经常遇到一些问题，一个问题通常有n种解法的，但其中肯定有一种解法是最优的，这个最优的解法被人总结出来了，称之为设计模式。
设计模式有20多种，对应20多种软件开发中会遇到的问题。

（2）单例模式

单例模式：
可以保证系统中，应用该模式的这个类永远只有一个实例，即一个类永远只能创建一个对象。

（3）饿汉单例模式

用类获取对象的时候，对象已经提前为你创建好了。

设计步骤：

**定义一个类，把构造器私有。
定义一个静态变量存储一个对象。**

   /** a、定义一个单例类 */
  public class SingleInstance {
 /** c.定义一个静态变量存储一个对象即可 :属于类，与类一起加载一次 */
public static SingleInstance instance = new SingleInstance();

        /** b.单例必须私有构造器*/
        private SingleInstance() {             
            System.out.println("创建了一个对象");
         }
    }

（4）懒汉单例

在真正需要该对象的时候，才去创建一个对象(延迟加载对象)。

设计步骤：

1.定义一个类，把构造器私有。
2.定义一个静态变量存储一个对象。
3.提供一个返回单例对象的方法

/**
   懒汉单例
 */
public class SingleInstance2 {

    /**
      2、定义一个静态的成员变量负责存储一个对象。
         只加载一次，只有一份。
       注意：最好私有化，这样可以避免给别人挖坑！
     */
    private static SingleInstance2 instance;

    /**
      3、提供一个方法，对外返回单例对象。
     */
    public static SingleInstance2 getInstance() {
        if(instance == null){
            // 第一次来拿对象 ：此时需要创建对象。
            instance = new SingleInstance2();
        }
        return instance;
    }


    /**
       1、私有化构造器
     */
    private SingleInstance2(){
    }
}

2.final关键字：

a.final的作用

final 关键字是最终的意思，可以修饰（类、方法、变量）
修饰类：表明该类是最终类，不能被继承。
修饰方法：表明该方法是最终方法，不能被重写。
修饰变量：表示该变量第一次赋值后，不能再次被赋值(有且仅能被赋值一次)。

b.final修饰变量的注意

final修饰的变量是基本类型：变量存储的数据值不能发生改变。

final修饰的变量是引用类型：那么变量存储的地址值不能发生改变，但是地址指向的对象内容是可以发生变化的。

3.常量：

常量是使用了public static final修饰的成员变量，==必须有要初始化==，而且执行的过程中其值不能被改变。

命名规范：

英文单词全部大写，多个单词下划线连接起来。

    public class Constant {
        public static final String LOGIN_NAME = "admin";
        public static final String PASS_WORD = "123456";
    }

常量做信息配置的原理、优势

1.在编译阶段会进行“宏替换”：把使用常量的地方全部替换成真实的字面量。
2.维护系统容易，可读性更好。

4.抽象类

a.概念说明：

**1.在Java中abstract是抽象的意思，可以修饰类、成员方法。
2.abstract修饰类，这个类就是抽象类；修饰方法，这个方法就是抽象方法**

格式：

   修饰符 abstract class 类名{
        修饰符 abstract 返回值类型 方法名称(形参列表)；


    public abstract class Animal {
        public abstract void run();
    }

注意事项

抽象方法只有方法签名，不能声明方法体。
一个类中如果定义了抽象方法，这个类必须声明成抽象类，否则报错。

b.抽象的使用场景

抽象类可以理解成不完整的设计图，一般作为父类，让子类来继承。
当父类知道子类一定要完成某些行为，但是每个子类该行为的实现又不同，于是该父类就把该行为定义成抽象方法的形式，具体实现交给子类去完成。此时这个类就可以声明成抽象类。

c.抽象类基本作用

作为父类，用来被继承的。

继承抽象类有哪些要注意？

一个类如果继承了抽象类，那么这个类必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。

d.特征和注意事项

**1.类有的成员（成员变量、方法、构造器）抽象类都具备
2.抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
3.一个类继承了抽象类必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。
4.不能用abstract修饰变量、代码块、构造器。
最重要的特征：得到了抽象方法，失去了创建对象的能力（==有得有失==）**

final和abstract是什么关系

互斥关系
**abstract定义的抽象类作为模板让子类继承，final定义的类不能被继承。
抽象方法定义通用功能让子类重写，final定义的方法子类不能重写。**

最后

十分感谢你可以耐着性子把它读完和我可以坚持写到这里，送几句话，对你，也对我：

1.你能真正影响的人，一定是你愿意在TA身上投入大量的时间，跟你有真正接触的人。

2人生啊，有很多的挫折，人生也有很多的苦楚，但是你自己，要瞧得起你自己。你最重要是做你觉得正确的事情，最重要的是，多年以后的你能够看得起现在的你，我们每个人都是顶天立地的人。

3.人生最大的痛苦就是你知道什么是对的，但却永远做出错误的选择，知道和做到这个巨大的鸿沟，你永远无法跨越。

最后如果觉得我写的还不错，请不要忘记==点赞==✌，==收藏==✌，加==关注==✌哦(｡･ω･｡)

愿我们一起加油，奔向更美好的未来，愿我们从懵懵懂懂的一枚==菜鸟==逐渐成为==大佬==。加油，为自己点赞！
​
注：本篇文章是本人在b站学习黑马程序员的学习笔记，无任何商用用途，仅为自己和读者的Java语言学习的学习资料。

​