java基础（四）

8．代码块、静态代码块
类的组成：成员属性、成员方法、静态属性、静态方法、代码块、静态代码块、成员内部类。
{
语句1
语句2
语句3
}
static{
语句1
语句2
语句3
}

1.代码块 优先于 构造器 执行。
2.静态代码块 优先于 代码块 执行。
3.父类的静态代码块 优先于 子类的静态代码块。
4.父类都执行完以后，在执行子类的。
5.多个代码块，按定义的先后顺序执行。

作用： 初始化资源，赋初值，链接数据库，检查网络。。。准备工作。

9．关键字final
final 的
finally 地
finalize

最终的。

（1）修饰类：该不能被继承，这个类 叫做 最终类。目的是为了保护该类。

（2）修饰方法：该方法不能被重写，可以被继承，该方法叫 最终方法。

static 和 final 可以一起修饰 方法：静态的，不能被重写，可以被继承。
static 和 abstract 不可以一起 修饰 方法：静态的，类名去掉静态方法，抽象方法不能直接执行。 矛盾。
abstract 和 final 不可以一起 修饰 方法：抽象方法，就是为了让子类去实现，最终方法不能重写。矛盾。

（3）修饰变量：该变量不能被修改，叫做常量。一般 static final 一起修饰 常量。
常量起名 一般 用 全大写。
10．内部类
一个.java文件中，可以有多个类的定义。但是 有且只有一个class 能被 public 所修饰，并且这个class 的名字 要与 文件名 一致。进行编译后，会生成多个.class文件。

（1）成员内部类
public class OutterClass {
    class InnerClass{
        public void eat(){
            System.out.println("InnerClass.eat");
        }
}
public void show(){
        InnerClass  inner= new InnerClass();
        Inner.eat();
}
public static void main(String[] args) {
        new OutterClass().show();
        InnerClass  inner = new OutterClass().new InnerClass();
        inner.eat();
    }
}

成员内部类 可以使用 外部类的 成员属性 和 成员方法。但是在内部类里使用this关键字 指代的是 内部类的对象。

public class OutterClass {
    private int num = 1000;
    public void drink(){
        System.out.println("OutterClass.drink");
    }
    class InnerClass{
        public void eat(){
            System.out.println(num);
            drink();
            System.out.println("InnerClass.eat");
        }
}
}

（2）局部内部类

局部内部类，写在方法内，需要先声明定义内部类，然后才可以 使用。

public class OutterClass {

    public void eat(){
        System.out.println("OutterClass.eat");

        class InnerClass{
            public void eat(){
                System.out.println("InnerClass.eat");
            }
        }
        InnerClass inner = new InnerClass();
        inner.eat();
    }
    public static void main(String[] args) {
        OutterClass outter = new OutterClass();
        outter.eat();
        //InnerClass inner = null;
    }
}
public class OutterClass {
    public int num=300;
    public void drink(){
        System.out.println("OutterClass.drink");
    }
    public void eat(){
        System.out.println("OutterClass.eat");
        class InnerClass{
            public void eat(){
                System.out.println(num);
                drink();
                System.out.println("InnerClass.eat");
            }
        }
        InnerClass inner = new InnerClass();
        inner.eat();
    }

（3）匿名内部类

不是没有名字，而是没有引用。
想使用一次，必须new一次。

public interface Flyable {
    int num = 100;
    public void fly();
}
public class Test {
    public static void main(String[] args) {
        new Flyable(){
            @Override
            public void fly() {
                System.out.println("自由飞翔");
            }
        }.fly();
        //Flyable.num = 200;
        System.out.println(new Flyable(){
            @Override
            public void fly() {
                System.out.println("自由飞翔");
            }
        }.num);
    }
}