上海传智播客JAVASE_day08学习笔记

《第八天总结》 张伦琦
《静态、单例、继承》
1.    静态变量    
    1.1成员变量和内存示例
        成员变量，因为都在成员中，是对象的成员。

        成员变量，随对象创建在堆中，多份（每生成一个成员就生成一份）。

    1.2静态变量和内存示例    
        静态变量在变量的类型前，用关键字static声明。

        静态变量是类的变量，随类的生成而生成在方法区的静态区中，一个类生成一个，与对象的多少无关。

    1.3成员变和静态变量的区别（局部变量和成员变量的区别）
        静态变量和成员变量的区别？
        区别一：生命周期不同。
            静态变量随着类的加载而加载，随着类的消失而消失。
            成员变量随着对象的创建而创建，随着对象的消失而消失。
        区别二：存储空间不同。
            静态变量存储在静态区。
            成员变量存储在对象所在的堆内存。
        区别三：创建个数不同。
            静态变量只有一份，被所有该类的对象共享。一改全改。
            成员变量有很多分，每个对象都独享自己的成员变量。改动相互不影响。
        区别四：所属元素不同。
            静态变量属于定义它的类，又叫类变量。
            成员变量属于它所在的对象，又叫实例变量。
        区别五：访问方式不同。
            静态变量有两种访问形式 classname.xxx(Student.country)和objectname.xxx(stu.country)
            成员变量有一种访问形式 objectname.xxx(stu.name)。。。。objectname（对象）
         成员变量和局部变量的区别?
        区别一：定义位置不同。
            成员变量定义在类中和对象相关。
            局部变量定义在方法中以及语句里，和方法相关。
        区别二：存储位置不同。
            成员变量存储在堆内存的对象中。
            局部变量存储在栈内存的方法中。
        区别三：存生命周期不同。
            成员变量随着对象的创建而创建，随着对象的消失而消失。
            局部变量随着的方法的进栈而创建，随着方法的弹栈而消失。
        区别四：作用范围不同。
            成员变量因为定义在类中，所以在类的{}内都有效。
            局部变量因为定义在方法或代码块中，所以只在方法或代码块的{}内有效。
        区别五：初始化不同。
            成员变量因为在堆内存中，所以有默认初始化值。
            局部变量因为在栈内存中，所以没有默认初始值，必须初始化后才可以使用。
    

2.    静态方法    
    2.1成员方法和静态方法    
        静态方法只能访问静态方法和静态变量，不能访问成员方法和成员变量，因为这个时候成员方法还没有生成呢
        成员方法既能访问静态变量和静态方法，又能访问成员方法和成员变量
        因为：
            静态方法，随着类的加载而加载，随着类的消失而消失。
            静态方法加载进内存的时候堆中的对象可能还不存在，
            因此不能访问和对象相关的成员变量和成员方法。
            成员方法是和对象相关的，对象的创建要比静态方法晚，

            成员方法访问已经存在的静态方法是没有问题的。

    2.2静态方法main方法
            public static void main(String[] args)
            public:访问修饰符，为了jvm到处都能找到入口，所有给main最大的权限
            static：jvm启动的时候还没有对象，那它咋执行代码捏？只好将方法声明为static，
                为了不用对象通过类名来调用。
            void：无返回值。异常处理（暂时没学）可以帮我们解决程序执行正确与否的问题，不需要返回值来判断。
            main：历史传统都叫main
            String[]：字符串数组，要求调用main方法时候输入信息。以前为了用键盘输入信息而设计，现在不用。

            args：arguments的简写。

    
    2.3静态方法应用—数组工具类    
            工具类，静态方法可以制作工具类，不需要工具类对象而直接使用工具类的功能。
            例子:
            class ArraysTool {
               //遍历数组
               public static  void  printArray(int [] arr){
                   for (int i=0;i<arr.length ;i++ ){
                       System.out.println(arr[i]);
                   }
               }
               //得到最大值
               public static int  getMax(int [] arr){
                   int max=arr[0];
                   for (int i=1;i<arr.length ;i++ ){
                     if (arr[i]>max){
                         max=arr[i];
                     }
                   }
                   return max;
               }
               //得到最小值
               public static int  getMin(int [] arr){
                   int min=arr[0];
                   for (int i=1;i<arr.length ;i++ ){
                     if (arr[i]<min){
                         min=arr[i];
                     }
                   }
                   return min;
               }
            }

3.    静态代码块    
    3.1静态代码块
        静态代码块,和类相关，类加载的时候执行一次，工具类使用时需要条件，怎么满足呢？在静态代码块中处理。
        作用
           1.加载类的时候处理一些条件。
           2.给静态变量初始化值。
    
            静态代码块在类加载的时候执行一次，多用于给类初始化。
          1.静态代码块，就是在类中用static关键字修饰的代码块！
          2.它在类加载的时候，只执行一次，并不是每次构建对象都执行的。
          3.它可以用于给初始静态变量，和做一些类加载时期的准备工作
          4.类加载->静态变量初始化->静态代码块->构造方法
          5.静态代码块和静态变量，静态方法一样是和类相关的，不能直接访问成员变量和成员方法，
            为此时可能对象还不存在。
        例子：
        static{
            country="中国";
            System.out.println("static block is run");
        }

    3.2构造代码块    
        构造代码块，和对象相关，每次创建对象都要执行。
        作用
           1.创建对象的时候可以处理一些条件
           2.给成员变量初始化值

        构造代码块
        构造代码块随着对象的创建而执行，多用于给对象初始化。
        1.构造代码块就是类中的一段独立的代码执行体，在每次构造对象的时候都会被执行。
        2.它可以用于给成员变量初始，和执行一些创建对象前的准备工作。
        3.它的地位和成员变量、成员方法类似，属于对象相关的东西。
        4.成员变量初始-->构造代码块->构造方法
        例子：
        {
            name="张三丰";
            System.out.println("construct block is run");
        }
    3.3局部代码块
         局部代码块，和方法相关
         作用：
           1.组织方法中一个功能
           2.控制局部变量的作用范围，生命周期
         例子：
        {
         int i=1;
         while(i<=10){
          System.out.println(i);
          i++;
         }
        }

4.    对象的创建过程    
        (如果有父类就先处理父类)类加载-->静态变量初始化-->静态代码块-->静态方法-->成员变量的初始化-->构造代码块-->构造方法

        对象的创建顺序。
         1.Person.class文件被加载进内存（如果有父类，将其父类的.class文件加载进内存）
         2.静态变量默认初始化
         3.静态变量显示初始化
         4.静态代码块执行
         5.成员变量默认初始化
         6.成员变量显示初始化
         7.构造代码块执行
         8.构造方法初始化。
         9.对象创建完毕。
        
         注意：
         静态元素是和类相关的，只有在第一次使用该类的时候执行一次，并且只执行一次。
         成员元素是和对象相关的，在每次创建对象的时候都要执行一次，可能执行很多次。

        构造方法和构造代码块
        1.构造方法是初始化特定对象的特定方式(new Person("张三",18))
        2.构造代码块是初始化所有对象的共同方式（new Person("张三",18) new Person()）
        3.特定的初始化方式写到构造方法中，共同的初始化方式写到构造代码块中。

5.    单例模式    
    5.1单例模式的引入
        设计模式：
        模式：练武套路。少林拳，铁砂掌。太极拳。
        建筑学：窗口朝南，通风，宽敞明亮。豪华装修
        软件工程学，也有一些解决问题的特定套路。设计的时候就应该考虑。
        设计模式：23种经典设计模式，不局限与23种。
        单例设计模式：要求一个只可以创建一个对象的类

    5.2单例模式的代码体现（饿汉式）    
        //饿汉式（开发）。不会有多线程问题。
        class Student{
          private static  Student stu=new Student();//类加载的时候初始化一次，创建一个对象
          private Student(){
              //外面不能new对象
          }
          public static Student getInstance(){
              //可以得到这个唯一的对象
             return  stu;
          }
        }
        
    5.3单例模式的代码体现（懒汉式）

        思想：
           问题：如果类外面能new Student()那将无法控制对象的个数。咋办？
           答案：将学生类的构造方法私有化。
           问题：一个对象都无法在类外面创建了。咋办？
           答案：在类内new 对象。对象有叫实例 instance
           问题：类和对象对无法访问 getInstance()，咋办？
           答案：将getInstance()声明为static
           问题：我多次调用getInstance()方法依然可以创建多个对象。咋办？
           答案：将学生对象搞成静态。
           问题：搞成静态依然没控制住。原因,对象不为空你依然new对象造成的。
           答案：判定一下，对象为空就new对象，不为空就不new对象。
           问题：数据对外暴露不安全，
           答案：对数据private
        单线程有效，多线程无效。
        懒汉式（面试）
        class Student{
          private static /*final*/ Student stu;
          private Student(){
          }
          public static Student getInstance(){
        // 此时线程1要new没new被叫停  线程2杀过来，创建一个对象，线程1醒来以后直接创建对象，导致对象不唯一。
              if (stu==null){
                 stu=new Student();;
              }
             return  stu;
          }
        }



6.    继承    
    6.1继承概述
        一、继承定义：
           继承就是子类从父类当中继承下来成员变量和成员方法。
           如果有重名的成员变量和成员方法，将保留两份，
           使用时，按先己后父原则查找。
        二、什么时候能继承？
           1.子类是父类的一种特殊类型的时候可以继承。
             比如：苹果是一种水果 ，梨子是一种水果，苹果和梨子都可以继承水果。
               学生是一种人，司机是一种人，学生和司机都可以继承人。
           2.apple is a kind of fruit. 子类和父类存在is a关系。
              父类更加通用，子类更加具体。 子类和父类是一种更加具体的关系。
           3.父类中存放，从多个子类中抽取出来的共同的属性和方法，子类中可以存储，
            和子类自己相关的特有的属性和方法。并不是所有的动物都和狗一样能看家。
             子类和父类，子类是一种个性的体现，父类是一种共性的体现。
        三、Java中的继承体系（单继承）
           1.一个父类可以有多个直接子类。Animal有Cat和Dog两个子类。
           2.一个子类有且只有一个直接父类。
           3.所有类的父类是Object类。
           4.单根（一个object根类）、多层(注意不要循环继承)、一颗树
        四、Java为啥不能多继承（为啥不能有多个父类）
           会出现菱形问题，不知道用哪个方法。

    6.2继承中子父类的同名变量
        /*
        继承中的特殊
        */
        class Fu{
            int i=2;
        }
        class Zi extends Fu{
            int i=3;
            public void show(){
                System.out.println(i);
            }
        }
        class  BianliangDemo
        {
            public static void main(String[] args)
            {
                //Zi zi=new Zi();
                //zi.show();
                Zi zi=new Zi();
                zi.i=5;
                zi.show();
            }
        }

    6.3子父类中同名方法
        先己后父，皆无报错！