day06

修饰符  
一、static 
  修饰属性，方法，代码块 

1、静态属性：全类公有，称为类变量 
             那么这个属性就可以用  类名.属性名  来访问 
             （共有的类变量与对象无关，只和类有关） 
   类加载：虚拟机通过I/O流把一个类的信息从字节码文件中读入虚拟机并保存起来  
           一个类只会加载一次 
   类变量，会在加载时自动初始化，初始化规则和实例变量相同。 
   注意：类中的实例变量是在创建对象时被初始化的，被static修饰的属性，也就是类变量，是在类加载时被创建并进行初始化，类加载的过程是进行一次。也就是类变量只会被创建一次。 
   
2、静态方法： 
   使这个方法成为整个类所公有的方法，可以用   类名.方法名  直接访问   
   
   注意：static修饰的方法，不能直接访问（可以通过组合方式访问）本类中的非静态(static)成员（包括方法和属性） 
         本类的非静态（static）方法可以访问本类的静态成员（包括方法和属性），可以调用静态方法。 
         静态方法要慎重使用。在静态方法中不能出现this关键字，因为这是针对对象而言的。 
         
   java中的main方法必须写成static的，因为，在类加载时无法创建对象，静态方法可以不通过对象调用。 
   所以在类加载时就可以通过main方法入口来运行程序。         
   
   注意：父类中是静态方法，子类中不能覆盖为非静态方法。 
         在符合覆盖规则的前提下，在父子类中，父类中的静态方法可以被子类中的静态方法覆盖，但是没有多态。 
         使用引用调静态方法，相当于使用引用的类型去调用静态方法。（在使用对象调用静态方法是其实是调用编译时类型的静态方法） 
         
3、初始代码块 
   在定义属性的位置上，在任何方法之外，定义一个代码块  
   动态初始代码块：在初始化属性之前调用初始化代码块  {……} 
   静态初始代码块：在类加载时运行    static{……}  只被运行一次，往往用作一个类的准备工作 
   
二、一个类在什么时候被加载？时机  （延迟加载，能不加载就不加载） 
（1）new 一个对象的时候，加载 
（2）没有创建对象，访问类中静态成员（方法和属性），加载 
（3）声明一个类的引用，不加载 
（4）创建子类，先加载父类，再加载子类 
（5）父类中的公开静态方法，子类继承，使用子类的类名调用此方法，加载父类 
     class Super{ 
          public static m(){} 
     } 
     class Sub extends Super{} 
     在主函数中运行以下代码： 
     Sub.m();   //加载了父类之后，虚拟机已经知道m()方法的调用了，就不会再加载子类，延迟加载 
（6）没有创建对象，访问类中静态常量（能计算出结果的常量，在编译的时候会用计算出来的结果替换表达式），不加载  
     没有创建对象，访问类中静态常量（不确定的值），加载   
（7）CoreJava day16     
     
     
三、设计模式（编程套路）     
   GOF（Group Of Four）四人帮模式 23种 
   
1、单例模式 Singleton： 
   
   class A{ 
        private static A a = new A();  //私有静态的实例变量指向自己，在类加载时创建唯一对象 
        public static A newInstance(){ //提供公开静态的访问点，回返唯一实例 
            return a; 
        } 
        private A(){}      //私有的构造方法，防止滥用 
   } 
   
2、不变模式 ： 
   便于实例共享，减少对存储空间的消耗 
   String类采用了不变模式 
   字符串中的内容是不变的 
   
   String a1 = "123";  //系统会先去串池中找"123",找到，就共享使用一个，没找到就在串池中创建一个 
   String a2 = new String("123");  //在堆空间中创建"123" 
   
   池化的思想，把需要共享的数据放在池中（节省空间，共享数据） 
   只有String类可以用“”中的字面值创建对象。 
   在String类中，以字面值创建时，会到串池空间中去查找，如果有就返回串池中字符串的地址，并把这个地址付给对象变量。 
   如果没有则会在串池里创建一个字符串对象，并返回其地址付购对象变量，当另一个以字面值创建对象时则会重复上述过程。 
   如果是new在堆空间中创建String类的对象，则不会有上述的过程。 
   
   a2=a1.intern();  //返回字符串在串池中的引用 
   
   消极方面：字符串连接“+”，产生很多的中间对象 
             StringBuffer类，字符串是可变的 
             s.append("A");  //连接字符串，不创建中间对象 
             大量字符串连接的时候用StringBuffer取代String 
   
   
四、final 
修饰变量，方法，类 

1、修饰变量 
   被fianl修饰的变量就是常量（常量名大写），一旦赋值不能改变   
   修饰局部变量：修饰基本数据类型 -> 变量的值不能改变 
                 修饰引用 -> 引用只能指向固定的对象 
   修饰实例变量：默认值不生效，可以再赋值 
                 有两次赋值机会：初始化变量的时候 final int a = 20;  对于直接在初始化时赋值，final修饰符常和static修饰符一起使用，避免浪费空间 
                                 构造方法中设置  this.a = a; 
                                 但是不能同时使用这两种方法                                                                 
                 在一个对象完成创建的时候，对象中的所有final属性必须都完成赋值 
   类变量可以是final的，也有两次赋值机会 ：定义变量的时候就赋值 ； 静态初始代码块中    

2、修饰方法                 
    不能被子类覆盖  
    从面向对象的角度理解，可以保持操作的稳定性 
   
3、修饰类 
    不能被继承  
    在树状单继承关系中，final类是树叶节点 
    在一个final类中的所有方法，默认都是final的 
    
  注意：final，不能用来修饰构造方法。 
        在父类中如果有常量属性，在子类中使用常量属性时是不会进行父类的类加载。 
        静态常量如果其值可以确定，就不会加载该类，如果不能确定则会加载该常量所在的类。   
        class Super{ 
           private final void m(){}   //用final可以证明出private的方法不继承给子类 
        } 
        class Sub extends Super{ 
           public void m(){}  //不是方法的覆盖 
        }        
        
五、abstract 抽象的 
  修饰类和方法            
  
1、修饰类 ->  抽象类 
    不能创建对象，可以声明引用，并通过引用调用类中的方法 
    主要用于被子类继承的，可以用父类引用指向子类对象 
    
2、修饰方法 
    只有声明，没有实现，用“；”代替“{ }”    
    需要子类继承实现（覆盖）。 
    
    如果一个类中有抽象方法，那么这个类必须是抽象类。 
    抽象类中不一定有抽象方法 
      
    注意：父类是抽象类，其中有抽象方法，子类继承父类，必须把父类中的所有抽象方法都实现（覆盖）了，子类才有创建对象的能力， 
          否则子类也必须是抽象类。 
          抽象类中可以有构造方法，是子类在构造子类对象时需要调用的父类（抽象类）的构造方法。 
          
   抽象类的合理性： 
      没有抽象类的实例，只有抽象类子类的实例 
      抽象方法，定义和实现分离    
      
      抽象（abstract）方法代表了某种标准，定义标准，定义功能，在子类中去实现功能（子类继承了父类并需要给出从父类继承的抽象方法的实现）。 
      方法一时间想不到怎么被实现，或有意要子类去实现而定义某种标准，这个方法可以被定义为抽象。(abstract)  
      
六、三个修饰符都能修饰方法（不包含构造方法） 
1、构造方法在创建对象的时候使用，如果是static，那么只会在加载类的时候调用一次 
   构造方法不能被继承（final），谈不到覆盖，更不会由子类实现（abstract） 
2、final和abstract，private和abstract，static和abstract，这些是不能放在一起的修饰符 
   因为abstract修饰的方法是必须在其子类中实现（覆盖），才能以多态方式调用，以上修饰符在修饰方法时子类都覆盖不了这个方法。 
   final是不可以覆盖，private是不能够继承到子类，所以也就不能覆盖。 
   static是可以覆盖的，但是在调用时会调用编译时类型的方法（引用类型的方法），因为调用的是父类的方法，而父类的方法又是抽象的方法，不能调用。 
   所以上的修饰符不能放在一起。          
   
作业:(语言高级特性,三个修饰符) 
1.修改Account类,银行用户的账号(id)是自动生成的,初始值为100000,第一个开户的用户id为100001,第二个为100002,依此类推. 
提示:构造对象的时候采用static属性为id赋值 
2.对于Account类,有两个方法,存款方法和取款方法,请修改这两个方法. 
存款方法改为不允许子类修改 
取款方法根据不同的子类而不同,因此,改为抽象方法,在两个子类中分别实现 

3.将Bank类作成单例