一、关键词：static

可以用来修饰的结构
- 属性、方法、代码块、内部类
static 修饰属性：静态变量（或类变量）
1. 将属性按照是否使用 static 修饰，分为类变量和实例变量。
  - 类变量：类创建的多个对象共用同一套类变量。
  - 实例变量：类创建的每个对象各自拥有一套实例变量。
2. 类的某一个对象可以调用类变量，其对类变量的修改，会导致其他对象调用此类变量时，是修改过了的，而类的某一个对象修改了实例变量，不会影响其他对象同名的实例变量的值。
3. 类变量，随着类的加载而加载，实例变量，随着对象的创建而加载。
4. 内存中，实例变量存储在堆空间中，类变量存储在静态域中，而静态域存储在方法区。
static修饰方法
1. 随着类的加载而加载。
2. 在静态方法内部：能调用静态的属性或静态的方法，不能调用非静态的属性或非静态的方法。
3. 在非静态方法内部：能调用静态的属性或静态的方法，也能调用非静态的属性或非静态的方法。
如何使用static关键字？
1. 什么样的属性适合声明为 static？
  1. 类的多个对象要共享此唯一的数据。
  2. 类中的常量。
2. 什么样的方法适合声明为 static？
  1. 工具类中的方法（比如：Arrays工具类）。
  2. 操作静态变量的方法，通常为静态的。
举例
- 单例模式、工具类：Arrays / Math / Collections / XxxUtils / XxxFactory

二、单例模式

设计模式的说明
1. 设计模式是在大量的实践中总结和理论优化之后的代码结构、编程风格以及解决问题的思考方式。
2. 总结出了一共23种经典的设计模式。

单例模式

要解决的问题
- 保证在整个软件系统中，对某个类只能存在一个对象实例。
实现方式的对比
- 实现方式有：饿汉式和懒汉式。
- 饿汉式：线程安全的创建方式。
- 懒汉式：延迟对象的加载，节省内存空间，是线程不安全的创建方式。

具体代码实现

// 饿汉式1
class Singleton1 {
	// 1.私有化构造器
	private Singleton1() {
		
	}
	
	// 2.内部创建当前类的实例，使用private static修饰
	private static Singleton1 singleton = new Singleton1();
	
	// 3.通过get()方法返回当前类的实例，使用public static修饰
	public static Singleton1 getInstance() {
		return singleton;
	}
}

// 饿汉式2
class Singleton2 {
	private Singleton2() {
		
	}
	
	private static Singleton2 singleton = null;
	
	// 代码块里进行实例化
	{
		singleton = new Singleton2();
	}
	
	public static Singleton2 getInstance() {
		return singleton;
	}
}

// 懒汉式
class Singleton3 {
	private Singleton3() {
		
	}
	
	private static Singleton3 singleton;
	
	public static Singleton3 getInstance() {
		if(singleton == null) {
			singleton = new Singleton3();
		}
		return singleton;
	}
}

三、main()的使用说明

main() 作为程序的入口。
作为一个类的普通的静态方法。
main() 可以作为用户与程序交互的一种方式（类似于Scanner）。

传入参数值：java 类名参数值1 参数值2 参数值3 ...
注意：此时传入的参数值都是 String 类型。

public static void main(String[] args) {
    // 方法体；
}

解释说明：

权限修饰符：private < 缺省 < protected < public
修饰方法的特殊关键字：static final abstract
方法的返回值类型：void / 具体的数据类型（方法体中一定会有return)
方法名：需要满足标识符的命名规则和规范；见名知意
形参列表：方法的重载；可变个数形参的方法；参数传递机制；多态性
方法体：体现方法的具体功能

四、类的结构之四：代码块

代码块（初始化块）：类的第四个成员（重要性较属性、方法、构造器差一些）

代码块的作用
- 用来初始化类或对象的信息
分类
- 静态代码块和非静态代码块
静态代码块
1. 可以输出语句。
2. 随着类的加载而加载，只执行一次。
3. 作用：用来初始化类的信息。
4. 静态代码块内部只能调用当前类的静态的属性或方法，不能调用非静态的结构。
5. 静态代码块的执行要早于非静态代码块。
6. 多个静态代码块之间，是按照声明的先后顺序执行的。
非静态代码块
1. 可以输出语句。
2. 随着对象的创建而执行，每创建一个对象，就执行一次。
3. 作用：用来初始化对象的信息。
4. 非静态代码块内部能调用当前类的静态的属性或方法，也能调用非静态的属性或方法。
5. 多个非静态代码块之间，是按照声明的先后顺序执行的。
属性赋值顺序
1. 默认初始化。
2. 显示初始化/在代码块中给属性初始化。
3. 构造器初始化。
4. 有了对象以后，通过“对象.属性”或“对象.方法”的方式，给属性赋值。
说明：赋值的先后顺序：①-②-③-④，其中步骤①②③只执行一次。

五、关键字：final

final：最终的

可以用来修饰的结构
- 类、变量、方法
具体使用说明
1. final 修饰类：表明该类不可被继承。比如：String 类。
2. final 修饰变量：表明此变量的值不能再被改变，即此变量实际上是一个常量。
  - final 修饰成员变量：此变量是一个常量，可以考虑赋值的方式有：①显示赋值 ②代码块中赋值 ③构造器中赋值。
3. final 修饰方法：表明此方法不能被重写。比如：Object 类中的 getClass()。

六、关键字：abstract

abstract：抽象的

可以用来修饰的结构
- 类、方法
具体使用说明
- abstract 修饰类：抽象类
  1. 抽象类是不可以被实例化的。
  2. 实际开发中，我们都会去提供抽象类的子类，由子类实例化，使用父类中声明的结构。
  3. 抽象类中一定存在构造器。构造器的作用：方便子类对象实例化时调用。
  4. 抽象方法所在的类一定是抽象类，反之，抽象类中可以没有声明抽象方法。
- abstract 修饰方法：抽象方法
  1. 子类继承抽象的父类以后，如果重写了所有的抽象方法，则此子类就不是一个抽象类，就可以实例化。
  2. 子类继承抽象的父类以后，如果没重写完所有的抽象方法，则此子类仍是一个抽象类，不可以实例化。
注意点
1. 抽象性依赖于继承性。
2. 不能用来修饰属性、构造器等结构。
3. 不和能 private / final / static 共用。
abstract 的应用实例
- 举例一：抽象类 GeometricObject (提供抽象方法：findArea())及其子类Circle 、MyRetangle。
- 举例二：InputStream 抽象类及其内部的抽象方法：read()。

七、关键字：interface

interface：接口

使用说明
1. 类与接口是并列的两个结构。
2. 接口使用interface关键字定义。
3. 接口中可以声明的结构：属性、方法。
  - 接口中不能声明构造器！意味着接口不能实例化。
  - 属性：接口中定义的属性都声明为：public static final 的（默认有，可以省略）。
  - 方法：jdk7 以及以前版本，接口中定义的方法都是抽象方法，声明为：
```
public abstract（默认有，可以省略）
```
    jdk8 开始，接口中除了定义抽象方法之外，还可以定义静态方法、默认方法。
4. 接口，实际上可以看成是一种标准、一种规范。
5. java 类和接口之间是实现（implements）关系，而且是可以多实现的。
```
// 格式：
class SubClass extends SuperClass implements 接口1，接口2，接口3，...{}
```
  如果 java 类实现了某个或某几个接口，则需要重写接口中的所有抽象方法，方可实例化。
  如果 java 类实现了某个或某几个接口，没重写接口中所有的抽象方法，则此类必须声明为抽象类。
6. 接口与接口之间是继承关系，而且可以多继承。
7. 接口与实现类之间的多态性。

体会面向接口编程的思想
jdbc 当中规定了很多的接口，用于规范 java 应用程序如何操作具体的数据库。
对于程序员来讲，只需要面向这套接口编程即可。
java8 中针对接口的新特性
1. jdk8 中可以额外定义静态方法和默认方法。
2. 具体的使用：
  - 知识点1：接口中的静态方法，不能被实现类直接调用，只能通过接口自己来调用。
  - 知识点2：可以通过实现类的对象调用接口中声明的默认方法。
  - 知识点3：如果父类和接口中声明了同名同参数的方法，则子类继承父类，实现接口以后，在没重写此方法的情况下，默认调用的父类中的方法。---"类优先"原则。
  - 知识点4：接口冲突：实现类实现了两个接口，而两个接口中定义了同名同参数的方法，则实现类默认情况下就报错。
    - 要求：实现类必须要重写同名同参数的方法。
  - 知识点5：通过“接口.super.方法”的方式调用实现的接口中的被重写的方法。

八、类的结构之五：内部类

内部类：类的第五个成员

定义
- 我们可以在一个类A的内部，声明另一个类B，此时，类A：外部类，类B：内部类。
内部类的分类
- 成员内部类（静态的 vs 非静态的） vs 局部内部类
说明
- 一方面，作为类：
  1. 内部可以声明属性、方法、构造器。
  2. 可以被 abstract 修饰。
  3. 可以被 final 修饰。
- 另一方面，作为外部类的成员：
  1. 可以被4种权限修饰符修饰。
  2. 可以调用外部的属性、方法等结构。
  3. 可以被 static 修饰。
成员内部类

如何创建成员内部类的对象？（静态的、非静态的）

// 如何创建静态的成员内部类对象
Person.Dog dog = new Person.Dog(); // 错误的：Person.new Dog()
dog.show();
// 如何创建非静态的成员内部类对象
// Person.Bird bird = new Person.Bird();//错误的
Person p = new Person();
Person.Bird bird = p.new Bird(); // 错误的：new p.Bird();
bird.display("麻雀");

如何在成员内部类中调用外部类的结构？

class Person{
    String name;

    class Bird{
        String name;

        public void display(String name){
            System.out.println(name); // 形参
            System.out.println(this.name); // Bird 的属性
            System.out.println(Person.this.name); // Person 的属性
        }
    }
}

局部内部类

// 此情况开发中很少见
public void method(){
    
    // 局部内部类
    class InnerClass{
        
    }
    
}

// 较为常见的
// 返回一个实现了 Comparable 的类的对象
public Comparable getInstance(){
    
    // 写法一：提供实现了接口的内部类
//      class MyComparable implements Comparable{
//
//          @Override
//          public int compareTo(Object o) {
//              return 0;
//          }
//          
//      }
//      
//      
//      return  new MyComparable();
    
    // 写法二：返回接口的匿名实现类的匿名对象
    return new Comparable(){

        @Override
        public int compareTo(Object o) {
            return 0;
        }
        
    };
}