精华内容
下载资源
问答
  • 2021-02-28 13:05:49

    package day6$6;

    public class Inside {

    public static void main(String[] args) {

    //先创建一个外部类对象

    Outside in=new Outside();

    //在通过外部类对象创建一个内部类对象

    Outside.Indoor oi = in.new Indoor();

    //调用内部类自己的属性和方法

    oi.Swim();

    System.out.println(oi.oo);

    //外部类自己调用外部类

    in.age=8;

    System.out.println(in.age);

    System.out.println("=============================================");

    //静态内部类

    //静态内部类的创建需要依赖外部类

    Out.Ind j=new Out.Ind();

    //静态内部类不可以调用外部类的属性和方法

    //静态内部类调用自己的属性和方法

    j.pp="ajk";

    j.Swim();

    //在静态内部类中,只能使用外部类名直接调用外部的静态属性和方法

    Out.age=3;

    }

    }

    //外部类

    class Outside {

    String name = "张";

    static int age = 29;

    public void run() {

    System.out.println("我在狂奔");

    // 内部类

    }

    class Indoor {

    String oo = "aljk";

    public void Swim() {

    System.out.println("我在游泳");

    run();

    }

    }

    }

    //外部类

    class Out {

    String name = "张了";

    static int age = 2;

    public static void run() {

    System.out.println("我在夕阳狂奔");

    }

    // 静态内部类

    static class Ind {

    String pp= "appk";

    int age=5;

    public void Swim() {

    System.out.println("我在水库游泳");

    //直接使用自己类中的age

    System.out.println(age);

    //调用外部类中的age

    System.out.println(Out.age);

    //外部类的方法直接调用

    run();

    }

    }

    }

    更多相关内容
  • 内部静态内部类调用方式

    千次阅读 2020-08-20 16:56:37
    一、静态内部类的创建需要依赖外部 Out.Ind j=new Out.Ind(); 二、非静态内部类 Outside in=new Outside(); //在通过外部对象创建一个内部对象 Outside.Indoor oi =in.newIndoor();

    一、静态内部类的创建需要依赖外部类

    二、非静态内部类

    三、如何在成员内部类中区分调用外部类结构

    四、开发当中,局部内部类的使用 

    五、 内部类的示例

    六、总结


    简介 


    内部类:
    java中允许将一个类A声明在另一个类B中,则类A就是内部类,类B为外部类

    内部类分类:成员内部类(静态,非静态) VS 局部内部类(方法内,代码块内,构造器内)

    调用非静态外部结构:Person.this.eat();

     1 成员内部类:


        一方面:作为外部类的成员
              》调用外部类的结构
              》可被static修饰
              》可以被4种不同的权限修饰
              
        另一方面:作为一个类
              》类内部可以定义属性,方法,构造器等
              》可以被final修饰,表示此类不能被继承,言外之意不使用final、修饰可以被继承
              
              》可以被abstract修饰
              


      2 局部内部类:不能写任何权限修饰符 

     

    1.   因为局部成员的作用域是所在方法,其他程序单元永远不可能访问另一个方法中的局部变量,所以所有的局部成员都不能使用访问控制修饰符修饰。
    2.   局部内部类访问包含他的方法中的变量必须有final修饰; java8如果局部内部类中使用到变量默认final可以省略不写
    3.   如果局部内部类访问外部类的变量不用定义为final的,只有在访问包含他的方法中的变量需要定义为final

              
    关注一下三问题
       1 如何实例化成员内部类
                 //静态成员内部类创建
            Outer.InnerStatic innerStatic = new Outer.InnerStatic();
            innerStatic.show();
            //非静态成员内部类创建
            Outer.Inner inner = new Outer().new Inner();
            inner.sing();
       2 如何在成员内部类中区分调用外部类结构
                System.out.println(name); 形参
                System.out.println(this.name);内部类的属性
                System.out.println(Outer.this.name);外部类的属性
       3 开发当中,局部内部类的使用
        //局部内部类
        public Comparable getComparable() {   
            //方式一,显示实现类
           // 方式二 匿名内部类

           //创建一个实现Comparable接口的局部内部类
            class MyComparable implements Comparable {
                @Override
                public int compareTo(Object o) {
                    return 0;
                }
            } return new MyComparable();
        }
       

     

    一、静态内部类的创建需要依赖外部类

    Out.Ind j=new Out.Ind();

     

    //静态成员内部类创建
    Outer.InnerStatic innerStatic = new Outer.InnerStatic();
    innerStatic.show();
    
    

    二、非静态内部类

    Outside in=new Outside();

    //在通过外部类对象创建一个内部类对象

    Outside.Indoor oi = in.new Indoor();

     

     

    Outer.Inner inner = new Outer().new Inner();
    inner.sing();
    System.out.println();
    inner.display("AA");

    三、如何在成员内部类中区分调用外部类结构

    Outer.this.eat(); //调用外部方法
    System.out.println(name); 形参
    System.out.println(this.name);内部类的属性
    System.out.println(Outer.this.name);外部类的属性
    

    四、开发当中,局部内部类的使用 

    //局部内部类
        public Comparable getComparable() {
    
            //创建一个实现Comparable接口的局部内部类
            //方式一,显示实现类
           // 方式二 匿名内部类
            class MyComparable implements Comparable {
                @Override
                public int compareTo(Object o) {
                    return 0;
                }
            }
    
            return new MyComparable();
        }

    五、 内部类的示例

    
    public class Outer {
    
        String name = "小明" ;
        int age;
        String  salary = "200";
    
        public void eat() {
            System.out.println("吃饭");
        }
    
        public static void main(String[] args) {
            //静态成员内部类创建
            Outer.InnerStatic innerStatic = new Outer.InnerStatic();
            innerStatic.show();
            System.out.println();
            //非静态成员内部类创建
            Outer.Inner inner = new Outer().new Inner();
            inner.sing();
            System.out.println();
            inner.display("AA");
        }
    
        static class InnerStatic {
            String  name ;
            int age;
    
            public void show() {
                System.out.println("卡巴是条狗");
    
            }
        }
    
        class Inner {
    
            String name="杜鹃";
            int age;
    
            public void sing() {
                System.out.println("我是一只小小鸟");
                Outer.this.eat(); //调用外部方法
            }
    
            public void display(String name) {
                System.out.println(name);
                System.out.println(this.name);
                System.out.println(Outer.this.name);
                salary  = "aaa";
                System.out.println(salary);
            }
    
    
        }
    
    
    
        //局部内部类
        public Comparable getComparable() {
    
            //创建一个实现Comparable接口的局部内部类
            //方式一,显示实现类
           // 方式二 匿名内部类
          class MyComparable implements Comparable {
                @Override
                public int compareTo(Object o) {
                    return 0;
                }
            }
    
            return new MyComparable();
        }
    
        public void hello () {
            String name  = "小鸟" ;
    
            class Bird {
    
                public void say () {
                    salary ="bbb";
    //                name = "ccc";  方法中name 被默认是定义为final 这里编译会报错
                    System.out.println(salary);// 成员变量没有必要定义为final
                    System.out.println(name);
                }
            }
        }
    }
    

     

     

    六、总结

    不管是静态内部类还是非静态内部类都需要先new 外部的类。然后用外部的去直接点静态内部类或者 点new 非静态内部类

     

     

     

    展开全文
  • Java静态方法调用内部类

    千次阅读 2019-07-11 15:17:24
    Java编写代码过程中遇到了一个问题,main方法中创建内部类的实例时,编译阶段出现错误,查看错误描述 No enclosing instance of type NoUseThreadDemo is accessible. Must qualify the all...

     

     

    文章原地址:https://www.cnblogs.com/runnigwolf/p/5570810.html

    Java编写代码过程中遇到了一个问题,main方法中创建内部类的实例时,编译阶段出现错误,查看错误描述

     

    No enclosing instance of type NoUseThreadDemo is accessible. Must qualify the allocation with an enclosing instance of type NoUseThreadDemo (e.g. x.new A() where x is an instance of NoUseThreadDemo).

     

     

    参考文章:

    Multiple markers at this line
     - The value of the local variable test is not used
     - No enclosing instance of type StaticCallDynamic is accessible. Must qualify the allocation with an enclosing instance of type StaticCallDynamic (e.g. 
      x.new A() where x is an instance of StaticCallDynamic).

    经过查证,是因为内部类是动态的(无static关键字修饰),而main方法是静态的,普通的内部类对象隐含地保存了一个引用,指向创建它的外围类对象,所以要在static方法(类加载时已经初始化)调用内部类的必须先创建外部类。即应该这样创建“DanymicTest test = new StaticCallDynamic().new DanymicTest();”其中StaticCallDynamic为外部类,DanymicTest为内部动态类;如果将内部内修改为静态类,可以在main中直接创建内部类实例。

      顺便看了下静态方法对动态方法的调用,如果在静态方法中直接调用动态方法,其中print()为类中的动态方法,会出现如下问题:

    Cannot make a static reference to the non-static method print() from the type StaticCallDynamic

      这个要从java的内存机制去分析,首先当你New 一个对象的时候,并不是先在堆中为对象开辟内存空间,而是先将类中的静态方法(带有static修饰的静态函数)的代码加载到一个叫做方法区的地方,然后再在堆内存中创建对象。所以说静态方法会随着类的加载而被加载。当你new一个对象时,该对象存在于堆内存中,this关键字一般指该对象,但是如果没有new对象,而是通过类名调用该类的静态方法也可以。

      程序最终都是在内存中执行,变量只有在内存中占有一席之地时才会被访问,类的静态成员(变态和方法)属于类本身,在类加载的时候就会分配内存,可以通过类名直接去访问,非静态成员(变量和方法)属于类的对象,所以只有在类的对象产生(创建实例)的时候才会分配内存,然后通过类的对象去访问。在一个类的静态成员中去访问非静态成员之所以会出错是因为在类的非静态成员不存在的时候静态成员就已经存在了,访问一个内存中不存在的东西当然会出错。

      所以要么将方法也改为静态方法,要么通过创建该方法所在的实例再通过实例来调用。

    展开全文
  • 外部类调用静态内部类的的方法 我们知道,一个的内部里面的方法,是不可以被直接调用的。但是如果我们想使用内部中的方法,我们应该怎么做呢? 第一种办法 public class test{ public static void main...

    外部类调用非静态内部类的的方法

    我们知道,一个类的内部类里面的方法,是不可以被直接调用的。但是如果我们想使用内部中的方法,我们应该怎么做呢?

    第一种办法

    public class test{
    	public static void main(String[] args) {
    	 Outer.inner p=new Outer().new inner(); // new 一个内部类inner的对象
    	 p.show();                              //我们要注意对象p是无法直接调用Outer类里面的方法的
    	 //Outer p1=new Outer();
         //p1.test();
     }
    }
     class Outer{
    	 int sum;
    	 class inner{
    		 public void show(){
    			 System.out.println("这是内部类的方法");
    		 }
    	 }
    	 public void test(){
    		 System.out.println("这是外部类的方法");
    	 }
     }
    

    第二种办法

    public class test{
    	public static void main(String[] args) {
    		Outer o=new Outer(); //让外部类的方法调用test方法调用内部类里面的show方法
    		o.test();
    	
     }
    }
     class Outer{
    	 int sum;
    	 class Inner{
    		 public void show(){
    			 System.out.println("这是内部类的方法");
    		 }
    	 }
    	 public void test(){      //在外部类中new一个内部类的对象,调用内部类中的方法
    		 Inner i=new Inner();
    		 i.show();
    	 }
     }
    
    展开全文
  • 静态成员内部类中不能有静态变量和静态方法 一.静态方法中,不能调用静态 1.因为,静态方法执行先于非静态。 2.静态方法中,要想使用非静态,就必须等静态方法执行结束,即执行完 } 为止,才能执行非静态。而非...
  • Java如何调用内部类方法

    千次阅读 2021-02-12 13:58:42
    展开全部参阅下段: 《内部类内部类是指...内部类可为静态,可用protected和private修饰(而外部只能使用public和缺省的包访问权限)。内部类主要有以下几:成员内部类、局部内部类、静...
  • 外部调用内部类方法
  • 在python中调用静态方法

    千次阅读 2021-03-05 20:30:36
    在第二个示例中,本身作为方法的第一个参数传递(与实例是第一个参数的常规方法相反,或者不接收任何其他参数的静态方法)。 现在回答你的实际问题。我认为你没有找到你的方法,因为你把Person放在一个模块Person....
  • java 静态内部类的使用

    万次阅读 2018-11-05 19:06:39
    java 静态内部类的使用
  • 首先static的成员是在加载的时候初始化的,JVM的CLASSLOADER的加载,首次主动使用加载,而非static的成员是在建立对象的时候,即new 操做的时候才初始化的;函数前后顺序是先加载,才能初始化,那么加载的时候初始...
  • 通过本文可理解静态变量、静态方法的含义,可以知道为什么静态方法内部不能调用静态变量
  • 静态内部类

    千次阅读 2021-07-25 13:04:24
    静态内部类就是用saitic关键字修饰的内部类类,是与共享的,所以静态内部类的对象不依赖于外部的对象,可直接创建。        我们先创建一个,在其中创建一个静态内部类。 ...
  • 内部类和外部之间的相互调用

    千次阅读 2021-03-15 10:28:12
    内部:①静态内部类中可以有非静态的方法②当内部中有静态方法或者静态成员变量时,一定是静态内部类一般内部在外部的成员变量位置,像这样:1 public classOuter {2 classInner{34 }5 }1、外部访问内部...
  • 静态和非静态方法调用方式

    千次阅读 2020-07-14 17:19:27
    1.非静态方法要实例化才能调用 2.静态方法可以直接调用。(静态方法调用含有非静态的变量和方法) 举例: public class OuterClass { ...// 静态内部类,静态只能是内部 public static class StaticInnerClass
  • 静态方法内部调用静态方法静态方法在调用时是与对象紧密连接在一起的,非静态方法必须要通过对象来调用,而**static**方法(静态方法)的加载是随着的加载而加载的,可以直接通过类名来调用,加载的过程中还...
  • 内部(成员内部静态内部类方法内部)

    万次阅读 多人点赞 2018-06-05 15:33:35
    一:成员内部类:最常见的内部类就是成员内部类,也称作普通内部类;1、Inner定义在Outer内部,相当于Outer的成员变量的位置,Inner可以使用任意访问修饰符,如:public、private、protected等。2、Inner...
  • 目录成员内部类静态内部类方法内部完整程序 成员内部 成员内部创建对象必须使用外部对象来创建内部对象,而不能直接new内部构造方法的方式创建; //普通成员内部创建对象,需通过外部对象进行...
  • ES6中新增class静态方法如何在类内部调用
  • 静态内部类的访问方式

    千次阅读 2018-07-31 09:58:10
    (1)静态内部类里有非静态方法  格式:  外部类名.内部类名 对象名 = 外部类名.内部对象; 代码演示如下: //静态内部类的访问方式 public class Demo3 { public static void main(String[] args) { //...
  • java中静态内部类的加载时机?

    千次阅读 2021-02-27 11:31:20
    1.问题: 静态内部类的加载时机?他和外部的加载有没有什么关系?...①一个内部有静态内部类和非静态内部类静态内部类和非静态内部类一样,都是在被调用时才会被加载 不过在加载静态内部类的过程中.
  • 内部类中不能使用静态的变量和静态方法,这句话今天刚听到的时候感觉没毛病,但是,内部类中也不一定不能使用静态的变量,我们可以通过添加final 的方法的来使用,内部类静态方法是不能使用的 看下面的代码 ...
  • 内部静态内部类区别及举例

    千次阅读 2021-07-02 17:04:26
    静态内部类相对与外部是独立存在的,在静态内部类中无法直接访问外部中的变量、方法。如果要访问的话,必须要new一个外部的对象,使用new出来的对象来访问。 但是可以直接访问静态变量,调用静态的方法。 ...
  • 前言 在项目开发过程中,我们需要用实体接收传递过来的参数,若前端传来的Json结构比较复杂,我们就需要用相对复杂的实体接收参数,即一个DTO引用另一...本文的重头戏,静态内部类粉墨登场了。 拾遗-什么是内部 ...
  • 静态方法调用静态方法

    千次阅读 2017-12-27 15:47:49
    静态方法不能(直接)调用静态变量,非静态方法可以引用静态变量。 静态方法不属于对象,是属于的,不需要实例化; 而非静态变量是属于对象的,需要先实例化。 在一个静态成员中去访问其非静态成员,因为...
  • (1)问题分析:考官主要相对... 内部静态内部类的区别;java中是否可以覆盖(override) 一个private或者是static的方法。(2)核心答案讲解:不可以。static方法是静态方法,是属于方法,非static方法是属于对象...
  • android的内部静态内部类的区别

    千次阅读 2018-10-17 10:53:19
    static修饰表示静态的,在加载时JVM会把它放到方法区,被本以及本中所有实例所公用。在编译后所分配的内存会在一直存在,直到程序退出内存才会释放这个空间。如果一个被所有实例公用的方法被申明为static,...
  • Java 静态内部类 的详细解释

    千次阅读 2021-03-11 02:30:47
    01:静态内部类 的成员可以是 静态的数据域 和 静态的方法 ,因为这个是静态的, 在加载的时候一并被加载进去如下图: //解释: 这个Outer在被虚拟机加载的时候, name被初始化, 因为StaticInner 依然是一个静态的...
  • 静态内部类和内部的关系 只有内部才能被声明为静态,即...如果一个内部不是被定义成静态内部类,那么在定义成员变量或者成员方法的时候,是不能够被定义成静态的; 总结: 是否能拥有静态成员:静态内部类.
  • 深入理解单例模式:静态内部类单例原理

    万次阅读 多人点赞 2018-05-26 02:00:54
    本文主要介绍java的单例模式,以及详细剖析静态内部类之所以能够实现单例的原理。OK,废话不多说,进入正文。 首先我们要先了解下单例的四大原则: 1.构造私有。 2.以静态方法或者枚举返回实例。 3.确保实例只有...
  • 内部类没有使用static关键字修饰,并且和外部的成员变量和方法属于同一级别,这样的是非静态成员内部类(可以使用权限修饰符修饰,和final、abstract关键字修饰)。 public class Atest { private String name = ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 643,156
精华内容 257,262
关键字:

静态内部类方法调用