Day14 Object、 类关系

1. 面向对象

1.1 内部类

1.1.1 概述

内部类：类体中还有一个类的声明

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，这个内部的完整结构，一般只是为了让外部类使用

而内部类还有一个作用是   可以访问外部类中的私有化属性

1.1.2 分类

 分类：
                     成员变量--> 成员内部类/普通内部类
                     静态变量--> 静态内部类
                     局部变量--> 局部内部类
                     形参/实参--> 匿名内部类

1.1.3 成员内部类

 成员内部类可以等同看做成员变量，类体中不需要使用static修饰
     
      可以使用权限控制修饰符
      
      成员内部类不能有静态声明 
      
      成员内部类中  可以直接访问外部类的所有属性
      
      内部类的类名：外部类$内部类 _01_OuterClass

 

 1.1.4 静态内部类

 

 1.1.5 局部内部类

 局部内部类等同于局部变量
  
  局部内部类，不能有静态声明
  局部内部类  不能使用static修饰符， 也不能使用权限控制修饰符
  如果外部方法是静态方法，则局部内部类不能直接访问外部类的成员属性
  如果外部方法 是成员方法 ， 则局部内部类中中可以直接访问外部类的所有属性
  
  局部内部类中如果要使用外部方法中的局部变量，则该变量必须使用final
  修饰（1.8开始，final可以省略）

1.1.6 匿名内部类

匿名内部类：在方法调用的时候，需要传入一个类的对象，这个时候可以直接传入一个匿名内部类
  
  一般该对象，是接口的实现类对象，匿名内部类，等于是子类，可以使用super等关键字
 
  语法：方法（new 父类/接口（）{类体}）；
  
  匿名内部类，会自动创建一个对象传入
  
  好处 少定义一个类，缺点  无法重复使用
  

1.2 设计模式

1.2.1 概述

1.2.2 单例模式

1.2.2.1 概述

设计模式：就是在编码实践中，人们发现很多的编码方式会经常用到
                  于是就总结出来，形成了固定的结构，就是设计模式
  
 单例模式：
              实例化多次，得到同一个对象，让某个类只能被实例化一次
  
  实现步骤：
              现在需要控制创建对象的数量，只有一个，所以就不能让用户决定
              创建或者不创建
                         1 不能让用户创建对象
                                   创建对象需要调用构造方法，如果不让用户创建对象，也就意味着不能让用户访问构造方法
                                   所以构造方法 需要私有化
                         2 我们创建一个给他，并且只创建一次即可
                                    上面已经把构造方法私有化了，就意味着用户创建不了对象了
                                    那么这个时候，我们必须提供一个让用户能够获取对象的一个方法
                                    既然是用于获取对象的方法，那么这个方法一定是静态方法
                                                    如果是成员方法的话， 调用该方法需要用到对象，而对象需要调用这个方法，相互矛盾
                         3 储存对象的变量
                                                   变量不储存，不能重复使用，所以为了保证对象只有一个，我们肯定是创建了对象之后，进行重复使用
                                                          局部变量:  具有临时性，方法执行后就不存在了，下一次调用该方法时，变量重新初始化
                                                          成员变量：静态方法中不能操作成员变量
                                                          静态变量：和类相关，和类生命周期一致
                                                   所以应该创建一个用来保存当前类对象的静态变量     
   
                总结：               
                                         1 构造方法私有化
                                         2 提供一个私有的静态的用来保存当前类对象的静态变量
                                         3 提供一个公共的静态方法，用来获取该对象
      
  根据创建对象的时机不同，分为两种
                   1 懒汉模式
                                      用到的时候在创建对象，也就是对以此获取的时候、
                   2 饿汉模式
                                      类加载的时候，就立刻创建对象   
                                      
   懒汉模式和饿汉模式的区别：
                   1 内存角度
                                       懒汉模式要好一些，用到的时候再创建使用，一般叫做懒加载/迟加载
                                       饿汉模式浪费内存，还用不到呢，对象就已经先创建了
                   2 线程安全角度
                                       饿汉模式是在类加载阶段就初始化的，所以在多线程环境下没有问题，因为类在生命周期中只会下载一次
                                       懒汉模式在多线程并发性的情况下，就不行了，可能创建多个对象，但是可以通过双重校验加锁解决
                   所以 一般我们使用懒汉模式居多，尽管在多线程下，也是用懒汉模式，使用双重校验枷锁解决并发问题即可      

 1.2.2.2 懒汉模式

1.2.2.3 饿汉模式 

 

1.2.3 工厂模式

1.2.3.1 概述