代码块、内部类

代码块：

用{}括起来的代码就叫代码块：

 ·普通代码块：直接在一个方法中出现的{}

·构造块

·静态块

·同步代码块

构造块：

class Demo{
    {    
        System.out.println("*******构造代码块*****");
    }
    public Demo(){
        System.out.println("*********构造方法**********")  ;
    }
} ;
public class CodeDemo02{
    public static void main(String args[]){
        new Demo() ;
        new Demo() ;
        new Demo() ;
    }
} ;

静态块：

使用关键字static声明的代码块称为静态块

class Demo{
    {    
        System.out.println("*******构造代码块*****");
    }
    static{
        System.out.println("*********类中的静态块***********");
    }
    public Demo(){
        System.out.println("*********构造方法**********")  ;
    }
} ;
public class CodeDemo03{
    static{
        System.out.println("*********主类中的静态块***********") ;
    }
    public static void main(String args[]){
        new Demo() ;
        new Demo() ;
        new Demo() ;
    }
} ;

可以看到静态块优先于主方法执行，静态块优先于构造快执行，而且只执行一次。

=================================================================================

内部类：

内部类：在类中定义的类。

例：

class     Outer{
    private String name = "hello world!" ;
    class     Inner{
    public void print(){
        System.out.println("name =" +  name) ;
    }
}  ;
    public void fun(){
        new Inner().print()  ;
    }
} ;
public class InnerClassDemo02{
    public static void main(String args[]){
        new Outer().fun() ;
    }
} ;

缺点是接口很混乱，内部类的唯一优点是可以访问外部类中的私有成员（变量）。

如果要在外部类中使用内部类的实例化对象，应该按如下格式

      外部类.内部类 内部类对象 =  外部类实例. new 内部类实例

class Outer{
    private String name = "HELLO WORLD!!!" ;
    class Inner{
        public void print(){
            System.out.println("name = " + name) ;
        }
    };
};
public class InnerClassDemo03{
    public static void main(String args[]){
        Outer out = new Outer() ;    // 外部类实例
        Outer.Inner in = out.new Inner() ;    // 实例化内部类对象
        in.print() ;
    }
};

一个内部类如果使用static来声明的话，则该内部类将变成外部类

class Outer{
    private static String name = "HELLO WORLD!!!" ;
    static class Inner{
        public void print(){
            System.out.println("name = " + name) ;
        }
    };
};
public class InnerClassDemo04{
    public static void main(String args[]){
        Outer.Inner in  = new Outer.Inner() ;    // 实例化内部类对象
        in.print() ;
    }
};

内部类可以在任何地方使用，如在方法中使用

如下

class Outer{
    private  String name = "HELLO WORLD!!!" ;
    public void fun(){
        class Inner{
            public void print(){
              System.out.println("name = " + name) ;
           }
       };

       new Inner().print()  ;
    }
};
public class InnerClassDemo05{
    public static void main(String args[]){
        new Outer().fun() ;
    }
};

在方法中定义的内部类，可以访问外部类中定义的各个成员，但是如果要访问方法中的参数，则在参数上要使用final关键字声明。

class Outer{
    private  String name = "HELLO WORLD!!!" ;
    public void fun(final int temp){
        class Inner{
             public void print(){
                System.out.println("temp = " + temp) ;
                System.out.println("name = " + name) ;
            }
        };
        new Inner().print()  ;
    }
};
public class InnerClassDemo06{
    public static void main(String args[]){
        new Outer().fun(30) ;
    }
};

内部类总结：

内部类的缺点，破坏了程序的结构。

使用static声明的内部类，就是外部类。

内部类可以在方法中声明，但是如果要访问方法中的参数，则参数钱必须要加上final关键字。