面向对象（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();
}

}