java中内部类

内部类

  • 成员内部类
    • 静态成员内部类
    • 非静态成员内部类
  • 局部内部类
    • 带名字的局部内部类
    • 匿名内部类

概念:

一个类定义在另一个类的类体中,这个里面的类叫内部类,外面的类叫外部类

分类:

1、静态成员内部类:声明在外部类的类体,由static关键字修饰

特点:可以在内部类中声明静态成员,

可以不需要创建外部类对象,直接创建内部对象类,可以访问外部静态类的成员

不能访问外部类普通成员。

2、普通成员内部类:声明在外部类的类体中,没有static修饰

特点:只能在内部类类体中声明普通成员,需要先创建外部类对象,在由外部类对象创建内部类对象,可以访问外部类所有的成员。

3、局部内部类:声明在方法体中的内部类

特点:不能脱离声明内部类的方法使用

4、匿名内部类是局部内部类的特殊形式,匿名内部类通常作为类的子类或者接口的实现类。

静态成员内部类

/*
 *静态内部类:
 * 可以在静态内部类里声明:静态属性、静态方法、普通属性、普通方法
 * 只能访问外部静态属性,静态方法
 *
 * 其他类使用时可以直接创建对象,  外部类.静态内部类  XXX = new 外部类.内部类();
 */
public class InStaticClass {

//外部普通属性
    private String outOne;

//外部静态属性
    private static String outTwo;

//外部普通方法
    public void outMethodOne(){
        System.out.println("外部普通方法");
    }

//外部静态方法
    public static void outMethodTwo(){
        System.out.println("外部静态方法");
    }

/************静态内部类*******************************************/
    static class Inner{

        //内部静态属性
        private static String innerOne;
        //内部普通属性
        private String innerTwo;
        //内部静态方法
        public static void innerStaticMethod(){

      //调用外部静态属性
            outTwo = "  ";
            //outOne = "";         //不能调用外部普通属性

            innerOne = "innerOne";
            System.out.println("内部静态方法");
//内部静态方法可以调用静态方法
            System.out.println("----------------内部类的静态方法调用外部静态方法");
            outMethodTwo();
        }
        //内部普通方法
        public void innerMethod(){
            innerOne = "innerOne";
            innerTwo = "innerTwo";
            outTwo = "  ";          //内部普通方法调用外部静态属性

            System.out.println("内部普通方法");
//内部普通方法可以调用静态方法
            System.out.println("----------------内部类的 普通方法 调用外部静态方法");
            outMethodTwo();

            // outMethodOne();      //静态内部类不能调用外部普通方法
        }
    }
}

调用内部类时:

public class InStaticClassTest {

    public static void main(String[] args) {

        //匿名调用innerMethod方法
        new InStaticClass.Inner().innerMethod();

        //创建对象调用内部静态类的方法
        InStaticClass.Inner inner = new InStaticClass.Inner();
        inner.innerMethod();
    }
}

普通成员内部类

*
 *内部普通类
 *
 * 可以在内部普通类中声明普通属性、普通方法
 * 可以访问外部静态属性、静态方法、普通属性、普通方法
 *
 * 调用时,必须先创建外部类的对象,
 *
 *方法一:
 * 外部类.内部普通类 XXX = new外部类().new 内部普通类();
 *
 * 方法二:
 * 外部类 XXX = new 外部类();
 *
 * 外部类.内部普通类 *** = new XXX.内部普通类();
 */
public class PuInnerClass {

//外部普通属性
    private String outOne;

//外部静态属性
    private static String outTwo;

//外部普通方法
    public void outMethodOne(){
        System.out.println("外部普通方法");
    }

//外部静态方法
    public static void outMethodTwo(){
        System.out.println("外部静态方法");
    }

//普通内部类
    class Inner{

        //不能定义内部静态属性
        //private static String innerOne;
        //内部普通属性
        private String innerTwo;
        //不能定义内部静态方法
//        public static void innerStaticMethod(){
//            innerOne = "innerOne";
//            System.out.println("内部静态方法");
内部静态方法可以调用静态方法
//            System.out.println("----------------内部类的静态方法调用外部静态方法");
//            outMethodOne();
//
//        }

        //内部普通方法
        public void innerMethod(){
            System.out.println("内部普通方法");
//内部普通方法可以调用静态方法
            System.out.println("----------------内部类的 普通方法 调用外部静态方法");
            outMethodOne();
            innerTwo = "innerTwo";

//内部普通类的方法可以调用外部普通方法,外部普通变量
            outMethodOne();
            outOne = "innerOne";
//普通内部类的方法调用外部静态方法,外部静态属性
            outTwo = "   ";
            outMethodTwo();
        }
    }
}

调用时:

public class PuInnerClassTest {

    public static void main(String[] args) {

        //不可以直接调用,必须先创建外部类,才能调用内部类
       // PuInnerClass.Inner = new PuInnerClassTest.Inner();

        //方法一
        PuInnerClass puInnerClass = new PuInnerClass();
        PuInnerClass.Inner inner = puInnerClass.new Inner();
        inner.innerMethod();

        //方法二
        PuInnerClass.Inner inner2 = new PuInnerClass().new Inner();
        inner2.innerMethod();

    }
}

带名字的局部内部类

/*
 *局部内部类
 *
 * 可以在局部内部类中声明普通属性、普通方法
 * 可以访问外部静态属性、静态方法、普通属性、普通方法
 *
 * 调用时只能在定义的方法中使用,(有作用域限制)
 *
 */
public class NameInnerClass {

    //外部普通属性
    private String outOne;

    //外部静态属性
    private static String outTwo;

    //外部普通方法
    public void outMethodOne(){
        System.out.println("外部普通方法");
    }

    //外部静态方法
    public static void outMethodTwo(){
        System.out.println("外部静态方法");
    }

    public void method(){

        //method方法内的局部类,注意public、private、static、是修饰类的成员的,不能用作局部变量的修饰
        class PartInner{
            //局部类静态属性
            //private static String innerOne;
            //局部类普通属性
            private String innerTwo = "innerwTwo";

//            //局部类静态方法
//            public static void innerStaticMethod(){
//
//                //调用外部静态属性
//                outTwo = "  ";
//                //outOne = "";         //不能调用外部普通属性
//                System.out.println("内部静态方法");
内部静态方法可以调用静态方法
//                System.out.println("----------------内部类的静态方法调用外部静态方法");
//                outMethodTwo();
//            }

            //局部类普通方法
            public void innerMethod(){
                innerTwo = "innerTwo";
                outTwo = "  ";          //局部类普通方法调用外部静态属性
                outOne = "  ";          //局部类普通方法调用外部普通属性

                System.out.println("内部普通方法");
//局部类普通方法可以调用静态方法
                System.out.println("----------------内部类的 普通方法 调用外部静态方法");
                outMethodTwo();

                outMethodOne();      //静态内部类调用外部普通方法
            }
        }

        PartInner partInner = new PartInner();
        String a = partInner.innerTwo;
        partInner.innerMethod();

        new PartInner().innerMethod();
    }
}

匿名局部类

//声明一个接口
public interface Teacher {

    public void gaToClass();
}

//匿名内部类
public class NoNameInnerClass {
    public static void main(String[] args) {

        //创建对象匿名内部类
        Teacher teacher = new Teacher() {
            @Override
            public void gaToClass() {
                System.out.println("class is Begining");
            }
        };

        method(teacher);

        //匿名对象,匿名内部类
        method(new Teacher() {
            @Override
            public void gaToClass() {
                System.out.println("class is Beging-----byAnonymity");
            }
        });
    }

    public static  void method(Teacher teacher){
        teacher.gaToClass();
    }
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值