精华内容
下载资源
问答
  • java调用局部内部类中的方法

    千次阅读 2019-08-09 12:21:26
    局部内部类中方法的调用

    使用Junit单元测试
    局部内部类封装在外部类的一个方法中,此方法一般会有一个返回值,返回该局部类类型

    package com.yzy.innerclass;
    
    import org.junit.Test;
    
    /**
     * @className LocalInnerClass.java
     * @author yangsir
     * @version V1.0
     * @date 2019年8月9日-上午12:03:03
     * @description 如何调用局部内部类
     */
    public class LocalInnerClass {
    	@Test
    	public void test1() {
    
    		// 1常规
    		Work w = new Student();// 父类引用指向子类对象
    		w.doWork();// 调用子类重写的接口中的方法
    		// 匿名类的对象
    		Work w1 = new Work() {
    			@Override
    			public void doWork() {
    				System.out.println("工作");
    			}
    		};
    		w1.doWork();// 调用匿名类的方法
    		System.out.println("===================================================");
    	}
    
    	@Test
    	public void test2() {
    
    		// 2匿名类的匿名对象
    		new Work() {
    			@Override
    			public void doWork() {
    				System.out.println("工作");
    
    			}
    		}.doWork();// 直接用new().work的形式,要重写doWork方法
    		System.out.println("===================================================");
    	}
    
    	@Test
    	public void test3() {
    
    		// 1.调用局部内部类
    //		Work work = new LocalInnerClass().getWork();  //new Teacher();  //创建一个局部内部类对象
    //		work.doWork();//调用getWork方法输出讲课(已注释)
    		// 2.调用
    		Work work = new LocalInnerClass().getWork();// 创建一个局部内部类对象
    		work.doWork();// 调用
    	}
    
    	// 局部内部类
    	public Work getWork() {
    		// 1局部内部类
    //		class Teacher implements Work{//局部内部类实现接口,重写doWork方法,返回值为Teacher
    //			@Override
    //			public void doWork() {
    //				System.out.println("讲课");
    //			}
    //		} 
    //		return new Teacher();//返回一个Teacher对象
    		// 2局部内部类 匿名类的匿名对象
    		return new Work() {// 直接return一个匿名对象,然后重写里面的方法即可,注意这里的括号
    			@Override
    			public void doWork() {
    				System.out.println("员工在工作");
    
    			}
    		};
    	}
    }
    
    interface Work { // 一个接口
    	void doWork();
    }
    
    class Student implements Work {// 实现接口的类,有自己的方法
    
    	@Override
    	public void doWork() {
    		System.out.println("学习");
    	}
    
    }
    
    

    下面放一位小姐姐的总结图
    内部类

    展开全文
  • 因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在...

    * 局部内部类访问局部变量必须用final修饰
    * 局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么?
    因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用

    1.8之前的版本是需要加final,1.8之后不用加也可以使用。

    public class Demo2_InnerClass {
        public static void main(String[]args){
            Outher o=new Outher();
            o.method();
        }
    }
    
    class Outher{
        public void method(){
            int num=10;
            class Inner{
                public void print(){
                    System.out.println("局部内部类成员方法");
                    System.out.println("访问局部变量需要设置为final:"+num);
                }
            }
            Inner i=new Inner();//在方法中创建Inner对象
            i.print();
        }
       /* public void run(){//局部内部类,只能在其所在的方法中访问
            Inner i=new Inner();
            i.print();
        }*/
    }

     

    展开全文
  • java内部之成员内部局部内部类和匿名内部

    千次阅读 多人点赞 2018-07-15 16:13:30
    2、局部内部类(包含匿名内部)。 成员内部 定义格式: 修饰符 class 名称 { 修饰符 class 名称 { //... } //... } 注意: 内部使用外部,可以随意访问,但是外部使用内部要借助内部的对象...

    内部类概念

    一个类中包含另外一个类。

    分类

    1. 成员内部类。
    2. 局部内部类(包含匿名内部类)。

    成员内部类

    定义格式:

    修饰符 class 类名称 {
        修饰符 class 类名称 {
            //...
        }
        //...
    }

    注意:

    内部类使用外部,可以随意访问,但是外部类使用内部类要借助内部类的对象。

    使用成员内部类

    两种方法:
    1. 间接方式:在外部类的方法中,使用内部类,然后main只调用外部类的方法。
    2. 直接方式:公式:
    一般类:类名称 对象名 = new 类名称();
    成员内部类:外部内名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();

    Body.java含有一个内部类Heart

    public class Body {
    
        private String name;
    
        //外部类方法
        public void methodBody() {
            System.out.println("外部类的方法");
            new Heart().beat();//在外部类方法中使用内部类。 
        }
    
    
        public  class Heart { //成员内部类
            //内部类方法
            public void  beat() {
                System.out.println("心脏跳动");
                System.out.println("我叫:"+name);
            }
        }
    }

    下面分别介绍两种方式访问内部类:

    间接方式访问内部类

    Demo01InnerClass.java

    public class Demo01InnerClass {
        public static void main(String[] args) {
            Body body = new Body();//外部类对象
    
            //通过外部类的对象,调用外部类的方法,里面间接使用内部类Heart
            body.methodBody();

    直接方式访问内部类

    public class Demo01InnerClass {
        public static void main(String[] args) {
            Body body = new Body();//外部类对对象
    
            //外部内名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
            Body.Heart heart = new Body().new Heart();
            heart.beat();
        }
    }

    外部类和内部类变量重名问题

    当外部类的变量和内部类变量重名时,在内部类方法中访问外部类变量的格式是:外部类.this.外部类成员变量名

    public class Outer {
        int number = 10;
    
        public class Inner {
            int number = 20;
    
            public  void methodInner() {
                int number =30;//内部类方法的局部变量
                System.out.println(number);//就近原则
                System.out.println(this.number);
                System.out.println(Outer.this.number);//外部类的成员变量
            }
        }
    }

    30
    20
    10


    局部内部类

    如果类是定义在一个方法内部的,那么这就是一个局部内部类。
    “局部”:只有当前所属的方法才能使用它,出了这个方法外面就不能用了。

    定义格式

    修饰符 class 外部类名称 {
        修饰符 返回值类型  外部类方法名称(参数列表) {
            class 局部内部类名称 {
                //...
            }
        }
    }

    Outer.java含有局部内部类

    public class Outer {
        public void methodOuter() {
    
            class Inner {
                int num = 10;
                public void methodInner() {
                    System.out.println(num);//10
                }
            }
            //这个内部列只有当前所属方法能够访问这个类,出了这个方法就不能用了
            Inner inner = new Inner();
            inner.methodInner();
        }
    }

    DemoMain.java

    public class DemoMain {
    
        public static void main(String[] args) {
            Outer outer = new Outer();
            outer.methodOuter();
        }
    }

    结果:
    10

    注意:

    局部内部类,如果希望访问所在方法的局部变量,那么这个局部变量必须是【有效final的】
    备注:从java 8+开始,只要局部变量事实不变,那么final关键字可以省略。
    原因:
    1. new 出来的对象在堆内存当中。
    2. 局部变量是跟着方法走的,在栈内存当中。
    3. 方法运行结束后,立刻出栈,局部变量就会立刻消失。
    4. 但是new出来的对象在堆当中持续存在,直到垃圾回收消失。

    public class MyOuter {
        public void methodOuter() {
            final int num = 10;//所在方法的局部变量
    
            /*在栈中的局部变量可能随着方法结束出栈消失了,但是创建的内部类对象还存在。
            对象使用常量时能直接将常量copy进来,这时就要保证这个常量是不可更改的,也就是final。
            */
            //num = 20;
    
            class MyInner {
                public  void methodInner() {
                    System.out.println(num);
                }
            }
            Inner myinner = new MyInner();
            inner.methodInner();
        }
    }

    修饰内部类的权限

    public > protected > (default) > private
    定义一个类的时候,权限修饰符规则:

    1. 外部类:public / (default)
    2. 成员内部类:都可以写,public > protected > (default) > private
    3. 局部内部类:什么都不能写,但不是de

    匿名内部类

    如果接口的实现类(或者是父类的子类)只需要使用唯一的一次。
    那么这种情况下就可以省略调该类的定义,而改为使用【匿名内部类】。

    匿名内部类定义格式:

    接口名称 对象名 = new 类名或者接口名称() {
        //覆盖重写所有抽象方法
    };

    代表继承了或者实现了该接口的子类对象。

    ==接口MyInterface.java==

    public interface MyInterface {
        void method1();//抽象方法
        void method2();
    }

    ==接口实现类MyInterfaceImp.java==

    public class MyInterfaceImpl implements  MyInterface {
    
    
        @Override
        public void method1() {
            System.out.println("实现类覆盖重写了方法1");
        }
    
        @Override
        public void method2() {
            System.out.println("实现了覆盖重写方法2");
        }
    }

    测试类

    一、一般接口实现方法

    DemoMain.java

    public class DemoMain {
        public static void main(String[] args) {
    //        MyInterface impl = new MyInterfaceImpl();
    //        impl.method();
            }
    }

    匿名内部类实现接口

    DemoMain.java

    public class DemoMain {
        public static void main(String[] args) {
    
            //使用匿名内部类,但不匿名对象,对象名称就叫obj
            MyInterface objA = new MyInterface() {
                @Override
                public void method1() {
                    System.out.println("匿名内部类实现了方法1-A");
                }
                @Override
                public void method2() {
                    System.out.println("匿名内部类实现了方法2-A");
                }
            };
            objA.method1();
            objA.method2();
    
            System.out.println("----------我是分割线----------");
    
            //使用匿名内部类,而且省略了对象名称,也是匿名对象
            new MyInterface() {
                @Override
                public void method1() {
                    System.out.println("匿名内部类实现了方法1-B");
                }
                @Override
                public void method2() {
                    System.out.println("匿名内部类实现了方法2-B");
                }
            }.method1();
        }
    }

    结果:
    匿名内部类实现了方法1-A
    匿名内部类实现了方法2-A
    ----------我是分割线----------
    匿名内部类实现了方法1-B

    匿名内部内应用

    • 实现倒计时5秒。
    public class Demo02_Time {
        public static void main(String[] args) {
            Timer timer = new Timer();
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    System.out.println("倒计时5秒");
                }
            },5000);//倒计时5秒
        }
    }

    注意事项:

    对格式进行解析:"new 接口名称 {...};"进行解析

    1. new代表创建对象的动作
    2. 接口名称就是匿名内部类需要实现那个接口
    3. {…}这才是匿名内部类的内容

    注意:

    1. 这个类只需要使用一次。匿名内部类在创建对象时,只能使用唯一一次。
      如果希望多次希望多次创建对象,而且内容一样的话,那么就必须使用单独定义的实现类。

    2. 匿名对象,在调用的时候,只能调用唯一一次。
      如果希望同一个对象,调用多次方法,那么必须给对象取一个名字。

    3. 匿名内部类是省略了【实现类/子类】,但是匿名对象是省略了【对象命名】。

    强调:匿名和匿名对象不是一回事。

    展开全文
  • 大家都知道,java的规范中是不允许局部匿名内部类调用非final的类型局部变量的,这点并没什么好说的毕竟是规范嘛。我们要无条件的遵守。 问题是官方的文档中还有一个词与之先关,“与final”相同效果的变量。之前...

    大家都知道,java的规范中是不允许局部匿名内部类来调用非final的类型局部变量的,这点并没什么好说的毕竟是规范嘛。我们要无条件的遵守。

    问题是官方的文档中还有一个词与之先关,“与final”相同效果的变量。之前很纳闷,它要表达什么意思呢。

    直到一次写代码的经历,本来局部匿名类中的方法调用一个局部变量没有问题,但当我的局部变量由于在获取值时要抛异常,所以就try了一下,导致声明与赋值由两个语句完成。突然我的内部类的方法报错了,告诉我无法访问非final类型的变量。我知道jdk6-7是编译不过,但我的是jdk8啊,应该没问题。可为什么会出现这个问题呢?在一路回撤操作中,突然发现是由于局部变量的赋值方式。比如 Object obj = null;obj=new Person();和Object obj = new Person();的区别。现在我明白什么叫与final相同效果了。不知道理解对对不对,应该指的就是初始化方式吧。要与final类型相同。

    展开全文
  • 如何调用局部内部类中的方法

    千次阅读 2018-04-01 10:12:57
    内部:将写在其他的内部,可以写在其他的成员位置和局部位置局部内部类:将写在其他的局部方法中例如public class outer { public void out(){ int i=2; class Inner{ int a=1; public void ...
  • JAVA局部内部类的使用

    千次阅读 2017-04-22 00:00:11
    我是在JDK8环境下实现的,与之前的版本规则有一些变化,所以在这里mark一下 public class localInnerClass{ public static void main(String []args)... //因为是顺序编译,要在内部类后面创建实例。 } }
  • 一、什么是内部 顾名思义,内部就是将写在其他的...内部分为成员内部局部内部类。内部也会生成.class文件。 1、成员内部 定义在外部中的成员位置,与中的成员变量相似,可通过外部对...
  • Java 匿名内部类调用局部变量

    千次阅读 2018-04-16 17:30:02
    Java 8 之前,匿名内部类中使用 局部变量,需要强制使用 final 修饰 Java 8 开始匿名内部类使用的外部变量不再被强制用final修饰。 外部变量要么是final的;要么自初始化后值不会被改变 这两种都是可以在匿名...
  • 一、 Java内部类分类: 1.非静态成员内部类内部类没有使用static关键字修饰,并且和外部的成员变量和方法属于同一级别,这样的是非静态成员内部类(可以使用权限修饰符修饰,和final、abstract关键字修饰)。 ...
  • Java中,局部内部类如果调用了方法中的变量,那么该变量必须申明为final类型,如果不申明,则编译就会出错。 这里的内部指的是方法内部或匿名内部,不包含静态内部和成员内部 这里通过一个例子分析 ...
  • Java基础系列(三十):局部内部类

    千次阅读 2018-09-04 21:04:52
    局部内部类就是定义在某个方法内部的内部,它的作用域仅限于这个方法。 Why 当我们在外围中定义的内部仅仅在某个方法中使用了一次,这种情况下,我们就可以选择去使用局部内部类。 How 以上节课的例子...
  • 局部内部类(包含匿名内部) 成员内部 定义格式: 修饰符 class 外部名称 { 修饰符 class 内部名称 { // .... } // .... } 内部的class文件命名为:外部$内部.class 使用成员内部 间接方式:...
  • 局部内部类是指定义在方法中的。 看下面的例子,哪些变量可以被局部内部类Inner访问并修改? public class Test{ private int a; static int b; public void func(){ int j=10; class Inner{ } } }...
  • java——局部内部类

    2017-07-26 22:18:41
    2-在局部位置,可以创建内部对象,通过对象调用内部方法,来使用局部内部类功能。 面试题:  局部内部类访问局部变量的注意事项; **局部内部类访问局部变量必须用final修饰 因为:局部变量是随着方法的...
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性?原理是什么Java语言有哪些特点什么是字节码?采用字节码的最大好处是什么什么是Java程序的主类?应用程序和小程序的...
  • 详解 Java 内部类

    万次阅读 多人点赞 2018-09-04 00:17:56
    从种类上说,内部可以分为四类:普通内部、静态内部、匿名内部局部内部类。我们来一个个看: 普通内部 这个是最常见的内部之一了,其定义也很简单,在一个里面作为的一个字段直接定义就可以...
  • Java内部类和匿名内部类的用法

    万次阅读 多人点赞 2016-07-21 15:46:41
    Java内部类和匿名内部类的用法 【尊重原创,转载请注明出处】http://blog.csdn.net/guyuealian/article/details/51981163一、内部类: (1)内部类的同名方法 内部类可以调用外部的方法,如果内部类有同名方法...
  • Test.java(测试):package cn.xxx.demo; public class Test { public static void main(String[] args) { Outer.Inner in = new Outer().new Inner();... // 调用内部类对象方法。 } } Outer.ja...
  • * 标题:Java内部[成员内部局部内部类、匿名内部和静态内部] * * 作者:Nstar * * 时间:2020年3月13日 * * 内容: * * 问:什么是内部? * 答:在 Java 中,可以将一个定义在另一个里面或者一...
  • Java——访问内部类的方法

    千次阅读 2019-05-05 21:29:10
    将一个定义在另一个的里面,对里面那个就称为内部类(内置,嵌套)。 访问特点: • 内部类可以直接访问外部中的成员,包括私有成员。 • 而外部要访问内部类中的成员必须要建立内部类的对象。 ...
  • 本文主要介绍了Java内部类的基本原理,使用方法和各种细节。 有关内部类实现回调,事件驱动和委托机制的文章将在后面发布。 具体代码在我的GitHub中可以找到 https://github.com/h2pl/MyTech 文章首发于我的个人...
  • java 静态内部类的使用

    万次阅读 2018-11-05 19:06:39
    java 静态内部类的使用
  • 因为生命周期不一致, 局部变量直接存储...而局部内部类对局部变量的引用依然存在,如果局部内部类调用局部变量时,就会出错。加了final,可以确保局部内部类使用的变量与外层的局部变量区分开,解决了这个问题。 ...
  • package Test;import java.util.Date;public class MyTread { /** * @author peter * @desc 启动多线程 推送消息到接口地址,匿名内部类调用外部方法属性 * @date 2017.09.13 */ public void test() { //
  • 最近在看内部的时候,有一个疑惑:局部内部类和匿名内部只能访问final的局部变量,看了几篇博客,明白了很多,下面来分析一下:
  • 调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在...
  • 详谈Java内部类(超详细代码示例)

    万次阅读 多人点赞 2018-09-30 00:30:44
    内部类 废话不多上,先上图:
  • 一、私有内部类: class Out { private int age = 12; private class In { public void print() { System.out.println(age); } } public void outPrint() { new
  • 内部类和静态内部类调用方式

    千次阅读 2020-08-20 16:56:37
    一、静态内部类的创建需要依赖外部 Out.Ind j=new Out.Ind(); 二、非静态内部类 Outside in=new Outside(); //在通过外部对象创建一个内部类对象 Outside.Indoor oi =in.newIndoor();
  • 内部类的同名变量访问_解决方法: 格式:外部名称.this.外部成员变量名 如何创建内部类对象 格式:外部名称.内部类名称 对象名 = new 外部名称().new 内部类名称(); 实例如下: 定义一个包含内部类的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 159,033
精华内容 63,613
关键字:

java局部内部类调用

java 订阅