代码块和内部类

1 代码块

定义：使用{ }定义的一段代码。

分类：

• 普通代码块
• 构造块
• 静态块
• 同步代码块

1.1 普通代码块

普通代码块：定义在方法中的代码块。

public class Test{
    public static void main(String[] args) {
        {//直接使用{}定义
            int x=10;
            System.out.println("x= "+x);
        }
        int x=100;
            System.out.println("x= "+x);
}

一般如果代码中方法代码过长，为了避免变量重名，使用普通代码块。

1.2 构造块

构造块：定义在类中的代码块（不加修饰符）。

class Student{
    {//定义在类中，不加任何修饰符
        System.out.println("1.Student类的构造块");
    }
    public Student(){
        System.out.println("2.Student类的构造方法");
    }
}
public class Test {
    public static void main(String[] args) {
        new Student();
        new Student();
    }
}

上述代码的执行结果为：

1.Student类的构造块
2.Student类的构造方法
1.Student类的构造块
2.Student类的构造方法

通过运行结果我们发现：构造块优先于构造方法执行，每产生一个新的对象就调用一次构造方法。

1.3 静态代码块

静态代码块：使用static定义的代码块

根据静态代码块所在的类的不同可分为以下类型：

1.3.1 在非主类中的静态块

class Student{
    {//定义在类中，不加任何修饰符
        System.out.println("1.Student类的构造块");
    }
    public Student(){
        System.out.println("2.Student类的构造方法");
    }
    static{
        System.out.println("3.Student类的静态块");
    }
}
public class Test {
    public static void main(String[] args) {
        new Student();
        new Student();
    }
}

上述代码的执行结果为：

3.Student类的静态块
1.Student类的构造块
2.Student类的构造方法
1.Student类的构造块
2.Student类的构造方法

通过运行结果我们发现：

1. 静态块优先于构造块执行。
2. 无论产生多少实例化对象，静态块都只执行一次。

1.3.2 定义在主类中的代码块

public class Test {

        {//定义在类中，不加任何修饰符
            System.out.println("1.Test类的构造块");
        }
    public Test(){
            System.out.println("2.Test类的构造方法");
        }
        static{
            System.out.println("3.Test类的静态块");
        }
    public static void main(String[] args) {
            System.out.println("----start----");
            new Test();
            new Test();
            System.out.println("----end----");
    }
}

上述代码的运行结果为：

3.Test类的静态块
----start----
1.Test类的构造块
2.Test类的构造方法
1.Test类的构造块
2.Test类的构造方法
----end----

通过上述代码的运行结果我们发现：在主类中定义的静态块，优先于主方法执行。

2 内部类的定义与使用

定义：在一个类的内部进行其他类结构的嵌套的操作。

为什么要有内部类？

1. 内部类方法可以访问该类定义所在作用域中的数据，包括被private修饰的私有数据；
2. 内部类可以对同一包中的其他类隐藏起来；
3. 内部类可以实现Java单继承的缺陷；
4. 当我们想要定义一个回调函数却不想写大量代码时可以考虑匿名内部类。

例：使用内部类实现“多继承”

class A{
    private String name="A类的私有域";
    public String getName() {
        return name;
    }
}
class B{
    private int age=20;
    public int getAge() {
        return age;
    }
}
class Outter{
    private class InnerClassA extends A{
        public String name(){
        return super.getName();
    }
}
    private class InnerClassB extends B {
        public int age() {
            return super.getAge();
        }
    }
    public String name(){
        return new InnerClassA().name();
    }
    public int age(){
        return new InnerClassB().age();
    }
}

public class Test{
    public static void main(String[] args) {
        Outter outter = new Outter();
        System.out.println(outter.name());
        System.out.println(outter.age());
    }
}

2.1 内部类与外部类的关系

• 对于非静态内部类，内部类的创建依靠外部类的实例对象，在没有外部实例之前是无法创建内部类的
• 内部类是一个相对独立的实体，与外部类不是is-a关系
• 内部类可以直接访问外部类的元素（包括私有域），但是外部类不能直接访问内部类的元素
• 外部类可以通过内部类引用来间接访问内部类元素

例：外部类可以通过内部类引用来间接访问内部类元素

class Outter {
    public void print(){
        //外部类访问内部元素，需要通过内部类引用来访问
        Inner inner=new Inner();
        inner.print();
    }
    class Inner{
        public void print(){
            System.out.println("我是一个内部类");
        }
    }
}
public class Test{
    public static void main(String[] args) {
        Outter outter = new Outter();
        outter.print();
    }
}

2.2 内部类

java中内部类主要分为：

• 成员内部类
• 静态内部类
• 方法内部类
• 匿名内部类

2.2.1 在外部类外部创建内部类

外部类.内部类 内部类对象 = new 外部类（）.new 内部类（）；

Outter.Inner in = new Outter().new Inner();

2.2.2 在外部类内部创建内部类

Inner in = new Inner();

2.3 内部类详解

2.3.1 成员内部类

1. 成员内部类不能存在任何的static变量或方法；
2. 成员内部类是依附于外部类的，所以只有先创建了外部类才能够创建内部类。

2.3.2 静态内部类

1. 使用static修饰内部类称为静态内部类；
2. 直接创建，不需要依赖外部类
3. 静态内部类不可以使用任何外部类的非static变量和方法。

创建语法：

外部类.内部类 内部类对象 = new 外部类.内部类();

例：使用static创建静态内部类

class Outter {
    private static String msg="Hello world!!";
    static class Inner{
        public void print(){
            System.out.println(msg);
        }
    }
    public void fun(){
        Inner in = new Inner();
        in.print();
    }
}
public class Test{
    public static void main(String[] args) {
        Outter.Inner in=new Outter.Inner();
        in.print();
    }
}

2.3.3 方法内部类

1. 定义在外部类的方法中。
2. 不允许使用访问权限修饰符。
3. 对外完全隐藏，除了创建这个类的方法可以访问，其它地方均不允许访问。
4. 方法内部类要想使用形参，该形参必须用final声明。（JDK形参变为隐式final声明）

class Outter {
    private int num;
    public void display(int test){
        class Inner{
            private void fun(){
                num++;
                System.out.println(num);
                System.out.println(test);
            }
        }
        new Inner().fun();
    }
}

public class Test{
    public static void main(String[] args) {
        Outter out = new Outter();
        out.display(10);
    }
}

这里输出的结果为：1   10

前面提到方法内部类要想使用形参，必须用final声明，说明形参值是不能修改的；

这里本应该输出结果是：0   10，为什么会是1呢？

因为这里所说的不能修改是不能修改形参的指向。

2.3.4 匿名内部类

1. 没有名字的方法内部类，符合方法内部类的所有约束；
2. 没有访问修饰符；
3. 必须继承一个抽象类或实现一个接口；
4. 不能存在任何静态成员或方法；
5. 没有构造方法，因为它没有类名；

interface MyInterface{
    void test();
}
class Outter{
    private int num;
    public void display(int msg){
        //匿名内部类，实现了MyInterface接口
        new MyInterface(){
            public void test(){
                System.out.println("匿名内部类"+msg);
            }
        }.test();
    }
}
public class Test{
    public static void main(String[] args) {
        Outter out = new Outter();
        out.display(10);
    }
}

总结 内部类的特点：

• 破坏了程序的结构
• 方便进行私有属性的访问
• 如果在类名称上出现了. ,应立即想到是内部类的概念