精华内容
下载资源
问答
  • 主要介绍了Java创建内部类对象实例详解的相关资料,需要的朋友可以参考下
  • Java 创建内部类实例

    千次阅读 2016-03-01 15:28:37
    编程中需要访问内部类,写C习惯了Java方式多少有些生硬。 其实很简单: 1 拥有内部类的一个类 public class B{ public void showData() { System.out.println("B"); } public class InnerB{ public...

    编程中需要访问内部类,写C习惯了Java方式多少有些生硬。

    其实很简单:

    1 拥有内部类的一个类

    public class B{
    		public void showData()
    		{
    			System.out.println("B");
    		}
    		public class InnerB{
    			public void showInnerB()
    			{
    				System.out.println("Inner B2");
    			}
    		}
    	}

    实例化内部类只需要:

    B b = new B();	//第一,先创建外部类	
    		InnerB innerB = b.new InnerB(); //在外部类实例上,创建内部类实例
    		innerB.showInnerB(); //调用内部类


    上面的内部类与包名无关系,只要在调用时注意在外部类实例上创建内部类即可。

    展开全文
  • 文章目录1 内部类的基本概念1.1 内部类的定义1.2 内部类的优缺点2 创建内部类2.1 在外部类外部创建非静态内部类2.2 在外部类外部创建静态内部类2.3 在外部类内部创建内部类语法3 内部类的分类3.1 成员内部类3.2 静态...

    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();
        }
    }
    
    • 内部类是一个相对独立的个体,与外部类没有关系。
    展开全文
  • Java如何创建内部类对象的方法

    千次阅读 2019-07-31 15:43:49
    如下,OuterClass是外部的,InnerClass是内部, /******************************************************************************* * @project: IDS_AutoView_2019 * @package: ...

    如下,OuterClass是外部的类,InnerClass是内部的类,

     

    /*******************************************************************************
     * @project: IDS_AutoView_2019
     * @package: com.acconsys.ids.convert.thread
     * @file: OuterClass.java
     * @author: zhangpei
     * @created: 2019-7-31
     * @purpose:
     * 
     * @version: 1.0
     * 
     * Revision History at the end of file.
     * 
     * Copyright 2019 esoon-tech All rights reserved.
     ******************************************************************************/
    
    /**   
    * @Title: OuterClass.java 
    * @Package com.acconsys.ids.convert.thread 
    * @Description: TODO(用一句话描述该文件做什么) 
    * @author Burns[张沛]   
    * @date 2019-7-31 下午3:41:15 
    * @version V1.0   
    */
    package com.acconsys.ids.convert.thread;
    
    /** 
     * @ClassName: OuterClass 
     * @Description: TODO(这里用一句话描述这个类的作用) 
     * @author Burns[张沛] 
     * @date 2019-7-31 下午3:41:15 
     *  
     */
    public class OuterClass {
    	public static void main(String[] args) {
    		//要想直接创建内部类的对象,必须使用外部类的对象来创建内部类对象
            InnerClass p = new OuterClass().new InnerClass();
        }
    
        class InnerClass {
            String name;
    
            public String getName() {
                return name;
            }
    
            public void setName(String name) {
                this.name = name;
            }
        }   
    
    }
    
    
    /*******************************************************************************
     * <B>Revision History</B><BR>
     * [type 'revision' and press Alt + / to insert revision block]<BR>
     * 
     * 
     * 
     * Copyright 2019 esoon-tech All rights reserved.
     ******************************************************************************/

     

    展开全文
  • Java匿名内部类实现线程的创建

    千次阅读 2019-05-06 14:47:12
    Java匿名内部类实现线程的创建

    Java匿名内部类实现线程的创建

    package com.zr;
    /*
        匿名内部类实现线程的创建
     */
    public class DemoThread {
        public static void main(String[] args) {
            //主线程main
            for (int i = 0; i <20 ; i++) {
                //Thread.currentThread().getName()获取线程名
                System.out.println(Thread.currentThread().getName()+"-->"+i);
            }
    
            //匿名内部类创建新线程
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i <20 ; i++) {
                        System.out.println(Thread.currentThread().getName()+"-->"+i);
                    }
                }
            }).start();
        }
    }
    
    
    展开全文
  • Java创建内部类对象

    千次阅读 2018-05-24 13:39:59
    public class OutClass { ...如果我们要直接创建内部类对象的话,必须先创建外部类对象,然后通过外部类对象来创建内部类对象。 没有外部类对象不可能创建内部类对象。 如果是静态内部类,则不需要对外部对象的引用。
  • java匿名内部类什么是匿名内部类?匿名内部类的使用场景?匿名内部类如何创建?匿名内部类的实现和使用例1(实现接口)例2(继承类) 什么是匿名内部类? 匿名内部类,顾名思义,就是不知道这个类到底是什么名字,也...
  • 有时候需要在Java的外部类的一个方法中创建一个内部类的对象,下面用一个简单的小例子来说明一种实现方法。 public class Out { public Out(){ System.out.println("外部类创建"); } class In{ public ...
  • Java】如何创建内部类的实例?

    千次阅读 2017-04-11 16:32:44
    1.问题:首先看一段代码:public class Test { //创建内部类Test2 public class Test2 { private double r; } public static void main(String[] args) { Test2 myTest2 = new Test2(); //创建Test2类的实例
  • java内部类创建方式

    千次阅读 2017-04-20 13:06:03
    内部类我们在程序开发中经常会用到,这里通过普通内部类,静态内部类和方法内部类三种方式来介绍一下内部类创建方式。  1.普通内部类创建: /** * * 普通内部类的定义 * */ class Outer { private String...
  • java内部类如何创建对象

    千次阅读 2016-11-04 09:08:08
    转载来自大牛博客:http://blog.csdn.net/huangbiao86/article/details/6364218 静态内部类可以直接创建对象new B.C(); 如果内部类不是静态的,那就得这样 B b = new B(); B.C c = b.new C();
  • (4)外部类不能直接访问所有内部类的成员和方法,但可以通过创建内部类对象的方式进行访问。 (5)外部类和内部类拥有同名的变量和方法时,内部类有需要进行访问外部的同名变量或方法,可以通过外部类.this.方法...
  • 详解 Java 内部类

    万次阅读 多人点赞 2018-09-04 00:17:56
    内部类Java 里面算是非常常见的一个功能了,在日常开发中我们肯定多多少少都用过,这里总结一下关于 Java内部类的相关知识点和一些使用内部类时需要注意的点。 从种类上说,内部类可以分为四类:普通内部类...
  • java非静态内部类如何创建对象实例

    千次阅读 2018-11-13 22:37:03
    java非静态内部类如何创建对象实例: public class A { public class NestA { } } 在A的外部创建NestA的方法如下 A a = new A(); A.NestA nestA = a.new NestA();   接下来我们通过实际的项目经历给大家...
  • Java内部类和匿名内部类的用法

    万次阅读 多人点赞 2016-07-21 15:46:41
    Java内部类和匿名内部类的用法 【尊重原创,转载请注明出处】http://blog.csdn.net/guyuealian/article/details/51981163一、内部类: (1)内部类的同名方法 内部类可以调用外部类的方法,如果内部类有同名方法...
  • java内部类之成员内部类、局部内部类和匿名内部类

    千次阅读 多人点赞 2018-07-15 16:13:30
    内部类概念 一个类中包含另外一个类。 分类 1、成员内部类。 2、局部内部类(包含匿名内部类)。 成员内部类 定义格式: 修饰符 class 类名称 { 修饰符 class 类名称 { //... } //... } 注意: 内部类...
  • java中的内部类内部接口详解

    千次阅读 2020-05-08 06:24:42
    一般来说,我们创建类和接口的时候都是一个类一个文件,一个接口一个文件,但有时候为了方便或者某些特殊的原因,java并不介意在一个文件中写多个类和多个接口,这就有了我们今天要讲的内部类和内部接口。...
  • 本文主要介绍了Java内部类的基本原理,使用方法和各种细节。 有关内部类实现回调,事件驱动和委托机制的文章将在后面发布。 具体代码在我的GitHub中可以找到 https://github.com/h2pl/MyTech 文章首发于我的个人...
  • 1.在非静态内部类条件下不能逐步创建对象,要先创建一个外部类对象,再创建内部类对象。 个人理解:因为类还没加载即还没分配内存,内部所有非静态成员都没分配内存,不可能直接创建一个非静态内部类对象。 2.在静态...
  • Java的匿名内部类

    万次阅读 多人点赞 2019-06-09 14:42:20
    匿名内部类适合创建那种只需要一次使用的类,定义匿名内部类的语法格式如下: new 父类构造器(实参列表) | 实现接口() { //匿名内部类的类体部分 } 从上面的定义可以看出,匿名内部类必须继承一个父类,或实现...
  • Java:如何直接创建内部类对象

    万次阅读 2016-11-11 10:34:42
    package thinking.learnInternalClass.hengbao;...//要想直接创建内部类的对象,不能按照想象的方式,去引用外部类的名字DotNew,而必须使用外部类的对象来创建内部类对象,就像上面的程序中所看到的那样.
  • Java——访问内部类的方法

    千次阅读 2019-05-05 21:29:10
    内部类: 将一个类定义在另一个类的里面,对里面那个类就称为内部类(内置类,嵌套类)。 访问特点: • 内部类可以直接访问外部类中的成员,包括私有成员。 • 而外部类要访问内部类中的成员必须要建立内部类的...
  • 详谈Java内部类(超详细代码示例)

    万次阅读 多人点赞 2018-09-30 00:30:44
    内部类 废话不多上,先上图:
  • java 静态内部类的使用

    万次阅读 2018-11-05 19:06:39
    java 静态内部类的使用
  • Java 匿名类(匿名内部类)

    千次阅读 多人点赞 2020-12-25 23:41:48
    Java匿名类(匿名内部类) 学习的参考博文:无恨之都 1. 初识 匿名类 标准说法: 内部类包括:成员类、局部类、匿名类(匿名内部类)。 匿名类概念: 匿名类可以使你的代码更加简洁 (JDK8之后Lambda更简洁)。 你可以...
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性?原理是什么Java语言有哪些特点什么是字节码?采用字节码的最大好处是什么什么是Java程序的主类?应用程序和小程序的...
  • 匿名内部类适合创建那些只需要使用一次的类,它的语法有些奇怪,创建匿名内部类会立即创建一个该类的实例,这个类定义立即消失,且不能重复使用。 &nbsp;&nbsp;&nbsp;&nbsp;定义匿名类的格式如下: ...
  • Java静态内部类(static class)

    万次阅读 多人点赞 2018-02-24 17:03:47
    在一个类中创建另外一个类,叫做成员内部类。这个成员内部类可以静态的(利用static关键字修饰),也可以是非静态的。 一、静态内部类的使用目的。 在定义内部类的时候,在其前面加上一个权限修饰符static。这个...
  • Java静态内部类的作用

    千次阅读 2019-02-22 05:00:22
    在一个类中创建另外一个类,叫做成员内部类。这个成员内部类可以静态的(利用static关键字修饰),也可以是非静态的。由于静态的内部类在定义、使用的时候会有种种的限制。所以在实际工作中用到的并不多。   在...
  • Java中匿名内部类的使用

    千次阅读 2018-10-04 16:24:35
     当类或接口类型作为参数传递时,可以直接使用匿名内部类方式创建对应的对象 3、匿名内部类嵌套使用 ① 需求:按main方法中给出的调用方式补全Class InnerClass中的代码,使得在控制台中能够输出HelloWorld。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 841,128
精华内容 336,451
关键字:

java创建内部类

java 订阅