java基础之认识内部类(未修订)

来源：互联网发布：杭州淘宝美工培训机构编辑：程序博客网时间：2024/06/05 20:53

内部类作用

内部类相当于集成了外部类的出去private修饰的所有东西
内部类还能实现多继承，如外部类已经继承，如果还想再继承可以建立内部类进行继承
内部类，除了外部类能够访问，其他类不能访问

成员内部类

成员内部类中不能存在任何static的变量和方法；
成员内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类

public class OuterClass {    private String str;    public void outerDisplay(){        System.out.println("outerClass...");    }    public class InnerClass{        public void innerDisplay(){            //使用外围内的属性            str = "chenssy...";            System.out.println(str);            //使用外围内的方法            outerDisplay();        }    }    /*推荐使用getxxx()来获取成员内部类，尤其是该内部类的构造函数无参数时 */    public InnerClass getInnerClass(){        return new InnerClass();    }    public static void main(String[] args) {        OuterClass outer = new OuterClass();        OuterClass.InnerClass inner = outer.getInnerClass();        inner.innerDisplay();    }

}--------------------chenssy...outerClass...

局部内部类

有这样一种内部类，它是嵌套在方法和作用于内的，对于这个类的使用主要是应用与解决比较复杂的问题，想创建一个类来辅助我们的解决方案，到那时又不希望这个类是公共可用的，所以就产生了局部内部类，局部内部类和成员内部类一样被编译，只是它的作用域发生了改变，它只能在该方法和属性中被使用，出了该方法和属性就会失效。

定义在方法里：

public class Parcel5 {    public Destionation destionation(String str){        class PDestionation implements Destionation{            private String label;            private PDestionation(String whereTo){                label = whereTo;            }            public String readLabel(){                return label;            }        }        return new PDestionation(str);    }    public static void main(String[] args) {        Parcel5 parcel5 = new Parcel5();        Destionation d = parcel5.destionation("chenssy");    }}

定义在作用域内:

public class Parcel6 {    private void internalTracking(boolean b){        if(b){            class TrackingSlip{                private String id;                TrackingSlip(String s) {                    id = s;                }                String getSlip(){                    return id;                }            }            TrackingSlip ts = new TrackingSlip("chenssy");            String string = ts.getSlip();        }    }    public void track(){        internalTracking(true);    }    public static void main(String[] args) {        Parcel6 parcel6 = new Parcel6();        parcel6.track();    }}

匿名内部类

如

button2.addActionListener(                  new ActionListener(){                      public void actionPerformed(ActionEvent e) {                          System.out.println("你按了按钮二");                      }                  });

再如:

public class OuterClass {    public InnerClass getInnerClass(final int num,String str2){        return new InnerClass(){            int number = num + 3;            public int getNumber(){                return number;            }        };        /* 注意：分号不能省 */    }    public static void main(String[] args) {        OuterClass out = new OuterClass();        InnerClass inner = out.getInnerClass(2, "chenssy");        System.out.println(inner.getNumber());    }}interface InnerClass {    int getNumber();}----------------Output:

是不是都不知道那个是匿名内部类了，为啥叫匿名内部类，因为他都没有名字。。。

再看看特点：

匿名内部类是没有访问修饰符的。
new 匿名内部类，这个类首先是要存在的。如果我们将那个InnerClass接口注释掉，就会出现编译出错。
注意getInnerClass()方法的形参，第一个形参是用final修饰的，而第二个却没有。同时我们也发现第二个形参在匿名内部类中没有使用过，所以当所在方法的形参需要被匿名内部类使用，那么这个形参就必须为final。
匿名内部类是没有构造方法的。因为它连名字都没有何来构造方法。

静态内部类

关键字static中提到Static可以修饰成员变量、方法、代码块，其他它还可以修饰内部类，使用static修饰的内部类我们称之为静态内部类

静态内部类与非静态内部类之间存在一个最大的区别：

我们知道非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围内，但是静态内部类却没有

特点：

它的创建是不需要依赖于外围类的。
它不能使用任何外围类的非static成员变量和方法。

public class OuterClass {    private String sex;    public static String name = "chenssy";    /**     *静态内部类     */    static class InnerClass1{        /* 在静态内部类中可以存在静态成员 */        public static String _name1 = "chenssy_static";        public void display(){            /*              * 静态内部类只能访问外围类的静态成员变量和方法             * 不能访问外围类的非静态成员变量和方法             */            System.out.println("OutClass name :" + name);        }    }    /**     * 非静态内部类     */    class InnerClass2{        /* 非静态内部类中不能存在静态成员 */        public String _name2 = "chenssy_inner";        /* 非静态内部类中可以调用外围类的任何成员,不管是静态的还是非静态的 */        public void display(){            System.out.println("OuterClass name：" + name);        }    }    /**     * @desc 外围类方法     * @author chenssy     * @data 2013-10-25     * @return void     */    public void display(){        /* 外围类访问静态内部类：内部类. */        System.out.println(InnerClass1._name1);        /* 静态内部类 可以直接创建实例不需要依赖于外围类 */        new InnerClass1().display();        /* 非静态内部的创建需要依赖于外围类 */        OuterClass.InnerClass2 inner2 = new OuterClass().new InnerClass2();        /* 方位非静态内部类的成员需要使用非静态内部类的实例 */        System.out.println(inner2._name2);        inner2.display();    }    public static void main(String[] args) {        OuterClass outer = new OuterClass();        outer.display();    }

}----------------Output:chenssy_staticOutClass name :chenssychenssy_innerOuterClass name：chenssy

阅读全文

0 0