第五章 高级类特性2

5.1 关键字 static

1. 类变量不用实例化，直接类名.属性就可以使用，是类的一部分，在设计类时，希望某些属性不因为对象的不同而改变，就将这些属性设置为类属性
2. 方法也可以用static修饰，类方法（静态方法）使用工具类最多。
3. 使用范围：属性、方法、代码块、内部类
4. 被修饰后的成员你具备一下特点：
   4.1 随着类的加载而加载
   4.2 优先于对象存在
   4.3 修饰的成员，被所有对象所共享
   4.4 访问权限允许时，可不创建对象，直接被类调用

5.1.1 单例（Singleton）设计模式

1. 设计模式：大量的实践中总结和理论化之后优选的代码结构、编码风格以及解决问题的思考方式。
2. 单例：只有一个实例（实例化对象），整个软件系统运行过程中，这个类只被实例化一次，以后不论在哪都只调用这一个实例
   2.1 饿（恶）汉式单例模式

public class HungrySingleton {
//    public Single(){
//        //假设构造中要执行1000行代码，要占用很大的资源，耗时10秒
//        //new Single对象需要10秒，运行1000行代码
//        //像这种情况，就是和使用单例模式，只new一次对象，之后一直使用这个对象
//    }
    //私有的构造,构造方法私有化，调用这个类的人，不能直接使用new来创建对象
    private HungrySingleton(){

    }

    //私有的Single类型的类变量
    private static HungrySingleton single = new HungrySingleton();

    public static HungrySingleton getInstance(){
        return single;
    }
}

2.2 懒汉式单例模式(存在线程安全问题)

public class LazySingleton {
    //先私有化构造方法让外边不能直接new对象
    private LazySingleton(){

    }
    //做一个本类静态变量的对象，一开始的时候是null
    private static LazySingleton s1 = null;
    //做一个返回当前实例的方法
    public static LazySingleton getInstance(){
        if(s1 == null){
            s1 = new LazySingleton();
        }
        return s1;
    }
}

2.3 饿汉式和懒汉式的区别就是什么时候new对象

• 饿汉式是在类加载之后还没有人调用的时候就先new好一个对象，以后不论谁来调用getInstance方法都是直接返回之前new好的那个对象
• 懒汉式实在第一次有人调用getInstance方法时来new对象，以后再有人调用getInstance方法直接就返回new好的对象

5.2 main方法

public static void main(String[] args]{
}

1. 为什么是公共的（public）

由于Java虚拟机需要调用类的main()方法，并且为了保证虚拟机在任何情况下都可以访问到main方法，所以该方法的访问权限必须是public

2. 为什么是静态的（static）

因为Java虚拟机在执行main（）方法时不必创建对象，就是说在创建对象之前就可以被虚拟机调用，所以该方法必须是static的

3. 为什么没有返回值（void）

因为Java不需要main方法向操作系统返回推出信息

4. main

main的名称不能变是为了JVM能够识别程序运行的起点

5. String[] args

args是arguments的缩写
在JVM执行main方法前保存输入的值

5.3 类的成员之四：初始化块

1. 非静态代码块

在new Person();时的顺序是

1. 先进行类属性的默认初始化和显示初始化
2. 执行代码块代码
3. 执行构造器的代码

2. 静态代码块

在程序运行中，非静态代码块每次new新的对象时都会执行，静态代码块不管new多少个对象都只会执行一次，并且先于非静态代码块执行
实际开发中，静态代码块用于初始化类的静态属性

5.4 关键字：final（最终）

1. final标记的类不能被继承
2. final标记的方法不能被子类重写
3. final标记的变量即称为常量，必须显示赋值且只能赋值一次

5.5 抽象类（abstract class）

1. 抽象化处理：不写具体的实现
2. abstract能用来修饰一个类，也能修饰一个方法

• 抽象方法没有方法体
• 抽象类不能被实例化，是用来作为父类被继承的。抽象类的子类必须重写父类的抽象方法
• 只要类中有一个抽象方法，则这个类必须是一个抽象类。
• 不能用abstract修饰final的方法，抽象类只有被继承才有意义，但final修饰的方法不能被继承。

3. 模板方法设计模式
   3.1 概述：抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式
   3.2 解决的问题

1. 当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴漏出去，让子类去实现。
2. 编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式。

5.6 接口

1. 有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。
2. 接口（Interface）是抽象方法和常量值的定义的集合。
3. 从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义而没有变量和方法的实现。
4. 实现接口类

class SubClass implements InterfaceA{}

5. 一个类可以实现多个接口，接口也可以继承其他接口。
6. 接口的特点

1. 用interface来定义
2. 接口中的所有成员变量都默认是由public static final修饰的
3. 接口中的所有方法都默认是由public abstract修饰的
4. 接口中没有构造器
5. 接口采用多层继承机制

7. 接口定义举例

public interface Runner{
    int ID = 1;
    void start();
    public void run();
    void stop();
}
相当于
public interface Runer{
    public static final int ID = 1;
    public abstract void start();
    public abstract void run();
    public abstract void stop();
}

8. 实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。否则，仍为抽象类。
9. 接口的主要用途就是被实现类实现。（面向接口编程）
10. 与继承关系类似，接口与实现类之间存在多态性。
11. 定义Java类的语法格式：先写extends，后写implements

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

12. 有了抽象类为什么要有接口
    12.1 如果不用接口，那么就只有类的继承，一旦父类中增加一个抽象方法的话，那子类孙类都需要具体化这个抽象方法否则就是抽象类了。用了接口的话就可以父类实现该接口，子类孙类选择性的实现该接口。
    12.2 抽象类是对于***一类具体事物***的高度抽象，其中既有属性也有方法；接口是对方法的抽象，也就是对***一系列动作***的抽象。
13. 工厂模式
    
    使用工厂模式开发人员A把类名改了的话不会影响到开发人员B的开发

5.7 类的成员之五：内部类：主要解决Java不能多重继承的问题

1. 在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。
2. Inner class一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称
3. Inner class可以使用外部类的私有数据，因为它是外部类的成员，同一个类的成员之间可以相互访问。而外部类要访问内部类中的成员需要：内部类.成员或内部类对象.成员。
4. 分类
   4.1 成员内部类（static成员内部类和非static成员内部类）
   4.2 局部内部类（不谈修饰符）
   4.3 匿名内部类

5.8 面向对象总结