精华内容
下载资源
问答
  • 方法内部类
    万次阅读
    2019-05-05 21:29:10

    内部类:

    • 将一个类定义在另一个类的里面,对里面那个类就称为内部类(内置类,嵌套类)。
    • 访问特点:

            • 内部类可以直接访问外部类中的成员,包括私有成员。

           • 而外部类要访问内部类中的成员必须要建立内部类的对象。

     

    内部类的位置:

    • 内部类定义在成员位置上

            • 可以被private static成员修饰符修饰。

            • 被static修饰的内部类只能访问外部类中的静态成员。

    • 内部类定义在局部位置上

           • 也可以直接访问外部类中的成员。

           • 同时可以访问所在局部中的局部变量,但必须是被final修饰的。

     

    内部类的访问规则:

    1,内部类可以直接访问外部类中的成员,包括私有。 之所以可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用, 格式 外部类名.this

    2,外部类要访问内部类,必须建立内部类对象。 (当内部类在外部类的实例域时,内部类可以被private修饰)

    class Outer
    {
    	private int x = 3;
     
    	class Inner//内部类
    	{
               int x = 4;//默认转换为final变量
    		void function()
    		{
                       int x = 6;
    			System.out.println("innner :" + Outer.this.x);
                       //x = 6; this.x = 4; Outer.this.x = 3;
    		}
    	}
    
    	void method()
    	{
    		Inner in = new Inner();
    		in.function();
    	}
    }
    
    class  InnerClassDemo
    {
    	public static void main(String[] args) 
    	{
               //访问内部类成员方法一
    		Outer out = new Outer();
    		out.method();//通过在外部内建立方法,在其中建立内部类对象。间接访问内部类中方法。
              //访问内部类成员方法二
    		Outer.Inner in = new Outer().new Inner();
    		in.function();//通过直接建立内部类的对象访问其方法
       }
    }
    /*
    innner :3
    innner :3
    */

     

    访问格式:

    1,当内部类定义在外部类的成员位置上,而且非私有,可以在外部其他类中。 可以直接建立内部类对象。 格式 外部类名.内部类名 变量名 = 外部类对象.内部类对象; Outer.Inner in = new Outer().new Inner();

    2,当内部类在成员位置上,就可以被成员修饰符所修饰。

    比如,private:将内部类在外部类中进行封装。

    static:内部类就具备static的特性。 当内部类被static修饰后,只能直接访问外部类中的static成员。出现了访问局限。

    在外部其他类中,如何直接访问static内部类的非静态成员呢?

    new Outer.Inner().function();

    在外部其他类中,如何直接访问static内部类的静态成员呢?

    Outer.Inner.function();

    注意:当内部类中定义了静态成员,该内部类必须是static的。 当外部类中的静态方法访问内部类时,内部类也必须是static的。

     

    //static不能修饰一般类,但是可以修饰内部类
    static class StaticDemo //static不能修饰外部类
    {
    	public static void show()
    	{
    		System.out.println("static class...");
    	}
    }
    
    class  InnerClassDemo2
    {
    	public static void main(String[] args) 
    	{
               StaticDemo sd = new StaticDemo();
    		sd.show();
    	}
    }
    /*
    Exception in thread "main" java.lang.Error: 无法解析的编译问题:
    	类 StaticDemo 的修饰符不合法;只允许使用“公用”、“抽象”和“终态”
    */

     

    class Outer
    {
    	private static  int x = 3;
    
    	static class Inner//静态内部类
    	{
    		static void function()
    		{
    			System.out.println("innner :"+x);
    		}
    	}
    
    	static class Inner2//静态类中可以定义静态方法也可以定义非静态方法;
    	{//但是含有静态方法的类一定要定义为静态类,除非是顶层类。
     //只能在静态类型和顶层类型中定义静态方法。
    		void show()
    		{
    			System.out.println("inner2 show");
    		}
    	}
    
    	public static void method()
    	{
    		new Inner(); //在外部类内的方法中可以实例化静态内部类
    		Inner.function();//静态内部类可以类名调用
    //		Inner2.show(); //不能对非静态方法进行类名访问
    		new Inner2().show();//非静态方法需要创建对象后访问
    	}
    
    }
    
    class  InnerClassDemo2
    {
    	public static void main(String[] args) 
    	{
    		Outer.method();
    	}
    }
    /*
    innner :3
    inner2 show
    */
    class Outer
    {
    	private static  int x = 3;
    
    	static class Inner//静态内部类
    	{
    		static void function()
    		{
    			System.out.println("innner :"+x);
    		}
    	}
    
    	static class Inner2
    	{
    		void show()
    		{
    			System.out.println("inner2 show");
    		}
    	}
    
    	public static void method()
    	{
    		new Inner(); //在外部类内的方法中可以实例化静态内部类
    		Inner.function();//静态内部类可以类名调用
    //		Inner2.show(); //不能对非静态方法进行类名访问
    		new Inner2().show();//非静态方法需要创建对象后访问
    	}
    }
    
    class  InnerClassDemo2
    {
    	public static void main(String[] args) 
    	{
    		Outer.method();//调用外部类中的方法
    		
    		Outer.Inner.function();
    //		Outer.Inner2.show();//不能通过类名调用非静态方法
    		
    		new Outer.Inner().function();
      //警告:应该以静态的方式访问类型Outer.Inner中的静态方法function()
    	}
    }
    /*
    innner :3
    inner2 show
    innner :3
    innner :3
    */
    
    //静态内部类通过new Outer.Inner();来创建对象
    class Outer
    {
    	private static  int x = 3;
    
    	static class Inner//静态内部类
    	{
    		static void function()
    		{
    			System.out.println("innner :"+x);
    		}
    	}
    
    	static class Inner2//静态类与其内方法是否静态无关
    	{
    		void show()
    		{
    			System.out.println("inner2 show");
    		}
    	}
    
    	public static void method()
    	{
    		new Inner(); //在外部类内的方法中可以实例化静态内部类
    		Inner.function();//静态内部类可以类名调用
    //		Inner2.show(); //不能对非静态方法进行类名访问
    		new Inner2().show();//非静态方法需要创建对象后访问
    	}
    }
    
    class  InnerClassDemo2
    {
    	public static void main(String[] args) 
    	{
    //		Outer.method();//调用外部类中的方法
    		
    //		Outer.Inner.function();
    //		Outer.Inner2.show();//不能通过类名调用非静态方法
    		
    		new Outer.Inner().function();
    		
    		Outer.Inner in = new Outer.Inner();//实例化静态内部类
    		in.function();
    		
    		Outer.Inner2 in2 = new Outer.Inner2();//实例化静态内部类
    		in2.show();		
    	}
    }
    /*
    innner :3
    innner :3
    inner2 show
    */

     

    更多相关内容
  • 内部类(成员内部类、静态内部类、方法内部类)

    万次阅读 多人点赞 2018-06-05 15:33:35
    一:成员内部类:最常见的内部类就是成员内部类,也称作普通内部类;1、Inner类定义在Outer类的内部,相当于Outer类的成员变量的位置,Inner类可以使用任意访问修饰符,如:public、private、protected等。2、Inner...

    一:成员内部类:

    最常见的内部类就是成员内部类,也称作普通内部类;

    1、Inner类定义在Outer类的内部,相当于Outer类的成员变量的位置,Inner类可以使用任意访问修饰符,如:public、private、protected等。

    2、Inner类中定义的test()方法可以访问Outer类中的数据,不受访问控制符的影响。

    3、 定义了成员内部类后,必须使用外部类对象来创建内部类对象,而不能直接去 new 一个内部类对象,即:内部类 对象名 = 外部类对象.new 内部类( );如创建Inner的内部类对象:要先创建外部类对象:Outer o = new outer(); 创建内部类:Inner i = o.new Inner();访问Inner中的test()方法:i.test();

    例如:

    4、如果外部类和内部类具有相同的成员变量或方法,内部

    展开全文
  • Java如何调用内部类方法

    千次阅读 2021-02-12 13:58:42
    展开全部参阅下段: 《内部类内部类是指32313133353236313431303231363533e4b893e5b19e31333262353462在一个外部类的内部再定义一个类。内部类作为外部类的一个成员,并且依附于外部类而存在的。内部类可为静态,...

    展开全部

    参阅下段: 《内部类》

    内部类是指32313133353236313431303231363533e4b893e5b19e31333262353462在一个外部类的内部再定义一个类。内部类作为外部类的一个成员,并且依附于外部类而存在的。内部类可为静态,可用protected和private修饰(而外部类只能使用public和缺省的包访问权限)。内部类主要有以下几类:成员内部类、局部内部类、静态内部类、匿名内部类

    为什么需要内部类?

    典型的情况是,内部类继承自某个类或实现某个接口,内部类的代码操作创建其的外围类的对象。所以你可以认为内部类提供了某种进入其外围类的窗口。使用内部类最吸引人的原因是:

    每个内部类都能独立地继承自一个(接口的)实现,所以无论外围类是否已经继承了某个(接口的)实现,对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力,一些设计与编程问题就很难解决。从这个角度看,内部类使得多重继承的解决方案变得完整。接口解决了部分问题,而内部类有效地实现了“多重继承”。

    A:成员内部类

    作为外部类的一个成员存在,与外部类的属性、方法并列。

    publicclass Outer {

    privatestaticinti = 1;

    privateintj = 10;

    privateintk = 20;

    publicstaticvoidouter_f1() {

    }

    publicvoidouter_f2() {

    }

    // 成员内部类中,不能定义静态成员

    // 成员内部类中,可以访问外部类的所有成员

    class Inner {

    // static int inner_i = 100;//内部类中不允许定义静态变量

    intj = 100; // 内部类和外部类的实例变量可以共存

    intinner_i = 1;

    void inner_f1() {

    System.out.println(i);

    //在内部类中访问内部类自己的变量直接用变量名

    System.out.println(j);

    //在内部类中访问内部类自己的变量也可以用this.变量名

    System.out.println(this.j);

    //在内部类中访问外部类中与内部类同名的实例变量用外部类名.this.变量名

    System.out.println(Outer.this.j);

    //如果内部类中没有与外部类同名的变量,则可以直接用变量名访问外部类变量

    System.out.println(k);

    outer_f1();

    outer_f2();

    }

    }

    //外部类的非静态方法访问成员内部类

    publicvoidouter_f3() {

    Inner inner = new Inner();

    inner.inner_f1();

    }

    // 外部类的静态方法访问成员内部类,与在外部类外部访问成员内部类一样

    publicstaticvoidouter_f4() {

    //step1 建立外部类对象

    Outer out = new Outer();

    //step2 根据外部类对象建立内部类对象

    Inner inner = out.new Inner();

    //step3 访问内部类的方法

    inner.inner_f1();

    }

    publicstaticvoid main(String[] args) {

    //outer_f4();//该语句的输出结果和下面三条语句的输出结果一样

    //如果要直接创建内部类的对象,不能想当然地认为只需加上外围类Outer的名字,

    //就可以按照通常的样子生成内部类的对象,而是必须使用此外围类的一个对象来

    //创建其内部类的一个对象:

    //Outer.Inner outin = out.new Inner()

    //因此,除非你已经有了外围类的一个对象,否则不可能生成内部类的对象。因为此

    //内部类的对象会悄悄地链接到创建它的外围类的对象。如果你用的是静态的内部类,

    //那就不需要对其外围类对象的引用。

    Outer out = new Outer();

    Outer.Inner outin = out.new Inner();

    outin.inner_f1();

    }

    }

    注意:内部类是一个编译时的概念,一旦编译成功,就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。

    B:局部内部类

    在方法中定义的内部类称为局部内部类。与局部变量类似,局部内部类不能有访问说明符,因为它不是外围类的一部分,但是它可以访问当前代码块内的常量,和此外围类所有的成员。

    publicclass Outer {

    privateints = 100;

    privateintout_i = 1;

    publicvoid f(finalint k) {

    finalint s = 200;

    int i = 1;

    finalint j = 10;

    //定义在方法内部

    class Inner {

    ints = 300;// 可以定义与外部类同名的变量

    // static int m = 20;//不可以定义静态变量

    Inner(int k) {

    inner_f(k);

    }

    intinner_i = 100;

    voidinner_f(int k) {

    //如果内部类没有与外部类同名的变量,在内部类中可以直接访问外部类的实例变量

    System.out.println(out_i);

    //可以访问外部类的局部变量(即方法内的变量),但是变量必须是final的

    System.out.println(j);

    //System.out.println(i);

    //如果内部类中有与外部类同名的变量,直接用变量名访问的是内部类的变量

    System.out.println(s);

    //用this.变量名访问的也是内部类变量

    System.out.println(this.s);

    //用外部类名.this.内部类变量名访问的是外部类变量

    System.out.println(Outer.this.s);

    }

    }

    new Inner(k);

    }

    publicstaticvoid main(String[] args) {

    // 访问局部内部类必须先有外部类对象

    Outer out = new Outer();

    out.f(3);

    }

    }

    C:静态内部类(嵌套类):(注意:前两种内部类与变量类似,所以可以对照参考变量)

    如果你不需要内部类对象与其外围类对象之间有联系,那你可以将内部类声明为static。这通常称为嵌套类(nested class)。想要理解static应用于内部类时的含义,你就必须记住,普通的内部类对象隐含地保存了一个引用,指向创建它的外围类对象。然而,当内部类是static的时,就不是这样了。嵌套类意味着:

    1. 要创建嵌套类的对象,并不需要其外围类的对象。

    2. 不能从嵌套类的对象中访问非静态的外围类对象。

    publicclass Outer {

    privatestaticinti = 1;

    privateintj = 10;

    publicstaticvoidouter_f1() {

    }

    publicvoidouter_f2() {

    }

    // 静态内部类可以用public,protected,private修饰

    // 静态内部类中可以定义静态或者非静态的成员

    staticclass Inner {

    staticintinner_i = 100;

    intinner_j = 200;

    staticvoidinner_f1() {

    //静态内部类只能访问外部类的静态成员(包括静态变量和静态方法)

    System.out.println("Outer.i" + i);

    outer_f1();

    }

    voidinner_f2() {

    // 静态内部类不能访问外部类的非静态成员(包括非静态变量和非静态方法)

    // System.out.println("Outer.i"+j);

    // outer_f2();

    }

    }

    publicvoidouter_f3() {

    // 外部类访问内部类的静态成员:内部类.静态成员

    System.out.println(Inner.inner_i);

    Inner.inner_f1();

    // 外部类访问内部类的非静态成员:实例化内部类即可

    Inner inner = new Inner();

    inner.inner_f2();

    }

    publicstaticvoid main(String[] args) {

    newOuter().outer_f3();

    }

    }

    生成一个静态内部类不需要外部类成员:这是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成:Outer.Inner in = new Outer.Inner();而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类(正常情况下,你不能在接口内部放置任何代码,但嵌套类可以作为接口的一部分,因为它是static 的。只是将嵌套类置于接口的命名空间内,这并不违反接口的规则)

    2Q==

    已赞过

    已踩过<

    你对这个回答的评价是?

    评论

    收起

    展开全文
  • Java 中的方法内部类

    千次阅读 2018-07-24 11:31:45
    方法内部类就是内部类定义在外部类的方法中,方法内部类只在该方法的内部可见,即只在该方法内可以使用。 一定要注意哦:由于方法内部类不能在外部类的方法以外的地方使用,因此方法内部类不能使用访问控制符和 ...

    方法内部类就是内部类定义在外部类的方法中,方法内部类只在该方法的内部可见,即只在该方法内可以使用。

    一定要注意哦:由于方法内部类不能在外部类的方法以外的地方使用,因此方法内部类不能使用访问控制符和 static 修饰符。

    //外部类
    public class HelloWorld {
        
        private String name = "爱慕课";
        
        // 外部类中的show方法
        public void show() { 
    		// 定义方法内部类
    		class MInner {
    			int score = 83;
    			public int getScore() {
    				return score + 10;
    			}
    		}
            
    		// 创建方法内部类的对象
            MInner mi=new  MInner();
            
            // 调用内部类的方法
    		
           int newScore=mi.getScore();
    		System.out.println("姓名:" + name + "\n加分后的成绩:" + newScore);
    	}
        
    	// 测试方法内部类
    	public static void main(String[] args) {
            
    		// 创建外部类的对象
            HelloWorld mo=new HelloWorld();
            
            // 调用外部类的方法
    		mo.show();
    	}
    }

     

    展开全文
  • JAVA中的内部类--方法内部类

    千次阅读 2015-06-28 17:54:57
    方法内部类就是内部类定义在外部类的方法中,方法内部类只在该方法的内部可见,即只在该方法内可以使用。 由于方法内部类不能在外部类的方法以外的地方使用,因此方法内部类不能使用访问控制符和 static 修饰符。 ...
  • /** * 标题:Java内部类[成员内部类、局部内部类、匿名内部类... * 答:在 Java 中,可以将一个类定义在另一个类里面或者一个方法里面,这样的类称为内部类。 */ public class Test13 { //测试类,用于测试案例 p...
  • java内部类最全详解

    万次阅读 多人点赞 2022-03-20 10:58:56
    成员内部类的创建需要依赖于外部类对象-(成员方法必须通过对象调用),在没有外部类实例之前无法创建成员内部类对象 b.内部类与外部类相对独立,不是is a 的关系(发动机-汽车) c.私有属性的互相访问,内部类...
  • 本文主要介绍了Java内部类的基本原理,使用方法和各种细节。 有关内部类实现回调,事件驱动和委托机制的文章将在后面发布。 具体代码在我的GitHub中可以找到 https://github.com/h2pl/MyTech 文章首发于我的个人...
  • 外部调用内部类方法
  • 内部类(四种内部类详解)

    千次阅读 2021-11-19 16:19:17
    [属性、方法、构造器、代码块、内部类]】,内部类最大的特点就是可以直接访问私有属性,并且可以体现类与类之间的包含关系,注意:内部类是学习的难点,同时也是重点,后面看底层源码时,有大量的内部类. 如果定义类在...
  • 当时只是回答了静态内部类能访问外部类的静态方法,成员内部类能访问外部类的所有方法。然后面试官问我原因我就答不上来了。还是原来看的不仔细,这里具体整理下。 通俗的理解,在一个类里面定义另一个类,这样的类...
  • 内部类与外部类之间的访问

    千次阅读 2022-04-14 17:54:16
    2.内部类的特点:内部类可以直接访问外部类的成员(成员变量和成员方法),包括私有成员。 3.内部类与外部类之间的访问 在测试类中调用成员内部类中的方法: 外部类访问成员内部类中的成员: 静态的成员内部类,只能...
  • 内部类如何调用外部类的方法

    千次阅读 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{ ...
  • 文章目录1 内部类的基本概念1.1 内部类的定义1.2 内部类的优缺点2 创建内部类2.1 在外部类外部创建非静态内部类2.2 在外部类外部创建静态内部类...3.2 静态内部类3.3 方法内部类3.4 匿名内部类4 内部类与外部类的关系...
  • 详解 Java 内部类

    千次阅读 2021-03-06 18:10:33
    内部类在 Java 里面算是非常常见的一个功能了,在日常开发中我们肯定多多少少都用过,这里总结一下关于 Java 中内部类的相关知识点和一些使用内部类时需要注意的点。从种类上说,内部类可以分为四类:普通内部类、...
  • Java静态方法调用内部类

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

    千次阅读 2020-05-19 11:38:47
    二是使用匿名内部类的方式重写其方法,也可以达到相同的效果,并且代码更加简洁。在这里第一种方法就不说了,重点看看第二种方法是怎么个用法 。 一个NIO处理目录树的例子 目录树意味着一个目录里既有文件也有子目录...
  • java 匿名内部类

    千次阅读 2022-04-10 09:07:39
    1. 匿名内部类介绍 使用 Java 编程时,常常需要创建不会被再次使用的对象。在这种情况下,非常适合使用一种特殊 的内部类:匿名内部类。这种类没有名称,是在同一条语句中声明和创建的。 要使用匿名内部类,可将...
  • Java内部类和匿名内部类的用法

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

    千次阅读 2016-12-10 16:59:13
    定义在代码块,方法体内的类叫局部内部类 局部内部类访问外部类的成员使用:外部类名.this.成员名 对外部世界完全隐藏,只在其作用域内生成对象 局部类不能加访问修饰符,因为它们不是类成员 成员内部类不能与外部类...
  • 详细介绍了Java中的内部类的概念,及各种内部类的访问案例演示。包括非静态内部类、静态内部类、局部内部类、匿名内部类
  • 根据成员内部类的定义: 首先生成外部类的实例对象 然后生成绑定到外部类实例对象的成员内部类实例对象 外部类实例对象的生成一定要先于成员内部类实例对象的生成 public class InnerClassDemo{ //对于final修饰...
  • 内部类和枚举类

    千次阅读 2021-02-27 14:57:02
    内部类可以定义在外部类的成员位置(与成员变量的位置相同)或局部位置(意思是,把类写在外部类的方法里面)。什么时候使用内部类 :一个具体的事物里面还有一个具体的事物。比如汽车中有发动机。1、成员内部类1.将内部...
  • java内部类 和外部类的区别

    千次阅读 2021-03-07 00:47:13
    下面说一说内部类(Inner Class)和静态内部类(Static Nested Class)的区别:定义在一个类内部的类叫内部类,包含内部类的类称为外部类。内部类可以声明public、protected、private等访问限制,可以声明 为abstract的...
  • 匿名内部类、lambda和方法引用其实是相通的,从匿名内部类到lambda到方法引用是一个进化的过程,是一个简化的过程,更加是一个从抽象的过程。 作用都是实现接口方法,换句话说就是实现接口;只是这个接口只有一个...
  • Java的内部类和匿名类 , 您了解过吗?

    千次阅读 多人点赞 2020-07-23 08:35:30
    内部类主要有成员内部类、局部内部类、静态内部类、匿名内部类内部类允许吧一些逻辑相关的类组织在一起,并且能控制内部类代码的可视性,将包含此内部类的类称为外部类。 匿名类 匿名类,也就是之前所...
  • java匿名内部类什么是匿名内部类?匿名内部类的使用场景?匿名内部类如何创建?匿名内部类的实现和使用例1(实现接口)例2(继承类) 什么是匿名内部类? 匿名内部类,顾名思义,就是不知道这个类到底是什么名字,也...
  • java调用内部类的两种方法

    万次阅读 2018-11-06 19:31:36
     //一、调用内部类的第一种方式,将内部类声明为static,直接通过总类调用  testList.add(new TestPrintList.User(3,"tom"));  testList.add(new TestPrintList.User(4,"jack"));  testList.add(new ...
  • 静态内部类

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

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,117,082
精华内容 846,832
关键字:

方法内部类

友情链接: autoDelLicenses.zip