精华内容
下载资源
问答
  • 文章目录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外部类外部访问

    2018-11-09 14:29:56
    public class Demo{  public static void main(String[]args){   //1、外部类外部访问成员内部类;  &...//建立外部类对象 ...//根据外部类对象建立内部类对...

    public class Demo{
     public static void main(String[]args){
      //1、外部类外部访问成员内部类;
      Outer out = new Outer();//建立外部类对象
      Outer.Inner in = out.new Inner();//根据外部类对象建立内部类对象
      in.inner_1();//内部类对象调用内部类方法
      //2、外部类外部访问外部类静态成员(通过外部类类名直接调用外部类静态方法);
      Outer.outer_2();
      //3、外部类外部访问静态内部类;(直接new一个外部类下的内部类对象)
      Outer.Inner_1 inner = new Outer.Inner_1();//不需要建立外部类对象
      inner.inner_2();
      inner.inner_3();
     }
    }
    class Outer{
     private int i = 1;
     private int j = 2;
     public void outer_1(){
      System.out.println(“外部类非静态方法”);
     
     }
     public static void outer_2(){
      System.out.println(“外部类静态方法”);
      
     }
     //成员内部类
     class Inner{             //内部类中不能定义静态成员
      private int i = 3;
      private int k = 4;
      public void inner_1(){
       outer_2();//内部类非静态方法直接调用外部类静态方法
       System.out.println(“内部类非静态方法”);
      }
     }
     //静态内部类
     static class Inner_1{
      static int q = 5;
      static void inner_2(){
       System.out.println(“静态内部类静态方法”);
      }
      void inner_3(){
       System.out.println(“静态内部类非静态方法”);
      }
     }
    }

    展开全文
  • 内部类和外部类

    千次阅读 2019-04-10 21:13:34
    外部类: 最普通的,我们平时见到的那种类,就是在一个后缀为.java的文件中,直接定义的类,比如 public class Student { private String name; private int age; } 内部类: 内部类,顾名思义,就是包含在外部类...

    外部类:

    最普通的,我们平时见到的那种类,就是在一个后缀为.java的文件中,直接定义的类,比如

    public class Student {
      private String name;
      private int age;
    }
    

    内部类:

    内部类,顾名思义,就是包含在外部类中的类,就叫做内部类。内部类有两种,一种是静态内部类,一种是非静态内部类。

    public class School {
      private static School instance = null;
      static class Teacher {}
    }
    
    public class School {
      private String name;
      class Teacher {}
    }
    

    静态内部类和非静态内部类之间的区别主要如下:

    1、内部原理的区别:

    静态内部类是属于外部类的类成员,是一种静态的成员,是属于类的,就有点类似于private static Singleton instance = null;非静态内部类,是属于外部类的实例对象的一个实例成员,静态类则是属于所有外部共有的,也就是说,每个非静态内部类,不是属于外部类的,是属于外部类的每一个实例的,创建非静态内部类的实例以后,非静态内部类实例,是必须跟一个外部类的实例进行关联和有寄存关系的。

    2、创建方式的区别:

    创建静态内部类的实例的时候,只要直接使用“外部类.内部类()”的方式,就可以,比如School.Teacher();创建非静态内部类的实例的时候,必须要先创建一个外部类的实例,然后通过外部类的实例,再来创建内部类的实例,new School().Teacher()

    通常来说,我们一般都会为了方便,会选择使用静态内部类。

    匿名内部类:

    public interface ISayHello {
      String sayHello(String name);
    }
    
    public class SayHelloTest {
      
      public static void main(String[] args) {
        //实现上面的接口创建了一个匿名内部类
        ISayHello obj = new ISayHello() {
          public String sayHello(String name) { return "hello, " + name }
        }
        System.out.println(obj.sayHello("leo"))
      }
    
    }
    

    匿名内部类的使用场景,通常来说,就是在一个内部类,只要创建一次,使用一次,以后就不再使用的情况下,就可以。那么,此时,通常不会选择在外部创建一个类,而是选择直接创建一个实现了某个接口、或者继承了某个父类的内部类,而且通常是在方法内部,创建一个匿名内部类。

    在使用java进行spark编程的时候,如果使用的是java7以及之前的版本,那么通常在对某个RDD执行算子,并传入算子的函数的时候,通常都会传入一个实现了某个Spark Java API中Function接口的匿名内部类。

    展开全文
  • 内部类如何理解对于外部类来说,因把内部类看作外部类的属性还是方法理解。内部类如何访问外部类的属性方法。及内部类的作用。 当内部类为静态时,情况又如何。
  • java内部类获得外部类对象

    千次阅读 2018-11-06 22:32:13
    前几天遇到一个问题,在内部类中获取外部类的引用,怎么获取? 外部类名.this

    前几天遇到一个问题,在内部类中获取外部类的引用,怎么获取?

    外部类名.this

    实时内容请关注微信公众号,公众号与博客同时更新:程序员星星
    在这里插入图片描述

    展开全文
  • thinkphp引入外部类或外部插件类

    千次阅读 2014-09-16 21:26:06
    关于thinkphp引入外部类 例子:关于thinkphp引入外部二维码类的两种方法。
  • Scala 内部类及外部类

    千次阅读 2015-12-06 11:24:21
    Scala内部类和外部类介绍。
  • 内部类与外部类

    千次阅读 2015-01-23 22:46:13
    作为外部类的一个成员存在,与外部类的属性、方法并列。 内部类和外部类的实例变量可以共存。 在内部类中访问实例变量:this.属性 在内部类访问外部类的实例变量:外部类名.this.属性。 在外部类的外部...
  • 其他内部类可以访问外部类,是因为持有外部类的引用。 成员内部类说明: 成员内部类拥有和外部类同名的成员变量或者方法时,会发生隐藏现象,默认情况下访问的是成员内部类的方法。访问外部类方法: 外部类.this....
  • 内部类如何调用外部类的方法

    千次阅读 2019-09-28 17:18:45
    内部类如何调用外部类的方法 直接上代码 public class test{ public static void main(String[] args) { Outer.Inner p=new Outer().new Inner(); p.show(); } } class Outer{ int sum; class Inner{ ...
  • 外部类: 最普通的,我们平时见到的那种类,就是在一个后缀为.java的文件中, 直接定义的类,比如 public class Student { private String name; private int age; } 内部类: 内部类,顾名思义,就是包含在外部...
  • Java 内部类与外部类的关系

    千次阅读 2016-11-23 21:39:06
    内部类分为:非静态内部类、静态类内部类...其实是,非静态内部类对象依赖于外部类对象而存在,没有外部类就没有内部类,有外部类不一定有内部类。这一点从内部类的使用语法上面可以看出: public class Outer { int
  • 内部类 外部类区别与联系

    万次阅读 2014-08-06 13:17:10
    内部类和外部类区别与联系
  • 关于内部类获得外部类对象的引用

    千次阅读 2019-03-30 17:32:03
    内部类调用外部类的非静态方法时,需要通过外部类对象的引用来调用:OuterClass.this.method() 以上适用于内部类与外部类方法重名时使用。 情况: 内部类与外部类的方法重名(参数相同)时,直接调用外部类方法,...
  • 格式:外部类名称.this.外部类成员变量名 如何创建内部类对象 格式:外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称(); 实例如下: 定义一个包含内部类的外部类: package NeiBuLei; //...
  • 外部类之外创建内部类对象

    千次阅读 2018-04-09 18:30:24
    外部类类名>.<内部类类名> 引用变量=<外部类对象引用>.new<内部类构造器>;(2) <外部类类名>.<内部类类名> 引用变量=new <...
  • 内部类和外部类的调用

    千次阅读 2018-02-25 12:37:31
    //外部类 public class Out{ private int yes = 0; int data = 1 ; //内部类 public class In{ int yes = 2 ; public void print() { System.out.println("外部类yes:" + Out.this.yes );//...
  • 内存泄漏-内部类持有外部类引用

    千次阅读 2019-11-25 00:28:45
    1.内部类持有外部类引用 我们在处理Android内存泄漏的时候,经常会遇到一些是由于内部类持有外部类引用而引发的。严格来说是非static的内部类的非static对象或匿名内部类的非static对象持有了当前所在外部类的引用...
  • 内部类与外部类的区别

    千次阅读 2018-03-19 15:32:41
    定义在其他类中的类就是内部类,内部类的外面一层就是外部类。简单来说,内部类和调用这个类的方法处于同一个类中,外部类就是和调用这个类的方法不在同一个类中。拿上一节关于事件监听的程序举例:内部类:class ...
  • java外部类与内部类的关系

    千次阅读 2018-12-04 21:48:16
    在学习外部类与内部类之前我们首先要弄明白private,public,protected,default在访问权限上有什么不同,这对我们之后的理解会有一定的帮助。 1、private:访问权限最低的访问控制符,被它修饰的变量只能访问本类...
  • 内部类如何访问外部类同名变量?

    千次阅读 2019-04-15 22:00:46
    如果内部类与外部类出现了重名现象那么 ①内部类使用内部类的成员变量格式是: this.内部类成员变量名 ②内部类使用外部类的成员变量格式是: 外部类名称.this.外部类成员变量名 ![在这里插入图片描述]...
  • 1.静态内部类不会持有外部类引用 下面我们写一个有静态修饰符的内部类 如下 静态内部类: public class MyClass { private static class MyInnerClass { private String innerString; public MyInnerClass...
  • 在内部类里,想引用外部类的对象,为什么是外部类.this而不是外部类加引用变量,还有.操作应该是成员操作符吧,这样this不就成了外部类成员了
  • 内部类引用外部类局部变量,必须保证外部类的局部变量为final的,因为内部类和外部类的局部变量生命周期不一样,外部类方法执行完该局部变量可能就没了,但该方法中的内部类可能还在执行(如线程),还要使用该变量...
  • 普通内部类持有外部类引用的原理

    千次阅读 2018-08-18 15:54:21
    普通内部类持有外部类引用的原理 内部类虽然和外部类写在同一个文件中, 但是编译完成后, 还是生成各自的class文件,内部类通过this访问外部类的成员。 1、编译器自动为内部类添加一个成员变量, 这个成员变量...
  • 内部类: ①静态内部类中可以有非...一般内部类在外部类的成员变量位置,像这样: 1 public class Outer { 2 class Inner{ 3 4 } 5 } 1、外部类访问内部类:  内部类被static修饰:可以直接new  Inner i...
  • 外部类外部访问非静态类内部类: package a; class Wai{ class Nei{ int i=3; } } public class test{ public static void main(String[] args){ Wai.Nei wn1=new Wai().new Nei(); System.out....
  • 我们都是知道内部类就是写在一个类里面的类,类里面的类,不知道你们有没有看过javac之后的结果,就是将一个外部类编译后,生成的字节码文件结果public class OutClass{ private String name; private int id; ...
  • 内部类调用外部类方法时传参是可以传参的,不管外部类方法是private,还是public;而且内部类里可以修改外部类的成员变量。 如果外部类方法无法得到内部类局部变量的值,那应该是哪里写错了。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,075,029
精华内容 430,011
关键字:

外部类