JAVA SE学习笔记(六)：面向对象编程-c

33.关键字static

01.在Java类中，可用static修饰属性、方法、代码块、内部类

02.被修饰后的成员具备以下特点：
a.随着类的加载而加载
b.优先于对象存在
c.修饰的成员，被所有对象所共享
d.访问权限允许时，可不创建对象，直接被类调用

03.类变量(即被static修饰的类属性)
       a.类变量不用实例化，直接类名.属性名就可以使用，是类的一部分，被所有类的实例化对象共享，也称为静态变量
       b.类变量的使用要小心，因为只要有一处改动说有对象都会得到变化
       示例代码：
           class Person {
               private int id;
               public static int total = 0;   //使用static修饰
               public Person() {               //构造方法，每new一个对象就使total加一并传给id
               total++;
               id = total;
               }
           }

   04.类方法(即被static修饰的类方法)
       a.没有对象的实例时，可以用类名.方法名()的形式访问由static标记的类方法.
       b.在static方法内部只能访问类的static属性，不能访问类的非static属性.
       c.因为不需要实例就可以访问static方法，因此static方法内部不能有this和super.
       d.重载的方法需要同时为static修饰或者非static修饰.
       示例代码：

class Person {
      private int id;
      private static int total = 0;
      public static int getTotalPerson() { 
             id++;    //非法
             return total;
      }
      public Person() {
          total++;
          id = total;
      }
}

34.单例 (Singleton)设计模式

   01.设计模式：设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式.
   02.单例设计模式：采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法
   03.目的：实例化对象的创建需要消耗大量的时间和资源时，这种情况就适合用单例设计模式，或者没有必要频繁的new新对象

04.饿汉式单例设计(先new好一个对象，有需要时都用这个对象)
示例代码：

   public class Single{
            //private的构造器，使得不能在类的外部使用new创建该类的对象
            private Single() {}
            //私有的，静态的Single类型的变量，只能在类的内部访问，并且类创建是就创建该变量
            private static Single onlyone = new Single();
            //getSingle()为static，不用创建对象即可访问
            public static Single getSingle() {
            //通过getSingle()方法返回对象
            return onlyone;
            }
            }

            public class TestSingle{
                public static void main(String args[]) {        
                    Single  s1 = Single.getSingle();      //访问静态方法
                    Single  s2 = Single.getSingle();
                    if (s1==s2){
                    System.out.println("s1 is equals to s2!");
                    }
                }
            }

   05.懒汉式单例设计(最开始对象为null,直到被调用才new一个对象，并且之后都用这个对象)
       示例代码:

 public class Singleton{
            //1.将构造器私有化，保证在此类的外部，不能调用本类的构造器。
            private Singleton(){}
            //2.创建Singleton类型的static对象
            private static Singleton instance = null;
            //3.设置公共的方法来访问类的实例
                public static Singleton getInstance(){
                    //3.1如果类的实例未创建，那些先要创建，然后返回给调用者：本类。因此，需要static 修饰。
                    if(instance == null){
                    instance = new Singleton();
                    }
                    //3.2 若有了类的实例，直接返回给调用者。
                    return instance;
                }  
            }

35.类的成员之四：初始化块(代码块)

   01.作用：对Java对象进行初始化
   02.程序的执行顺序：
       声明成员变量的默认值->静态代码块->显式初始化、多个初始化块依次被执行（同级别下按先后顺序执行）->构造器再对成员进行赋值操作
   03.静态代码块：一个类中初始化块若有修饰符，则只能被static修饰，称为静态代码块(static block )，当类被载入时，类属性的声明和静态代码块先后顺序被执行，且只被执行一次。
   04.static块通常用于初始化static (类)属性
       代码示例:
       class Person {
           public static int total;
           static {
           total = 100;//为total赋初值
           }
           …… //其它属性或方法声明
       }

   05.非静态代码块：没有static修饰的代码块
       a.可以有输出语句。
       b.可以对类的属性声明进行初始化操作。
       c.可以调用静态和非静态的变量或方法。
       d.若有多个非静态的代码块，那么按照从上到下的顺序依次执行。
       e.每次创建对象的时候，都会执行一次。且先于构造器执行
06.静态代码块：用static 修饰的代码块
       a.可以有输出语句。
       b.可以对类的属性声明进行初始化操作。
       c.不可以对非静态的属性初始化。即：不可以调用非静态的属性和方法。
       d.若有多个静态的代码块，那么按照从上到下的顺序依次执行。
       e.静态代码块的执行要先于非静态代码块。
       f.静态代码块只执行一次

36.关键字：final

   01.在Java中声明类、属性和方法时，可使用关键字final来修饰,表示“最终”。
   02.final标记的类不能被继承。提高安全性，提高程序的可读性。
   03.final标记的方法不能被子类重写。
   04.final标记的变量(成员变量或局部变量)即称为常量。名称大写，且只能被赋值一次。
   05.final标记的成员变量必须在声明的同时或在每个构造方法中或代码块中显式赋值，然后才能使用。
   06.static final：全局常量
   示例代码：

public final class Test{
            public static int totalNumber = 5 ;
            public final int ID;
            public Test(){
                ID = ++totalNumber;  //可在构造方法中给final变量赋值
            }
               public static void main(String[] args) {
                Test t = new Test();
                System.out.println(t.ID);        
                final int I = 10;
                final int J;
                J = 20;
                J = 30;  //非法
            }
        }

37.抽象类和抽象方法(abstract class and functions)

   01.定义:Java允许类设计者指定：超类声明一个方法但不提供实现，该方法的实现由子类提供。这样的方法称为抽象方法。有一个或更多抽象方法的类称为抽象类。
   02.用abstract关键字来修饰一个类时，这个类叫做抽象类；
    03.用abstract来修饰一个方法时，该方法叫做抽象方法:abstract int abstractMethod( int a );
   04.含有抽象方法的类必须被声明为抽象类。
   05.抽象类不能被实例化。抽象类是用来作为父类被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。
   06.不能用abstract修饰属性、私有方法、构造器、静态方法、final的方法。
   代码示例：

        //Vehicle是一个抽象类，有两个抽象方法。
        public abstract class Vehicle{
            int num;
            public abstract double calcFuelEfficiency();    //计算燃料效率的抽象方法
            public abstract double calcTripDistance();    //计算行驶距离的抽象方法
        }
        public class Truck extends Vehicle{
            public double calcFuelEfficiency( )   { //写出计算卡车的燃料效率的具体方法   }
            public double calcTripDistance( )    {  //写出计算卡车行驶距离的具体方法   }
        }

        public class RiverBarge extends Vehicle{
             public double calcFuelEfficiency( ) { //写出计算驳船的燃料效率的具体方法  }
             public double calcTripDistance( )  {  //写出计算驳船行驶距离的具体方法}
        }

//注意：抽象类不能实例化,new Vihicle()是非法的.抽象类可以有构造方法，只是不能直接创建抽象类的实例对象而已。

38.模板方法设计模式(TemplateMethod)

   01.抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，在抽象类中给出的抽象方法相当于文章的各章节标题(模式)，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。
   02.使用目的：当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。
   03.代码示例：

 //程序计时
        abstract class Template{
            public final void getTime(){
                long start = System.currentTimeMillis();
                code();                                    //将code()；程序留白，在子类中根据需要再编写
                long end = System.currentTimeMillis();
                System.out.println("执行时间是："+(end - start));
            }
            public abstract void code();
        }
        class SubTemplate extends Template{
            public void code(){
                for(int i = 0;i<10000;i++){
                System.out.println(i);
                } 
            } 
        }

39.接口

   01.接口(interface)是抽象方法和常量值的定义的集合，从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。
   02.一个类可以实现多个接口，接口也可以继承其它接口。
   03.作用1：
       有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承，只支持多层继承。有了接口，可以让子类实现多个接口，就可以得到多重继承的效果。
   04.接口的定义：

           //用interface来定义。
           //接口中的所有成员变量都默认是由public static final修饰的。
           //接口中的所有方法都默认是由public abstract修饰的。
           //接口没有构造器。
           //接口采用多层继承机制。
       代码示例：
           public interface InterfaceA{
               int ID = 1;
               void start();
               public void run();
               void stop();
           }

   05.接口的实现
       class SubClass implements InterfaceA{
           //实现接口中的抽象方法
       }
   06.实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。否则，仍为抽象类。
   07.接口的主要用途就是被实现类实现。（面向接口编程）
   08.与继承关系类似，接口与实现类之间存在多态性，即接口可以接收一个类的对象，即将对象转为接口类型，对象中只包含接口中定义的方法。
   09.定义Java类的语法格式：先写extends，后写implements
       格式：

       < modifier> class < name> [extends < superclass>]
       [implements < interface> [,< interface>]* ] {
           < declarations>*
       }

010.作用2：
当抽象父类中需要新增抽象方法时，子类中必须实现该新增方法，否则子类就应改为抽象类，同理，子类的子类...都需要作出改变，这样代价大，不方便。这时可以将新增的抽象方法写为一个借口，在根据需要在对应的子类中实现接口即可。
代码示例：

           interface Runner { public void run();}
           interface Swimmer {public double swim();}
           class Creator{public int eat(){…}}
           class Man extends Creator implements Runner ,Swimmer{
                   public void run() {……}
                   public double swim() {……}
                   public int eat() {……}
           }

011.接口也可以继承另一个接口，使用extends关键字
012.抽象类是对一类事物的高度抽象，其中既有属性也有抽象，方法；接口是对方法的抽象，即一系列动作的抽象。所以，当需要对一类事物的抽象时，就用抽象类，以形成父类；当需要对一系列动作进行抽象时，就使用接口，在需要这些动作的类中实现这些接口。

40.工厂方法(FactoryMethod)

01.FactoryMethod模式是设计模式中应用最为广泛的模式，在面向对象的编程中，对象的创建工作非常简单，对象的创建时机却很重要。
02.通过工厂把new对象隔离，通过产品的接口可以接受不同实际产品的实现类，实例的类名发生改变并不影响其他人对类的调用。

41.内部类

   01.在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类
   02.可以使用外部类的私有数据，因为它是外部类的成员，同一个类的成员之间可相互访问。而外部类要访问内部类中的成员需要:内部类.成员或者内部类对象.成员。
   03.最大的作用：解决Java不能多重继承的问题(接口也可以)，有时只有一个方法想要继承，专门写一个接口显得有点繁琐，可以在类中写一个内部类，用内部类继承该类的方法即可。
   04.可以声明为static的，但此时就不能再使用外层类的非static的成员变量。
   05.非static的内部类中的成员不能声明为static的，只有在外部类或static的内部类中才可声明static成员
   06.可以声明为abstract类，因此可以被其它的内部类继承