面向对象（static静态、内部类）
**例一：**static 静态属性与静态方法
//static的共性：
//1、凡是static的，都跟对象无关，都是类级别的
//2、凡是static的，都在加载期会有特殊处理
public class Student {
//当属性没有使用static修饰的时候：
//1、语法上，该属性必须用对象进行访问；
//2、内存上，该属性是放在每个对象身上的（每个对象有一个name属性）；
//3、语义上，该属性是属于某个对象的；
//4、变量产生的时机，是在new对象的时候
//5、根据语义分析，很少有变量属性是static的
//6、普通属性、非静态属性
// public String name;
//当属性使用static修饰的时候：
//1、语法上，虽然可以用对象进行访问，但更多的是用类名直接访问;
//2、内存上，该属性是没有放在对象上的，而是存在数据段的静态区且全类共享一个；
*//3、语义上，该属性是跟类相关而跟对象无关的；
//4、变量产生的时机，是在加载类的时候；*
//5、常量属性可以不用考虑，直接设计为public static final
//6、静态属性、类属性
public static String name;
//构造绝对不能用static
public Student(){
}
//没有用static修饰的方法
//1、语法上，必须使用对象进行调用
//2、非静态方法既可以操作静态属性也可以操作非静态属性，既可以调用
// 其它的静态方法也可以调用其他的非静态方法；
//3、加载上非static的方法被后加载
//4、语义上，如果该方法与某个学生对象有关，就只能设计为非static的
//5、设计上，如果方法的实现部分需要操作跟对象有关的属性或其他方法，
// 那么该方法就应该设计为非static的。
// public void study(){
// System.out.println(this.name + “说：好好学习，天天向上！”);
// }
//用static修饰的方法
//1、语法上，虽然可以用对象进行调用，但更多的是用类名直接调用;
//2、静态方法只能操作静态属性，调用其他静态方法，甚至不能写this/super
//3、在加载上，static方法优先被加载；
//4、语义上，如果某个方法*与学生对象无关*，只与学生类有关，才设计为static的
//5、在设计上，如果该方法是工具类的工具方法，那么该方法应该设计为static的
public static void study(){
System.out.println(name + "说：好好学习，天天向上！");
}
}
实例初始化块与静态初始化块
public class PersonBean {
//实例初始化块
//该代码块在new对象的构造的时候会被自动执行，new一次就执行一次
//new对象构造方法要执行4步，该代码块在第3步之前执行，即在对属性进行初始化之前
//因此先在初始化块中对属性进行赋值，会被第3步的赋值覆盖
{
System.out.println(“Person的实例初始化块”);
}
//静态初始化块
//该代码块是在加载PersonBean的class的时候就被自动执行了
//*一个类只*加载一次*，所以静态初始化块也只执行一次*
***//所以很多打开资源、开启链接的预加载动作可以写到静态初始化块中***
static{
System.out.println("Person的静态初始化块");
}
//属性
private String name;
private int age = 20;
private static int a;
//构造
public PersonBean(){
System.out.println("PersonBean的构造");
}
public PersonBean(String name, int age){
this.name = name;
this.age = age;
}
//方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
MaleBean 继承PersonBean当产生子类对象，会依次执行父类静态初始化块，子类静态初始化块，父类实例初始化块，父类构造，子类实例初始化块，子类构造。
public class MaleBean extends PersonBean {
{
System.out.println("MaleBean的实例初始化块");
}
static{
System.out.println("MaleBean的静态初始化块");
}
public MaleBean(){
System.out.println("MaleBean的构造");
}
}
例二：内部类
1、成员内部类有特例—静态内部类
2、局部内部类有特例—匿名内部类
//OutClass被称之为外部类
//所有的内部类都是一个独立的类，都拥有各自的属性、行为、构造等等
//每个内部类都会被编译成一篇独立的Class文件，文件名都带外部类类名public class OutClass {
private int a;
private static int b;
//成员内部类
//位置：直接写在外部类当中，位置和属性、构造、方法平行。
//Class文件的名字：”外部类类名” + + “内部类类名”
//可以有访问修饰符，代表是否可以在外部的类使用
//不管带什么访问修饰符，本类（外部类）的所有方法都可以使用
public class InnerClass1{
public void innerMethod(){
//内部类如果要调用外部类的属性，请书写下面格式：
OutClass.this.a = 100;
}
}
//静态内部类--成员内部类的特例
//位置：直接写在外部类当中，位置和属性、构造、方法平行。
//Class文件的名字：”外部类类名" + $ + "内部类类名”
//可以有访问修饰符，代表是否可以在外部的类使用
//不管带什么访问修饰符，本类（外部类）的所有方法都可以使用
public static class InnerClass2{
public void innerMethod(){
//静态内部类只能使用外部类的静态属性或静态方法，请书写下面格式：
OutClass.b = 100;
}
}
public void test1(final int e){
this.a = e;
final int A = 1200;
//局部内部类
//位置：直接写在外部类的方法当中，其位置和局部变量平行。
//Class文件的名字：”外部类类名" + $ + "序号" + "内部类类名”
//没有访问修饰符，只能在所定义的外部类方法中使用
class InnerClass3{
public void innerMethod(){
//局部内部类不能操作它所在方法的局部变量（非常特殊）
System.out.println(OutClass.this.a);
System.out.println(e);
}
}
//直接产生内部类对象
InnerClass3 in = new InnerClass3();
in.innerMethod();
}
public void test2(){
//匿名内部类--是局部内部类的特例
//位置：直接写在外部类的方法当中，其位置和局部变量平行。
//Class文件的名字：”外部类类名" + $ + "序号"
//在产生对象的同时去定义这个类，只能用这一次
new Object(){
public void introduce(){
//匿名内部类不能操作它所在方法的局部变量（非常特殊）
System.out.println("我可不是Object哦~~~");
}
}.introduce();
}
}
//main方法
public static void main(String[] args) {
// TODO Auto-generated method stub
//在外部使用成员内部类–首先产生外部类对象、然后使用特殊语法外部类对象.new
//产生内部类对象，然后再调用内部类对象的属性或方法（受访问修饰符限制）
OutClass out = new OutClass();
OutClass.InnerClass1 oi = out.new InnerClass1();
oi.innerMethod();
//在外部类使用静态内部类---可以用外部类类名直接访问操作，无需产生外部类对象
OutClass.InnerClass2 oi2 = new OutClass.InnerClass2();
}
}