static

变量：
    1.只能是成员变量，类变量，
    2.类的实例所共享。
    3.在权限允许范围内可以直接通过类名.变量名的形式访问
    4.某种意义上更类似于全局变量。
方法：
    1.类方法
    2.在权限允许范围内可以直接通过类名.方法名访问    

    Note：
        static方法不能被重写为非静态的方法
        并且static方法就算被重写也不会有多态的体现。
    Animal an = new Cat();
    an.shout();
代码块：
    static修饰的代码块在类加载的时候执行一次
    没有static修饰的代码块在每一次构建对象时执行一次


在所有的静态上下文中不能访问非静态的成员(变量和方法)。

静态导入：

import static packageName.clsname.staticMember;

final

1.变量：final修饰的变量时常量。必须进行显示初始化。
    1.实例变量：
        初始化过程三选一(必须且只能选一个)
        1.声明即初始化
            final int a = 100;
        2.在匿名代码块中进行初始化：
            final int a;
            {
                a = 100;
            }
        3.可以在构造器中进行显示初始化：
            要求在类中的每一个构造器中都要进行初始化。
    2.类变量：
        二选一（必选）：
        1.声明即初始化
            static final int b = 200;
        2.在静态代码块中初始化：
    3.局部变量：
        在使用之前进行显示初始化。
2.方法：
    final修饰的方法不能被覆盖（重写）
3.类：
    final修饰的类不能被继承。

abstract

1.方法：抽象方法
    1.不能有方法体
    2.抽象方法所在类一定是抽象类。
    3.抽象方法存在就是被覆盖的。如果子类继承了带有抽象方法的抽象类，必须对所有的抽象方法进行覆盖。
    4.多态。
2.类：抽象类
    1.抽象类不能被实例化。但是可以声明抽象类类型的变量。
    2.抽象类是对类的抽象，抽象类所具有的共有特征和行为。
    3.抽象类存在的目的就是用来被继承，实现代码复用。
    4.抽象类中可以有抽象方法，也可以没有。抽象类可以和普通类一模一样（拥有各种类型的变量和方法）
    5.如果一个类继承抽象类，必须实现抽象类中所有抽象方法，或者子类本身也是抽象类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

abstract class Animal{
	private String name;
	abstract void shout();
}
class Dog{
}
class Cat{
}
	interface Action{
		 void run();
		 void xxx();
	}
	interface USBDevice{
		xx = ""; 
		driver();
	}
	
	class Person{
		void let(){
		
		}
	}

接口

1.接口是比抽象类还抽象的存在，接口是抽象类的极致抽象。
2.接口中所有的方法都是public abstracht，接口中所有的变量都是public static final
3.接口主要用来定义标准。
4.接口可以多继承。一个类可以实现多个接口。
5.接口的存在本身可以规避java不能多继承的操作特点。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

interface USBDevice{
	String type="USB";
	void driver();
}
class Mouse{
	select();
}
class USBMouse extends Mouse implements USBDevice{
}
	
class Computer{
	void use(USBDevice usb){
		usb.driver();
	}
}

对象：
    1.信息载体对象(域对象)
    2.行为对象

内部类：

定义在类体部，方法体部，甚至比方法体更小的代码块内部的类
1.静态内部类（内部类中最简单的形式）
    1.声明在类体部，方法体外，并且使用static修饰的内部类
    2.访问特点可以类比静态变量和静态方法
    3.脱离外部类的实例独立创建
        在外部类的外部构建内部类的实例
            new Outer.Inner();
        在外部类的内部构建内部类的实例
            new Inner();
    4.静态内部类体部可以直接访问外部类中所有的静态成员，包含私有
2.成员内部类(实例内部类)
    1.没有使用static修饰的内部类。
    2.在成员内部类中不允许出现静态变量和静态方法的声明。
        static只能用在静态常量的声明上。
    3.成员内部类中可以访问外部类中所有的成员(变量，方法)，包含私有成员，如果在内部类中定义有和外部类同名的实例变量，访问：
        OuterClass.this.outerMember;
    4.构建内部类的实例，要求必须外部类的实例先存在
        外部类的外部/外部类的静态方法：new Outer().new Inner();
        外部类的实例方法：
            new Inner();
            this.new Inner();
3.局部内部类:
    1.定义在方法体，甚至比方法体更小的代码块中
    2.类比局部变量。
    3.局部内部类是所有内部类中最少使用的一种形式。
    4.局部内部类可以访问的外部类的成员根据所在方法体不同。
        如果在静态方法中：
            可以访问外部类中所有静态成员，包含私有
        如果在实例方法中：
            可以访问外部类中所有的成员，包含私有。
      局部内部类可以访问所在方法中定义的局部变量，但是要求局部变量必须使用final修饰。

4.匿名内部类
    1.没有名字的局部内部类。
    2.没有class,interface,implements,extends关键字
    3.没有构造器。
    4.一般隐式的继承某一个父类或者实现某一个接口