递归，单例模式 ，权限修饰符和特征修饰符

权限修饰符

1. public(公共的）：
   　　可以修饰：类，成员变量，成员方法，构造方法；
   　　被访问的方式：工程下的任意位置包括（同工程下的异包，本类，同包下的类，子类），
2. 默认不写：
   　　可以修饰：类，成员变量，构造方法；
   　　被访问的方式：本类，同包，子类；
3. private（私有的）：
   　　可以修饰：成员方法，成员变量，构造方法；
   　　被访问的方式：本类；
4. protected（受保护的）：
   　　可以修饰：成员变量，方法，构造方法；
   　　被访问的方式：本类，子类；
   　　被protected修饰的类不能被继承；

特征修饰符

1. final：
   　　可以修饰：类，成员变量，成员方法，变量；
   　　修饰的类：不能被继承，没有子类；
   　　修饰的成员变量：分为基本数据类型和引用数据类型：
   　　＾基本数据类型：一旦被初始化，就不能再次赋值；
   　　　　　　　　　　　一旦定义，后面必须给变量赋值；final int num = 0;
   　　＾引用数据类型：必须给这个变量初始化一个值，否则引用类型的数据就会有一个默认值null，并且这个值也改变不了，就会毫无意义。
   　　修饰成员方法：这个方法不能被继承；
   　　修饰变量：分为基本数据类型和引用数据类型：
   　　＾基本数据类型：一旦被初始化，就不能再次赋值；
   　　　　　　　　　　　一旦定义，后面必须给变量赋值；final int num = 0;
   　　＾引用数据类型：必须给这个变量初始化一个值，否则引用类型的数据就会有一个默认值null，并且这个值也改变不了，就会毫无意义。

2. static
   　　　可以修饰：成员变量，成员方法，程序块，内部类；
   　　　特点：
   　　　　　　（１）静态元素在内存中有一个单独的区域存放它们，在方法去内的静态存储区；
   　　　　　　（２）静态元素是属于类的，而成员变量和方法是属于对象的；
   　　　　　　（３）静态元素在加载类的时候就会存在；
   　　　　　　（４）使用静态元素可以采用（类名．静态元素名）的方式调用；
   　　　　　　（５）静态元素属于共享元素，因为在内存中只有一份静态区；
   　　　　　　（６）静态方法只能调用静态方法，因为在加载类的时候，只有静态元素区，这时候还没有创建对象，所以调用不了非静态成员变量和非静态成员方法；
   　　　　　　（７）静态元素处在方法区的静态区中，不会被JVM的垃圾回收器回收；
   　　　　　　（８）执行方法的时候，会占用栈内存的空间，当方法执行完毕时，系统就会自动回收；而堆内存只有在创建对象的时候会占用堆内存的空间，当对象执行完毕时，就会回收掉；
   　　　　　　（９）非静态方法可以访问静态方法和静态变量；
   　　　　　　（１０）静态元素的名字每个字母都要大写；
   　　　　　　（１１）静态方法内，不能使用this和super关键字；

3. abstract
   　　（１）修饰方法：
   　　　　用abstract修饰的方法，只有方法的结构，没有方法体，叫做抽象方法；
   　　　　有抽象方法的类一定是抽象类或者接口；
   　　（２）修饰类：
   　　　　用abstract修饰的类，叫做抽象类；
   　　　　抽象类中不一定含有抽象方法；
   　　　　抽象类含有构造方法，我们不能听过构造方法创建对象；
   　　　　抽象类只能通过子类来继承；
   　　　　抽象类可以继承抽象类（单继承）；
   　　　　抽象类可以继承具体类（一般不会这样写）；
   　　　　具体类不可以继承抽象类（将父类的抽象方法具体化，加上方法体；或者子类也变成抽象类）；

单例模式

实现：

1. 私有的构造方法（不让别的类创建该类的对象）；
2. 私有的静态的当前类的对象作为属性；（因为这个对象只有一份，所以用static修饰，而且只有类名可以调用；只有一份的话，就不能随便被创建对象，就要用private修饰）；
3. 共有的静态方法返回当前类的对象；

优点：

1. 在栈内存中只.开辟一个空间，节省空间；
2. 避免对资源的占用；

缺点：

1. 没有接口，不能继承；

分类：

1. 饿汉式；立即加载类；

public class Singleton {
    private static Singleton singleton = new Singleton();//立即加载类
    private Singleton(){}
    public static Singleton getSingleton(){
            return singleton;
    }
}

2. 懒汉式；延迟一会，再加载类；

public class Singleton {
    private static Singleton singleton;
    private Singleton(){}
    public static Singleton getSingleton(){
        if (singleton == null){判断，延迟
            return new Singleton();
        }else {
            return singleton;
        }
    }
}

3. 生命周期托管

递归

• 概念：在方法中调用本方法就叫递归；
• 注意事项：
  　　＾递归必须要有出口，否则就是死递归；
  　　＾递归的此数不宜过多，否则就会造成栈溢出；
  举个例子：5的阶乘

    public class Test {
    public static void main(String[] args) {
        System.out.println("输入一个整数：");
        Scanner input = new Scanner(System.in);
        int i = input.nextInt();
        int result = factorial(i);
        System.out.println(result);
    }
    public static int factorial(int i){
        if (i == 1){
            return 1;
        }else {
            return factorial(i - 1) * i;
        }
    }
}