1.尚硅谷全套JAVA教程--基础必备（67.32GB）/尚硅谷Java入门教程，java电子书+Java面试真题（2023新版）/08_授课视频/123-面向对象(高级)-第08章复习与企业真题.mp4原创

好，那么第八章的内容呢，我们就讲完了啊，讲完以后呢，整个我们这个第二阶段的一个内容啊，算是就高一阶段了啊，然后呢，第八章的话呢，我们做一个复习，来打开我们这个零三的一个复习笔记啊，来看一下我们这个。好，首先的话呢，我们来看一看这一章主要我们讲的一些内容啊，这一章的话呢，相较于前面两章来讲呢，这个东西呢，稍微说就多一些啊呃，我们一个个来，首先第一个的话呢，我们提到了一个关键字啊，这个关键字呢。诶叫做这个static。OK，诶，关于它的一个使用啊，这个我们要清楚，这个完了以后的话呢，我们接着相当于提了一个设计模式，这个设计模式呢，成为呢叫单利模式。哎，有时候呢，也称为呢，叫做单子模式哈。哎，子的话呢，就是实力的意思是吧。好呃，这个呢，是我们说的这个第二个，然后第三个的话呢，我们接着呢，提了一下这个may方法啊，May方法的话呢，其实我们从第一天写hard沃呢就开始在用了，只不过呢，这里边我们把相应的一些关键关键字是吧，哎，就都熟悉了，熟悉哈，所以这块呢，我们就诶。写成一个叫理解一下，这个没方法。

诶，关于他的一个情况，好，这个没方法，完了以后的话呢，接着我们就提了一下类的成员之四。诶成员之四啊，这块我们提到叫代码块，也称为呢，叫做初始化块，代码块呢是从它这个结构上来看的，然后初始化块呢，是从它这个作用的角度来看的。啊，这个呢，我们叫代码块了，然后这个完了以后呢，接下来诶，我们提了一个关键字呢，叫做这个final是吧。啊，关键字啊，叫做这个final，好，那这块的final的话呢，我们需要关注的就是它能够修饰哪些相关的结构啊OK，好，那final完了以后呢，我们接下来啊，又提了几个关键字啊，首先呢，是叫做abstract。啊，这个呢，我们知道呢，来叫抽象的啊，修饰这个类或者是方法的啊，接着第七个呢，我们讲了一下这个关键词呢，叫interface。那我们称为它叫接口啊，与类并列的一个结构啊，好，这个完了以后呢，接下来我们再提的就是类的成员之五。

诶植无这个呢，我们称为它叫诶内部类，诶它的一个使用，好，那其实这个内部类讲完之后呢，基本上我们的面向对象呢，差不多就到这个收尾的这个内容了啊这儿呢，我就把诶我们另外的两种结构呢，诶给大家抛出来了，前面的话呢，我们更多的说的是类，然后呢，引出来了跟类并类的一个结构呢，叫做interface啊，叫做接口了，然后之后的话呢，我们就提到了叫枚举类啊，关于它的一个使用，所以这块你可以说成是关键字的使用也行，因为我们引入的这个叫做innu，或者叫an是吧，叫枚举类了啊。好，这是一个，然后接下来的话呢，我们就提到另外一个呢，叫做注解。哎，这个注解的话呢，我们用的叫annotation。诶，关于它的一个使用这两块呢，我们从这个定义的角度来看啊，算式呢跟类并列的啊，就好比是我们右键呢，需要去new的时候呢，这块能看到的这几个并列的概念，OK啊行这呢是我们说的这个内容，然后这个最后的话呢，我们又谈了谈啊还有一个呢，叫包装类的一个使用。

诶，这个呢，就是纯粹呢，是我们说的一种特殊的类了啊，然后最后的话呢，我们再讲一讲关于idea当中。啊，它的一个叫快捷键和debug。嗯，和第八个啊，第八个呢，我们称为呢叫调试的意思了，好这呢，就是我们这一章呢，一共讲的这个内容啊，其实呢不少了啊，从今往后呢，我们稍微的熟悉熟悉啊看一看。好，第一个话呢，我们提到这个叫这个关键字了啊，这块呢，因为我们讲的时候呢，只讲过属性和方法啊，所以当时讲它的时候呢，我们也只谈了属性和方法，那现在的话呢，我们整体来看，首先呢，我们关注一下这个static呢，都能用来修饰哪些结构。哎，修饰。呃，首先呢，注意它呢，主要来修饰的是类的内部的成员了。啊，表现的这个特点，咱们先这样说吧。啊，这样的话呢，大家反而更好理解一点啊，只要呢，我们看到这个static的话呢，它就称为叫静态的啊。

哎，这个呢叫静态的，那一提到静态的话呢，一般我们都会接着呢，就是跟一句话叫随着类的加载而怎么着是吧。哎，而怎么着呢，有的呢叫随着类的加载而加载，有的呢叫随着类的加载而执行。是吧，这个呢就不太一样了，所以说呢，随着类的加载而怎么着这块的话呢，我们这个static呢，你就不要用它去修饰我们所说的这个外部类了。啊，就是我们平时说的那个类就不行了，因为它本身呢，是随着类的加载你那个东西，它修饰的那个东西，而是怎么着的，所以你得找他修修饰的那个东西啊，它修饰的话呢，其实就是类的内部成员。啊类的内部成员呢，我们讲了五个，其中有一个呢是不能用它修饰的。对，就是构造器了，哎，所以呢，它能用来修饰的就是另外几个啊，属性方法哎，代码块。诶内部类是吧，诶就是这样的一些结构啊好，那这块呢，你也可以稍微的想一下，为什么死在这个不能用来修饰构造器呢。

啊，那你要想修饰构造器有什么意义呢？是吧？对刚才有同学说说谁来用呢？对你看构造器啊，或者我们现还在提一下这个斯staic啊，这个staic呢，它为代表的就是静态的叫随着类的加载，而是怎么着，然后的话呢，假设呢，这个呢，就是类呃加载的时候的一些相关的结构的信息了，然后呢，我这呢，画一条薄薄的一层线哈，一个边界，这个边界的下边的话呢，可以理解成呢，比如说就是我们创建的这种对象了。哎，这个静态的结构呢，我们说了跟对象呢，其实没有关系，都是跟类呢是有关系的，那中间这个薄薄的一层边界，其实就是呃，类这块呢，创建了对象。啊，那中间这条线呢，其实为代表的，你可以理解成呢，就是以构造器为代表的。啊，因为构造器的调用呢，就使得我们这个对象呢，就创建成功了。

所以呢，这块你说构造器呢，硅造代这个也没什么意义啊，因为呢，你说诶前面这些结构的话呢，我们都可以理解成呢，这个呢是自动执行的，是类的加载时候执行的，然后你要是不用静态修饰就是对象呢，哎，在创建的时候呢执行的哈，这个你要是用构造器修饰的话呢，意义。不大是吧，因为啥呢，本身呢，没有对象的时候呢，我们用类呢，这块相当于呢，就呃加载过道器，然后调用过道器制造对象了，你加了静态呢，是用用类去调，你不加磁带力的话呢，它也正正常的也能够去掉。啊，没什么用啊呃，这呢，所以说主要用来修饰的还是其他的几个结构啊好，那这一说呢，我们讲的这个细节，当时呢，我们主要呢，还是区分了一下这个带这个修饰的这个属性，带这个修饰的这个方法是吧，跟没有用带这个修饰的属性方法有什么区别，这块呢，大家熟悉一下就可以了。哎，熟悉熟悉啊。这个是熟悉。呃，因为呢，这个代码块内部类咱们后边还讲了啊，所以这块我们主要呢，还是说他俩熟悉一下，诶，使用static啊修饰的这个属性啊，和我们这个也称为呢，叫做类变量了。

哎，以及呢，叫做诶类方法与不使用，哎时代这个修饰的这个区别。呃，区别啊，这个区别的话呢，咱们在这个课件里边其实写的比较详细了啊，稍微的我们看一眼啊这呢，我们提到这个，呃，带这个使用的时候，关于呢，变量的这块啊，我们通过这样的一些位置是吧？啊一个一个的都做了一个分析。诶大家呢去体会就行，方法这块的话呢，诶我们这块儿也都详细的去进行一个说明，这块呢，大家不用死记硬背啊，稍微呢，你往下顺的话呢，能够基本上清晰就可以了。一定要明确的一个点，尤其呢，是我们这个叫类变量哈。哎，这个类变量的话呢，非常明确的就是我们在整个类的生命周期过程当中，就只有一个啊，当前这个类变量。它呢，被类的多个对象呢所共享是吧。

哎，类的生命周期内。啊，只有啊一个啊，然后呢，被类的多个实例来共享。哎，就这样一个场景啊，它跟我们前面提到这个叫实例变量呢是不一样的啊，类方法的话呢，你就知道直接用这个类呢去进行调用啊就可以，内部呢只能调用这种，呃，当前类的这个类变量啊，或者其他的这个类方法不能调用非静态的结构就行了啊这个细节呢，就不用多说了啊，诶更多的呢，需要大家去从代码层面来掌握的，或者要熟悉的是什么呀，就是我们啊遇到这个属性是吧。或方法时。啊，需要考虑是否要生命为静态的啊。是否啊需要啊，需要考虑是否生明为啊IC的。这个呢是咱们需要关注的点啊，当初呢，我们其实还写了写了比如说呢，诶我们要考虑呢，是不是当前这个变量呢，适合被类的多个实例呢所共享，而且呢，就大家的值呢，是不是都一样啊，如果都一样的话呢，这个我们可以考虑呢，就共享了。

然后接着的话呢，我们在实际开发当中一些常量啊，通常呢，也都是上面成了一个静态的了，就是在这个final的了。然后呢，这个方法这块的话呢，操作类变量的这种呢，一般呢，都是静态方法，像概率方法啊，自然而然的也都就静态了啊，再呢，就是工具类当中常常都是静态方法。啊，这块我们熟悉一下这个事儿啊就可以了，行，所以呢，这块呢，这个内容呢，也就这样了啊，然后后边这块呢，我们提到了一个设计模式哈，叫做单利模式，首先呢，关于设计模式这块呢，先来了解一下。这个经典的。哎，设计模式呢，有。23种是吧，OK啊，那这个呢，做一个了解就行，然后单模式呢，属于其中的一种，主要呢，属于这个叫创建型的啊，用于呢，创建对象这样的一个场景啊，那单立模式呢，首先你得知道呢，它表达的是什么意思啊，解决的是什么问题。

啊，解决问题呢，就是在整个软件系统中。啊，只存在。哎，当前类的唯一实例，哎，就这一个对象啊，你就拿着一个对象的去用就可以了。哎，就是这样的一个情况啊，然后呢，具体实践这块的话呢。哎，我们这块呢，典型的讲了两种，一种呢叫做饿汉式。懒汉式。是吧，哎，这样两种方式啊，后边的话呢，我们是不是还讲了。哎，枚举类的方式是吧。OK啊，那其实呢，使用内部类呢，也可以去实现的。哎，这个呢，我就写一个等了。OK啊行，那如果呢，在这个笔试当中出现的话呢，一般啊，大家写的话呢，可能都会习惯上的去写这两种。啊，那其实网上呢，也有相关的一些帖子哈，就是在谈到底这些方式里边哪个好，应该怎么着更合适啊，其实这块呢，也穿插了很多更高级的一些内容，比如说后续我们讲的反射的问题等等。

呃，这个呢，一两句话呢，咱们是说不清的，包括呢，我们还有一些未知的知识点还没有讲，所以暂且的话呢，我们就不展开去说，各种各样的方式有什么区别了，以后呢，大家呢，诶等我们讲完扎va记住以后呢，你可以呢，诶搜一搜啊，相应的有很多这个知识可以去探讨的啊，所以呢，就是相应一些知识点呢，我们去挖掘的话呢，其实呃，很多内容啊，其实可以不断的去往里挖的。OK啊行，那么这里边儿的话呢，我们主要需要关注的就是这个鄂汉式和懒汉式了，呃，需要呢，对比二者的区别。OK啊行，那我们讲它的这个优点缺点呢，其实也都谈了一些了啊，那么典型的话呢，关于这个恶汉市呢，我们需要记住一个点。哎，我们用一个词来修饰呢，叫做立即加载是吧。就相当于呢，一上来我们这个对象呢，就创建成功了，那相比较来讲，这个懒汉式呢。对，我们调用这个方法的时候，需要的时候呢，我们才会去加载，所以呢，它称为呢叫延迟加载。

那自然而然呢，它对于内存就比较节省一些是吧，OK啊，那这呢，也可以理解成是这个懒汉时的一个好处了啊，那它的这个主要的弊端呢。对，就是县城的不安全性，咱们也稍微的提了一下这个事儿啊，然后呢，这个鄂汉市呢，就是县城安全的。OK啊好，那另外一个角度来讲呢，就是这个所谓的利益加载呢，它的生命周期呢，就比较长，那对于我们用户来讲啊，比如我们用的这个手机是吧，对用户来讲的话呢，其实我们很多时候呢，都是拿这个内存啊去换的，用户的这个执行的效率啊，现在这个安卓手机的话呢，我们说一整这个内存的空间就比较大了啊，所以呢，很多这个任务的话呢，它都在这个内存当中都提前加载好了，你需要的时候呢，直接呢，我们就呃点一下直接就从内存里边进行加载。而不是说呢，从这个磁盘当中先加载内存，内存呢再进行一个调用，这就显得要慢一些啊，诶所以呢，这个立即加载的话呢，这个缺点呢，就是说占内存时间比较长，但是呢，如果你要内存空间比较大的话呢，用空间呢来去换用户的这个执行的这个时间啊。

好，这呢也是一种解决问题的思路啊。哎，这个呢，我们就完事了，大家需要呃掌握的呢，就是呃这两种方式要会写。哎，要会写啊，这呢我也稍微的提一下，哎，需要呢会手写这个饿汉式和懒汉式啊。这个呢，我们就不用多说了，然后下边这块我们再提一下，这个叫may方法啊，这个may方法的话呢，因为我们讲完代这个之后呢，关于他声明当中的每一个关键字呢，咱们就都能够说清楚它的具体的意思了。啊，整个呢，它这个格式呢，这不就是长这样了啊，这我们天天见的。哎，May啊，死针类型的一个，诶那么关于他的这个说明的话呢，我们也是基于这个声明入手的，首先啊，他为什么是这样的声明的，尤其是前三个，这都是关键字了。其实我们也都知道是什么原因了啊，说过了权限呢最大，然后呢，这个呃有类来进行调用，你要拿对象调了也不合适，因为这个它是入口了，你要是造对象也得是通过入口先进去，那现在还没有对象呢。

没办法进去是吧，所以这块呢，必须得有类来进行调用啊，外的就不用返回了，因为呢，从这个诶战里边呢，我们这个战争的角度来讲，May方法呢，相当于是最底层这个了，May里边呢，出发你去调其他的一些方法，上面这些放一些战争，其他这些方法调用完以后的话呢，他再返回下一个这个，把这个结果呢返回给他的调用者，就是下一个这个战争了，你已经在最后了，你也不需要返回给谁了，所以是wide了啊。好，然后那个行参的话呢，我们体会呢，就是咱们可以啊传这个参数。啊，也演示了通过命令行呀，哎，通过我们的idea啊是吧，我们如何呢去传这个参数啊，就这几个事儿啊，所以第一个的话呢，大家需要啊这个理解的是吧。啊，理解的第一个事儿呢，就是它呢，作为我们说呢，叫程序的一个入口啊，另外一个呢，它也可以理解成呢，就是一个普通的呃静态方法啊，你也可以呢，在另外的一个类当中去调这个方法，就把它看成是个普通静态方法去调，也可以该传参传参啊然后这个关于它的一个理解二呢，就是我们诶如何使用这个may方法。

哎，使用我们这个没方法。这个小写的啊，诶与咱们这个，诶控制台呢，进行数据的交互啊。诶这个事儿呢，大家了解就行，平时我们开发的话呢，其实也很少用啊，呃，稍微注意一点的话呢，就是我们进行交互的时候呢，使用命令行的话。这个呢，我们是在运行的这个时候啊，也就是说我们在使用这个java.es这个指令的时候，对这来一个空格，这个相对应呢，就是我们这个类名，然后在后边啊，通过这种比如说诶双引号的方式，哎，我们去传相关的这个数据。啊，空格一下啊，比如说这个叫a Jerry啊，再空格一下，比如来个123，当然了，这一对双引号呢，可以省略啊这呢我就相当于是传了三个数据，作为呢这个数组的三个元素出现。就传递进去了啊好，那么这个数据的话呢，注意都是字符串，那你如果说在这里边呢，需要呢，以int的方式去呈现啊，我们呢，不是也讲了这个叫包装类了吗。

给它转换一下就可以了啊。好，这个呢，我们做一个了解就行，下边呢叫做代码块啊，代码块这块呢，我们也提到了它的一个修饰啊，呃，根据呢，是否使用带个修饰呢，自然而然的我们就有一个分类。啊，叫做静态代码块。非啊静态代码块，诶就这样一个情况啊，好，那么一提到这个代码块的话呢，呃，大家呢，需要关注的点，第一个我们首先呢，从使用频率上来讲。哎，频率上啊来讲啊用的比较少。诶，这个呢用的比较少啊，所以呢，我们主要关注的还是属性方法构造器，平时呢，我们在定义一个类的时候呢，主要呢是定义刚才我说的这三个结构了啊呃，代码块这块的话呢，我们会在一些特殊场景下呢，才会去做这个使用更多的话呢，还是源码当中用的比较多，大家呢需要知道就是诶这个源码当中它用了什么时候执行的，哎，你得清楚啊。

所以这儿的话呢，就提到一个点，他到底什么时候执行。啊，这块呢，就根据它是静态的还是非静态的话呢，我们有个区分了，OK，那对于静态代码块，那一提到它的话呢，大家呢，就要跟着一句话叫随着。类的加载而。对这块我们这个词呢，叫执行了，就是它呢，不是让我们主动来调的啊，它是自动来执行的。啊，那相对应的非静态代码块。对。随着对象的创建而。执行。好，那知道这个事儿呢，其实就可以了啊，那由这个出发的话呢，其实我们又讲了一个内容，这个内容的话呢，其实看做是一个具体的总结了啊，这周我往下放一下啊。哎，我写成一个这个吧。啊，这个总结呢，我们称为呢，叫对象的实例变量可以复制的位置及先后顺序是吧。

哎，对象的这个实例变量可以赋值的位置及啊先后顺序。诶OK啊，那这个代码块的话呢，是我们讲的其中的一个结构啊，如果呢，要从这个重要性来看的话呢，它的重要性其实还没有这个重要性高，因为呢，这个实力变量啊，这我们在这个创建类的时候呢，是经常用的啊，这个呢是需要大家掌握的啊，咱们相应的把它呢就写到了在这块啊，诶点开这不就我们说的这样的几个事儿吗。把它呢，我们CTRLC拿过来。好这呢，我就粘过来了啊。啊，就这样一个场景。哎，这样啊。哎，这一根线呢，我就把它就去了吧。哎，这样啊好，嗯，这个呢，我们不用多说了，呃，需要大家能够记住啊，就是我们在创建一个类的时候呢，如果提供了实例变量啊，你要考虑就是我们在哪个位置呢，给它去做赋值啊。合适就行了。好，这块呢，也不用过多的，大家去看了OK。

行，然后接下来的话呢，我们提到一个关键词呢，叫做final啊，那我们对于这种关键字的话呢，首先要关注的它能够用来修饰哪些结构啊。哎，用来修饰。呃，类方法。变量是吧，这个变量的话呢，既包括我们的成员变量。也包括呢，局部变量是吧。哎，没问题啊。好，那么这块呢，其实这个关键字呢，不是特别难啊，它主要呢，就翻译成了叫做最终的是吧。哎，最终的啊，那么对应我们这个类的话呢，它就表现为相应的叫。哎，不可被继承是吧，哎，我把这个呢往这放吧。那最终的啊，所以呢，这个类呢，就是不能被继承。诶方法的话呢。不能被重写，然后呢，变量呢。哎，就是。哎，是一个常量是吧。就是一旦赋值不能修改啊。

哎，不能修改好，然后呢，接下来的话呢，对于我们这里边儿这个成员变量呢，我们提到了成员变量能复制的位置呢，就是上面这样的一些位置了，那我们说呢，只有三个位置呢，可以去给他复。就是123是吧，诶默认赋值呢是不行的，就即使呢，你想用它的默认值，那你应该写出来，实际上呢，就变成显示复制了。哎，那么通过这个对象调属性对象调方法的方式呢，去复制这个也不靠谱。啊，因为万一要你不掉呢，你不调不成了，就没有值了吗？哎，所以说这块呢，我们必须得考虑呢，在造对象啊结束之前，你得把这个实例变量呢，给附上值。那如果是静态变量呢，那类似的啊，要是静态的去修饰一个变量成现变量的话呢，你可以显示赋值，那么静态代码块中去赋值回到器中就不要负了。啊，因为呢，我静态变量，万一你要是不掉构造器找对象呢。是吧，诶所以呢，你要是静态变量就考虑这两个就行，诶诶一说呢，大家应该也能理解啊呃，局部变量的话呢，其实没啥特别的，就是你在调之前呢，附上个值就可以了，一旦赋值就不要改。

就可以了啊，所以final这块呢，其实我们使用的话呢，不是特别困难。那在实际开发当中。啊，我们呃，经常呢，可能就想不起来去用final了，这我在讲课的时候也提到过啊，比如说我们现在有一个类，这个类呢，其实呢，你不会让他去被其他的此类呢去，呃，其他的类呢去继承了，但这时候我就没有讲final。没家就没家了是吧？啊，你说这个方法的话呢，我们也，哎不需要呢，其他的这种子类呢，去重写了，那你就自己主动点，你就不要去重写就完了，哎，我们呢，也就想不起来去用final来修饰了。呃，其实呢是可以的啊，当然呢，我们说对于圆码来讲的话呢，它在设计的时候呢，就要更严谨一些，防止呢一些成序员啊，因为我们知道这个成员，这个团队的话呢，这个世界范围内。啊，其实这个体量呢是很大的，但是呢，每一个成员的这个技术水平啊，是参差不齐的，高级的呢，可以非常高级啊。嗯，达到这个叫什么级别很高的这个程度了是吧，呃，也可以呢，类似于像这个叫科学家一样这个级别是吧。

OK，但是呢，这个级别低的话呢，也可以很低啊，我们都可以呢，就直接就码龙了就是吧。那这时候呢，大家都去完成这个功能，那这个万一要写的很很烂怎么办呢？是吧，所以呢，这个JDK呢，在设计的时候呢，成员呢，去作为使用者去使用的时候，他就得设计的严谨一些，不让用的得明确的提出来是吧，比如这块的不能让你继承的，不能让你重写的，他就得该加上就都得加上。看你自己写的，那你自己注意点儿也行。当然，你说我也，家长当然更严谨更好了。或者说呢，这些成员里边有一部分呢，他是写一些框架的，然后呢，被另外的一些人去使用，那这些人的话呢，他在写的时候，他也得小心一点。啊，这个该加的得加，因为别人用嘛，只要一别人用这个就怕他会断整啊，该加的就加啊。好，那么我们要是用这个反正的时候呢，一般这个变量这块有的时候咱们还是会注意一下去使用的，确实呢，我们这定义了一个常量。

啊，比如我们说那个像设计游戏的时候呢，这个上下左右这个我们就直接呢定义成是常量了啊哎，再包括呢，后边呢，我们比如说设计一个容器，就像这个集合框架一样，这个容器的话呢，默认的容量呢，假设是十或者是16，那这时候呢，十或者16呢，我们也定义成是常量，然后在你这个相关的这个代码当中，我直接使用这个常量就可以了。就是一看这个名，就是你要写个十很抽象，诶这十为啥用十呢？哎，如果你把它改成呢，叫initial啊，Lie或者initial capacity叫初始化容量啊，一看这个名呢，就非常的清晰啊，我们所以呢，在代码中一般呢，要用到一些数值的时候呢，习惯性的我们会把这个数值呢，都先提前定义成一些常量。啊，然后通过这个名呢，我们在这儿呢去调用，看着呢就更加的可读性好一点啊。好，这呢，我们就过了。好，在下边的话呢，这算是两个比较重的内容啊，一个呢叫abstract啊，一个呢叫做interface。好，首先的话呢，关于这个abstract，翻译过来叫做抽象的是吧。

然后接下来呢，就是用来修饰。啊，一个叫类，一个叫做方法。OK啊，那虽然说这个ofsri的话呢，我们看着是挺重的一个内容，但其实呢，呃，具体来看的话呢，还是比较简单的哈，它呢用来修饰这个类，那就是一个抽象类。啊，修饰一个方法。哎，那就是抽象方法啊，诶抽象类的话呢，一提到它主要特点是。不能实例化是吧。哎，不能找对象了，那一提到抽样方法呢。没有方法起是吧，哎，必须呢，由子类呢。呃，实现此方法，或者你要重写此方法也可以。哎，就这样一个特点啊，那么前面我们也提到过这个抽象方法呢，虽然它没有方法体，但是这个方法呢，它主要是做什么的，是不是已经确定下来了。对的啊，那由这个出发的话呢，我们不就也提到这个接口了，接口呢，传统意义上来讲就是抽样方法。

啊，那由这个角度来说的话呢，我们把接口呢，称为它是用来定义规范的是吧。啊，接口。首先呢，这个单词哈，咱翻译过来呢，就叫做接口。哎，是用来定义啊一组。规范。哎，或者叫定义一种标准。哎，就是这样一个场景啊，然后典型的这个规范或者标准的话呢，咱们就以啊授课的时候呢，这个课件里边我们提到的这个GDBC，大家呢，去理解啊，会更清晰一些。看他啊，这个JDBC呢，就是S公司出面定义了一套接口。啊，里边呢，主要都是interface啊，那用这个接口定义的规范是干嘛的呢？就是使用Java程序来操作数据库的啊一种规范。里边呢，大量的接口，大量的抽样方法，然后呢，由具体的数据库厂商出出面啊，他们呢，去提供这套接口的实现类的集合。

那实践类呢，自然而然里边抽象方法呢，它也进行了一个重启或者叫实现，那么这些抽象类的集，实践类的集合呢，我们就称为呢对应的驱动。哎，就是这样的场景，所以说这个驱动的话呢，是具体的数据库厂商他们自己开发的。那可能我们会问这个厂商，他们有动力去针对这套接口呢，提供这个时间类吗？你散公司这块出来了，你说我这块有一套标准，大家都这样去连接数据库，然后他们就老老实实的就开发了，这个想的有点太美好了是吧，我凭啥要迎合你呢？大家觉得呢？要迎合是吧，为啥呢？先入为主是因为上公司呢，它是有影响力的，为啥呢，他拿着攥着Java呢是吧。诶，这是一张王牌啊，就是你可以看不起S公司，但是你不能看不起Java程序员是吧？啊，因为Java的这个市场呢，实在是太庞大了啊，S公司呢，它是拥用它的所有权，然后他出面的时候，我开发一套标准啊，所以在扎药成员呢，都看向我是吧。

哎，如果呢，你具体的这个数据库呢，你不去提供对应的驱动，那只能是被Java成员呢所抛弃哈。啊，你比如说现在呢，这个公司里边要这个做一个项目了，这时候要选择后台这个数据库了，假设呢，Oracle没有提供这个驱动。啊，那这个老板说，说我们这个架构呢，数据库应该用什么呀？啊，你肯定会推荐，比如说其他的这些场景啊，你说那我们用Oracle吧，啊，我这块有关系，可以便宜一些是吧，不好使，你说这块呢不能用是吧，一句话就给它堵回去了，其实也能用，只不过就是你不愿意呢去使用它而已，是吧。啊，因为呢，他这要是没有这一套驱动的话呢，你就得需要关注于Oracle的细节了，它的这种实现方式，操作方式呢，可能跟其他的呢，就有很大的区别了。所以呢，你要是不提供这驱动呢，最终的效果呢，就是它的市场占比呢，会受到影响，OK啊，当然了，实际情况是什么呢？实际情况的话呢，就这个散公司呢，他在定义这套GDC标准的时候呢，他也不是自己说了算的，也不是这个独裁的哈，他呢其实呢，会把这些厂商呢都拉到一起，咱们呢建立一个组织，这个组织呢是由散呢呃出出面的是吧，他呢这个话语权比较重，但是大家呢都能参与进来，然后呢，咱们共同的来开发这样一套标准。

哎，那尽量的话呢，能够满足大家共同的这个特征，哎，其实这个过程当中就少不了这种妥协是吧。诶这呢也是为了诶把这个GDC把它烘托起来啊，如果呢，真要他自己独裁去整的话呢，万一这家这些联合说我也不用你了，那最后导致结果就可能市场份额也会往下掉是吧。哎，所以这个都是相互的啊。OK哎，你包括呢，我们现在看到这个JDK啊，每半年的更新一个版本，实际上的一个更新当中啊，也不是完全的现在不是三公司了，是Oracle了啊，不是完全Oracle说了算的啊，这Oracle呢，它相当于是在现在的这个组织当中，它这个话语权比较重，然后呢，实际上是各家都可以参与进来，包括咱们国内的一些相关的公司，像阿里呀。像原来那个是叫龙鑫啊等等啊，一些公司他们也参与到JDK的更新当中啊，还占有相应的一定的比重。

啊，就是大家呢，共同来去维护这样的一套生态，这样的话呢，才使得这个生命力呢更呃旺盛一些啊呃，以这个为代表的呢，其实是另外的一家公司。啊，极个性的叫做Apple是吧。啊叫苹果啊，诶你会发现呢，这个苹果的话，它的这个对手啊，竞争对手呢，基本上就是除了他之外的全世界了。啊，咱们用的这个以iPhone手机为例啊，从他呢，一开始使用的这个CPU的这种架构啊，自己研发的操作系统，自己研发的编程语言自己研发的，开发工具自己研发的。啊，基本上呢，从头到尾都是他自己来的，所以呢，他是典型的叫封闭式的这种公司啊。啊，而另外的这种呢，我们都主张的叫开源的，开放的，诶这样的一个特点啊，这个呢，是典型的两种不同的思路。啊，你像我这个大学的，我们组里边那个哥们儿啊，然后他呢，就后来又去美国读了一个书有啊进修了一下，然后呢，他毕业之后呢，就去苹果地图这块去工作了啊，他那块儿就讲他拿着他那个card的。

啊，那个门禁卡是吧，他只能够打开他的这个实验室的门禁卡，而且他打开以后呢，当时第一天去也挺兴奋啊，自己都自拍了一张照片，然后还没发布出去呢，就被警告说说不允许发布啊，让他呢就给删掉。啊，就是典型的苹果的文化就是这样的啊，而对应的这个，呃，还有一家公司呢，叫做谷歌嘛，是吧。诶，谷歌这个文化呢，跟他就有很大的区别，当年呢，呃，很早的时候呢，谷歌就有那个谷歌眼镜嘛。是吧，大家可能咱们都没带过啊，这已经都过去了，然后呢，国眼镜还没有推向市场的时候呢，这个他们那个CEO像拉里佩奇啊等等，他们就开大会在内部啊。他就已经都把这个事儿都说透了啊，包括怎么演示怎么功能都说完了，只不过说完以后呢，就是大家呢，因为也受一些法律的保护，就是不要出去乱说就行。而且呢，这个谷歌呢，号称呢，就是他们这个门禁卡卡呢，就基本上你可以呢，随意的打开一些实验室的门，大家呢，互相之间多探讨探讨啊探讨探讨是吧，诶一些思维火花的一些碰撞哈，所以两家公司的话呢，是明显的风格是不一样的。

啊，这种特点啊。呃，其实呢，这个你要说哪个更好呢。咋说呢？嗯，就是两种不同的思路而已是吧，开源的话呢，其实你像我们说安卓这个操作系统是一个开源的，好处的话呢，就是大家每家都可以用啊，每家呢都可以去改。啊，然后国内呢，我们就涌现了一批，其实呢，本质上来讲呢，其实就是一个UI是吧，当然呢，大家都叫OS嘛。叫就叫了，反正你开机画面我这还是啊，下边有个安卓的一个标识是吧。OK啊，诶，当然了，大家现在也在探讨，说到底鸿蒙算不算一个操作系统，还是仅仅是一套UI啊，其实呢，应该理解成是就操作系统了。只不过呢，你不管是安卓也好，鸿蒙也好，底层呢，大家都是使用的Linux内核而已。啊，那为什么不用不换掉还是就用Linux内核呢？首先这个内核呢，是开源的，大家都可以用，而且已经这么多年的机电了，我们没有必要呢，非得把它呢再去重新的再写一个，那个成本是极高的啊，已经迭代了这么多年了，是吧。

所以呢，都是基于内的内核，我们网上衍生出来的不同的操作系统而已啊，至于说其他家的原来叫米ii呢，现在也是米OS了，都是吧，这个咱们就不去探讨到底是不是OS这个级别了啊。那么相对应的这个苹果这个iOS的话呢，永远不会有一天呢去开放的，它就是封闭的一个特点，也为它的封闭性啊，它如果做得好的话呢，这家公司一定是一家非常出色的公司是吧？所以大家会看到苹果的操作系统，即使它的内存不高啊，这个可能这个电量你也觉得没有那么那么那么强大，你也可以用五年前甚至更早的这个。苹果的手机你发现呢？照样的非常流畅，其实都源于它的封闭性。OK啊，所以呢，我们刚才谈的这个事呢，其实也是一种开放性啊，通过这种接口体现这种规范标准，大家呢都去实施，我们共同来构建这样一套生态，有利有弊啊，就好比是呢，我们这个应用程序，你说我避开GDBC，我就直接去连你可不可以呢？当然可以了，而且这种性能的话呢，其实比我们通过JDBC呢要好一些。

但是呢，你不具备通用性是吧。哎，扩展性也比较差。啊，你可以理解成这块呢，就好比是苹果的思路，这块呢，就好比是我们其他的这种厂商，It领域里边的我们的普遍的思路啊。好，这个我们拉回来。好，那回到我们这个复习这个层面哈，那abstra的话呢，去修饰一个类抽象类啊方法，抽象方法那就完事了啊，那主要呢，其实大家呢，就理解它的话呢，就是基于我们前面讲的继承性了。啊，以前的时候呢，我们这个复类啊，有方法方法还有方法体，子类呢继承它，然后再重写，后来干脆说呢，这个类不要造对象了，方法这块呢也别写方法体了，直接让这个子类这块呢去重写得了。哎，相当于呢，我们基于继承的一种进一步的演化啊，所以呢，这个呢，并不是特别难，以后呢，我们见到一些类呢，如果是抽象的啊，你要想用它，你就去找它的子类，或者你自己提供它的子类。

OK啊。然后这个interface呢，我们叫做这个接口了，诶大家呢，需要去体会这样的一个意思啊，这个如果理解呢，还是不是特别到位呢，你也不用去纠结了，因为以后呢，我们会见到很多的接口，诶通过不断的去使用接口呢，你再去体会它就行了。好，然后接下来的话呢，我们需要大家掌握的一个点是什么呢？就是接口中可以声明的这个结构哈。啊，这块的话呢，我们提到了接口里边呢，首先是可以来声明属性的，只不过这个属性呢，必须是使用。对，我们叫全局常量了啊，使用的叫public static。Final来修饰的是吧，这是没得商量的啊，哎，你要是不写这三个关键字呢，默认的也有，所以呢是可以省略的，好，那关于方法这块呢，这个事儿就稍微的多一些了啊，多一些了，在这一八之前呢，我们只能。哎，声明。抽象方法。

哎，然后呢，去使用呢，叫public，哎tract来进行这个修饰的好，然后呢，在这个JDK8当中。哎，我们呢，就是可以呢去声明。哎，这个呢，叫静态方法是吧。或者呢，叫做默认方法。OK啊，那么这些方法的话呢，都是有这个具体的方法起的，那怎么使用呢？咱们也稍微的给大家讲一讲，那在GT9当中呢，又多了一个啊，可以呢，去声明叫private这样的方法了，也是有方法的行，这块的话呢，咱们就关注一下就可以了啊。诶好比是什么呢？就是诶我们呢，去定义的一个接口，它是一种规范了啊，比如我们后边呢，去想讲集合框架的话呢，有一些容器是吧，可以装东西的哈，有一些规范了，那具体呢，怎么去装啊。不确定是吧，所以呢，我们就是暴露出来的，还是抽象方法。但是呢，这个我们现在呢，随着呃GT8我们后边会讲这个呃STEMAPI啊，拉姆表达式啊等等，你会发现呢，这个我们给这个集合容器啊，里边加了一些功能。

啊，它可以呢，去处理一些数据，这个数据的话呢，我就不管你是什么数据了，我都可以来进行处理。啊，像一些排序啊。是吧，等等的一些过滤呀，是吧，一些操作哎，我都可以做了，而且这个事儿的话呢，跟你类型没有关系了，那这时候呢，其实说白了就可以写有方法体的方法了。但是这个话你说我写到别的类里边呢倒也行，但是呢，它其实就是个容器里边的功能，所以呢，它就又想给它放到接口里，但放到接口里边呢又比较纠结，原来接口呢只有抽样方法这些呢，功能呢又是确定的。当然呢，也适合放在这儿，那干脆就放进来吧，那一放进来那没有办法了，这个方法有方法体，那咱们就规定了你可以放这些方法，那其实呢，就定义成的是一个默认方法，那间接的话呢，我们实现了这个类呢，要是实现接口的话呢，是不是你这个类呢，就也能拿到这个方法了。所以呢，我们通过这样的一个场景体现呢，呃类呢，我们不是说单机整性嘛，呃，你现在呢，去实现这个接口，而且还可以多实现，实现了功能的一个扩展。

啊，这个一定程度上缓解了这个单基层的这个局限性啊。好，这个私有呢，我们前面也都提到过了，这个呢，大家做一个了解就行啊，好，那我们自己以后在开发的时候呢，其实更多的场景我们仍然定义的都是抽象方法，这个事儿的话呢，基本上我们不会太用的啊，更多的是源码里边了。行，然后接下来的话呢，就是关于这个接口呢，大家呢，去写一些练习题就可以了啊。好这块呢，也可以说呢，有一道这个，呃，传统意义上比较经典的这个叫笔试题了，是吧。哎，这个我们说过啊，就是这个抽象类和接口的一个对比。行，这个呢，我在课件里边呢，放了一个表格啊，当然呢，根据那个表格呢，看一下就可以了，那么在讲这个对比的时候呢，你也可以呢，体现一点不同，那我说叫经典呢，是因为它比较老了哈，所以呢，大家在答的时候呢，可以加点新鲜的东西，那就是你把这个JD8JD9里边这个新特性呢，你稍微的给它也带进去。就显得呢。

你不是从网上找这个现成的是吧，一找大家都有是吧，这块你也补了点新鲜的东西。啊，OK啊，面试官呢，能眼前一亮是吧？好，然后后边这块的话呢，叫类的成员之舞，叫做内部类。啊，内部类，呃，内部类这块呢，我们讲起来呢，其实是比较快的，哎，大家呢，其实就关注这么几个事儿就可以了。嗯，我写到这儿了是吧。呃，内部类啊，就在这儿。诶主要呢，关注的就是关于啊成员内部类的理解啊，就是一方面它是个类，一方面呢又是一个外部类的成员，诶理解一下就行，诶第二的话呢，如何创建成员内部类的对象。哎，咱们呢，以那个哎person为例呢，一个叫dog啊一个呢叫bird是吧？哎咱们上面这块也都创建了，哎这两个方式呢，大家呢得诶掌握一下啊，然后呢，如何调样外部类的成员，诶主要呢，就是有同名的时候呢，怎么处理的问题，诶局部类部类的使用这块呢，主要就是我们去创建匿名的。啊，实现类的对象的时候呢，这个事儿如何去做。

啊，这个呢，主要呢，就是关注。如何在？哎，这个方法内啊，去创建啊，这叫匿名的。啊，局部啊，内部类的，哎，对象啊，这个对象呢，有没有名倒都行，关键就是前面这块啊，你得知道它是一个匿名内部类了啊。行相应的这个代码呢，这不是，呃一方面的话呢，我们前面讲这个呃接口的时候呢，这是讲了USB这个题啊，这个题里边呢，其实我们第三种和第四种方式，这里边儿呢，就在方法当中，我们创建了实现了USB接口的匿名的内部类。这个类呢，因为是放在me方法内部了，这就是内部类了哈，然后我们这块呢，这不又单独的写了一个这个，呃，Al class test2啊，在这里边儿呢，这不我们又写了好多的这个举例啊，诶，当然呢，就是把上面这个还有这个啊汇聚写以后的话呢，我们可能就不去显示提供一个接口的实现类了，我们直接再就用匿名的方式了。哎，这个你要能看得懂，自己呢也要会写，OK。

好，这就过了啊，然后下边这个关系叫枚举类啊，以后呢，大家再去定义枚举类的时候呢，就使用这个关键字就可以了，我们自定义的那种方式，5.0之前呢，你就不要用了。没必要了啊，完全用它呢去替换，所以这块呢，大家需要掌握的呢，就是使用啊inu关键字来定义枚举类。哎，枚举。类啊即可。哎，这样就行啊，那这块其实大家呢，就做两个练习就行，一个练习的话呢，就相当于是我们这里边写的啊，就好比是这里边儿这个练习二一样啊，那此时的话呢，我们这个枚举类的这个对象呢，没有任何的实例变量了，那所以说呢，就最简洁的方式。就这样写，然后呢，另外一个题目呢，还是这个color，只不过此时的话呢，我们这几个对象呢，它都有一些事例变量了，那对应的就是RGB3个属性，还有一个描述，那我们这块呢，写法呢，就是这样写的，所以大家呢，其实也就知道这两种写法就行，一个呢是有实例变量，一个是没有的，所以典型的这两个情况就行。

以他俩为例啊，你回去写这俩例子呢，这以后就查不了啊。好，这个呢，我们其实也就过了啊，其实也不是特别难，诶，然后下边这块呢，有一个叫注解叫annotation啊，这个注解的话呢，实际上呢，对于我们后期的开发来讲是比较重要的。啊，只不过呢，我们这块呢，就没有办法展开去讲太多啊，因为的话呢，我们基础阶段其实也见不到几个注解啊，诶这呢，我们不是提到有一个公式嘛，就是后期呢，我们来看啊框架呢，就相当于呢，首先有这个注解。然后注解的话，我们再通过这个反式呢，去读这个注解的信息，哎，再配合相关的这种设计模式。哎，就是构成了我们这个框架，然后框架呢，再结合你的具体的业务，实现你整个这个项目。啊，这就是相应的一个组合啊好，那这里边儿呢，就需要一个注解了，注解的话呢，诶大家呢，在我们这个Java基础阶段。

啊，其实呢，比较简单。啊，我们也就关注了几个注解而已哈，第一个呢，叫做over。Ride是吧？哎，这个表示就是，诶这个修饰这个方法呢，表示呢，就要重写了哈，还有呢，叫待。Heated。啊，这个呢，表示呢，它所修饰的结构呢，过时了，哎，但是还能用啊，哎，再一个呢，叫surprise。王明。哎，这个啊。好，这个呢，我们称为它叫抑制编译器警告啊，这个呢，大家做一个熟悉就行了，然后呢，它之所以重要呢，是我们在后期的框架中去用啊，到那个时候的话呢，我们再关注一下，你看是具体是什么注解啊，怎么用什么作用啊就可以了啊，现在的话呢，我们也没法展开去讲。好，然后呢，这呢是我们讲的一个注解的，算是一个基本使用了，接着的话呢，我们提到一个概念叫做圆注解是吧。啊，这个稍微了解一下啊，这个圆圆柱解的话呢，它主要呢，是对现有的这个注解。

啊进行啊解释说明的是吧。或者进行这个修饰的这样一个作用啊，叫圆柱解了，圆柱解这里边儿呢，我们有四个啊，主要关注的话呢，大家就看两个啊，第一个呢，叫做target。哎，它呢，用来表示呢，你所修饰的这个结构，哎这个对应的，比如说是修饰这个override是吧？哎，这个override呢，它能够用来修饰哪些结构。那这个呢叫target，还有一个呢，叫做rotation。哎，表示呢，我们当前这个注注解的一个生命周期是吧。哎，表明哎生命。哎，周期的，呃，这个呢是表明。对，叫使用范围也行啊，或者要表明可以用来修饰的结构。OK啊行，然后剩下其他的这个，比如说documented呀，Inherited呀，是吧，这两个呢，我们就不多说了啊，诶也就关注一下这个事儿就行，然后呢，我们下边呢，又自己呢写了一个啊叫如何自定义注解这个呢，白天就玩一玩就得了，写了之后呢，你也看不出来有啥用是吧，我写了我修饰个类了，那能干啥呀，因为你还没想反射呢哈，你洗完之后呢，关键得通过反射呢去用它吊它才有意义。

哎，那这块就提了，反正呢，要是能掉它，那就意味这个注解呢，在运行的时候呢，它还在，所以呢，我们这个生命周期呢，你得用那个runtime的。啊，不知道还有没有印象啊。稍微的看一眼吧，看有的同学这个比较迷茫了，就啊。这个咱们讲这个生命周期的话呢，不是提到它有三种情况是吧，第一个呢，就是资金码文件当中呢，就不存在了，第二呢，就是资金文件中存在，但运行时候不在，第个呢，就是运行时候也在，哎我们要想通过反射呢，能够去调对应的这个注解，那你相应的这个生命周期呢，它就得长一点。所以呢，我们得用这个runtime啊。行，这块有个印象，你如果忘了忘了也没关系，后边我们讲到反射的时候呢，再说一下就行了啊。

好，也就这样啊，这呢，我们在技术阶段呢，大家也不用当成是一个重点，好下边这块呢，叫包装类，首先呢，大家需要掌握的。哎，那就是基本数据类型对应的包装类都长啥样啊？啊，包装类都有哪些。啊，这个呢，你得能够说出来，这应该是都没啥问题啊，啊这是一个点，然后第二点的话呢，我们主要呢，需要大家掌握的就是基本数据类型。化妆类。啊，还有这个string啊，三者之间的转换。诶把这个事呢，我们记住它啊，那其中这个前两者之间，他俩做转换的时候呢。这个事儿呢，就比较省事了。对，因为我们讲过这个GD5.0的一个新特性，哎，这个我们说呢，叫自动的装箱和拆箱。所以呢，诶比较顺滑啊，然后呢，这个基本数据类型包装类，哎跟咱们这个string。

这个做转化的时候呢，这块的话呢，就是前者转化成后者，你就去后者里边找方法，这个string呢，转换成它呢，你就去包装类里边找方法就可以了。哎，所以这块呢，我们一方面哈，哎转的时候呢，调用这个，哎，String的一个方法叫value of是吧。这个呢，是转换成这个字符串的这个场景啊，然后呢，要是诶这个此类呢，转化成前者的话呢，这块我们就去包装类里边去找。对，包装类呢，它有一个叫pass。Pass，这个叫A叉叉叉是吧，这个呢，你把相应的这个字符串你放进来，这个呢就可以转过去了啊行，这个呢就比较清楚了，然后我们在实际开发当中呢，在相应的场景，如果呢，他需要包装类的对象了，你就转过去。诶，然后呢，我们要是拿这个字符串呢，里边是个123，你再给他转回来是吧，这个相互之间会转就可以了啊好，下边这个快捷键debug，诶快捷键这块没得说，这个呢，就大家相应的多去练一练，记一记是吧，第bug的话呢，要有意识的会去使用，它会贯穿整个我们的学习阶段和大家的开发阶段。

这个就是啥呢，跟快捷键一样啊，就是讲呢，我们都讲了。哎，但是你得用啊，你不用的话呢，你就不熟，你不熟，越不熟你越不想用，越不想用你就越不熟，真正遇到一个大的项目的话呢，不知道该从何入手了。所以时不时的话呢，大家你就debug呢，自己去感受感受使用使用是吧。就可以了啊。好，那下边的话呢，我们来看一下这个客户的这个题目啊。啊，这块是关于这个study关键字的啊，说静态变量和实例变量的区别啊，区别使用场景，这个其实咱们也都讲过了是吧。诶，它俩的区别的话呢，这不是在课件里边，我们这呢列了好几个点嘛。哎，上边这块就是123456。没问题是吧？啊使用场景，这个使用场景呢，其实呢，就大家去说明一下，我们什么时候呢？哎，要把一个变量生明成实例变量，什么时候生明成是个静态变量，哎这不我们在下边儿这块不也都讲了吗。

哎，直播也都说了是吧，诶所以这个事儿的话呢，都是比较清晰的哈，或者换句话说呢，诶我在讲课之前呢，我都把这些都看过了是吧。哎，回不去了，我们再去设计这个课程的内容了啊，就相当于呢，企业需要什么呢，我们这块相应的就会讲哪些内容啊。好，下边说静态属性，静态的方法是否可以被继承，是否可以被重写，以及原因，诶这里边呢，蕴含了一个小的知识点，哎，可以呢，给大家呢再去说一下。这个属性这一块呢，我们这个，呃，静态的属性，静态方法，他首先问第一个能不能被继承。哎，这个继承的话呢，你看我们怎么去理解这个事儿了哈，如果呢，我再具体一点说呢，我们在这个此类当中，能不能调用父类中的静态的结构呢。哎，可以的啊，在权限允许的情况下，你直接调就可以了。啊，就相当于你是拿这个子类点啊去调就行啊好这个事儿。哎，需要给大家再去讲一下啊，就是我们前面讲方法重启的时候呢，因为我们当时还没有讲在。

当然是先讲的继承啊，那现在的话呢，我们属于一个复习的内容了，我们就可以谈谈这个事儿了，静态的方法能不能被重写的问题。不能，对这块一定要先明确这个结论哈，就是静态方法不能被重写。不能被重写意味着什么？诶，稍微的我找一个位置，咱们整两行代码。这个位置我们应该选在哪合适呢？哎，其实按说呢，应该讲到这个静态里边合适一点是吧。我把这个我收起来啊。嗯，静态或者我这块我再去新建一个吧。毕竟我们这属于一个复习的内容啊，新建一个包。这个呢，我来一个这个叫哎，14点。啊，这个我们叫一个复习吧，Review啊。好在这里边儿呢，我去创建这样的几个类啊，这个咱们首先呢，是关于静态的。哎，它的一个使用，哎这么着。好来这儿啊，嗯，这块呢，比如说我们就还是拿这个person来说吧，在这里边儿呢，我们来一个it的方法。

然后呢，我再去提供这个类的一个子类哈。哎，让他呢，去继承我们的这个person，这个呢，我们就写成叫哎学生吃饭。好，这个没问题，接下来的话呢，我们在这块啊。那方法一过来。我呢，就用多肽的方式去展示。那此时的话，多肽的方式。此时的话呢，我们通过这个P1呢，我去调了一的方法，这呢，因为是一个方法的重写啊，所以我们在执行的时候呢，实际上调的是这个学生的这个方法。行，这块是没有问题的啊好，那么接下来大家看啊，我把这个方法呢，声明成是静态的，其实这里边儿呢，还隐含了一个知识点，就是说负类中的这个方法，诶我们如果是静态的，那么此类呢，你不能够跟负类定义这个叫同名同参数的，而且你还是非静态的。

就是如果呢，你出现了一个同名同参数的，实际上呢，表达意思就是你想。想重写了是吧，诶但是的话呢，这块呢，诶我们必须保证呢，你这个此类方法呢，如果负类呢，用静态了，你也得是静态的。但是呢，一旦你竞赛以后啊。这个其实也就不叫重写了。对，也不能叫重启了，也就是说什么意思啊，如果呢，子复类当中出现同名同参数的方法了，那么这两个方法要么全是static的。要么全不是static。啊，不是死在这个的时候呢，就要重写是吧？是死在这个时候呢，仅仅叫呢同名而已啊。这个呢也不叫重启了，那么它影响是什么呢？你看这儿啊，我现在话呢，还是一个多态的场景，我调一的方法，注意我这块是拿对象调的。哎，其实这块呢，跟对象有关系吗。对，没有关系是吧，所以这是我们要调的时候呢，这个结果就是成了。

哎，父类里边了。是吧，这个呢，你可能会觉得，诶怎么会这样呢，其实这个事儿呢，也没啥不好理解的，咱们前面呢，还都做过这个事儿呢，不更夸张吗。这个呢叫P2，这能写成no p2点呢，我们去调一的方法。对，你发现了，这时候呢，是不是都不会报控制针是吧。哎，直接掉了，还是我们这个人吃饭，他说说白了啊，他跟你这个对象呢，已经没有关系了，我根本也不看你是谁的对象，我只看我是什么类型，还是由类发起对这个方法的一个调用的。诶，所以这块呢，跟你多不多肽，多肽呢是你对象的事儿，我现在是静态的方法，跟多肽没有关系。所以呢，静态的方法，记住这个结论呢，就是它呢是不存在这种重启的，也不能被覆盖。OK啊，所以呢，我们在静态方法这块呢，是不存在。不太性的是吧。哎，这个大家注意一下啊。这个以及原因，原因的话呢，其实就我们刚才也说了啊，跟你这对象没关系啊。

这样写不就更直接吗？是吧？跟对象没有关系啊。啊，类似的这个问题啊，这个说可以呢，重载一个重载哈，静态方法能重载吗。重载可以，那你愿意写带参数你就写呗。比如说这块呢，我们哎把这个方法呢，CTRLC一下，嗯，翻过来这块的话呢，我们来一个哎，String类型的一个food的比说呢，诶这个喜欢吃。这个呢，你加上一个负的啊，这没问题啊，这个呢，我们还可以理解成这叫重载了。调的时候呢，你看你这个参数是什么不同，然后决定调的是哪一个啊，这没问题啊。说可以覆盖一个静态方法吗？这不就指的是重写吗？不能是吧？过了说，是否可以从一个静态方法内部发出对非静态方法的调用？对，正常来讲呢，静态方法内是不能调非静态方法的，除非。使用对象调是吧。

对啊，我们说呢，呃，只能。所以这块你严密来讲，你也别说能或不能啊，他呢，可能你说不能吧，他说你造对象就能，你要说能吧，他说我调的就报错了，所以你干脆就给他说清楚，是只能呢，是通过哎对象来进行。啊，或者来对这个非。静态方法的调用。这呢是咱们最初的时候呢，为什么在may方法里边，我们想使用一个非静态方法的时候啊，为什么每次说咱们先造对象，然后调方法，就是因为呢没方法是静态的，你想调一些非静态方法呢，得造对象。下边被static修饰的这个成员能否再使用private呢进行修饰？类呀类，这个类肯定是内部类了啊，方法呀，程序变量用private修饰可以不。可以，完全没问题啊。嗯，完全可以，所以呢，这块呢，就体现叫封装性能不能被调，这个呢，体现的是随着类的加载而加载的一些特点啊。

所以呢，没问题，当然这里边儿呢，你注意呢，此在这个修饰的呢，是那个。呃，这些结构啊，有个特别的，不是那个代码块吗。代码块你就别P了啊，这是因为代码块本身呢，不能够用全修饰出来修饰啊，除了代码块之外呢，其他的位置该修饰还可以啊。啊，这个我说一下，除了代码块是吧。好，接着啊，设计模式，说你知道哪些设计模式，咱们目前呢，接触到的很少。所以咱就说了一个叫单利模式，或者叫单子模式，说了一个模板方法的设计模式是吧。哎，方法的设计模式，其实呢，我们还稍微提了一个那个想圆设计模式。在哪儿说的？想园是吧，设计模式。就是咱们讲这个的时候，诶，它里边呢，不是用这个，呃，这个叫I的话呢，它不是复为一，接的话呢，复制为一，这时候的话呢，它不就是用的它内部的那个数组的是吧。

诶，它在负128，哎，在正能127范围内，这不都是它吗？这个呢，就相当于是一种响圆的设计模式，包括呢，我们后边呢，提到这个S串常量池，诶都是这样的一种思路啊。呃，当然这块的话呢，大家其实不用去深究哈，像这块的话呢，这些点，呃，说一下也行，不说也没关系，重点呢，他其实想让你说的是以后我们用到一些高级的设计模式。哎，我们提到框架呢，不是说要用设计模式吗？哎，到时候讲框架的时候呢，我会谈到很多的设计模式啊OK。所以目前的话呢，我们你要说非要讲剑道的啊，也就这仨啊。好，下一个说开发中都用到哪些设计模式，用在什么场合，这个咱们现在呢，其实这个问题呢，是打不了的。OK啊。好，没方法说，能不能从public那改成private，为什么？对对可以改，但是呢，改完以后呢。就不是程序入口了是吧。对，就是一个普通的一个静态方法权限的是私有的而已啊。

它就不能够体现入口这样一个概念了，下一个说，那方法中是否可以调用非静态的方法？跟上面这个一样是吧，诶可以你只能是通过对象来调。啊，这个才行啊，好，下边一个说类的组成和属性赋值的一个执行顺序啊，这咱们前面已经讲过了啊。哎，就是属性复制的先后顺序呢，我们提到了这个代码块的一个作用啊。只不过咱们讲的时候呢，我拿的是实例变量来讲的，那实际的话呢，我们也可能是一个类变量。啊，类变量的时候呢，尽量我们就不考虑那构造器了啊。好，下边说静态代码块，普通代码块构造方法，从类加载开始的一个执行顺序。那这块呢，我们就把这个静态呢，也给他拿过来了，那肯定呢，是不是静态的先。对啊，静态代码块它肯定是比较早的啊，它之后的话呢。代表的就是这个类的加载就结束了啊，诶类的加载结束以后呢，再就是你如果创建对象呢，就对象的事儿了，然后呢，这是你要注意呢，这个普通的代码块，它的一个执行要早于构造器。

所以把构造器呢往后放啊。哎，这样就可以了。前面的话呢，其实我提到过，属于一个拓展知识，我们在看这个资金码文件的时候，它是不是会把这两个结构合在一起，形成一个叫的方法。其实还有一个就是关于变量的显示赋值也会放到in里边是吧。对的啊，那其实这个哥们儿呢，他也会以一个方法的形式呢呈现。啊，这个其实就就纯是一个拓展啊，我这样一说你也一听就完事了。你看我写一个啊。哎，这个呢，我们称为呢，叫block的一个测试。好，这个类里边呢，我就直接写了啊，比如说这块呢，你看我写这个代码块，这个我写一个输出语句叫hello。就它了哈，好，然后呢，呃，现在的话呢，哎，我我再写一个构造器吧。哎，这是一个构造器，然后我再来一个。

诶，我就随意的这样一写了啊好，这是两个构造器，然后此时的话呢，你看我这做一个编译啊。编译完以后的话呢，我们这时候再去看这个最起码文件方法这块呢，是不是就有俩。诶，这两个呢，分别对应的就是这两个算是叫构造器了哈，但是这个构造器里边呢，第一个里边哈，它其实不光有这个东西，它还有我们刚才上面这个代码块哈。所以这块你看哈，也在这里啊，然后呢，这个呢，你要用这个构造器造对象的时候呢，诶它这里边呢，是不是也有我们相应的这个哈，在这儿呢，是吧。诶是类似的啊，然后呢，接着我这块呢，如果要是声明一个叫做static的一个静态代码块。啊，这些个ABC吧。我们重新再再做一个编译。这个ABC怎么去呈现呢？哎，它呢不会呈现在我们这个的方法里了，因为这是跟你造对象相关的啊。诶刷新一下，你看多了一个。看这个。叫C是吧。

是不能看清。这个CR的话呢，你可以把它呢，就理解成是class。啊，这就关于这个类初始化的信息吗。那类初始化信息是不是就静态代码块了？哎，所以这里边儿呢，他放的代码呢，其实就是我们这个ABC的信息啊，他不会放这个信息。行，我这一说你一听就完了，你说没听懂，没听懂就当我没说就行。啊，这个呢，不用去研究塔啊，因为我们也还不涉及这个更深层次的，你想研究GM了，这个GM的时候呢，这个你得知道它的运行机制，然后呢，你才能够去调优，那运行机制呢，这块呢，它的出发点呢，就是自解码文件，所以呢得从自解码文件开始去揪，但是咱们现在不是还没有讲这个东西嘛，是吧。好，下边描述一下对final的理解，对了啊。修饰和变量时呢？是引用不能改变引用指向的对象是否可以改变？他这个说的都不明确是吧。

还是小米的啊。呃，引用它确实不能变，对吧。哎，引用。不能改变。N改变啊。他这块呢，后一边呢，后边这个呢，其实想说的点呢，是引用的这个对象呢，里边的一些属性能不能改变。可以改是吧。啊，引用指向的。哎，这个对象实体中的这个属性。啊，这个如果没有使用final修饰。啊则可以改变。啊，这个是没问题的，OK。好，下一个说final呢，不能用于修饰构造器。是的。也没问为什么是吧。对修饰构造器的话没有意义是吧。啊，不能变了，那构造器不能变是啥意思呢？方法呢，你要是不能变，说不能重写，构造器本身也不能重写是吧。

对，没有意义啊。好，下一个用the final static final修饰的成员面料啊，能不能进行加加的操作？都final了就不能了是吧，能不能进行加一的操作呢？那个可以啊，因为你这个变量本身没变是吧，加加呢就变了啊。什么是抽象类？如何识别一个抽象类？这，这有点太low了吧，是吧？哎，就是使用abstract修饰的，这就是一个抽象类了哈。哎，如何识别，那就看有没有这个修饰呗。嗯，说为什么不能用它去修饰这些结构，咱们已经讲过了。哎，上课那时候我特意说过这个事儿啊。啊，这个呢，忘了，你可以稍微的翻一下我们这个笔记这里边啊，说白了就是为了我们这个语言的自洽是吧。就是你不能这个语言呢，设计完了以后呢，相互之间又矛盾的点啊，比如说修饰一个方法，这个方法呢，我们通常得让他去重写了，结果呢，你来了一个final，修饰final还不让重写，那麻烦了嘛，矛盾了是吧，所以为了自洽，所以编译器呢，一旦发现你要是共用了这块呢，他就给你报错。

不让你编译通过啊好，它俩的区别。啊，很多地方看都考。略了是吧，哎，我在课件里边有那个表格记一下。看一眼啊。是不是在我们最后这儿。这不有个表格，这个表格的话你再补一个啊，你说呢JDK8啊当中接口呢，可以去定义啊，在这我也写了是吧，新特性JK94个方法，这个会显得稍微的有点新意了啊。像这种题的话就是，嗯，这个对方要考的话呢，我们其实心里边可以比试一下，因为太low了是吧，当然这块呢，你答的时候呢，你也得答的差不多啊，你要答的稀碎的话呢，这就是人家就会觉得你太low了是吧。好接口是否可以继承接口？那必须可以是抽象类，是否可实现接口？想想。

可以吗？可以吧？你看说这个也没讲过呀，哎，那我问一个类。实现一个接口，这个接口里边有俩抽样方法，结果他就重写了一个，那个没重写。那你这类不就得是个抽象类吗？那抽样类能实现接口吗？那不就可以吗？是吧，诶是的啊，好，抽象类是否可以继承实现类。这个实践类呢，就是非抽象的类。那你没有写负类不就是object object不就是非抽象的？是吧，诶所以呢，就是诶灵活一些啊。接口可以有自己的属性吗？可以必须呢是。哎，对，Public static。啊。说访问接口的默认方法如何使用？默认方法啊。访问接口的默认方法。

对这块你得用它对应的这个实现类的这个对象去访问了是吧。来使用实现类的这个对象。啊，进行一个调用啊，而且呢，这个我们说呢，这个时间类呢，还可以去重写这个此默认方法是吧。哎，这个是可以的啊。好，下边内部类有几种，呃，这个咱讲了就是成员内部类，局部内部类是吧？呃，具体的我就列了啊说内部类呢，它的特点说一下，这个呢，你可以重点的去说一下我们讲到的这个关于类的这个理解。啊，就是这块来说一下这个特点呢，其实就可以了啊说匿名说一下。一名类。匿名类的话呢，它其实呢，主要想让我们说的呢，就是我们前面提到这个局部类，部类使用的时候的那个匿名的场景。哎，就又想咱们那个USB的那个时候。是吧，还有呢，我们这块列的这个代码的这个时候，哎就可以了哈，行这块说的话呢，其实就是可以提一提我们什么时候会用，就是有的时候呢，我们就不想显示的去造一个这个实现类了，就想临时呢，我们这块造一个用就得了，哎这个我们就这样去做，以后的话呢，我们会讲拉姆达表达式。

啊，拉曼表达式呢，其实呢，也都可以理解成这种匿名的这种方式了啊。所以这块呢，我就哎对了啊，说枚举呢，可以继承吗。啊，这个呢，如果你是使用咱们这个innu或者叫I来进行定义的啊，其父类呢，就是。这个累是吧，就不要呢再去写其他的继承关系了。就不要在。嗯，继承其他的A了。啊，如果你要写那就报错了啊，你要自定义的话，不如用这个in了，就自己写了个class，那你愿意咋继承就咋继承是吧。诶，它们之间的一个区别啊，这是基本数据类型，这是包装类啊，这是一个类了是吧，那这个区别呢，很显然呢，这个呢，我们就可以造对象调方法，这个没有是吧。哎，谈谈你对面向对象的理解？这个题目的话呢，其实咱们可以说上。哎，二三十分钟都没问题是吧。

诶，这个呢是很大的哈，诶我这呢只抛一个方向啊，诶谈谈你对面向对象的理解，首先呢，这块你先要提到这个类和对象的这个概念，哎，它呢作为我们整个面向对象的两个要素啊。是吧？诶类和对象，哎，这你可以简单说一下，类啊是抽象的啊概念上的定义，对象呢是类啊，实打实的创建出来这个对象实体啊，是具体的一个一个存在的个体，是吧？诶我们Java当中啊接着呢，这块提到叫面向对象编程。啊，那也就意味着我们在完成具体功能的时候呢，通常都是由对象的出发啊，对类中声明的方法进行的调用，这时候呢，还体现了一个叫法，我们叫万事万物皆对象。哎，这个话呢，你一说基本上你就准备好，对方呢，可能要问你怎么理解，万事万物皆对象。

前提呢是对方呢也愿意想跟你聊的情况下是吧。啊，那这个时候呢，是不是就要引这个事儿了啊，这个事儿的话呢，咱们说了啊，暂且呢，咱们还说不透啊，随着后续咱们的讲解，包括下一章咱们上来就讲异常处理，在Java中，你说我这个程序挂了，出问题了，这就出了一个异常，那么这异常的话呢，也会以类的对象的方式呈现。你像我们前面讲数组的时候呢，是呢，你出了一个控制帧异常，哎，这块你看CTRLN异下，控制帧异常呢，叫now po exception。哎，Exception就它呗，这是不是就是个类啊。哎，你出了明明是个异常，咱们这块呢成了一个。累了呢是吧，诶就是在Java当中，我们这个异常呢，也是以类的对象的方式去呈现的，这个呢，就是其中的一个举例嘛。啊，也就是在Java当中，我们各种各样的这种行为啊操作啊，都是封装为对象的概念，就叫万事万物皆对象啊，你可以给大家去举例子，诶这呢就是一条线，第二条线的话呢，就是面向对象的。

三大特征。诶这三大层征呢，咱们在复议的时候呢，我都具体说了，你该怎么去讲是吧？诶这个事儿就过了啊，然后呢，诶再者呢，可以做相关的一个补充，补充这块呢，你可以把这个接口的概念呢去起一下是吧？呃，因为呢，我们前面提到面向对象，似乎呢都在讲类核对象，其实呢，接口也是我们非常重要的一个结构，而且呢，接口在使用的时候也会体现这个多肽的特征。它呢，作为我们呃，语类并列的一个结构的一个补充内容啊。诶作为一个补充，这个补充的话呢，还可以从另外一个角度去理解，就是咱们前面讲这个类的继承关系的时候呢，叫单机整性，而这里边呢，我们提到了这个类呢，诶可以实现多个接口是吧，实现功能的一个扩展。啊，弥补这个单集成的这种局限性，哎，把这个呢，我们再提一下，而且你可以再提一下接口呢，在八当中还可以有默认方法和静态方法，还可以有方法起。是吧，其实呢，这个类呢，大家现在接口呢，大家现在来看是不是长得越来越像类了。

啊，都有方法体的都是吧，哎，然后呢，这个类的话呢，它也可以有抽象方法，是不是有抽象类嘛，大家呢，都在向彼此靠拢。啊，OK。哎，就是从这个角度上去说就行了啊，这个细节呢，咱们前面都讲过，就不在这儿具体展开了说面向对象的特征呢，有哪些方面啊，就是这仨吗？然后你把这三个呢，再展开去说一下就行，OK啊，面向对象的核心是什么啊，其实呢，你可以第一个和结合着第二个这样去说就行啊。好，整个的关于面向对象，诶我们就告一段落了，诶宏观上来看的话呢，整个呢，我们涉及到这样三个章节，细节呢很多，呃，需要了解的呢不算多，重点内容很多。诶大家呢，如果说觉得诶觉得还差点意思，也不用太过于担心，因为咱们后边这块呢，都是一些具体的应用了，在这个应用的过程当中啊，都体现了面向对象的这些思想，哪一块儿呢，你觉得我学的差点意思没关系，后边这块我们通过复习，通过不断的使用呢，大家呢，诶自然而然的就会捡起前面一些重点内容。

不断的用啊，其实自然而然的这个理解呢，你也就上去了。OK，咱们就先到这儿。