Java常用类

一、内部类

概念： 在一个类的内部再定义一个完整的类。

class Outer{
     class inner{
   }
}

特点： 1、编译之后可生成独立的字节码文件 ----outer.class 和 Outer$inner.class

            2、内部类可直接访问外部类的私有成员，且不破坏封装

            3、可为外部类提供必要的内部功能组件。

1、成员内部类

特点：1、在类的内部定义，与实例变量、实例方法同级别的类。

            2、外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。

                 Outer outer = new Outer();

                 Innerinner = outer.new Inner();

            3、当外部类、内部类存在重名属性时，会优先访问内部类属性。

                   访问外部时要： Outer.this.name;         

 注意：成员内部类里不能有静态变量 :

             报错： private static String name="张三"；

           可以有静态常量：

            可以：  private static final String name="张三"；

class Outer{
     //实例变量 
     private String name = "张三";
     private int age = 22;

     // 内部类
     class Inner{
           private String address = "北京";
           private String phone = "110";

           // 方法
           public void show(){
               System.out.println(name);
               System.out.println(age);
               System.out.println(address);
               System.out.println(phone);
              
       }

   }
}

public class Test{
         public static void main(String[] args){
         //1、 创建外部类对象
          Outer outer = new Outer(); 
         // 2、 创建内部类对象
          Inner inner = outer.new Inner();
          // 1+2 
          Inner inner = new Outer().new Inner();

           inner.show();
     }
}

2、静态内部类（级别与外部类相同）

  不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。

   Outer.Inner inner = new Outer.Inner();

class Outer{
     //实例变量 
     private String name = "张三";
     private int age = 22;

     // 静态内部类，与外部类同级
     static class Inner{
           private String address = "北京";
           private String phone = "110";
           //静态成员
           private static int count = 1000;

           public void show(){

               // 调用外部类属性
               Outer outer = new Outer();
               System.out.println(outer.name);
               System.out.println(outer.age);

               // 调用静态内部类属性和方法
               System.out.println(address);
               System.out.println(phone);

               // 调用静态内部类的 静态属性
               System.out.println(Inner.count);
       }

   }
}

public class Test{
         public static void main(String[] args){
         //直接创建 静态内部类对象
          Outer.Inner inner = new Outer.Inner();

          inner.show();
     }
}

3、局部内部类

定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。

class Outer{
     //实例变量 
     private String name = "张三";
     private int age = 22;

           public  void show(){

          // 定义局部变量
               String address = "深圳";

          // 局部内部类 ： 注意不能加任何访问修饰符
              class Inner{

             // 局部内部类的属性
               private String phone = "1123";
               private String email = "waliunah@mails.cn";
               
               public void show2(){

               // 调用外部类属性
               System.out.println(Outer.this.name);
               System.out.println(age);

               // 调用静态内部类属性和方法
               System.out.println(email);
               System.out.println(phone);

            }
       }
     }
              Inner inner = new Inner();
              inner.show2();
}

4、匿名内部类

没有类名的局部内部类（与局部内部类相同）。

必须继承一个父类或者实现一个接口。

// 接口
public interface Usb{
         void service();
}

public class  testUsb{
       public static void main(String[] args){

          // 创建接口类型的变量
         //  Usb usb = new Mouse();
         //  usb.service();
       
//局部内部类
         class Fan implements Usb{
              public void service(){
                   
                 System.out.println("连接电脑成功，风扇开始工作。。。。");
             }
        }
        // 使用局部内部类创建对象
           Usb usb = new Fan();
           usb.service();


//匿名内部类

         Usb usb = new Usb(){

            public void service(){
     
                   System.out.println("连接电脑成功，风扇开始工作。。。。");
          }
       };
            usb.service();

       
    }
}

public class Mouse implements Usb{

        public void service() {

              System.out.println("连接电脑成功，开始工作。。。。")           

      }

 }