JAVA类（下）

我看完了Java类,与C++相比，复杂了一点。其中有类的嵌套定义即内部类，枚举类等。

我看这两节花了我很多时间。其中有一些概念还是有点难懂。

下面，我详细总结内部类与枚举类。

内部类

内部类的主要作用：

1. 提供更好的封装。
2. 内部类成员可以直接访问外部类的私有数据。进而可以实现回调
3. 匿名内部类适合用于创建那些仅需要一次使用的类。

   注意，匿名内部类，在枚举中使用十分适合，应用广泛。

1.1非静态内部类

1.2静态内部类

1.3使用内部类

1.4匿名内部类

1.5闭包与回调

 

1..1

定义方式：方法中定义，称为局部内部类。

         方法外定义，称为成员内部类。

因为内部类作为其外部类的成员，所以可以使用public private protected default

 

public
class Cow {

    private
double
weight;

    public Cow(){}

    public Cow(double weight)

    {

        this.weight=weight;

    }

    private
class CowLeg

    {

        private
double
length;

        private String color;

        public
CowLeg(){}

        public CowLeg(double length,String color)

        {

            this.length=length;

            this.color=color;

        }

        

        public
void
setLength(double length)

        {

            this.length=length;

        }

        public
void
setColor(String color)

        {

            this.color=color;

        }

        public
double
getLength()

        {

            return
this.length;

        }

        public String getColor()

        {

            return
this.color;

        }

        

        public
void info()

        {

            System.out.println("当前的长方形颜色是："

                                +color+",高:"+length);

            System.out.println("长方形的重量是："+ weight);

        }

    }

    public
void test()

    {

        CowLeg c1=new CowLeg(1.12,"黑白相间");

        c1.info();

    }

    public
static
void main(String[] args) {

        // TODO Auto-generated method stub

        Cow cow =new Cow(378.9);

        cow.test();

    }

}

产生了两个class字节文件

可以看到内部类与外部类的区别了吧！！

执行结果:

关键的知识点：

    在非静态内部类里可以直接访问外部类的private成员，这是因为在非静态内部类对象里，保存了一个它寄存的外部类的对象的引用。

    简单点説：必须有一个非静态内部类实例必须寄存在外部类实例里,因此，在外部类中不能使用内部类中的成员变量

System.out.println(new Cow().weight);

如上句话，就可以访问内部类的私有变量了。

如果外部类成员变量、内部类成员变量与内部类里方法的局部变量同名，则可以通过:

this

外部类名.this.局部变量名

来调用内部、外部。

非静态内部类不能有静态方法、静态成员变量、静态初始化块

1.2

定义方式：与1.1中定义相同，但是修饰符为static

 

public
class StaticInnerClassTest {

 

    private
int
propl=5;

    private Object StaticInnerClass;

    private
static
int
prop2=9;

    public
static
void info()

    {

        System.out.println("我是静态变量");

    }

    static
class StaticInnerClass

    {

        private
static
int
age;

        public
void accessOuterPro()

        {

            System.out.println(prop2);

            info();

        }

    }

    public
static
void main(String[] args) {

        // TODO Auto-generated method stub

        StaticInnerClassTest test=new StaticInnerClassTest();

        StaticInnerClassTest.StaticInnerClass demo=new StaticInnerClassTest.StaticInnerClass();

        demo.accessOuterPro();

    }

 

}

 

这个类属于外部类的本身，称类内部类，并且 static不可以修饰外部类，但可以修饰内部类.

静态内部类能有静态方法、静态成员变量、静态初始化块

以及非静态的。

静态内部类只能访问外部类的类成员

接口中允许使用：内部类 修饰符，一般为public

1.3

 

public
class CreateInnerLnstance {

 

    class In

    {

        public In(String msg)

        {

            System.out.println(msg);

        }

    }

    public
static
class CreateInnerInstance

    {

        public
static
void testt()

        {@SuppressWarnings("unused")

        CreateInnerLnstance.In in = new CreateInnerLnstance().new In("信息测试");}

    

    }

    @SuppressWarnings("static-access")

    public
static
void main(String[] args) {

        // TODO Auto-generated method stub

        CreateInnerLnstance.CreateInnerInstance in = new CreateInnerLnstance.CreateInnerInstance();

        in.testt();

    }

 

}

执行结果:

内部类的深层次嵌套:

package test;

 

public
class tes {

 

    public
static
class t

    {

        public t()

        {

            System.out.println("I am outclass");

        }

        public
static
class t1

        {

            public t1()

            {

                System.out.println("I am inner1");

            }

            public
static
class t2

            {

                public t2()

                {

                    System.out.println("I am inner2");

                }

            }

        }

    }

    public
static
void main(String[] args) {

        // TODO Auto-generated method stub

        tes.t.t1.t2 testt2=new tes.t.t1.t2();

    }

}

执行结果

在外部类以外使用非静态内部类

    在外部类以外的地方定义内部类

        OuterClass.new InnerConstructor ()

非静态内部类的构造器必须使用外部类对象来调用。因此在使用上一句时，必须已经创建了外部类了。

继承内部类

class Out

{

    class In

    {

        public In(String msg)

        {

            System.out.println(msg);

        }

    }

}

class SubClass extends Out.In

{

    public SubClass(Out out)//此参数不可少！！！！

    {

        out.super("hello");//此句话不可少！！！！

/*** 函意是:调用out的内部类的构造函数 ***/

 

    }

}

 

在外部类以外使用静态内部类

定义格式

    new OuterClass.InnerConstructor ()

1.4

New 父类构造器(实参列表) | 实现接口( )

{

//实现接口、或抽象类
}

 

package Anonymous;

interface Product

{

    public
double getPrice();

    public String getName();

}

public
class AnonyMousTest {

 

    public
void test(Product p)

    {

        System.out.println("购买了一个"+p.getName()+"\n价格是 "+p.getPrice());

    }

    public
static
void main(String[] args) {

        // TODO Auto-generated method stub

        AnonyMousTest ta = new AnonyMousTest();

        ta.test(

                new Product()

                {

                    public
double getPrice()

                    {

                        return 1;

                    }

                    public String getName()

                    {

                        return
"AGP显卡";

                    }

                }

             );

    }

 

}

package AnonymousInner;

abstract
class Device

{

    private String name;

    public
abstract
double getPrice();

    public Device(){}

    public Device(String name)

    {

        this.name = name;

    }

    public String getName()

    {

        return
this.name;

    }

}

public
class AnonymousInner {

    public
void test(Device d)

    {

        System.out.println("购买了一个"+d.getName()+",花掉了"+d.getPrice());

    }

    public
static
void main(String[] args) {

        // TODO Auto-generated method stub

        AnonymousInner ai = new AnonymousInner();

        ai.test(new Device("电子示波器")

        {

            public
double getPrice()

            {

                return 67.8;

            }

        });

        Device d = new Device()

        {

            {

                System.out.println("匿名内部类的初始化块...");

            }

            public
double getPrice()

            {

                return 56.2;

            }

            public String getName()

            {

                return
"键盘";

            }

        };

        ai.test(d);

    }

 

}

 

interface A

{

    void test();

}

public
class Atest {

    
 

    

    public
static
void main(String[] args) {

        // TODO Auto-generated method stub

        final
int age = 1000;

        A a =new A()

        {

            public
void test()

            {

                System.out.println(age);

            }

        };

        a.test();

    }

 

}

 

 

1.5

    闭包：一种被调用的对象，它保存了创建它的作用域信息。

        可以把非静态内部类当成面向对象领域的闭包。

回调：某个方法一旦获得了内部类对象的引用后，就可以在适合的时候反过来云调用外部类实例的方法。

interface Teachable

{

    void work();

}

class Programmer

{

    

    private String name;

    public Programmer(){}

    public Programmer(String name)

    {

        this.name=name;

    }

    public String getName()

    {

        return
name;

    }

    public
void work()

    {

        System.out.println(name+"在灯下认真敲键盘。。。");

    }

}

class TeachableProgrammer extends Programmer

{

    public TeachableProgrammer(){}

    public TeachableProgrammer(String name)

    {

        super(name);

    }

    private
void teach()

    {

        System.out.println(getName()+"老师在讲台上讲解。。。");

    }

    private
class Closure implements Teachable

    {

        public
void work()

        {

            teach();

        }

    }

    public Teachable getCallbackReference()

    {

        return
new Closure();

    }

}

public
class ATest {

    public
static
void main(String[] args) {

        TeachableProgrammer tp = new TeachableProgrammer("李刚");

        tp.work();

        tp.getCallbackReference().work();

 

    }

 

}

 

枚举类

例一

 

public
class EnumTest {

 

    public
void judge(SeasonEnum s)

    {

        switch(s)

        {

        case
SPRING:

            System.out.println("春暖花开，正好踏青");

            break;

        case
SUMMER:

            System.out.println("夏日炎炎，适合游泳");

            break;

        case
FALL:

            System.out.println("秋高气爽，进补及时");

            break;

        case
WINTER:

            System.out.println("冬日雪飘，围炉赏雪");

            break;

        }

    }

    public
static
void main(String[] args) {

        // TODO Auto-generated method stub

        for(SeasonEnum s:SeasonEnum.values())

        {

            System.out.println(s);

        }

        new EnumTest().judge(SeasonEnum.SPRING);

    }

 

}

 

public
enum SeasonEnum {

    SPRING,SUMMER,FALL,WINTER;

}

 

例二

 

public
enum Gender {

    MALE("man"),FEMALE("woman");

    private
final String name;

    private Gender(String name)

    {

        this.name=name;

    }

    public String getName()

    {

        return
this.name;

    }

}

 

public
class GenderTest {

 

    /**

     * @param args

     */

    public
static
void main(String[] args) {

        // TODO Auto-generated method stub

        Gender g= Enum.valueOf(Gender.class, "FEMALE");

        System.out.println(g+" stand for "+g.getName());

    }

 

}

 

例三

 

例四