内部类、代码块

基本概念

一、内部类可以方便的访问外部类的私有属性

package practice;

class Outner{    //外部类
    private String msg = "Hello World";
    class Inner{   //内部类
        public void print(){
            System.out.println(msg);
        }
    }
    public void fun(){
        //实例化内部类对象并调用print()方法
        new Inner().print();   //使用匿名对象，此时不必声明对象
    }
}

public class Inner {
    public static void main(String [] args){
        Outner a = new Outner();  //声明外部对象并实例化外部类
        new Outner().fun();  //调用外部类方法-------用a调用和用new Outner()调用一样
    }
}

二、外部类也可以方便的访问内部类的私有属性

package practice;

class Outner{    //外部类
    private String msg = "Hello World";
    class Inner{   //内部类
                private String info = "世界，你好"；
        public void print(){
            System.out.println(msg);
        }
    }
    public void fun(){
        //声明并实例化内部类对象
        Inner in = new Inner();   
                //直接利用内部类调用了内部类中定义的方法
                System.out.println(in.info);
    }
}

public class Inner {
    public static void main(String [] args){
        Outner a = new Outner();  //声明外部对象并实例化外部类
        new Outner().fun();  //调用外部类方法-------用a调用和用new Outner()调用一样
    }
}

三、类名称.this.属性

package practice;

class Outner{    //外部类
    private String msg = "Hello World";
    class Inner{   //内部类
        public void print(){
                  //this表示当前，若不加Outner，this.msg表示查找当前类
            System.out.println(Outner.this.msg);
        }
    }
    public void fun(){
        //实例化内部类对象并调用print()方法
        new Inner().print();   //使用匿名对象，此时不必声明对象
    }
}

public class Inner {
    public static void main(String [] args){
        Outner a = new Outner();  //声明外部对象并实例化外部类
        new Outner().fun();  //调用外部类方法-------用a调用和用new Outner()调用一样
    }
}

转换(内部类的实例化方法)

package practice;

class Outner{    //外部类
    private String msg = "Hello World";
    class Inner{   //内部类
        public void print(){
            System.out.println(Outner.this.msg);
        }
    }
    
}

public class Inner {
    public static void main(String [] args){
              //外部类.内部类 对象 = new 外部类().new 内部类();
        Outner.Inner in = new Outner().new Inner();
        in.print();
    }
}

static定义内部类

package practice;

class Outner{    //外部类
    private static String msg = "Hello World";
    static class Inner{   //内部类
        public void print(){
            System.out.println(msg);
        }
    }   
}
public class Inner {
    public static void main(String [] args){
        Outner.Inner in = new Outner.Inner();
        in.print();
    }
}

方法中定义内部类

内部类可以在任意位置定义，包括类、方法、代码块。

package practice;

class Outner{    //外部类
    private String msg = "Hello World";
    public void fun(){
        class Inner{
            public void print(){
                System.out.println(Outner.this.msg);
            }
        }
        new Inner().print();;
    }
    
}

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

内部类和外部类之间可以方便的进行私有属性的访问

package practice;

class Outner{    //外部类
    private String msg = "Hello World";
    public void fun(int num){
        double score = 99.9;
        class Inner{
            public void print(){
                System.out.println("属性："+Outner.this.msg);
                System.out.println("方法参数："+num);
                System.out.println("方法变量："+score);
            }
        }
        new Inner().print();;
    }
    
}

public class Inner {
    public static void main(String [] args){
        new Outner().fun(100);
    }
}

---

分类

代码块分为普通代码块、构造块、静态块、同步代码块。由{}括起来的才为代码块。

普通代码块

作用避免代码过多时，有可能产生重复变量。

public class Demo{
      public static void main(String [] args){
         //下面大括号内容即为普通代码块，若去掉普通代码块则程序错误，变量名重复
           {
             int num = 10;   //局部变量
             System.out.println(num);
           }
           int num = 10;   //全局变量
           System.out.println(num);
    }
}

构造块

构造块执行优先于构造方法

class Gouzhao{
        public  Gouzhao(){    //构造方法
            System.out.println("【A】 构造方法产生");
   }
  {
          System.out.println("【B】 构造块产生");       
  }
}
public class Demo{
    public static void main(String [] args){
          new Gouzhao();
}
}

静态块

含有static关键字的都为静态块，分为两种在主类中和非主类中。

非主类静态块

执行优先于构造块，但是只执行一次，作用为类中的static属性初始化。

class Gouzhao{
        static String mag;
        public  Gouzhao(){    //构造方法
        System.out.println("【A】 构造方法产生");
   }
  {
        System.out.println("【B】 构造块产生");       
  }
  static{       //静态块
        msg = "Hello";
        System.out.println("【C】 静态块产生");       
  }
}
public class Demo{
    public static void main(String [] args){
          new Gouzhao();
          new Gouzhao();
          new Gouzhao();
          System.out.println(Gaozhao.msg);  
}
}

主类静态块

执行优先于主方法。

public class Demo{
static{       //静态块
        System.out.println("静态块产生");       
  }
    public static void main(String [] args){
        System.out.println("Hello World");       
}

同步代码块

......

总结

四大代码块开发制造一般不会使用，但在测试程序时有可能会使用到静态块。