Java内部类大全

什么是内部类？

可以将一个类的定义放在一个类的内部，这就是内部类。广义上我们将内部类分为四种：成员内部类、静态内部类、局部（方法）内部类、匿名内部类。

为什么要用内部类？

因为java中的 只能单继承 但是如果在 写一个内部类 就又可以继承了

而且内部 是可以享用外部类的一切

注：内部类可以嵌套内部类，但是这极大的破换了代码的结构，这里不推荐使用。）

内部类的特点

内部类提供了更好的封装，除了该外围类，其他类都不能访问。

内部类信息（属性、方法）可以和外部类重名

内部类是具有类的基本特征,可以利用访问修饰符隐藏内部类的实施细节，提供了更好的封装；静态内部类使用时 可直接使用，不需先创造外部类。

同级 内部类之间 是可以访问的 静态内部类直接 类名 点 静态方法

不是静态 的可以new对象

成员内部类

  1. 成员内部类可以是任何的访问修饰符。
  2. 成员内部类不能含有static的变量和方法。因为成员内部类需要先创建外部类，才能创建它自己的
  3. 成员内部类也是类,该继承继承，该重写重写，该重载重载，this和super正常使用。
  4. 成员内部类可以直接使用外部类的任何信息，如果属性或者方法发生冲突，调用外部类.this.属性或者方法。
  5. 外部类访问内部类必须 new 内部类才行

定义内部类

全部示例:

public class test {//外部类
        public String name;
        private  String age;//同名外部变量
        public void show(){
            System.out.println("我是外部类test");
        }
         //外部类通过方法 调用内部类
        public void neiBu(){
            test1 d1=new test1();
            d1.show();
        }


    public class  test1{//内部类

        public  String name123;
        private  String age;//同名内部变量
        public void show(){
            System.out.println("我是内部类test1");
        }

        //内部类调用外部类 直接调用  没有任何权限限制
        public void neiBu(){
            //调用外部类的同名属性
           String age=test.this.age;
           String emmm=name; //调用外部类的属性
            String emm123=this.name123;//调用自己类中的属性
            //调用外部类的同名方法
              test.this.show();
              //调用内部类自己的方法
              this.show();
        }

    }

    public static void main(String[] args) {
    //第一种引用方式 通过外部类的方式 来 实现内部类的功能
        test d1=new test();
        d1.neiBu(); //我是内部类test1
      //第二种 直接调用内部类  需要类型 和 两层new 才能得到内部的 对象
        test.test1 neib=new test().new test1();
        neib.show();  //我是内部类test1

    }
}

静态内部类

  1. 内部可以包含任意的信息。 (也就是没限制了 和正常类一样了随便定义)
  2. 静态内部类的方法只能访问外部类的static关联的信息, 本类正常访问。
(如果想要访问 外部类的成员   就需要外部成员 是静态的)
  1. 静态内部类也是类,该继承继承，该重写重写，该重载重载，this和super正常使用。
  2. 外部类方法 访问内部类普通成员 必须 new 内部类才行
内部类  变量名=new 内部类 ();
  1. 因为静态内部类中只能访问外部类的静态成员 那么就没有重名这一回事
    因为调用的使用 你使用类名. 不就行了

静态成员 调用就不用写了把 直接类名点就行了 和外部类没关系

调用静态内部类的 普通方法

public class test {
    
         public static class  test1{
            public void show(){
            System.out.println("我是内部类");
            }
        }

    public static void main(String[] args) {
       //因为是静态类 所以 不需要new 直接将类.出来   
        test.test1 da=new test.test1();
        da.show();
    }
}

局部内部类

说白了就是在方法内 { } 中创建一个类而已

  1. 可以随意的访问外部类的任何信息。
  2. 局部内部类类似方法的局部变量，所以在类外或者类的其他方法中不能访问这个内部类，但这并不代表局部内部类的实例和定义了它的方法中的局部变量具有相同的生命周期。
  3. 外部不能new局部内部类
  4. 类前不能有访问修饰符。 只能在方法内部 new之后使用，不存在外部可见性问题，因此没有访问修饰符。
  5. 不能在局部 内部类中 改变 外部方法内定义的 局部变量 虽然可以调用但是不能进行 修改

因为方法结束是会弹栈,也就是方法内部的变量没了,而你创建的类还存在堆中这时候类就找不到这个变量了所以不能修改外部局部变量,但是能获取

  1. 无法创造静态信息。
  2. 可以访问外围类的成员变量。如果是static方法，则只能访问static修饰的成员变量。在1.8之前 必须使用final修饰才能调用 在1.8之后就不需要了 但是不能被改变 只能引用
  3. 可以使用final 或 abstract修饰。
public class test {
    
    
    

    public void show(){
        String a1="10";
        class    test_neibu{

            public void show_1(){
                String name=a1;
                System.out.println("我是局部内部类");
            }
        }
        test_neibu test_neibu=new  test_neibu();
        test_neibu.show_1();
    }
    
    
    
    

    public static void main(String[] args) {
        test s=new test ();
        s.show();
    }

}
//我是局部内部类

还可以通过多态的方式 来将内部类 传递出去

public class test {


    public   interface neibu{
        void show_2();
    }

    
    
    
    public neibu  show_1(){
        String a1="10";

        class  test_neibu implements neibu{

            @Override
            public void show_2() {
                System.out.println("我是内部类");
            }
        }
        neibu test_neibu=new  test_neibu();

        return test_neibu;
    }

    
    
    
    
    public static void main(String[] args) {
        neibu s=new test ().show_1();
        s.show_2();
//我是内部类
    }

}

匿名内部类

  1. 匿名内部类不能定义任何静态成员、方法。
  2. 匿名内部类中的方法不能是抽象的；
  3. 匿名内部类必须实现接口或抽象父类的所有抽象方法。 同时自动继承他们的成员变量
  4. 如果抽象类 或者类中 定义了构造 那么子类 必须赋值 就和new对象一样 给括号里添加
  5. 匿名内部类因为没有类名，可知匿名内部类不能定义构造器。
  6. 因为在创建匿名内部类的时候，会立即创建它的实例，可知匿名内部类不能是抽象类，必须实现接口或抽象父类的所有抽象方法。
  7. 匿名内部类会继承一个父类（有且只有一个）或实现一个接口（有且只有一个），实现父类或接口中所有抽象方法，可以改写父类中的方法，添加自定义方法。
  8. 内部类可以访问外部类私有变量和方法.

案例

public class test {
    
    public  abstract   class  neibulei{//抽象类
        public String name;
        
        public neibulei(String name){//定义构造
            this.name=name;
        }

        public abstract void show_1();
    }



    public  String sex;// 我是 类的成员属性
    public void tesst_1(){
        System.out.println("我是类的成员方法");
    }

    public neibulei show_1(){    //我是类的成员 方法
        int num=10;
        String name="胡";

        return new  neibulei(name) {//使用匿名内部类  给构造赋值
            @Override
            public  void show_1(){

                System.out.println("我的名字是: "+ name+"  我的年龄是 :" +num+"我的性别:"+sex);
                tesst_1();

            }
        };
    }
    public static void main(String[] args) {

        test ts=new test();
        ts.sex="男";
        neibulei a= ts.show_1();
        a.show_1();

    }

}

我的名字是: 胡  我的年龄是 :10我的性别:
我是外部类的方法

还可以和接口

public class test {


    public interface neiming_inter { //接口

        void  show();
    }



    public  String sex;// 我是 类的成员属性
    public void tesst_1(){
        System.out.println("我是外部类的方法");
    }

    public neiming_inter show_1(){    //我是类的成员 方法
        int num=10;
        String name="胡";

        return new neiming_inter() {
            @Override
            public void show() {
                System.out.println("我的名字是: "+ name+"  我的年龄是 :" +num+"我的性别:");
                tesst_1();
            }
        };

    }
    public static void main(String[] args) {

        test ts=new test();
        ts.sex="男";
        neiming_inter a= ts.show_1();
        a.show();

    }

}

我的名字是: 胡  我的年龄是 :10我的性别:
我是外部类的方法

除了使用方法 返回值值外 还可以将将 对象 赋值给 变量

public interface Inter {
    void  show();
}


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

        Inter in=new Inter() {
            @Override
            public void show() {
                System.out.println("我是匿名内部类重写的方法");
            }
        };

        in.show();
    }
}

//我是匿名内部类重写的方法

匿名对象(只能使用一次)

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

        new Inter() {
            @Override
            public void show() {
                System.out.println("我是匿名内部类重写的方法");
            }
        }.show();

    }
}
//我是匿名内部类重写的方法
//我是匿名内部类重写的方法


点赞 -收藏-关注-便于以后复习和收到最新内容 有其他问题在评论区讨论-或者私信我-收到会在第一时间回复 如有侵权，请私信联系我 感谢,配合,希望我的努力对你有帮助^_^

java内部类总结 java内部类有哪些_java内部类总结