精华内容
下载资源
问答
  • 局部内部类 1点睛 ...这样的内部作用范围仅限于方法体或特定的作用域内,因此也称为局部内部类。 2代码 class InnerClassTest { int score = 95; void inst() { class Inner { void ...

    一 局部内部类

    1 点睛

    内部类不仅可以在类中定义,也可以定义在方法体或作用域内。这样的内部类作用范围仅限于方法体或特定的作用域内,因此也称为局部内部类。

    2 代码

    class InnerClassTest
    {
        int score = 95;
        void inst()
        {
            class Inner
            {
                void display()
                {
                    System.out.println("成绩: score = " + score);
                }
            }
            Inner in = new Inner();
            in.display();
        }
    }
    public class ObjectInnerClass
    {
        public static void main(String[] args)
        {
            InnerClassTest outer = new InnerClassTest();
            outer.inst();
        }
    }

    3 运行

    成绩: score = 95

    二 匿名内部类

    1 点睛 

    使用匿名内部类,必须要继承一个父类或实现一个接口。需要注意的是:匿名内部类是没有class关键字做修饰的;匿名内部类是直接使用new来生成一个对象的引用。在new之前,这个匿名内部类的父类是要先定义的。

    2 代码

    abstract class Bird
    {
        private String name;
        public String getName()
        {
            return name;
        }
        public void setName(String name)
        {
            this.name = name;
        }
        public abstract int fly();
    }
    
    public class AnonymousInnerClass
    {
        public void birdBehaviour(Bird bird)
        {
            System.out.println(bird.getName() + "最高能飞 " + bird.fly() + "米");
        }
        public static void main(String[] args)
        {
            AnonymousInnerClass AnonyObjObj = new AnonymousInnerClass();
            AnonyObjObj.birdBehaviour(new Bird()
                {
                    public int fly()
                    {
                        return 1000;
                    }
                    public String getName()
                    {
                        return "小鸟";
                    }
                });
        }
    }

    3 说明

    小鸟最高能飞 1000米

    展开全文
  • Java 内部类、成员局部类、匿名

    万次阅读 多人点赞 2016-10-11 17:49:15
    Java各种称呼详解Java有各种各样内部类、嵌套、成员局部类(本地)、静态、匿名、文件以及这些组合起来的称呼,成员内部类,成员匿名,成员嵌套,本地匿名等,真是多的不行,但有些其实...

    Java各种称呼类详解

      Java有各种各样类,内部类、嵌套类、成员类、局部类(本地类)、静态类、匿名类、文件类以及这些组合起来的称呼类,成员内部类,成员匿名类,成员嵌套类,本地匿名类等,真是多的不行,但有些其实是一个意思,在这里好好理一理。

    声明

      1.注意,这些称呼都是翻译过来的,但是同一个英文单词或一个词组翻译过来可能有不同叫法,比如local nested class,local有局部、本地意思,其实是一个意思,local nested class翻译过来就是局部嵌套类(本地嵌套类),又因为非静态嵌套类都称为内部类,所以local nested class又叫为内部局部类(本地内部类),最终又简称为:局部类(本地类)。我个人觉得局部类更加形象点所以下面都优先采用局部类一说。
      2.我通过搜索找到两种不太相同的内部类定义,一种认为:定义在类里面的称为嵌套类(nested class),而非静态嵌套类才是内部类(inner class),也就是说嵌套类包含内部类;另外一种则是认为:定义在类里面的称为内部类,这样静态嵌套类也是内部类,也就是说嵌套类=内部类。但是,第一种才是Java语言规范规定的,我一开始不确定,找到Java7的语言规范验证,结果确实如此,即第一种才是正确的,那么问题来了:依照第一种划分,静态内部类其实是一种错误说法。。。只有静态嵌套类,内部类是没有静态一说的!
      但是对于大多数中国程序员,貌似将定义在类里面的类称为内部类不是更符合文意么?也许这就是为什么会有这么多人一直认为静态内部类的存在。嘛,反正不管怎么称呼,只要知道代表什么意思就好,细节什么的不要在意(光哥:所以不注意细节的你写的代码才这么一大堆bug么?还不赶紧去改(怒吼))。
      我这里采用Java语言规范上说的。

    0.文件类

      文件类放在最前面,是因为文件类是与主类(一个文件中public类)关系最不密切的一类。什么是文件类?看代码就知道:

    public class Main{}
    class Test{}//Test就是文件类
    //是的,一个.java文件里面定义在主类外面的就是文件类
    //主类、文件类称为顶级类(top level class),Java语言规范中定义:非嵌套类即为顶级类。

    【注意】:主类这一定义是我自己按语义称呼的,有的地方称为基本类,但我觉得很不符合语义,Java语言规范我也没找到相关定义。

    1. 因为一个.java文件只能有一个主类(public 类),所以文件类默认只能是包访问权限,即:不是同一个包的是无法引入和使用的。

    1.嵌套类

      由上面文件类可有类似定义:一个.java文件里面定义在类里面的就是嵌套类,定义在类内部,包括块、静态块、构造器、方法内。这个时候该类也相对来被称为包装类(enclosing class)或外部类。
      嵌套类是可以有层次的,也就是说嵌套类里面还可以定义类,成为嵌套类中的嵌套类。
      在Java语言规范里面,嵌套类定义是:

    A nested class is any class whose declaration occurs within the body of 
    another class or interface. 

      说的简单一点,就是定义在类(这里还包括接口,下同)里面的类。所以说,以下所有的类都可以称为嵌套类。嵌套类分为两种:静态嵌套类和非静态嵌套类,非静态嵌套类就是内部类(inner class)。

    静态嵌套类

      简称静态类,和主类关系也不大,只是在其他类中引用使用的时候需要加上外部类限定,但在技术上来看,完全是两个独立无关系的类。

    public class Main{
        public static class NestClass{}
    }
    //在外面使用时候形式如下,在Main中使用则不需要加上外部类限定
    Main.NestClass nestClass = new Main.NestClass();

      从形式上来看,静态类可以说是类的一个静态成员(所以也可以说是成员类一种),但从技术上来看,其实二者没什么关系,可以看做第三类顶级类。但也因此,静态类不怎么常用,因为它同一般类没什么优势可言。

    1. 静态类不能访问外部类的非静态成员和非静态方法(不管是public还是private的);
    2. 静态类的实例不需要先实例化外部类成员,可直接实例化。

    2.内部类

      Java语言规范里的定义:

    An inner class is a nested class that is not explicitly or implicitly 
    declared static.
    //即非静态嵌套类即为内部类

    内部类包括:成员类、局部类、匿名类。

    1. 内部类中不能有静态修饰的成员(比如块、字段、方法、接口等),总之不能有static关键字,除了一种情况,那就是静态常量,又因为常量成员字段必须在声明的时候初始化,所以形式只能如:public static final int a = 6;
    2. 内部类可以访问外部类任何成员,不管是公有的还是私有的,静态的还是非静态的(并且内部类的成员的名字也可以同外部相同,只不过这样会覆盖掉去外部类的),这是因为每一个内部类都保存了一个对外部类的一个引用。这很好理解,因为你要实例化这个内部类,肯定是通过外部类的一个实例,而内部类保留的这个引用就是这个外部类实例。
    3. 内部类命名格式:外部类名称+$+[该种类同名类中该类顺序]+[内部类名称],例如成员类,成员类不能同名,所以也就没有同名类顺序:com.fcc.test.OuterClass$MemberClass;局部类:com.fcc.test.OuterClass$1LocalClass;匿名类:匿名类没有名称,所以格式如:com.fcc.OuterClass$1。

    成员类

      这里说的是非静态成员内部类(如果静态嵌套类也算是成员类一种的话),non-static member (inner) class。而一般说的也是这种,但从技术上来看,成员类应该还包括静态嵌套类。

    A member class is a class whose declaration is directly enclosed in 
    another class or interface declaration.

      成员类算是最常见最常用的一种内部类,我们一般说的内部类说的就是成员类:在类里面,但不在块、构造器、方法里面。

    //成员类,从技术上来说,可以分为两种:成员内部类和成员嵌套类。
    //1.成员内部类即这里说的成员类,全称是非静态成员内部类
    //2.成员嵌套类即上面的静态嵌套类
    public class Main{
        public class MemberClass{}//成员内部类,常简称为成员类
    }

      成员类,可以使用public,private,protected访问控制符,也可以用static,final关键字修饰,并且有enclose class属性。
    这里题外说明一下:

    1. 成员(member),只要是在类里面的(但不在块、构造器、方法内),都是成员:可以是变量,就是成员变量(一般又称为成员字段,Field);可以是方法,好吧,方法都是成员(因为Java中方法不可能位于类外)的;当然,同样的,也可以是接口、枚举、注释类以及类。
    2. 关于static理解,有static修饰的是类本身属性(共性),所以访问可以不通过类的实例对象,而非static修饰的,是对象属性(个性),必须通过类的实例对象访问,因为个性是个体的属性啊,当然要创建出个体,然后这个个性才有意义。
    3. 关于enclose class,enclose method,enclose constructor属性,可以理解为这个类是被类、还是方法、构造器包装起来的。关于这些属性,可以参考Class类:Java源码解析(2) —— Class(1)

    局部类(本地类)

      local nested class,局部嵌套类,简称局部类,局部类所属范围:在块、构造器以及方法内,这里的块包括普通块和静态块。局部类只在本块范围内有效。
    定义:

    A local class is a nested class8) that is not a member of any class 
    and that has a name.

    翻译过来就是:局部类是嵌套类,但不是成员类,而且有名称(不是匿名类)。

    public class Test {
        {
            class AA{}//块内局部类
        }
        public Test(){
            class AA{}//构造器内局部类
        }
        public static void main(String[] args){
        }
        public void test(){
            class AA{}//方法内局部类
        }
    }
    //注意到了吧,可以同名,编译后,形成诸如:外部类名称+$+同名顺序+局部类名称
    //Test$1AA.class/Test$2AA.class/Test$3AA.class

      局部类最多只能有final修饰,但不同的是,块内局部类有enclose class属性,而构造器局部类有enclose constructor属性,方法局部类有enclose method属性,嘛,其实很好理解的吧,一看就知道。

    1. 局部类只能访问(使用)这个块中(局部类外)final属性。这里的块包括了上面说的块、构造器、方法。

    匿名类

    定义:

    An anonymous class declaration is automatically derived from a class 
    instance creation expression by the Java compiler

      匿名类,就是没有名称的类,其名称由Java编译器给出,一般是形如:外部类名称+$+匿名类顺序,没有名称也就是其他地方就不能引用,不能实例化,只用一次,当然也就不能有构造器。
      匿名类根据位于地方不同分为:成员匿名类和局部匿名类。

    public class Test {
        InterfaceA a = new InterfaceA() {};//成员匿名类
        public static void main(String[] args){
            InterfaceA a = new InterfaceA() {};//局部匿名类
            //以上两种是通过实现接口实现匿名类,称为接口式匿名类,也可以通过继承类
            Test test = new Test(){};//继承式匿名类
            //还可以是位于参数上
            new Thread(new Runnable() {
                @Override
                public void run() {
                }
            }).start();//属于局部匿名类一种
        }
        private interface InterfaceA{}
    }

      匿名类不能使用任何关键字和访问控制符,匿名类和局部类访问规则一样,只不过内部类显式的定义了一个类,然后通过new的方式创建这个局部类实例,而匿名类直接new一个类实例,没有定义这个类。匿名类最常见的方式就是回调模式的使用,通过默认实现一个接口创建一个匿名类然后,然后new这个匿名类的实例。

    总结

      本文讨论的是:嵌套类、内部类、成员类、局部类、匿名类相关,这些类的划分主要是根据类声明(或位于)的地方划分的:
    1.嵌套类,位于类内部,又分为:静态嵌套类和非静态嵌套类。
    2.静态嵌套类即为静态类。静态类只有这一种,技术来说,也可以看成静态成员类。
    3.非静态嵌套类即为内部类,又分为:成员类、局部类(本地类)、匿名类。
    4.成员类:位于类内部但不包括位于块、构造器、方法内,且有名称的类。
    5.局部类:位于块、构造器、方法内的有名称类。
    6.匿名类:类内无名称类,又可细分为:成员匿名类和局部匿名类。

    展开全文
  • 但实际编译的时候,内部编译成Outer.Inner,这说明内部所处的位置和外部中的方法处在同一个等级上,外部中的方法中的变量或参数只是方法的局部变量,这些变量或参数的作用域只在这个方法内部有效。...

       是变量的作用域的问题,因为匿名内部类是出现在一个方法的内部的,如果它要访问这个方法的参数或者方法中定义的变量,则这些参数和变量必须被修饰为final。因为虽然匿名内部类在方法的内部,但实际编译的时候,内部类编译成Outer.Inner,这说明内部类所处的位置和外部类中的方法处在同一个等级上,外部类中的方法中的变量或参数只是方法的局部变量,这些变量或参数的作用域只在这个方法内部有效。因为编译的时候内部类和方法在同一级别上,所以方法中的变量或参数只有为final,内部类才可以引用。

    Java代码:
    package com.cxz.j2se;  
     
    public class MyClass {  
        public MyClass() {  
            final int finalValue = 10;  
            int not$Final = 20;  
            MyInterface myInterface = new MyInterface() {  
                public void functionWithoutPara() {  
                    //compile Error  
                    //System.out.println(noFinal);   
                    System.out.println(finalValue);  
                }  
     
                public void functionWithPara(int num) {  
                    System.out.println("The parameter " + num  
                            + " has been passed by the method");  
                }  
     
            };  
            myInterface.functionWithoutPara();  
            myInterface.functionWithPara(not$Final);  
            System.out.println(myInterface.getClass().getName());  
        }  
     
        public static void main(String[] args) {  
            new MyClass();  
     
        }  
     

    二、为什么局部内部类只能访问final变量
    简单的来说是作用域的问题。就好像方法外面做的事情并不能改变方法内才定义的变量,因为你并不知道方法里面这个时候已经存在了这个局部变量了没有。在这个内部类中方法里面的本地变量是失效的,也就是不在作用域内,所以是不能够访问的

    但是为什么这里用final却又可以访问呢?
    因为Java采用了一种copy   local   variable的方式来实现,也就是说把定义为final的局部变量拷贝过来用,而引用的也可以拿过来用,只是不能重新赋值。从而造成了可以access   local   variable的假象,而这个时候由于不能重新赋值,所以一般不会造成不可预料的事情发生

    三、如果定义一个局部内部类,并且局部内部类使用了一个在其外部定义的对象,为什么编译器会要求其参数引用是final呢?
    注意:局部内部类,包括匿名内部类。

    原因如下:

    abstract class ABSClass{
    public abstract void print();
    }

    public class Test2{
    public static void test(final String s){//一旦参数在匿名类内部使用,则必须是final
    ABSClass c=new ABSClass(){
    public void print(){
    System.out.println(s);
    }
    };
    c.print();
    }
    public static void main(String[] args){
    test("Hello World!");
    }
    }

    JVM中每个进程都会有多个根,每个static变量,方法参数,局部变量,当然这都是指引用类型.基础类型是不能作为根的,根其实就是一个存储地址.垃圾回收器在工作时先从根开始遍历它引用的对象并标记它们,如此递归到最末梢,所有根都遍历后,没有被标记到的对象说明没有被引用,那么就是可以被回收的对象(有些对象有finalized方法,虽然没有引用,但JVM中有一个专门的队列引用它们直到finalized方法被执行后才从该队列中移除成为真正没有引用的对象,可以回收,这个与本主题讨论的无关,包括代的划分等以后再说明).这看起来很好.

    但是在内部类的回调方法中,s既不可能是静态变量,也不是方法中的临时变量,也不是方法参数,它不可能作为根,在内部类中也没有变量引用它,它的根在内部类外部的那个方法中,如果这时外面变量s重指向其它对象,则回调方法中的这个对象s就失去了引用,可能被回收,而由于内部类回调方法大多数在其它线程中执行,可能还要在回收后还会继续访问它.这将是什么结果?

    而使用final修饰符不仅会保持对象的引用不会改变,而且编译器还会持续维护这个对象在回调方法中的生命周期.所以这才是final变量和final参数的根本意义.
    文章出处:飞诺网(www.firnow.com):http://dev.firnow.com/course/3_program/java/javajs/20100719/460085.html

    展开全文
  • 1.匿名内部肯定是局部内部类(在一个方法里面定义的内部),因为在java中,语句必须写在方法里,而匿名内部其实就是一条特殊的语句; 2.外部给定的对象就是所有外来的对象:外部方法的形参、局部变量、基

    http://ldzyz007.iteye.com/blog/844380

    如果定义一个匿名内部类,并且希望它使用一个在其外部定的对象,那么编译器会要求其参数引用是final的。


    1.匿名内部类肯定是局部内部类(在一个方法里面定义的内部类),因为在java中,语句必须写在方法里,而匿名内部类其实就是一条特殊的语句;
    2.外部给定的对象就是所有外来的对象:外部方法的形参、局部变量、基本类型或自定义类型等。
    3.内部类很微妙,它可以直接访问外部类的private field,这打破了类的封装。但是内部类又有它自身的好处,比如简洁,可见性等,于是就把它定位成“只读”,也就是final。不过这个保护也非常脆弱!
    4.local inner class访问local var时,那个var必须是final的。因为可以通过enclosing class访问那个local var,也可以通过inner class访问,可能造成问题,所以就必须是final的
    5.匿名内部类为什么只能用final.是变量的作用域的问题,因为匿名内部类是出现在一个方法的内部的,如果它要访问这个方法的参数或者方法中定义的变量,则这些参数和变量必须被修饰为final。因为虽然匿名内部类在方法的内部,但实际编译的时候,内部类编译成Outer.Inner,这说明内部类所处的位置和外部类中的方法处在同一个等级上,外部类中的方法中的变量或参数只是方法的局部变量,这些变量或参数的作用域只在这个方法内部有效。因为编译的时候内部类和方法在同一级别上,所以方法中的变量或参数只有为final,内部类才可以引用。

    6.例子
    public class LocalInnerClassTest{
         public static void main(String[] args){
            Outer obj=new Outer();       //生成一个外部类对象
           //调用外部类中的outer()方法,返回一个SuperInner类型对象赋值给si
            SuperInner si=obj.outer();                                      
            si.m1();                     //调用被覆盖的方法m1(),输出:Inner's m1() 20
         }
    }
    
    /**
    *定义一个接口SuperInner,内部定义一个抽象方法m1(),无返回类型
    */
    interface SuperInner{
         public void m1();
    }
    
    /**
    *定义一个类Outer,内部只定义一个方法outer(),返回类型为SuperInner
    */
    class Outer{
         public SuperInner outer(){
            int a=10;                //方法中定义一个局部变量a,并赋值为10
            final int b=20;          //再定义一个final局部变量b,初始化为20
           
            //在outer()方法中定义一个局部内部类Inner,实现接口SuperInner
            class Inner implements SuperInner{            
               public void m1(){    //类中只有一个覆盖接口SuperInner的方法m1()
                  System.out.println("Inner's m1()"+a);    //编译报错
                  //编译通过,输出:Inner's m1() 20
                  System.out.println("Inner's m1() "+b);  
               }
            }
            return new Inner();
         }
    }

    我们先从主方法开始看代码的执行顺序,先生成一个Outer类对象obj,obj调用本类中方法outer();程序开始跳到outer()方法内执行程序语句,先后生成局部变量a和b,再定义一个局部内部类Inner,返回一个SuperInner类型的对象。将返回的SuperInner类型对象地址传给SuperInner类型对象si。si再调用m1()方法,因为已经在局部内部类中覆盖了接口中的m1()方法,所以将调用局部内部类中的m1() 方法,程序跳到局部内部类中m1()方法内执行程序语句,先输出一段字符串和a,结果编译报错,先 将这条程序语句隐藏,执行下面的语句,你会发现编译通过而且输出Inner's m1() 20!

    为什么会这样呢?大家都知道局部变量仅仅在一个范围内有效,在方法调用完就被内存释放,在Outer类对象obj调用outer()方法时,a和b才产生,调用结束后被内存释放,那么b这个值也就不复存在了,为什么还会输出20呢?难道局部变量被final修饰就不会被内存释放而保留?

    其实有部分操作对于程序员是透明的,那是JAVA语言开发者的小把戏,在定义a和b 时JVM(JAVA虚拟机)做了程序员看不到的操作,他将b拷贝了一份给局部内部类,也就是说JVM在局部内部类中定义了一个final int b=20;这个操作程序员是不知道的!当调用m1()方法时输出的20并不是原来outer()方法中定义的b,而仅仅是JVM拷贝的一个副本。那么为什么a没被打印出呢?那是因为JVM并没有拷贝它,因为没有final修饰,说明它可以被修改,如果把a 改为 a++,此时JVM就不知道拷贝a还是a++了,所以对于无final修饰的局部变量JVM是不会拷贝传给局部内部类的,自然无法打输出!
    展开全文
  • 一、内部类定义 内部类(nested classes),面向对象程序设计中,可以在一个内部定义另一个。嵌套分为两种,即静态嵌套和非静态嵌套。静态嵌套使用很少,最重要的是非静态嵌套,也即是被称作为内部...
  • 大家面试的时候肯定被问过java 接口、抽象、具体内部类、匿名内部类的区别及它们之间的关系。那么下面我就来整理下它们之间的关系。
  • Java讲课笔记16:内部类

    千次阅读 2020-05-12 19:33:41
    文章目录零、本讲学习目标1、掌握成员内部的使用2、掌握局部内部类的使用3、掌握静态内部的使用4、掌握匿名内部的使用一、内部概述二、成员内部(Member Inner Class)1、成员内部定义2、成员内部说明...
  • Java内部类(Inner Class),类似的概念在C++里也有,那就是嵌套(Nested Class),乍看上去内部类似乎有些多余,它的用处对于初学者来说可能并不是那么显著,但是随着对它的深入了解,你会发现Java的设计者在内部...
  • 内部类种类以及使用方法

    千次阅读 2019-02-24 16:13:20
    定义: 内部指的是在的内部定义再定义一个。 内部仅仅是一个编译时的概念。Outer.java 中定义一个Inner.java ,编译成功后会生成两个完全不同的class... 局部内部类; 匿名内部; 静态内部; 成员内...
  • android 匿名内部类使用外部变量

    千次阅读 2016-01-02 13:12:15
    方法中的变量必须final reason: ...如果定义一个匿名内部,并且希望它使用一...1.匿名内部肯定是局部内部类(在一个方法里面定义的内部),因为在java中,语句必须写在方法里,而匿名内部其实就是一条特殊的语句;
  • 局部变量和全局变量,以及作用范围

    万次阅读 多人点赞 2018-11-11 13:56:55
    变量按存储区域分:全局变量、静态全局变量和静态局部变量都存放在内存的静态存储区域,局部变量存放在内存的栈区。 变量按作用域分:  全局变量:在整个工程文件内都有效;“在函数外定义的变量”,即从定义变量...
  • java匿名内部类详解

    千次阅读 2018-02-06 20:56:44
    匿名内部类,顾名思义,就是没有名字的,匿名内部类格式如下: new name(parameter) { ...... } name:父类或是接口的名字。 parameter:若name为父类,则parameter为父类构造函数的参数。 匿名...
  • Java学习笔记一面向对象内部类

    千次阅读 2020-03-17 14:31:09
    内部类成员可以直接访问外部的私有数据,外部不能访问内部类的实现细节,例如内部类的成员变量。内部类比外部可以多使用三个修饰符:private、protected、static。内部类的上一级单元是外部,它就具有4个...
  • 匿名内部肯定是局部内部类(在一个方法里面定义的内部),因为在java中,语句必须写在方法里,而匿名内部其实就是一条特殊的语句;  2.外部给定的对象就是所有外来的对象:外部方法的形参、局部变量、基本类型...
  • 简述一下内部类的实质是什么?
  • 成员变量、变量(静态变量)、局部变量的区别

    千次阅读 多人点赞 2017-08-03 20:31:04
    如果局部变量的名字和成员变量的名字相同, 要想在该方法中使用成员变量,必须使用关键字this [java] view plain copy class People {   String name = "体重定义的name";
  • 第一、与其它的局部成员一样,局部有效范围被限定在包含的代码块中,一旦超出该范围,该局部内部类就不能被访问了。 第二、局部内部类不能被访问修饰符修饰,也就是说不能使用private、protected、public任一...
  • Java内部类、修饰符

    千次阅读 2018-10-17 18:10:51
    大部分时候,内部都被作为成员内部定义,而不是作为局部内部类。成员内部是一种与成员变量、方法、构造器和初始化块相似的成员;局部内部类和匿名则不是成员。 案例: package org.westos.practice;...
  • 1、全局变量的有效范围为 从定义变量的位置开始到本源文件结束 。 extern声明外部变量 :extern是用作变量的声明,而不是变量定义。它只是对一个已定义的外部变量作声明,以扩展其作用域。外部变量定义和...
  • 如果局部变量的名字和成员变量的名字相同, 要想在该方法中使用成员变量,必须使用关键字this 成员变量和局部变量的区别成员变量:1、成员变量定义在中,在整个中都可以被访问。2、成员变量随着对象的建立而...
  • 局部变量只有在自己所在的程序块内有效,也就是说如果你在函数内的一对大括号中定义一个局部变量,这个局部变量只在这个大括号范围有效,出了大括号就失效了,不论他是否与程序块之外的变量重名。 同C语言的值...
  • 局部变量和成员变量的定义和区别

    千次阅读 多人点赞 2018-06-23 15:38:07
    局部变量和成员变量的区别和定义 局部变量 成员变量 ... 本(内有效) 命名冲突: 局部变量之间不允许重名 可与局部变量重名,局部变量优先 注:如果成员变量的声明和赋值...
  • JavaSE入门 P14 【进阶】多线程、同步、匿名内部类、死锁、生命周期 1.概述 2.多线程实现(模拟卖票) 3.多线程安全问题&解决方案 4.匿名内部类 5.同步 6.死锁,多线程生命周期 7.面试题
  • Java各种详解

    千次阅读 2017-12-25 16:16:21
    Java 内部类、成员局部类、匿名等 Java有各种各样内部类、嵌套、成员局部类(本地)、静态、匿名、文件以及这些组合起来的,成员内部类,成员匿名,成员嵌套,本地匿名等,真是多...
  • C中定义变量的有效范围

    千次阅读 2013-10-24 21:01:16
    #include void fun(int ip); int main() { fun(5); return 0; } void fun(int ip){ if(1) { char *buff = "hello"; } printf("%s\n",buff);//buff只在花括之间有效。 }
  • 子父类方法调用关系,内部类总结

    千次阅读 2012-08-15 23:28:21
    6.因匿名内部局部内部类,所以局部内部类的所有限制都对其生效。  //A、继承式的匿名内部 public class Car { public void drive(){ System.out.println("Driving a car!");   } public ...
  • 全局变量:在整个全局范围有效 全局变量在局部可以使用(即函数内部可以方位函数外部定义的变量) 局部变量在局部范围可以使用 局部变量在全局范围无法使用,在局部范围内(比如函数)将局部变量用global函数定义...
  • C语言全局变量和局部变量

    千次阅读 多人点赞 2018-09-03 22:45:43
    首先是一个变量,其次,这个变量只是在程序的局部范围有效局部变量定义在那些位置: 1. 函数的开头; 2. 函数内的复合语句内定义; 3. 形式参数; 4. 函数中间(非开头); #include <stdio.h&...
  • 全局变量全局变量又叫成员变量,它是声明在里,函数,静态语句块外的变量,全局变量又分为变量(静态变量)、实例变量两种. 通过代码来看一下:private long i;//实例变量 private static long j;//变量实例变量...
  • 局部变量和全局变量的作用域

    千次阅读 2019-06-30 19:10:34
    即在一个函数内部定义的变量,只在本函数范围有效 全局变量:“在函数外定义的变量”,即从定义变量的位置到本源文件结束都有效  当有外部变量时,main函数中的同名变量就是全局变量。如果没有外部变量,main...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 93,215
精华内容 37,286
热门标签
关键字:

局部内部类的有效范围