精华内容
下载资源
问答
  • 2019-06-22 07:54:37

    一 局部内部类

    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.匿名类:类内无名称类,又可细分为:成员匿名类和局部匿名类。

    展开全文
  • 内部类的主要特征:1.内部类可以声明为抽象,因此可以被其他的内部类继承,也可以声明为final; 2.和外部不同,内部类可以声明为private或protected,外部只能用public和default; 3.内部类可以声明为static...

    【1】内部类定义

    我们所说的内部类,官方的叫法是嵌套类(Nested Classes)。嵌套类包括静态内部类(Static Nested Classes)和内部类(Inner Classes)。而内部类分为成员内部类,局部内部类(Local Classes)和匿名内部类(Anonymous Classes)。

    内部类是一个编译时的概念,一旦编译成功,就会成为完全不同的两个类,分别为outer.class和outer$inner.class类。所以内部类的成员变量/方法名可以和外部类的相同。

    当你访问外部类的私有数据成员时,JDK会在外部类中创建包级访问权限的(package-acess)成员函数以便内部类来访问外部类的私有成员。这种结果会导致一个安全漏洞。通常情况下,我们应当尽量避免使用内部类。

    只有当内部类仅仅只和外部类的上下文相关或者内部类需要被设置为私有的且只能被外部类访问的这些情况下,我们才使用内部类。内部类主要被用来实现类似Iterators、Comparators这些辅助类。它们被使用在外部类的上下文中。


    【2】内部类特点

    内部类是指在一个外部类的内部再定义一个类,内部类作为外部类的一个成员并且依附于外部类而存在的。

    注意这里明确说明了是在类的内部作为其成员,而不仅仅只是和外部类在同一个class文件中!

    如下所示:枚举类Operator和OO均为SearchFilter的内部类
    在这里插入图片描述
    如下所示,class BB 和class SearchFilter在同一个class 文件中,但是二者并无关系。唯一需要注意的是,一个class文件只能有一个public类型的外部类!
    在这里插入图片描述

    编译后的class文件显示如下:
    在这里插入图片描述
    可以在一个外部类中定义多个内部类,这些内部类在逻辑上是一个整体,与外部类之间是从属关系。在内部类中可以访问外部类定义的私有成员。

    其特点如下:

    • 非静态内部类能够访问其外部类的所有属性和方法;

    • 静态内部类能够访问其外部类的static属性和static方法

    • 内部类能够隐藏起来,不被同一个包中的其他类访问。如果一个类只对某个类提供使用,那么可以将其定义为内部类;

    • 匿名内部类可以方便的用在回调方法中,典型应用是图形编程中的事件处理;

    • 外部类不能直接访问内部类的成员, 但是可以通过内部类的实例访问内部类的私有成员;

    • 局部类不仅可以访问外部类的所有成员,还可以访问方法体的局部变量,但必须是final修饰的局部变量;

    • 非静态内部类不能够定义静态字段和方法,但是静态内部类则可以定义静态字段和方法也可以定义非静态字段和方法。

    • 内部类可以声明为抽象类,因此可以被其他的内部类继承,也可以声明为final;

    • 和外部类不同,内部类可以声明为private或protected,外部类只能用public和default;

    • 内部类可以声明为static,但此时就不能再使用外层封装类的非static成员变量;

    • 非static的内部类的成员不能声明为static的,只有在顶层类或static的内部类才可以声明static成员。

    • 内部类有效实现了“多重继承”,优化 java 单继承的缺陷。

    • 匿名内部类可以很方便的定义回调。


    内部类示例代码如下:

    public class Outer{
    	private int size;
    	//此处为成员内部类-非静态内部类
    	public class Inner{
    		public void duStuff(){
    		//内部类可以访问外部类的私有属性
    		size++;
    		}
    	}
    	//方法定义
    	public void testInner(){
    		//调用内部类中的方法
    		Inner i = new Inner();
    		i.duStuff();
    	}
    }
    

    在上述代码中,在Outer类中定义了属性size、内部类Inner和方法testInner(),在方法中调用内部类,直接通过"对象.方法"的形式即可调用。

    如果在其他类中需要调用Inner类中的方法,则可以使用以下格式:

    //方法一
    Outer.Inner in = new Outer().new Inner();
    in.doStuff();
    
    //方法二
    Outer o = new Outer();
    Outer.Inner in = o.new Inner();
    in.doStuff();
    

    内部类可以通过static修饰,称为静态内部类,在静态内部类中调用外部类成员,外部类成员也要求用static修饰。

    如果内部类用static修饰,则可以使用以下格式调用其方法。

    Outer.Inner in = new Outer.Inner();
    in.doStuff();
    

    当外部类和内部类成员变量相同时,在内部类中需要使用“外部类.this.attr”来调用外部类的变量。

    示例如下:

    public class A{
    
    	private int i = 100;
    
    	class B {
    		private int i = 10;
    		public void show(){
    			//若不显示指明,默认为内部类成员
    			System.out.println(i);
    			//该处打印外部类的成员变量
    			System.out.println(A.this.i);
    		}
    	}
    }
    
    输出结果:10   100
    

    【3】局部内部类与静态内部类

    二者区别

    • 创建静态内部类的对象可以直接通过外部类调用静态内部类的构造器;创建非静态的内部类的对象必须先创建外部类的对象,通过外部类的对象调用内部类的构造器。

    • 在静态内部类中调用外部类成员,成员也要求用static修饰。

    • 非静态内部类能访问外部类的一切成员, 包括私有成员。外部类虽然不能直接访问内部类的成员, 但是可以通过内部类的实例访问内部类的私有成员。

    • 局部内部类定义在方法体内,只能在该方法或条件的作用域内才能使用,退出这些作用域就无法引用。

    • 局部类不仅可以访问外部类的所有成员,还可以访问方法体的局部变量,但必须是final修饰的局部变量。

    示例如下:

    public class TestInnerClass {
    	public static void main(String[] args) {
    		//创建静态内部类的对象:可以直接通过外部类调用静态内部类的构造器
    		Person.Dog d = new Person.Dog();
    		
    		//创建非静态的内部类的对象:必须先创建外部类的对象,
    		//通过外部类的对象调用内部类的构造器
    		Person p = new Person();
    		Person.Bird b = p.new Bird();//new p.Bird();
    		b.info();
    		b.setName("杜鹃");
    	}
    }
    
    class Person{
    	String name = "韩梅梅";
    	int age;
    	//成员内部类(非static的)
    	class Bird{
    		String name = "黄鹂";
    		int id;
    		public Bird(){
    	}
    		public void setName(String name){
    			System.out.println(name);//杜鹃
    			System.out.println(this.name);//黄鹂
    			System.out.println(Person.this.name);//韩梅梅
    		}
    		public void info(){
    		//调用外部类的成员方法
    			show();
    		}
    	}
    	//成员内部类(静态内部类)
    	static class Dog{
    		
    	}
    	/*成员方法*/
    	public void show(){
    		System.out.println("我是show()方法");
    	}
    	
    	public void method1(){
    		/*局部内部类*/
    		class A{
    			
    		}
    	}
    }
    

    运行结果:

    我是show()方法
    杜鹃
    黄鹂
    韩梅梅
    

    【4】局部内部类与匿名内部类的使用

    示例如下:

    public class TestInnerClass1 {
    	
    }
    class OuterClass{
    	//局部内部类
    	//如下的使用方式较少
    	public void method1(){
    		class InnnerClass{	
    		}
    	}
    	//常常使用一个方法,使其返回值为某个类或接口的对象。
    	//而这个类或接口在方法内部创建
    	
    	//使用方式一
    	public Comparable getComparable(){
    		//1.创建一个实现Comparable接口的类:局部内部类
    		class MyComparable implements Comparable{
    			public int compareTo(java.lang.Object o) {
    				return 0;
    			}
    		}
    	}
    	//使用方式二
    	public Comparable getComparable1(){
    		//返回一个实现Comparable接口的匿名内部类的对象
    		return new Comparable(){
    			public int compareTo(java.lang.Object o) {
    				return 0;
    			}	
    		};
    		/*
    		new Thread(new Runnable() {
    			public void run() {
    				for(int i = 1;i <= 100;i++){
    					if(i % 2 == 0){			
    	System.out.println(Thread.currentThread().getName() + ":" + i);
    								}
    							}
    			}
    		});
    		*/
    	}
    }
    
    

    为什么匿名内部类和局部内部类只能访问final变量?

    参考博文:浅谈匿名内部类和局部内部类只能访问final变量


    【5】静态内部类和非静态内部类

    非静态嵌套类(即内部类)对它嵌套的外部类的成员拥有全部的访问权限。

    而静态嵌套类并不包含对外部类的实例引用,这就使得静态嵌套类不能够调用外部类实例的非静态方法或者访问外部类的非静态字段。

    在声明成员字段和方法上,非静态嵌套类不能够定义静态字段和方法。但是,静态内部类则可以定义静态字段和方法也可以定义非静态字段和方法。

    非静态内部类的实例是通过使用外部类的对象引用来创建的,也就在说在内部类中已经定义了外部类实例。但是静态嵌套类实例的创建过程中并不涉及到外部类的引用,这就是说它并不拥有外部类的实例。

    示例如下:

    public class OuterClass {
    
        class InnerClass {
            // static int x; not allowed here
        }
    
        static class StaticInnerClass {
            static int x; // allowed here
        }
    }
    
    class Test {
        public static void main(String... str) {
            OuterClass oc = new OuterClass();
            OuterClass.InnerClass obj1 = oc.new InnerClass();// need of inclosing
                                                                // instance
            OuterClass.StaticInnerClass obj2 = new OuterClass.SIC();
            // no need of reference of object of outer class
        }
    }
    

    【6】成员变量与局部变量

    成员变量:随着对象的创建而存在,随着对象的消失而消失,存储在堆内存中。

    局部变量:在方法被调用,或者语句被执行的时候存在,存储在栈内存中。当方法调用完,或者语句结束后,就自动释放。

    作用域

    成员变量:针对整个类有效。
    局部变量:只在某个范围内有效。(一般指的就是方法,语句体内)

    存储位置

    成员变量:随着对象的创建而存在,随着对象的消失而消失,存储在堆内存中。
    局部变量:在方法被调用,或者语句被执行的时候存在,存储在栈内存中。当方法调用完,或者语句结束后,就自动释放。

    生命周期

    成员变量:随着对象的创建而存在,随着对象的消失而消失
    局部变量:当方法调用完,或者语句结束后,就自动释放。

    初始值

    成员变量:有默认初始值。
    局部变量:没有默认初始值,使用前必须赋值。

    使用原则

    在使用变量时需要遵循的原则为:就近原则 首先在局部范围找,有就使用;接着在成员位置找。

    展开全文
  • 的成员变量分为变量(又称静态变量,被static修饰的变量)和实例变量(不被static修饰的变量),此外,还有定义在函数内部的变量称为局部变量,仅在函数内部有效。private String name; 这就是定义一个String...

    写在前面:
    大家好,我是 花狗Fdog ,来自内蒙古的一个小城市,目前在泰州读书。
    很感谢能有这样一个平台让我能够在这里分享所学所感。
    我喜欢编程,喜欢代码,喜欢去做一个程序员。
    努力学习,争取多年后,给亲人更好的生活。
    QQ/WX:2506897252 欢迎交流。



    0.先看一个代码

    package number;
    public class Book {
    
    private String name;//定义一个String类型的成员变量
    
    public String getName()//定义一个getName()方法
    {  
        int id=0;          //局部变量
        setName("Java");  //调用类中其他方法
        return id+this.name;//设置方法返回值
    }
    
    private void setName(String name)//定义一个setNAme()方法
    {
        this.name=name;    //将参数值赋予类中的成员变量
    }
    
    public Book getBook()
    {
        return this;      //返回Book类引用
    }
    
    }

    1.成员变量

    类的成员变量分为类变量(又称静态变量,被static修饰的变量)和实例变量(不被static修饰的变量),此外,还有定义在函数内部的变量称为局部变量,仅在函数内部有效。
    比如上述代码中:
    private String name; 这就是定义一个String类型的成员变量(实例变量)。
    现在先不管变量类型前面的修饰符。


    2.成员方法

    上述代码,包含了getName()和setName()两个成员方法,这两个成员方法分别获取图书名称和设置图示名称的方法。
    定义成员方法的语法格式如下:
    权限修饰符 返回值类型 方法名(参数类型 参数名 )
    {
    具体执行代码
    return 返回值
    }
    如果成员方法无返回值,可用void表示。
    在成员方法中可以调用其他成员方法和类成员变量,如上述代码中getName()调用了setName()方法。
    需要注意的一点是如果一个方法中含有与成员变量同名的局部变量,则方法中对这个变量的访问以局部变量进行。


    3.权限修饰符

    java中的权限修饰符主要包括private,public,protected,,这些权限修饰符控制着对类和类的成员变量,成员方法的访问,如果一个类的成员变量或成员方法被修饰private,则该成员变量或成员方法只能在本类中被使用,在子类中式不可见的,也就是自己都有。如果一个类的成员变量或成员方法被修饰public,那么除了可以在本类中使用这些数据之外,还可以在子类和其他包的类中使用,也就是自己大公无私,一视同仁,如果一个类的访问权限被设置为private,这个类将隐藏其内的所有数据,以免用户直接访问它,如果一个类的成员变量或成员方法被修饰protected,那么只能本包内的类或者子类可以访问。相对于public,protected比较小气,但是比private大气。

    访问包位置privateprotectedpublic
    本类可见可见可见
    同包其他类或子类不可见可见可见
    其他包的类或子类不可见不可及可见

    当声明类时不使用public,private , protected 这些修饰符时,只有一个包中的类和子类可以调用这个类的成员变量以及方法。而且java语言规定,类的权限约束类成员的权限设定。比如一单类被修饰为private,但是类成员为public,但是还是无法使用类成员。
    权限比较:private >protected >public


    4.局部变量

    上述代码中,int id=0; id被定义在函数内部,所以叫局部变量。局部变量在方法被执行时创建,在方法执行结束时被销毁。局部变量在使用时必须进行赋值操作或者被初始化,否则会出现编译错误。

    5.局部变量的有效范围


    局部变量的有效范围就是变量的作用域,如果在该方法开始处被定义,那么作用域就是该方法结束,如果变量在方法中的for语句中被定义,那么该变量作用域只有该for执行完毕。

    6.this关键字


    可以看到上述代码中的this.name=name语句,在方法setName()方法,形参名为name,成员变量为name,那么该怎么区别?在java语言中规定使用this关键字来代表本类对象的引用。this关键字被隐式地用于引用对象的成员变量和方法,,this相当于对象的衍生品,谁调用this就指谁,对象可以调用成员变量和成员方法,this关键字也可以,除此之外,this还可以作为方法的返回值。如代码最后 return this;在getBook()方法中,方法的返回值为Book类,所以方法体中使用return this这种形式将Book的对象进行放回。


    若有错误,欢迎指正批评,欢迎讨论。
    每文一句:别人讲我们不好,不用生气、难过。说我们好也不用高兴,这不好中有好,好中有坏,就看你会不会用?

    展开全文
  • 在一个函数内部定义的变量是内部变量,它只在本函数范围有效,也就是说只有在本函数内才能使用它们,在此函数以外是不能使用这些变量的。同样,在复合语句中定义的变量只在本复合语句范围有效。这称为局部变量...
  • 一、内部类定义 内部类(nested classes),面向对象程序设计中,可以在一个内部定义另一个。嵌套分为两种,即静态嵌套和非静态嵌套。静态嵌套使用很少,最重要的是非静态嵌套,也即是被称作为内部...
  • 局部变量和全局变量,以及作用范围

    万次阅读 多人点赞 2018-11-11 13:56:55
    变量按存储区域分:全局变量、静态全局变量和静态局部变量都存放在内存的静态存储区域,局部变量存放在内存的栈区。 变量按作用域分:  全局变量:在整个工程文件内都有效;“在函数外定义的变量”,即从定义变量...
  • 大家面试的时候肯定被问过java 接口、抽象、具体内部类、匿名内部类的区别及它们之间的关系。那么下面我就来整理下它们之间的关系。
  • Java讲课笔记16:内部类

    千次阅读 2020-05-12 19:33:41
    文章目录零、本讲学习目标1、掌握成员内部的使用2、掌握局部内部类的使用3、掌握静态内部的使用4、掌握匿名内部的使用一、内部概述二、成员内部(Member Inner Class)1、成员内部定义2、成员内部说明...
  • 内部类种类以及使用方法

    千次阅读 2019-02-24 16:13:20
    定义: 内部指的是在的内部定义再定义一个。 内部仅仅是一个编译时的概念。Outer.java 中定义一个Inner.java ,编译成功后会生成两个完全不同的class... 局部内部类; 匿名内部; 静态内部; 成员内...
  • Java内部类(Inner Class),类似的概念在C++里也有,那就是嵌套(Nested Class),乍看上去内部类似乎有些多余,它的用处对于初学者来说可能并不是那么显著,但是随着对它的深入了解,你会发现Java的设计者在内部...
  • Java内部类、修饰符

    千次阅读 2018-10-17 18:10:51
    大部分时候,内部都被作为成员内部定义,而不是作为局部内部类。成员内部是一种与成员变量、方法、构造器和初始化块相似的成员;局部内部类和匿名则不是成员。 案例: package org.westos.practice;...
  • 全局变量往往在Main函数中声明,其作用范围为整个代码;局部变量存在于声明该变量的块语句或方法结束的右花括号({})之前的作用域内。本文对C#中的一些变量声明和范围关系借几个demo展示出来。 情况一:变量包含产生...
  • 1.匿名内部肯定是局部内部类(在一个方法里面定义的内部),因为在java中,语句必须写在方法里,而匿名内部其实就是一条特殊的语句; 2.外部给定的对象就是所有外来的对象:外部方法的形参、局部变量、基
  • 根据定义的位置不同,把分为成员变量(在里定义的变量)和局部变量(在方法里定义的)。 成员变量: 被分为 变量(static)和实例变量(木有static)。 有static则为变量,没有就是实例变量。 局部变量:...
  • java匿名内部类详解

    千次阅读 多人点赞 2018-02-06 20:56:44
    匿名内部类,顾名思义,就是没有名字的,匿名内部类格式如下: new name(parameter) { ...... } name:父类或是接口的名字。 parameter:若name为父类,则parameter为父类构造函数的参数。 匿名...
  • 区分静态变量、动态变量、内部变量(局部变量)、外部变量(全局变量)静态变量、动态变量、内部变量(局部变量)、外部变量(全局变量)变量的分类来看 静态变量、动态变量、内部变量(局部变量)、外部变量(全局...
  • 局部变量:只在某个范围有效(例如方法中)。 变量:有效性主要和变量前的修饰符有关,例如private修饰就只对此类有效,public对所有包都有效。 存储位置: 成员变量:随着对象的创建而创建,对象消失则此变量也...
  • 【十】Java内部类与常用

    千次阅读 2020-02-27 19:31:55
    思维导图参考:【十】Java内部类与常用思维导图 【经典StringBuilder案例与详解】 1、jdk中StringBuilder字符串调优和intern();方法 2、四种内部类详解和区别实例 3、equals与==的区别以及equals方法的重写 4、...
  • 通常来说,一段程序代码中所用到的名字并不是有效和可用的,而限定这个名字的可用性的代码范围就是这个名字的作用域。作用域的使用提高了程序逻辑的局部性,增强了程序的可靠性,减少了名字冲突。 2.2.4 变量的作用...
  • 局部变量一般指函数内部局部变量,这部分的变量保存在栈里面,当函数调用结束,这些局部变量就会被自动释放。可以说这部分变量是系统自动管理的 全局变量或则是file scope的变量。这部分变量存储在 全局/静态存储...
  • 成员变量、变量(静态变量)、局部变量的区别

    千次阅读 多人点赞 2017-08-03 20:31:04
    如果局部变量的名字和成员变量的名字相同, 要想在该方法中使用成员变量,必须使用关键字this [java] view plain copy class People {   String name = "体重定义的name";
  • 一、什么是嵌套内部类  可以在一个内部定义另一个,这种称为嵌套(nested classes),它有两种类型:静态嵌套和非静态嵌套。静态嵌套使用很少,最重要的是非静态嵌套,也即是被称作为内部...
  • 第一、与其它的局部成员一样,局部有效范围被限定在包含的代码块中,一旦超出该范围,该局部内部类就不能被访问了。 第二、局部内部类不能被访问修饰符修饰,也就是说不能使用private、protected、public任一...
  • 内部类的修饰和各种访问形式

    千次阅读 2011-04-09 00:56:00
    一:总结 A成员内部类:相当于的成员1.修饰: 有private protected public final abstract等修饰。...访问:(1)内部类调用外部,访问外部中与内部类同名的实例变量用 外部类名.this.变量名
  • 本文广州市智昊电气技术有限公司在国网多省份中标的不同形式及技术要求的局部放电在线监测装置MCSG-PD-系列产品在电网中的实应用,向高压开关及成套环网柜箱企业介绍对比:环网箱特高频UHF/超声波AE/地电压波TEV局放...
  • JavaSE入门 P14 【进阶】多线程、同步、匿名内部类、死锁、生命周期 1.概述 2.多线程实现(模拟卖票) 3.多线程安全问题&解决方案 4.匿名内部类 5.同步 6.死锁,多线程生命周期 7.面试题
  • Java学习笔记一面向对象内部类

    千次阅读 2020-03-17 14:31:09
    内部类成员可以直接访问外部的私有数据,外部不能访问内部类的实现细节,例如内部类的成员变量。内部类比外部可以多使用三个修饰符:private、protected、static。内部类的上一级单元是外部,它就具有4个...
  • Go 局部变量&全局变量

    千次阅读 2021-12-24 21:30:58
    只能在哪个{}内部访问,离开作用域自动进行释放 看个例子 package main import "fmt" func main() { //定义在{}里面的变量就是局部变量,只能在{}里面有效 //执行到定义变量那句话,才开始分配空间,离开作用域自动...
  • 局部变量和全局变量的作用域

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

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 107,300
精华内容 42,920
热门标签
关键字:

局部内部类的有效范围