精华内容
下载资源
问答
  • 外部类修饰方法
    2018-09-27 22:45:06

    对于顶级类(外部类)来说,只有两种修饰符:public和默认(default)。因为外部类的上一单元是包,所以外部类只有两个作用域:同包,任何位置。因此,只需要两种控制权限:包控制权限和公开访问权限,也就对应两种控制修饰符:public和默认(default)。可以满足所有的情况了。

    如果类使用了private修饰符,说明是个内部类。内部类的上一级是外部类,那么对应的有四种访问控制修饰符:本类(private),同包(default),父子类(protected),任何位置(public)。当一个内部类使用了private修饰后,只能在该类的外部类内部使用。

    上面这些都是平时使用司空见惯的,但是为什么是这种情况呢?

    可以想一下,一个java项目是不可能在一个class里面完成的。mvc模式中,是把类分为三层,一层层调用类。如果定义为私有的和受保护的就无法调用。换句话说,对于一个java文件,要么就是自己单独运行,要么就是被其他程序作为库调用,如果一个java文件的类被private修饰,那么是不是其他的程序或是类是无法使用它的,那么他作为一个单独的文件就没啥用了。如果它作为单个文件运行,类加载怎么找到它呢,因为它对外不可见。同时,也失去了类的存在意义。

    因此,类只有public和默认修饰符。

    更多相关内容
  • 今天小编就为大家分享一篇关于Java的外部类为什么不能使用private和protected进行修饰的讲解,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • 外部类只能用public、final或者abstract(二选一)。 内部类比外部类多三种:private、protected、...其中,前两种只要不用private修饰,另一个都可访问它们。后两种,另一个不允许访问它们。 匿名内部可看作是局部

    外部类只能用public、final或者abstract(二选一)。

    内部类比外部类多三种:private、protected、static。

    局部内部类:fianl或者abstract

    内部类分为四种:带static的

           不带static的

           局部内部类

           匿名内部类

    其中,前两种只要不用private修饰,另一个类都可访问它们。后两种,另一个类不允许访问它们。

    匿名内部类可看作是局部内部类的特殊,都是在方法里的类。

    展开全文
  • 当内部调用外部类的私有属性时,其真正的执行是调用了编译器生成的属性的静态方法(即acess$0,access$1等)来获取这些属性值。这一切都是编译器的特殊处理。外部类可以通过内部的实例获取私有属性x的操作.如何让...

    注意:

    在内部类构造的时候,会将外部类的引用传递进来,并且作为内部类的一个属性,所以内部类会持有一个其外部类的引用。

    当内部类调用外部类的私有属性时,其真正的执行是调用了编译器生成的属性的静态方法(即acess$0,access$1等)来获取这些属性值。这一切都是编译器的特殊处理。

    外部类可以通过内部类的实例获取私有属性x的操作.

    如何让内部类私有成员不被外部访问

    相信看完上面两部分,你会觉得,内部类的私有成员想不被外部类访问都很困难吧,谁让编译器“爱管闲事”呢,其实也是可以做到的。那就是使用匿名内部类。

    由于mRunnable对象的类型为Runnable,而不是匿名内部类的类型(我们无法正常拿到),而Runanble中没有x这个属性,所以mRunnable.x是不被允许的。

    1 内部类对象的创建依赖于外部类对象;

    2 内部类对象持有指向外部类对象的引用。

    关于内部类如何访问外部类的成员, 分析之后其实也很简单, 主要是通过以下几步做到的:

    1 编译器自动为内部类添加一个成员变量, 这个成员变量的类型和外部类的类型相同, 这个成员变量就是指向外部类对象的引用;

    2 编译器自动为内部类的构造方法添加一个参数, 参数的类型是外部类的类型, 在构造方法内部使用这个参数为1中添加的成员变量赋值;

    3 在调用内部类的构造函数初始化内部类对象时, 会默认传入外部类的引用。

    java中,匿名内部类可以使用外部类的成员变量吗

    https://segmentfault.com/q/1010000002796833

    细话Java:"失效"的private修饰符

    http://droidyue.com/blog/2014/10/02/the-private-modifier-in-java/

    深入理解Java中为什么内部类可以访问外部类的成员

    http://blog.csdn.net/zhangjg_blog/article/details/20000769

    展开全文
  • 内部外部类之间的访问

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

    目           录

    1.内部类与外部类

    2.内部类的特点:内部类可以直接访问外部类的成员(成员变量和成员方法),包括私有成员。

    3.内部类与外部类之间的访问

    在测试类中调用成员内部类中的方法:

     外部类访问成员内部类中的成员:

    静态的成员内部类,只能访问外部类的静态成员

    私有的成员内部类,外界就无法直接创建其对象,可以通过外部类的方法访问

     局部内部类,在外界没有直接创建其对象的语法

    局部内部类访问外部类的局部变量:


    1.内部类与外部类

    将一个类A 定义到另一个类B的内部,那么类A叫做内部类,类B叫做外部类。

    根据内部类在外部类中定义的位置不同,分为 成员内部类,和局部内部类

    • 成员内部类: 定义在外部类的成员位置。
    • 局部内部类: 定义在外部类的局部位置,也就是外部类中的方法内部。
    class B {           //B是外部类
       
        class A {       //A是成员内部类
    
        }
    
        public void show() {
            
            class C {    //C是局部内部类
    
            }
        }
    
    }

    2.内部类的特点:内部类可以直接访问外部类的成员(成员变量和成员方法),包括私有成员。

    
    package org.xingyun.interface1;
    
    public class Wai {           //外部类
        int num = 20;
        private int a = 60;
    
        //成员内部类
        public class Nei {
            public void neiShow() {
                System.out.println("内部类的show方法");
                //内部类的特点:内部类可以直接访问外部类的成员,包括私有成员。
                System.out.println(num);              //外部类的成员变量
                System.out.println(a);                //外部类的私有变量
                waiShow();                            //外部类的成员方法
                hehe();                               //外部类的私有方法
            }
        }
    
        public void waiShow() {
            System.out.println("外部类的show方法");
        }
    
        private void hehe() {
            System.out.println("外部类的私有方法");
        }
        
    }
    

    如果外部类与内部类的成员有重名的话 ,可以这样拿到外部类的成员:外部类名.this.变量名(其中 Outer.this 表示外部类对象)

    class Outer {
        //外部类的成员变量
        public int num = 10;
    
        class Inner {
            //内部的成员变量
            public int num = 20;
    
            public void show() {
                //局部变量
                int num = 30;
                System.out.println(num);      //30(就近原则)
                System.out.println(this.num); //20(内部类的变量)
    
                System.out.println(Inner.this.num); //20(内部类的变量,也可以这样取到)
               
                System.out.println(new Outer().num); //10(创建了一个外部类的对象去取变量)这样太繁琐了
                // 可以这样Outer.this.num .   (Outer.this 表示外部类对象)
                System.out.println(Outer.this.num);  //10
     
            }
        }
    }

    3.内部类与外部类之间的访问

    在测试类中调用成员内部类中的方法:

    需要先创建成员内部类的对象的语法格式:外部类名.内部类名 对象名 = new 外部类名().new 内部类名();

     class Wai {       //外部类
         private int a=100;
        //成员内部类
        public class Nei {
    
            public void neiShow() {
                System.out.println("内部类的show方法" );
            }
        }
    
        public void waiShow() {
            System.out.println("外部类的show方法");
        }
    }
    
    
    public class Test {
        public static void main(String[] args) {
            //在测试类里面,调用内部类的方法
            //创建成员内部类的对象    外部类名.内部类名 对象名 = 外部类对象.内部类对象
            Wai.Nei nei = new Wai().new Nei();
            nei.neiShow();
            System.out.println("====================================");
            //内部类可以直接访问外部类的成员,包括私有成员。
            Wai wai = new Wai();
            wai.waiShow();
        }
    }
    //执行结果:
    /*
    内部类的show方法
    ====================================
    外部类的show方法
     */

     外部类访问成员内部类中的成员:

    需要先创建成员内部类的对象:     内部类名 对象名 =new 内部类名();

    public class Wai {        //外部类
    
        //成员内部类
        public class Nei {
            //内部类的成员变量
            int n = 5;
            int x = 100;
    
            //内部类的成员方法
            public void neiShow() {
                System.out.println("内部类的show方法");
            }
        }
    
        public void waiShow() {
            System.out.println("外部类的show方法");
        }
        //外部类访问内部类的成员
        public void test() {
            //创建内部类对象
            Nei nei = new Nei();
            //访问内部类的成员变量
            System.out.println(nei.n);
            System.out.println(nei.x);
            //访问内部类的成员方法
            nei.neiShow();
            
            //直接访问外部类成员
            waiShow();
        }
    }
    

    静态的成员内部类,只能访问外部类的静态成员

    静态的成员内部类,创建对象的语法: 外部类名.内部类名 对象名 = new 外部类名.内部类名();

    public class Test {
        public static void main(String[] args) {
            //静态的成员内部类,创建对象的语法
            Wai.Nei nei = new Wai.Nei();
            nei.neiShow();
            //静态的成员内部类,只能访问外部类的静态成员。
        }
    }
    
    
     class Wai{
        static int num = 100;
    
        //static 也可以修饰内部类
        public static class Nei {
            public void neiShow() {
                //静态的成员内部类,只能访问外部类的静态成员。
                System.out.println(num);
            }
        }
    }

    私有的成员内部类,外界就无法直接创建其对象,可以通过外部类的方法访问

    public class privateNei {
        public static void main(String[] args) {
            //私有的成员内部类,外界就无法创建其对象了
            //通过外部类的方法访问
            Outer outer = new Outer();
            outer.waiShow();
        }
    }
    
    class Outer {     //外部类
        //内部类可以私有修饰
        private class Inner {        //成员内部类
            public void neiShow() {
                System.out.println("nei show");
            }
        }
    
        public void waiShow() {
            //可以外部类访问内部类,创建内部类对象
            Inner inner = new Inner();
            inner.neiShow();
        }
    }

     局部内部类,在外界没有直接创建其对象的语法

    public class Test {
        public static void main(String[] args) {
            //局部内部类,在外界没有直接创建其对象的语法。通过外部类方法访问
            Wai wai = new Wai();
            wai.waiShow();
        }
    }
    
    class Wai {
        int num = 20;
        private double a = 3.5;
    
        public void waiShow() {
            //局部内部类
            class Nei {
                int t = 50;
    
                public void neiShow() {
                    System.out.println(num);
                    System.out.println(a);
                }
            }
            //创建局部内部类对象
            Nei nei = new Nei();
            nei.neiShow();
        }
    }

    局部内部类访问外部类的局部变量:

    局部内部类访问外部类的局部变量,局部变量必须用final修饰,使之成为常量.

    为什么呢? 因为局部变量会随着方法的调用完毕而消失,这个时候,局部对象并没有立马从堆内存中消失,还要使用那个变量。为了让数据还能继续被使用,就用final修饰,这样,在堆内存里面存储的其实是一个常量值。(JDK1.8之后,final会默认加上)

    class Outer {
        public void waiShow(final int a) {
            //局部变量
            final int num = 20; 
    
            //定义局部内部类
            class Inner {
                public void neiShow() {
                    //局部内部类,要访问外部类的局部变量,局部变量,必须用final修饰,使之成为常量
                    System.out.println(num);    //20
                    System.out.println(a);      //20
                }
            }
        }
    }

    (小编也在努力学习更多哟!以后会多多分享哒!)  

    希望对友友们有所帮助!!!

    展开全文
  • Java外部类不能用private和protected修饰

    千次阅读 2020-03-20 10:42:11
    private(私有的)无法访问:使用private关键字,就意味着被声明的成员或方法,除了本,其他任何都无法访问。 public(公共的)接口访问权限:使用public关键字,就意味着被声明的成员或方法对所有都是可以...
  • 【单选题】下面哪一个是正确的的声明?【多选题】关于super关键字以下说法哪些是正确的?【其它】军训专题摄影 要求上交一组(5-10张)军训照片,表现学生军训的刻苦,坚韧的意志品质和精神面貌。 可以拍摄全景,特写,...
  • 1.外部类,最大的修饰符有public(表示该在项目所有中可以被导入),default(该只能在同一个package中使用),abstract,final 2.内部指位于内部但不包括位于块、构造器、方法内,且有名称的,...
  • MMTTMM访问控制修饰符Java中,可以使用访问控制符来保护对、变量、方法和构造方法的访问。Java支持4种不同的访问权限。默认的,也称为default,在同一包内可见,不使用任何修饰符。私有的,以private修饰符指定,...
  • 关于外部类只能用public或默认修饰的说法:我是这样理解的:这些修饰权限是针对中的那些变量、方法、内部来说的,而外部类已经在最外部(即不存在说在哪个的内部,或是哪个的子类这些范围),作为单独文件...
  • 一个如果是final的,那么其中所有的成员方法都无法进行覆盖重写,java中典型的final修饰 String 作用:使当前这个不能有任何子类 说明:当用final修饰一个时,表明这个不能被继承。 final中的成员...
  • 方法、成员变量和局部变量的可用修饰修饰 成员访求 构造方法 成员变量 局部变量 abstract(抽象的) √ √ - - - static (静态的) - √ - √ - public(公共的) √ √ √ √ - ...
  • 关于外部类无法访问修饰符为"private"的成员变量、方法、构造函数 错误(私有权限的问题) 在外部类中getDeclaredMethod确实可以访问private修饰方法,但是并不能调用方法 xx.invoke(). 因此解决办法就是进行...
  • final可以修饰类方法,变量。 final修饰不可以被继承。 final修饰方法不可以被覆盖。 final修饰的变量是一个常量,只能被赋值一次。 内部只能访问被final修饰的局部变量(JDK8之前)。 //final修饰...
  • ⒈ 静态内部⒉ 成员内部⒊ 局部内部⒋匿名内部几种内部的共性:A、内部仍然是一个独立的,在编译之后会内部会被编译成独立的.class文件,但是前面冠以外部类命和$符号。B、内部不能用普通的...
  • java内部外部类的区别

    千次阅读 2021-03-07 00:47:13
    下面说一说内部(Inner Class)和静态内部(Static Nested Class)的区别:定义在一个内部的叫内部,包含内部称为外部类。内部可以声明public、protected、private等访问限制,可以声明 为abstract的...
  • 这里所说的“匿名内部”主要是指在其外部类的成员方法内定义,同时完成实例化的,若其访问该成员方法中的局部变量,局部变量必须要被final修饰。 原因是编译程序实现上的困难:内部对象的生命周期会超过局部...
  • static修饰的内部相当于一个普通的,访问方式为(new 外部类名.内部方法() )。如下所示: public class OuterClass { public static class InnerClass{ InnerClass(){ System.out.println("==========...
  • 类修饰

    千次阅读 2021-03-31 16:48:18
    1、 修饰符分为:可访问控制符和非访问控制符两种。 可访问控制符是:公共类修饰符 public protect 非访问控制符有:抽象类修饰符 abstract ;最终类修饰符 final 1、公共类修饰符 public : Java 语言中的可...
  • (转)java中的方法修饰

    千次阅读 2021-03-22 16:11:51
    Java程序在定义时,除了使用class关键字标识之外,还可以在class之前增加若干修饰符来修饰限定所定义的的特性。修饰符分为访问控制符和非访问控制符两大修饰符之间的先后排列次序对的性质没有任何...
  • 内部外部类之间的相互调用

    千次阅读 2021-03-15 10:28:12
    ①静态内部中可以有非静态的方法②当内部中有静态方法或者静态成员变量时,一定是静态内部一般内部外部类的成员变量位置,像这样:1 public classOuter {2 classInner{34 }5 }1、外部类访问内部:内部...
  • 内部没有使用static关键字修饰,并且和外部类的成员变量和方法属于同一级别,这样的是非静态成员内部(可以使用权限修饰修饰,和final、abstract关键字修饰)。 public class Atest { private String name = ...
  •  1.abstract可以修饰class表示抽象,可以修饰方法表示抽象方法,但是不能修饰成员变量,也是没有抽象的成员变量。  2.用abstract修饰的中可以有abstract方法,也可以没有abstract方法;可以有非abstract方法...
  • private修饰方法

    千次阅读 2021-04-22 06:45:11
    A 解析 在子类覆盖父类的方法时,如果父类的方法修饰符是Public,子类一定要用public。如果父类的方法修饰符是private,子类就不能直接访问或重载这个方法。最新......方法的定义语法 【访问修饰符】 返回值类型 ...
  • 如果在IDE中,用protected和private修饰外部类,一定会报错的。 protected class Demo{ // 会报错! } private class Demo{ // 会报错! } public class Demo{ // 正确! } class Demo{ // 正确! } 什么...
  • 自从用eclipse写Java代码后,虽然效率得到了解放。但是很多Java有关的概念一下子弱了很多。没办法,自动提示、自动导包、自动这自动那的...最近重温了Java中权限...一、权限修饰修饰外部类的包内包外情况分析:...
  • 首先,不清楚Java外部类和内部的同学可以先百度一下。 其次,我们简单了解一下四种权限修饰符: private(私有的)无法访问:使用private关键字,就意味着被声明的成员或方法,除了本,其他任何都无法访问。...
  • static为什么可以修饰类

    千次阅读 2021-02-28 13:04:36
    展开全部Java里面static一般用来修饰成员变量或函数e68a84e8a2ad...被static修饰的内部可以直接作为一个普通来使用,而不需实例一个外部类(见如下代码)public class OuterClas...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 217,633
精华内容 87,053
关键字:

外部类修饰方法