精华内容
下载资源
问答
  • 文章目录1 内部类的基本概念1.1 内部类的定义1.2 内部类的优缺点2 创建内部类2.1 在外部类外部创建非静态内部类2.2 在外部类外部创建静态内部类...类3.2 静态内部类3.3 方法内部类3.4 匿名内部类4 内部类与外部类的关系...

    1. 内部类的基本概念

    1.1 内部类的定义

    内部类: 所谓内部类就是在一个类内部进行其他类结构的嵌套操作。

    class Outer{
        private String str ="外部类中的字符串";
        //************************** 
        //定义一个内部类
        class Inner{
            private String inStr= "内部类中的字符串";
            //定义一个普通方法
            public void print(){
                //调用外部类的str属性
                System.out.println(str);
            }
        }
        //************************** 
        //在外部类中定义一个方法,该方法负责产生内部类对象并调用print()方法
        public void fun(){
            //内部类对象
            Inner in = new Inner();
            //内部类对象提供的print
            in.print();
        }
    }
    public class Test{
        public static void main(String[] args)
        {
            //创建外部类对象
            Outer out = new Outer();
            //外部类方法
            out.fun();
        }
    }
    

    运行结果:外部类中的字符串
    但是如果去掉内部类:

    class Outer{
        private String outStr ="Outer中的字符串";
        public String getOutStr()
        {
            return outStr;
        }
        public void fun(){  //2
            //this表示当前对象
            Inner in = new Inner(this); //3
            in.print();                 //5
        }
    }
    class Inner{
        private String inStr= "Inner中的字符串";
        private Outer out;
        //构造注入
        public Inner(Outer out)  //3
        {
            this.out=out;       //4.为Inner中的out变量初始化
        }
        public void print(){    //6
            System.out.println(out.getOutStr()); //7
        }
    } 
    public class Test{
        public static void main(String[] args)
        {
            Outer out = new Outer();  //1.
            out.fun(); //2.
        }
    }
    

    执行结果:Outer中的字符串
    但是去掉内部类之后发现程序更加难以理解。

    1.2 内部类的优缺点

    内部类的优点:

    1. 内部类与外部类可以方便的访问彼此的私有域(包括私有方法、私有属性)。
    2. 内部类是另外一种封装,对外部的其他类隐藏。
    3. 内部类可以实现java的单继承局限。

    内部类的缺点:

    结构复杂。
    记录:使用内部类实现多继承:

    class A {
        private String name = "A类的私有域";
        public String getName() {
            return name;
        }
    }
    class B {
        private int age = 20;
        public int getAge() {
            return age;
        }
    }
    class Outter {
        private class InnerClassA extends A {
            public String name() {
                return super.getName();
        }
    }
        private class InnerClassB extends B {
            public int age() {
                return super.getAge();
        }
    }
        public String name() {
            return new InnerClassA().name();
        }
        public int age() {
            return new InnerClassB().age();
        }
    }
    public class Test2 {
            public static void main(String[] args) {
                Outter outter = new Outter();
                System.out.println(outter.name());
                System.out.println(outter.age());
            }
    }
    

    在这里插入图片描述

    2. 创建内部类

    2.1 在外部类外部 创建非静态内部类

    语法: 外部类.内部类 内部类对象 = new 外部类().new 内部类();
    举例: Outer.Inner in = new Outer().new Inner();

    2.2 在外部类外部 创建静态内部类

    语法: 外部类.内部类 内部类对象 = new 外部类.内部类();
    举例: Outer.Inner in = new Outer.Inner();

    2.3 在外部类内部创建内部类语法

    在外部类内部创建内部类,就像普通对象一样直接创建:Inner in = new Inner();

    3. 内部类的分类

    在Java中内部类主要分为成员内部类、静态内部类、方法内部类、匿名内部类

    3.1 成员内部类

    类比成员方法

    1. 成员内部类内部不允许存在任何static变量或方法 正如成员方法中不能有任何静态属性 (成员方法与对象相关、静态属性与类有关)
    class Outer {
        private String name = "test";
        public  static int age =20;
    
        class Inner{
            public static int num =10;
            public void fun()
            {
                System.out.println(name);
                System.out.println(age);
            }
        }
    }
    public class Test{
        public static void main(String [] args)
        {}
    }
    

    在这里插入图片描述
    2. 成员内部类是依附外部类的,只有创建了外部类才能创建内部类。

    3.2 静态内部类

      关键字static可以修饰成员变量、方法、代码块、其实还可以修饰内部类,使用static修饰的内部类我们称之为静态内部类,静态内部类和非静态内部类之间存在一个最大的区别,非静态内部类在编译完成之后会隐含的保存着一个引用,该引用是指向创建它的外围类,但是静态类没有。没有这个引用就意味着:
      1.静态内部类的创建不需要依赖外部类可以直接创建。
      2.静态内部类不可以使用任何外部类的非static类(包括属性和方法),但可以存在自己的成员变量。

    class Outer {
        public String name = "test";
        private static int age =20;
    
        static class Inner{
            private String name;
            public void fun()
            {
                System.out.println(name);
                System.out.println(age);
            }
        }
    }
    public class Test{
        public static void main(String [] args)
        {
            Outer.Inner in = new Outer.Inner();
        }
    }
    

    在这里插入图片描述

    3.3 方法内部类

    方法内部类顾名思义就是定义在方法里的类
    1.方法内部类不允许使用访问权限修饰符(public、private、protected)均不允许。

    class Outer{
        private int num =5;
        public void dispaly(final int temp)
        {
            //方法内部类即嵌套在方法里面
            public class Inner{
            }
        }
    }
    public class Test{
        public static void main(String[] args)
        {}
    }
    

    在这里插入图片描述
    2. 方法内部类对外部完全隐藏,除了创建这个类的方法可以访问它以外,其他地方均不能访问 (换句话说其他方法或者类都不知道有这个类的存在)方法内部类对外部完全隐藏,出了创建这个类的方法可以访问它,其他地方均不能访问。
    3. 方法内部类如果想要使用方法形参,该形参必须使用final声明(JDK8形参变为隐式final声明)

    class Outer{
        private int num =5;
        //普通方法
        public void dispaly(int temp)
        {
            //方法内部类即嵌套在方法里面
            class Inner{
                public void fun()
                {
                    System.out.println(num);
                    temp++;
                    System.out.println(temp);
                }
            }
            //方法内部类在方法里面创建
            new Inner().fun();
        }
    }
    public class Test{
        public static void main(String[] args)
        {
            Outer out = new Outer();
            out.dispaly(2);
        }
    }
    

    在这里插入图片描述

    3.4 匿名内部类

      匿名内部类就是一个没有名字的方法内部类,因此特点和方法与方法内部类完全一致,除此之外,还有自己的特点:
    1.匿名内部类必须继承一个抽象类或者实现一个接口。
    2.匿名内部类没有类名,因此没有构造方法。

    //匿名内部类
    //声明一个接口
    interface MyInterface {
        //接口中方法没有方法体
        void test();
    }
    class Outer{
        private int num = 5;
        public void dispaly(int temp)
        {
            //匿名内部类,匿名的实现了MyInterface接口
            //隐藏的class声明
            new MyInterface()
            {
                public void test()
                {
                    System.out.println("匿名实现MyInterface接口");
                    System.out.println(temp);
                }
            }.test();
        }
    }
    public class Test{
        public static void main(String[] args)
        {
            Outer out = new Outer();
            out.dispaly(3);
        }
    }
    

    在这里插入图片描述

    4. 内部类与外部类的关系

    • 对于非静态的内部类,内部类的创建依赖外部类的实例对象,在没有外部类实例之前是无法创建内部类的。
    • 内部类可以直接访问外部类的元素(包括私有域)—外部类在内部类之前创建,创建内部类时会将外部类的对象传入
    class Outer{
        //成员变量  与对象有关
        private String msg;
        private int age;
        //--------------------------
        class Inner{
            public void dispaly()
            {
                //此处有一个隐藏的Outer.this
                msg = "test";
                age = 20;
                System.out.println(msg);
                System.out.println(age);
            }
        }
        //--------------------------
        public void test()
        {
            Inner in = new Inner();
            in.dispaly();
        }
    }
    public class Test{
        public static void main(String[] args)
        {
            Outer out = new Outer();
            out.test();
        }
    }
    
    • 外部类可以通过内部类的引用间接访问内部类元素 – -要想访问内部类属性,必须先创建内部类对象
    class Outer{
        public void dispaly()
        {
            //外部类通过创建内部类的对象间接访问内部类元素
            Inner in = new Inner();
            in.dispaly();
        }
        class Inner{
            public void dispaly()
            {
                System.out.println("内部类");
            }
        }
    }
    public class Test1{
        public static void main(String[] args)
        {
            Outer out = new Outer();
            out.dispaly();
        }
    }
    
    • 内部类是一个相对独立的个体,与外部类没有关系。
    展开全文
  • lucene 3.02 Directory的分类以及对应的读写类的关系

    一、Directory的分类

    Directory分为两种类型:一种是内存目录,一种是文件目录。


    1、内存目录即RAMDirectory
    2、文件目录即FSDirectory

    FSDirectory又分为3类:

    1)windows下的SimpleFSDirectory

    2)linux支持NIO的NIOFSDirectory

    3)还有一个是内存Map目录MMapDirectory


    SimpleFSDirectory是一个FSDirectory的简单实现,对并发处理能力有限,使用MMapDirectory会更好些。
    NIOFSDirectory是用与在Linux下的目录,可以提供很好的性能,

    二、继承Directory的工具


    除此之外Directory还有两个工具类。

     

    1、一个是用于可以同时在两个不同的目录中读取文件的FileSwitchDirectory,这是个代理类。

    2、另一是用户读取复合文件的CompoundFileReader,只能读取扩展名为cfs的文件。(写扩展名为cfs的文件用CompoundFileWriter)CompoundFileReader仅在SegmentReader中被引用。

     

    三、Directory与读写对象的对应关系

     

    Directory是个抽象类,定义了获取读写对象的方法createOutput()和openInput()。
    FSDirectory是个抽象类,每个继承了FSDirectory的类都实现了自己的createOutput()和openInput()方法,返回符合每个不同类型Directory的IndexInput和IndexOutput。

    openInput()返回的对象:

    Directory -->RAMDirectory ===> IndexInput --> RAMInputStream
    Directory -->FSDirectory -->SimpleFSDirectory ===>IndexInput -->BufferedIndexInput-->SimpleFSIndexInput
    Directory -->FSDirectory -->NIOFSDirectory ===>IndexInput -->BufferedIndexInput-->NIOFSIndexInput
    Directory -->FSDirectory -->MMapDirectory ===>IndexInput -->BufferedIndexInput-->MMapIndexInput/MultiMMapIndexInput
    Directory -->FileSwitchDirectory  =====>  IndexInput --> 用于交叉读取的上述类型的对应的IndexInput
    Directory -->CompoundFileReader =====> IndexInput --> BufferedIndexInput --> CSIndexInput

     

     


    createOutput()返回的对象:

    Directory -->RAMDirectory ===> IndexInput --> RAMOutputStream
    Directory -->FSDirectory -->SimpleFSDirectory ===>IndexOutput -->BufferedIndexOutput-->SimpleFSIndexOutput
    Directory -->FSDirectory -->NIOFSDirectory ===>IndexOutput -->BufferedIndexOutput-->SimpleFSDirectory.SimpleFSIndexOutput
    Directory -->FSDirectory -->MMapDirectory ===>IndexOutput -->BufferedIndexOutput-->SimpleFSDirectory.SimpleFSIndexOutput
    Directory -->FileSwitchDirectory  =====>  IndexInput --> 用于交叉读取的上述类型的对应的IndexInput
    Directory -->CompoundFileWriter =====> CompoundFileWriter没有继承IndexOutput是因为CompoundFileWriter使用add(String File)进行增加,而不是writeBytes()

     

    展开全文
  • 类与类的关系(关联,组合,聚合,依赖)

    转载注明出处:http://blog.csdn.net/maybehelios/article/details/2038685c

    1. 种类: Generalization(泛化),Dependency(依赖关系)、Association(关联关系)、Aggregation(聚合关系)、Composition(合成关系)。

    2.  其中Aggregation(聚合关系)、Composition(合成关系)属于Association(关联关系),是特殊的Association关联关系。

    3.  Generalization(泛化)表现为继承或实现关系(is a)。具体形式为类与类之间的继承关系,接口与接口之间的继承关系,类对接口的实现关系。

    4.  Association关联关系表现为变量(has a )。类与类之间的联接,它使一个类知道另一个类的属性和方法。例如如果A依赖于B,则B体现为A的全局变量。关联关系有双向关联和单向关联。双向关联:两个类都知道另一个类的公共属性和操作。单向关联:只有一个类知道另外一个类的公共属性和操作。大多数关联应该是单向的,单向关系更容易建立和维护,有助于寻找可服用的类。

       

    5.  Aggregation(聚合关系) 是关联关系的一种,是强的关联关系。聚合关系是整体和个体的关系。普通关联关系的两个类处于同一层次上,而聚合关系的两个类处于不同的层次,一个是整体,一个是部分。同时,是一种弱的“拥有”关系。体现的是A对象可以包含B对象,但B对象不是A对象的组成部分。具体表现为,如果A由B聚合成,表现为A包含有B的全局对象,但是B对象可以不在A创建的时刻创建。

     


     

    6.  Composition(组合关系)是关联关系的一种,是比聚合关系强的关系。它要求普通的聚合关系中代表整体的对象负责代表部分的对象的生命周期。Composition(组合关系)是一种强的“拥有”关系,体现了严格的部分和整体的关系,部分和整体的生命周期一致。如果A由B组成,表现为A包含有B的全局对象,并且B对象在A创建的时刻创建。


    7.  Dependency(依赖关系)表现为函数中的参数(use a)。是类与类之间的连接,表示一个类依赖于另一个类的定义,其中一个类的变化将影响另外一个类。例如如果A依赖于B,则B体现为局部变量,方法的参数、或静态方法的调用。


     


    展开全文
  • 设计模式中类的关系

    万次阅读 多人点赞 2012-01-09 14:51:50
    在java以及其他面向对象设计模式中,之间主要有6种关系,他们分别是:依赖、关联、聚合、组合、继承、实现。他们耦合度依次增强。 1. 依赖(Dependence)  依赖关系的定义为:对于两个相对独立...

         在java以及其他的面向对象设计模式中,类与类之间主要有6种关系,他们分别是:依赖、关联、聚合、组合、继承、实现。他们的耦合度依次增强。

    1. 依赖(Dependence)

            依赖关系的定义为:对于两个相对独立的对象,当一个对象负责构造另一个对象的实例,或者依赖另一个对象的服务时,这两个对象之间主要体现为依赖关系。定义比较晦涩难懂,但在java中的表现还是比较直观的:类A当中使用了类B,其中类B是作为类A的方法参数、方法中的局部变量、或者静态方法调用。类上面的图例中:People类依赖于Book类和Food类,Book类和Food类是作为类中方法的参数形式出现在People类中的。

    代码样例:

    public class People{
        //Book作为read方法的形参
         public void read(Book book){
            System.out.println(“读的书是”+book.getName());
        }
    }
    

    2.关联(Association)

    单向关联:

     

    双向关联:

            对于两个相对独立的对象,当一个对象的实例与另一个对象的一些特定实例存在固定的对应关系时,这两个对象之间为关联关系。关联关系分为单向关联和双向关联。在java中,单向关联表现为:类A当中使用了类B,其中类B是作为类A的成员变量。双向关联表现为:类A当中使用了类B作为成员变量;同时类B中也使用了类A作为成员变量。

    代码样例:

    public class Son{
       //关联关系中作为成员变量的类一般会在类中赋值
        Father father = new Father();
        public void getGift(){
            System.out.println(“从”+father.getName()+”获得礼物”);
        }
    }
    
    public class Father{
        Son son = new Son();
        public void giveGift(){
            System.out.println(“送给”+son.getName()+“礼物”);
        }
    }

    3.聚合(Aggregation)

            聚合关系是关联关系的一种,耦合度强于关联,他们的代码表现是相同的,仅仅是在语义上有所区别:关联关系的对象间是相互独立的,而聚合关系的对象之间存在着包容关系,他们之间是“整体-个体”的相互关系。

    代码样例:

    public class People{
        Car car;
        House house; 
        //聚合关系中作为成员变量的类一般使用set方法赋值
         public void setCar(Car car){
            This.car = car;
        }
        public void setHouse(House house){
            This.house = house;
        }
    
        public void driver(){
            System.out.println(“车的型号:”+car.getType());
        }
        public void sleep(){
            System.out.println(“我在房子里睡觉:”+house.getAddress());
        }
    }

    4.组合(Composition)

            相比于聚合,组合是一种耦合度更强的关联关系。存在组合关系的类表示“整体-部分”的关联关系,“整体”负责“部分”的生命周期,他们之间是共生共死的;并且“部分”单独存在时没有任何意义。在下图的例子中,People与Soul、Body之间是组合关系,当人的生命周期开始时,必须同时有灵魂和肉体;当人的生命周期结束时,灵魂肉体随之消亡;无论是灵魂还是肉体,都不能单独存在,他们必须作为人的组成部分存在。

    Public class People{
        Soul soul;
        Body body; 
        //组合关系中的成员变量一般会在构造方法中赋值
         Public People(Soul soul, Body body){ 
            This.soul = soul;
            This.body = body;
        }
    
        Public void study(){
            System.out.println(“学习要用灵魂”+soul.getName());
        }
        Public void eat(){
            System.out.println(“吃饭用身体:”+body.getName());
        }
    }
    

    5.继承(Generalization)

            继承表示类与类(或者接口与接口)之间的父子关系。在java中,用关键字extends表示继承关系。UML图例中,继承关系用实线+空心箭头表示,箭头指向父类。

    6.实现(Implementation)

             表示一个类实现一个或多个接口的方法。接口定义好操作的集合,由实现类去完成接口的具体操作。在java中使用implements表示。UML图例中,实现关系用虚线+空心箭头表示,箭头指向接口。

            在java中继承使用extends关键字,实现使用implements关键字,很直观。就不代码演示了。

    展开全文
  • 记录一下快乐学习2小时速成大法之UML类图与类的关系 虚线箭头指向依赖; 实线箭头指向关联; 虚线三角指向接口; 实线三角指向父类; 空心菱形能分离而独立存在,是聚合; 实心菱形精密关联不可分,是组合; 在画...
  • 类的关系 在UML类图中,常见的有以下几种关系: 泛化(Generalization), 实现(Realization),关联(Association),聚合(Aggregation),组合(Composition),依赖(Dependency) 1. 泛化(Generalization) ...
  • UML类图与类的关系详解

    千次阅读 2011-05-28 11:46:00
    UML类图与类的关系详解  2011-04-21 来源:网络  在画类图的时候,理清类和类之间的关系是重点。类的关系有泛化(Generalization)、实现(Realization)、依赖(Dependency)和关联(Association)。...
  • java外部类与内部类的关系

    千次阅读 2018-12-04 21:48:16
    private,public,protected,default的访问权限区别 ...1、private:访问权限最低的访问控制符,被它修饰的变量只能访问本类的对象。 2、public:访问权限最高,不仅是本类,子类,本包,其他的包,都可以去...
  • Java 内部类与外部类的关系

    千次阅读 2016-11-23 21:39:06
     内部类可以直接访问外部类的私有属性,这是由于这个原因。  1、非静态内部类对象会持有外部类的对象。其实是,非静态内部类对象依赖于外部类对象而存在,没有外部类就没有内部类,有外部类不一定有内部类。这一点...
  • UML类图与类的关系详解 在画类图的时候,理清类和类之间的关系是重点。类的关系有泛化(Generalization)、实现(Realization)、依赖(Dependency)和关联(Association)。其中关联又分为一般关联关系和聚合关系...
  • C# 类与类的关系(2)

    千次阅读 2012-01-17 14:02:30
    这段时间在学习设计模式,对于每个模式的UML图感觉不好理解,究其原因,应该是我们对之间的关系不是很清楚,所以,我们首先,需要弄懂之间的关系才能看懂类图。 继承(Inheritance)   继承用冒号":...
  • ASM 5.0.3 主要类的关系和简单实例

    千次阅读 2014-12-14 17:09:21
    ASM包括主要三个:1、ClassReader : 负责从文件中读取输入流,并依照固定顺序调用 ClassVisitor 中声明多个 visitorXxx方法。...三者依赖关系和继承关系如下图:下面是一个例子一、首先定
  • java中类的关系

    千次阅读 2013-04-25 11:25:50
    在java以及其他面向对象设计模式中,之间主要有6种关系,他们分别是:依赖、关联、聚合、组合、继承、实现。他们耦合度依次增强。 1. 依赖(Dependence)   依赖关系的定义为:对于两个相对独立...
  • Java中集合类的关系

    千次阅读 2016-10-15 10:08:12
    参考文献...  上述类图中,实线边框是实现,比如ArrayList,LinkedList,HashMap等,折线边框是抽象,比如AbstractCollection,AbstractList,AbstractMap等,而点线边框是接口,比如Coll
  • Java中类与类的关系

    千次阅读 2007-08-21 23:00:00
    yaogao@gmail.com之间存在以下关系:1、 泛化(Generalization)很简单,就是我们常说继承。是说子类获得父类功能同时,还可以扩展自己功能。如图:Java代码中表现为:extends 和 implements2、 依赖...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 160,344
精华内容 64,137
关键字:

类的关系