修饰符的相关问题、单例模式、接口

1.权限修饰符：

从大到小：

public（公共的）,protected（受保护的）,默认不写,private（私有的）;

2.特征修饰符：

final（最终的，不可改变的）,static（静态的）,abstract（抽象的）,native（静态的，本地的）,*transient（短暂的，瞬时的）--->对象的序列化，临时存储,*synchronized（同步的）,*volatile（不稳定的）;（synchronized和volatile是保护属性和方法的线程安全的）

native在hashCode里用过(调用本地其他语言)：

public native hashCode();

---

1.权限修饰符：

从两个角度：修饰什么？范围如何？

(1).修饰什么：

权限修饰符可以用来修饰：类和类中的成员（除了块）；

修饰类的时候只可以用public和默认不写，如果用public可以强制要求类名和文件名一致，否则无法编译，文件中只有一个类可以被用public修饰；

(2).范围如何：

本类中，四种都可以访问；

在同包中，除了private，其他三种都可以访问（同包是指在同一个package里，package里面的package里面的文件和外部文件不算同包；即同包的首行package后面的名字相同）；

在子类范围里中，可以通过子类对象访问protected、public（如果在其他类里面new一个子类对象，是无法访问的）；如果是通过父类对象，那么只可以访问public；

public在当前项目中任意类的位置只要有对象都可以访问；

public;

protected;

默认不写;

private;

---

面向对象的三个特征：继承、封装、多态、（抽象）；

封装：

1.将一些数据/执行过程包装起来，保护这些数据/执行过程；

2.方法本身就是封装，封装了执行的过程，保护了过程的安全，隐藏了执行的过程，增强复用性；

将方法和属性放到类里--->类也是一种封装；

属性私有--->将属性封装在类里，提供操作属性的方式--->公有的方法；

3.属性最好不要共有，方法看情况；

4.因为一般属性都是private，那么操作属性的方式--->有命名规约：例--->设置属性：setAge，获取属性：getAge;

---

2.特征修饰符：

(1).修饰什么；(2).修饰了以后有什么特点；

final：

1.可以修饰变量、属性、方法、类本身；

2.用final修饰变量时：如果在定义变量时没有赋初始值，那么会给变量一次存值的机会，变量是没有默认值的（如果是引用类型那就需要new），如果不给机会，就没法使用，一旦被存储值后，就不可以再改变；如果在定义引用数据类型变量时，可以更改变量的各个数，但是不可以给这个变量一个新的地址；如果在定义基本数据类型/String类型变量时，里面的值是不可以改的；

3.用final修饰属性时：属性是一种全局变量，储存在对内存的对象空间内的一个空间，属性如果没有赋值是有默认值的；所以属性用final修饰的时候需要赋初始值，否则报错，因为会直接等于默认值，之后不可修改，和我们的初衷相违背，如果在定义引用数据类型变量时，可以更改变量的各个数，但是不可以给这个变量一个新的地址；如果在定义基本数据类型/String类型变量时，里面的值是不可以改的；

4.用final修饰方法时：方法不可以更改，方法重载不是修改方法，因为参数不一样，不是一个方法；但是继承关系里方法重写（覆盖），算是修改方法，所以final修饰的方法不允许子类重写；

5.用final修饰类本身时：此类不可以被其他子类继承，通常是一些被定义好的工具类（Math，Scanner，Integer等）；

*static（类加载机制）：

1.可以修饰属性、方法、块、（内部）类、（不可以修饰变量）；

2.特点：

(1.)静态元素在类加载的时候就初始化了，创建的非常早（此时没有创建对象）；

(2).静态元素存在静态元素区，每个类都有一个自己的区域，和其它类不冲突，

(3).静态元素只加载一次（只有一份），全部的类对象及类都可以共享；     

(4).由于静态元素区加载的时候，有可能没有创建对象，可以通过类名字直接访问（一般不需要new一个对象，如果需要new那么不同的对象会覆盖里面的值，最好不这样）；

(5).可以看作静态元素是不属于任何对象的，是属于类的； 

(6).内存管理：栈内存创建开始用完即回收，堆内存由GC（Garbage Collection）回收，但是静态元素区GC无法管理，可以认为是常驻内存；

(7).非静态成员（堆内存对象里）中可以访问静态成员（静态区）；

(8).静态成员中可以访问静态成员（都在静态区）；

(9).静态成员不可以访问非静态成员（堆内存里面可能不止一份，不知道要找哪一个；非静态成员属于对象，静态成员属于类）；

(10).静态元素中不可以出现this或者super关键字（静态元素属于类，没有对象）；

*(11).存在继承关系的类的加载机制及执行过程：

加载父类；
加载父类自己的静态空间；
先执行父类静态块中的代码；
加载子类；
加载子类自己的静态空间；
执行子类的静态块；
开辟父类对象空间，开辟子类对象空间（父在子类里面）；
加载父类的非静态成员 属性、方法、块、构造方法；
执行块、构造方法；
加载子类的非静态成员 属性、方法、块、构造方法；
执行块、构造方法；
将对象空间的地址引用交给变量来储存；

native：

1.Java源代码中看到native就表示再也看不到后续代码了；

2.后续会调用其他编程语言（C++/C等）执行内存的操作--->帮我们操作（如hashCoad）；

*abstract：

1.可以修饰类和方法；

2.用abstract修饰符修饰的方法，只有方法的结构没有方法体，叫做抽象方法，注意：用native修饰的方法虽然没有方法体但不是抽象方法，只是执行的过程是其它语言写的，看不见；

public abstract void eat（）；

3.用abstract修饰符修饰的类叫做抽象类--->通常用来描述事物，还不是很具体，目前来看抽象方法，需要放进抽象类/接口中；抽象类中不一定要有抽象方法；普通类不允许有抽象方法；

4.抽象类--->特点？

(1).抽象类中的可以有一般的属性；（final，private，static都可以）

(2).抽象类中的可以有一般的方法；（final，private，static都可以，注意：抽象类中允许含有抽象方法）

(3).抽象类中的可以有一般的代码块；（static也可以）

(4).抽象类中的可以有一般的构造方法；（包括重载）

(5).抽象类含有构造方法，但是不能通过调用构造方法直接创建对象；--->所以抽象类只能给子类用；

(6).抽象类-----直接单继承-----抽象类：可以；抽象类-----直接单继承-----具体类：可以，但一般不这样；具体类-----不可以直接单继承------抽象类：需要将父类的抽象方法方法重写--->具体化，或者子类也变成抽象类；--->更加灵活

*(7).抽象类里面可以都是具体方法--->可以；

抽象类里面都是抽象方法--->可以--->抽象到极致--->质变--->这样就不再叫做抽象类了，而是叫做接口--->还是一个类的结构--->不能用class来修饰，改用interface来修饰；

---

接口--->一般只用来定义规则/功能，不描述具体过程/内容--->具体的交给普通类--->继承抽象类、实现接口：

1.接口也是一个类的结构，只不过是用interface来修饰，而不用原来的class；

2.接口里面有：属性、方法；接口里面没有代码块（无论是否是static），因为代码块就是一个具体的，所以不能出现在接口里；接口里面没有构造方法（任何）--->区别抽象类，因为接口里面的属性是存放在常量区的，不需要创建对象，并且其方法只有名字不做事，而这个名字在类模板中也有，所以也不需要创建对象--->不需要构造方法；

3.接口里的属性不能是一般的属性，需要是公有的（public）静态的（static）常量（final）属性，可以不写这三个修饰符，默认是这样的；

*接口中不能含有一般的方法，只能有公有的（public）、抽象的（abstract）方法，abstract修饰符可以省略，但是1.8以后可以用defaul来修饰一个具体方法；

public interface TestInterface{
    
   //用default修饰一个具体方法，不加public和abstract；
     
    default void eat(){}

}

4.接口是无法创建对象的，只能通过子类实现来做事--->多实现（implements）；

public class A implements B,C,D{

//implements 就是多实现的意思，A多实现B,C,D；

}

5.接口和别的类的结构关系：

抽象类-----直接多实现-----接口；

具体类-----不可以直接多实现，需要将所有抽象方法重写（override）或者改成抽象类-----接口；

接口不可以继承别的类；

*接口-----直接多继承-----接口--->可以通过直接多实现；

---

设计模式：

1.设计模式23种，单例模式Singleton；

2.设计模式是一种设计经验的总结，是一种思想；

3.设计模式用来解决某些场景下的一类问题--->通用的解决方案；

4.设计模式可以提高复用性、可靠性、可拓展性；

设计模式分为三类：

1.创建型模式（5种）--->用来解决对象创建的过程；

单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式；

2.结构型模式（7种）--->把类或对象通过某种形式结合在一起，构成某种复杂或合理的结构；

适配器模式、装饰者模式、代理模式、外观模式、桥接模式、组合模式、享元模式；

3.行为型模式（11种）--->用来解决类或对象之间的交互，更合理的优化类或对象之间的关系；

观察者模式、策略模式、模板模式、责任链模式、解析器模式、迭代子模式、命令模式、状态模式、备忘录模式、访问者模式、中介者模式；

单例模式（Singleton）：

设计让一个类只创建一个对象，有效减少内存空间；

饿汉式（立即加载，对象在启动时就加载）、懒汉式（延迟加载，对象用到的时候才加载）、生命周期托管（单例对象让别人帮我们处理，对象加载过程交给别人），都是指的对象的加载时间；

饿汉式：不会产生对象没有就拿来用的问题--->空指针异常；但是启动项目加载的对象过多，有时候还没有使用，服务器承载压力太大；

如图这是饿汉式，还没到需要new对象的时候（也就是调用方法的时候）就已经创建好了；

*懒汉式（使用较多）：可能会由于没操作好，导致异常（严谨）；好处是启动项目时只有需要的才加载，不需要的还没创建，不会浪费空间；

由图可见，懒汉型就是在我需要使用对象的时候（调用方法）才去加载；为了防止一直调用方法会出现多次创建，需要加一个判断--->只有时null（也就是还没有创建的时候）才可以创建一个对象，不然就不可以继续创建；