我看完了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());

    }

 

}

 

例三

 

例四

JAVA类（下）的更多相关文章

  1. DOC下编译和运行带有包的java类文件

    前言: 带有包名的java类在DOC下编译可以成功,但是运行出错  错误: 找不到或无法加载主类 com.soanl.socket.MyServer D盘temp文件下有个Hello.java文件,包 ...

  2. Eclipse下生成/编辑Java类图或时序图（UML）[转载]

    一 引用文章 1.[eclipse下生成Java类图和时序图,生成UML图(更完整版)](https://blog.csdn.net/guomainet309/article/details/5302 ...

  3. [Java]类的生命周期(下）类的初始化[转]

    上接深入java虚拟机——深入java虚拟机(二)——类加载器详解(上),在上一篇文章中,我们讲解了类的生命周期的加载和连接,这一篇我们接着上面往下看. 类的初始化:在类的生命周期执行完加载和连接之后 ...

  4. [ 转载 ] Java基础10--关于Object类下所有方法的简单解析

    关于Object类下所有方法的简单解析 类Object是类层次结构的根类,是每一个类的父类,所有的对象包括数组,String,Integer等包装类,所以了解Object是很有必要的,话不多说,我们直 ...

  5. 带包的java类在cmd环境下的执行办法

    带包的java类在cmd环境下的执行办法:工程目录为D:\Program Files\eclipse\workspace\ReadFileByLinesUniq上面目录下有两个文件夹bin和src源文 ...

  6. java扫描某个包下的所有java类并加载

    最近在学习java的反射和注解,实际情景中需要扫描某个包下的所有java类,然后使用类加载器加载类. 基本思路,获得程序的路径扫描src下某个包内的子包和java类,实现也比较简单. 运行环境:win ...

  7. Java中的静态方法和实例方法的调用的理解（不同的类下的方法调用）

    public class MethodCall { public static void main(String[] args) { Test.sayStatic(); Test test = new ...

  8. eclipse debug模式下总是自动跳到ThreadPoolExecutor.java类

      1.情景展示 使用eclipse,debug模式运行项目时,总是会调用这个ThreadPoolExecutor.java类,明明没有打断点却自动停止运行. 2.原因分析 在eclipse中,默认是 ...

  9. Java取得一个对象里所有get方法和set方法, 读取某个类下所有变量的名称

    所有get方法和set方法public void getMethod(Object obj){ Class clazz=obj.getClass();//获得实体类名 Field[] fields = ...

随机推荐

  1. 计算两个String 类型的时间相关几个月

    /** * 返回两个时间段相隔几个月 * @param date1 * @param date2 * @return * @throws ParseException * @throws ParseE ...

  2. 1. 初识ZooKeeper。

    转自:https://blog.csdn.net/en_joker/article/details/78661466 Apache ZooKeeper是由 Apache Hadoop的子项目发展而来, ...

  3. 109.vprintf vfprintf vscanf vfscanf

    vprintf //输出到屏幕 int POUT(char *str, ...) { va_list arg_p=NULL; //读取 va_start(arg_p, str); //接受可变参数 i ...

  4. 1.1 Introduction中 Kafka as a Messaging System官网剖析（博主推荐）

    不多说,直接上干货! 一切来源于官网 http://kafka.apache.org/documentation/ Kafka as a Messaging System kafka作为一个消息系统 ...

  5. C#中数组与ArrayList的简单使用

    1. 多维数组 2. 锯齿数组 3. 数组的常用操作 4. ArrayList 1. 多维数组 多维数组:行数和列数在定义时已确定 string[,] arr = new string[2, 3]; ...

  6. ASP.NET Core 2.2 十九. 你扔过来个json，我怎么接

    原文:ASP.NET Core 2.2 十九. 你扔过来个json,我怎么接 前文说道了Action的激活,这里有个关键的操作就是Action参数的映射与模型绑定,这里即涉及到简单的string.in ...

  7. shader 3 rendering path

    渲染通道, rendering path. vertexlit, forward 和 Deferred lighting 旧有的非统一架构下: 分为顶点着色引擎和像素渲染通道 渲染通道是GPU负责给图 ...

  8. 分治法（divide & conquer）与动态规划（dynamic programming）应用举例

    动态规划三大重要概念:最优子结构,边界,状态转移公式(问题规模降低,如问题由 n 的规模降低为 n−1 或 n−2 及二者之间的关系): 0. 爬台阶 F(n)⇒F(n−1)+F(n−2) F(n−1 ...

  9. Redo 非current损坏

    Redo log 文件损坏或丢失,在启动数据库时在alert日志中会有如下错误: ORA-00313: open failed for members of log group 1 of thread ...

  10. Codeforces Round #258 (Div. 2)——B. Sort the Array

    B. Sort the Array time limit per test 1 second memory limit per test 256 megabytes input standard in ...