精华内容
下载资源
问答
  • 文章目录1 内部类的基本概念1.1 内部类的定义1.2 内部类的优缺点2 创建内部类2.1 在外部类外部创建非静态内部类2.2 在外部类外部创建静态内部类2.3 在外部类内部创建内部类语法3 内部类的分类3.1 成员内部类3.2 静态...

    1. 内部类的基本概念

    1.1 内部类的定义

    内部类: 所谓内部类就是在一个类内部进行其他类结构的嵌套操作。

    class Outer{
        private String str ="外部类中的字符串";
        //************************** 
        //定义一个内部类
        class Inner{
            private String inStr= "内部类中的字符串";
            //定义一个普通方法
            public void print(){
                //调用外部类的str属性
                System.out.println(str);
            }
        }
        //************************** 
        //在外部类中定义一个方法,该方法负责产生内部类对象并调用print()方法
        public void fun(){
            //内部类对象
            Inner in = new Inner();
            //内部类对象提供的print
            in.print();
        }
    }
    public class Test{
        public static void main(String[] args)
        {
            //创建外部类对象
            Outer out = new Outer();
            //外部类方法
            out.fun();
        }
    }
    

    运行结果:外部类中的字符串
    但是如果去掉内部类:

    class Outer{
        private String outStr ="Outer中的字符串";
        public String getOutStr()
        {
            return outStr;
        }
        public void fun(){  //2
            //this表示当前对象
            Inner in = new Inner(this); //3
            in.print();                 //5
        }
    }
    class Inner{
        private String inStr= "Inner中的字符串";
        private Outer out;
        //构造注入
        public Inner(Outer out)  //3
        {
            this.out=out;       //4.为Inner中的out变量初始化
        }
        public void print(){    //6
            System.out.println(out.getOutStr()); //7
        }
    } 
    public class Test{
        public static void main(String[] args)
        {
            Outer out = new Outer();  //1.
            out.fun(); //2.
        }
    }
    

    执行结果:Outer中的字符串
    但是去掉内部类之后发现程序更加难以理解。

    1.2 内部类的优缺点

    内部类的优点:

    1. 内部类与外部类可以方便的访问彼此的私有域(包括私有方法、私有属性)。
    2. 内部类是另外一种封装,对外部的其他类隐藏。
    3. 内部类可以实现java的单继承局限。

    内部类的缺点:

    结构复杂。
    记录:使用内部类实现多继承:

    class A {
        private String name = "A类的私有域";
        public String getName() {
            return name;
        }
    }
    class B {
        private int age = 20;
        public int getAge() {
            return age;
        }
    }
    class Outter {
        private class InnerClassA extends A {
            public String name() {
                return super.getName();
        }
    }
        private class InnerClassB extends B {
            public int age() {
                return super.getAge();
        }
    }
        public String name() {
            return new InnerClassA().name();
        }
        public int age() {
            return new InnerClassB().age();
        }
    }
    public class Test2 {
            public static void main(String[] args) {
                Outter outter = new Outter();
                System.out.println(outter.name());
                System.out.println(outter.age());
            }
    }
    

    在这里插入图片描述

    2. 创建内部类

    2.1 在外部类外部 创建非静态内部类

    语法: 外部类.内部类 内部类对象 = new 外部类().new 内部类();
    举例: Outer.Inner in = new Outer().new Inner();

    2.2 在外部类外部 创建静态内部类

    语法: 外部类.内部类 内部类对象 = new 外部类.内部类();
    举例: Outer.Inner in = new Outer.Inner();

    2.3 在外部类内部创建内部类语法

    在外部类内部创建内部类,就像普通对象一样直接创建:Inner in = new Inner();

    3. 内部类的分类

    在Java中内部类主要分为成员内部类、静态内部类、方法内部类、匿名内部类

    3.1 成员内部类

    类比成员方法

    1. 成员内部类内部不允许存在任何static变量或方法 正如成员方法中不能有任何静态属性 (成员方法与对象相关、静态属性与类有关)
    class Outer {
        private String name = "test";
        public  static int age =20;
    
        class Inner{
            public static int num =10;
            public void fun()
            {
                System.out.println(name);
                System.out.println(age);
            }
        }
    }
    public class Test{
        public static void main(String [] args)
        {}
    }
    

    在这里插入图片描述
    2. 成员内部类是依附外部类的,只有创建了外部类才能创建内部类。

    3.2 静态内部类

      关键字static可以修饰成员变量、方法、代码块、其实还可以修饰内部类,使用static修饰的内部类我们称之为静态内部类,静态内部类和非静态内部类之间存在一个最大的区别,非静态内部类在编译完成之后会隐含的保存着一个引用,该引用是指向创建它的外围类,但是静态类没有。没有这个引用就意味着:
      1.静态内部类的创建不需要依赖外部类可以直接创建。
      2.静态内部类不可以使用任何外部类的非static类(包括属性和方法),但可以存在自己的成员变量。

    class Outer {
        public String name = "test";
        private static int age =20;
    
        static class Inner{
            private String name;
            public void fun()
            {
                System.out.println(name);
                System.out.println(age);
            }
        }
    }
    public class Test{
        public static void main(String [] args)
        {
            Outer.Inner in = new Outer.Inner();
        }
    }
    

    在这里插入图片描述

    3.3 方法内部类

    方法内部类顾名思义就是定义在方法里的类
    1.方法内部类不允许使用访问权限修饰符(public、private、protected)均不允许。

    class Outer{
        private int num =5;
        public void dispaly(final int temp)
        {
            //方法内部类即嵌套在方法里面
            public class Inner{
            }
        }
    }
    public class Test{
        public static void main(String[] args)
        {}
    }
    

    在这里插入图片描述
    2. 方法内部类对外部完全隐藏,除了创建这个类的方法可以访问它以外,其他地方均不能访问 (换句话说其他方法或者类都不知道有这个类的存在)方法内部类对外部完全隐藏,出了创建这个类的方法可以访问它,其他地方均不能访问。
    3. 方法内部类如果想要使用方法形参,该形参必须使用final声明(JDK8形参变为隐式final声明)

    class Outer{
        private int num =5;
        //普通方法
        public void dispaly(int temp)
        {
            //方法内部类即嵌套在方法里面
            class Inner{
                public void fun()
                {
                    System.out.println(num);
                    temp++;
                    System.out.println(temp);
                }
            }
            //方法内部类在方法里面创建
            new Inner().fun();
        }
    }
    public class Test{
        public static void main(String[] args)
        {
            Outer out = new Outer();
            out.dispaly(2);
        }
    }
    

    在这里插入图片描述

    3.4 匿名内部类

      匿名内部类就是一个没有名字的方法内部类,因此特点和方法与方法内部类完全一致,除此之外,还有自己的特点:
    1.匿名内部类必须继承一个抽象类或者实现一个接口。
    2.匿名内部类没有类名,因此没有构造方法。

    //匿名内部类
    //声明一个接口
    interface MyInterface {
        //接口中方法没有方法体
        void test();
    }
    class Outer{
        private int num = 5;
        public void dispaly(int temp)
        {
            //匿名内部类,匿名的实现了MyInterface接口
            //隐藏的class声明
            new MyInterface()
            {
                public void test()
                {
                    System.out.println("匿名实现MyInterface接口");
                    System.out.println(temp);
                }
            }.test();
        }
    }
    public class Test{
        public static void main(String[] args)
        {
            Outer out = new Outer();
            out.dispaly(3);
        }
    }
    

    在这里插入图片描述

    4. 内部类与外部类的关系

    • 对于非静态的内部类,内部类的创建依赖外部类的实例对象,在没有外部类实例之前是无法创建内部类的。
    • 内部类可以直接访问外部类的元素(包括私有域)—外部类在内部类之前创建,创建内部类时会将外部类的对象传入
    class Outer{
        //成员变量  与对象有关
        private String msg;
        private int age;
        //--------------------------
        class Inner{
            public void dispaly()
            {
                //此处有一个隐藏的Outer.this
                msg = "test";
                age = 20;
                System.out.println(msg);
                System.out.println(age);
            }
        }
        //--------------------------
        public void test()
        {
            Inner in = new Inner();
            in.dispaly();
        }
    }
    public class Test{
        public static void main(String[] args)
        {
            Outer out = new Outer();
            out.test();
        }
    }
    
    • 外部类可以通过内部类的引用间接访问内部类元素 – -要想访问内部类属性,必须先创建内部类对象
    class Outer{
        public void dispaly()
        {
            //外部类通过创建内部类的对象间接访问内部类元素
            Inner in = new Inner();
            in.dispaly();
        }
        class Inner{
            public void dispaly()
            {
                System.out.println("内部类");
            }
        }
    }
    public class Test1{
        public static void main(String[] args)
        {
            Outer out = new Outer();
            out.dispaly();
        }
    }
    
    • 内部类是一个相对独立的个体,与外部类没有关系。
    展开全文
  • 使用this关键字获取内部类外部类对象的引用 在实际工作中,应该尽量避免这种情况。即在定义变量名字的时候,内部类中的变量名字尽量不要与外部类中的变量名字相同。但是如果真的发生这种情 况的话,Java编译器...

    使用this关键字获取内部类与外部类对象的引用

    在实际工作中,应该尽量避免这种情况。即在定义变量名字的时候,内部类中的变量名字尽量不要与外部类中的变量名字相同。但是如果真的发生这种情 况的话,Java编译器还是有手段可以解决这个变量名字的冲突问题。如果在类中的成员内部类中遇到成员变量名字与外部类中的成员变量名字相同,则可以通过 使用this关键字来加以区别。如现在有一个类名字叫做student。而在这个类中又创建了一个成员内部类,名字叫做age。现在在这两个类中各自定义 了一个成员变量i,用来做循环之用。此时如果在成员内部类中调用这个变量,该如何进行区分呢?通常情况下,如果使用this.i 的方式来调用变量,则表示这个变量是成员内部类中定义的变量。而通过使用student.this.i的形式调用变量时表示此时引用的是外部类的成员变 量。也就是说,如果内部类中引用外部类中同名的成员,需要通过外部类迷名字.this.外部类成员名字的方式加以引用。而且,在引用成员内部类自己的定义 的成员时也需要使用this关键字,以加以区别。显然这非常的麻烦。为此笔者仍然要强调一遍,除非有非常特殊的必要,否则的话要尽量避两外部类与成员内部 类中成员变量或者成员方法采用相同的名字。否则的话,会给后续的引用带来很大的麻烦。

    程序:

     1 public class Test {
     2     public int a = 1;
     3 
     4     public class Tes {
     5         public int a = 3;
     6 
     7         public void out() {
     8             System.out.println("内部类的a值:" + a);
     9             System.out.println("外部类的a值:" + Test.this.a);
    10         }
    11     }
    12 
    13     public Test() {
    14         new Tes().out();
    15     }
    16 
    17     public static void main(String[] args) {
    18         new Test();
    19 
    20     }
    21 }
     

    运行结果:

    内部类的a值:3
    外部类的a值:1
    

     

     

     

    转载于:https://www.cnblogs.com/ouyxy/p/6680023.html

    展开全文
  • 静态内部类调用外部类成员和方法, Comparable内部比较器接口的使用; 实现的封装 将输入的英雄数据装入数组中 再将数组中的数据以操作系数排序再次输出 代码如下: 代码中有相应的注释 外加一些快捷键的使用...

    静态内部类调用外部类的成员和方法,

    Comparable内部比较器接口的使用;

    实现类的封装

    将输入的英雄数据装入数组中

    再将数组中的数据以操作系数排序再次输出

    代码如下:
    代码中有相应的注释
    外加一些快捷键的使用方法

    package src.com;
    import java.util.Arrays;
    import java.util.Scanner;
    //外部类
    public class Two implements Comparable<Two>{
    //输入接口后报错,鼠标点击红线,ALT+回车
        //implements Comparable<Two> 方法,让实体类实现内部比较器接口
    
        private String name;//名字
        private double difficulty;//难度
        private String code;//职业
    
        public void show(){
            System.out.println("真正的大师,永远都怀着一颗学徒的心");
        }
    
        @Override
        public int compareTo(Two o) {
            //使用基本数据类型doublede 的包装类Double的compare方法可以比较俩个double类型的数据,返回int类型
            return Double.compare(this.difficulty,o.difficulty);
        }
    //ALT+insert键 选toString()方法,里面,Ctrl+A全选即可
        @Override
        public String toString() {
            //“”双引号内的内容根据自己习惯进行修改
            return "\n" +
                    "英雄:" + name  +
                    ", 操作系数:" + difficulty +
                    ", 职业:" + code  +
                    ';';
        }
    
    //ALT+insert键 选Getter and Setter方法 里面,Ctrl+A全选即可
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public double getAge() {
            return difficulty;
        }
        public void setAge(double age) {
            this.difficulty = age;
        }
        public String getCode() {
            return code;
        }
        public void setCode(String code) {
            this.code = code;
        }
    
    //静态内部类
        public static class One{
            //主方法写在内部类中
            public static void main(String[] args) {
                //引入Scanner
                Scanner sc=new Scanner(System.in);
                System.out.print("请输入数组长度:");
                int a=sc.nextInt();
                //创建一个外部类的数组,定义为ts数组
                Two[] ts=new Two[a];
    
                for (int i = 0; i <ts.length ; i++) {
                    //内部类调用外部类的成员
                    //新(new)创建一个对象
                    Two t=new Two();
                    System.out.print("输入第"+(i+1)+"个英雄名字:");
                    t.name=sc.next();
                    System.out.print("操作难度:");
                    t.difficulty=sc.nextDouble();
                    System.out.print("职业:");
                    t.code=sc.next();
                    //将输入的数据装入外部类ts数组
                    ts[i]=t;
                }
                System.out.println("-----------------------------");
    
                //将输入的数据,以数组的方式一个一个输出
                System.out.print("英雄名单:");
                for (int i = 0; i <ts.length ; i++) {
                    System.out.print(ts[i]);
                    //为了美化输出,最后一组数据输出后自动转行
                    if (i==ts.length-1){
                        System.out.println();
                    }
                }
                System.out.println("-----------------------------");
    
                System.out.print("根据操作难度排序:");
                //此处传入比较的 数组 和 内部比较器对象
                Arrays.sort(ts);
                //将对象数组转换为字符串输出
                System.out.println(Arrays.toString(ts));
                System.out.println("-----------------------------");
    
                //调用外部类内的show()方法
                Two t=new Two();
                t.show();
            }
        }
    }
    

    输出效果如图所示:
    在这里插入图片描述

    展开全文
  • 内部类调用外部类方法时传参是可以传参的,不管外部方法是private,还是public;而且内部类里可以修改外部成员变量。 如果外部方法无法得到内部类局部变量的值,那应该是哪里写错了。

    上问题代码

    public class SettingActivity extends Activity {
    
    @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_setting);
            initRemoteLockScreen();
        }
    
    public void initRemoteLockScreen(){
            SettingClickView rls = (SettingClickView) findViewById(R.id.siv_remoteLockScreen);
            rls.setTitle("远程锁屏密码设置");
            rls.setDesc("点击进行设置密码");
    
            rls.setOnClickListener(new OnClickListener() {
                @Override
                public void onClick(View view) {
                    startremotelockdialog();
                }
            });
    
        }
    
        public void startremotelockdialog(){
    
            showPasswordSetDailog(dialogTitle,new AlertDialogEngineInterface() {
                @Override
                public void saveSp(String value) {
                    if (value == null){
                        return;
                    }
                    mPref.edit()
                            .putString("lockScreenPass",
                                    MD5Utils.encode(value)).commit();
                }
    
            });
        }
    
        public void showPasswordSetDailog(String title, final AlertDialogEngineInterface dialogInterface) {
            AlertDialog.Builder builder = new AlertDialog.Builder(this);
            final AlertDialog dialog = builder.create();
    
            View view = View.inflate(this, R.layout.dailog_set_password, null);
    
        dialog.setView(view, 0, 0, 0, 0);
            TextView tvTitle = (TextView) findViewById(R.id.dialog_tv_title);
            tvTitle.setText(title);
            Log.e("xxx",title);//**title值不为空**
            final EditText etPassword = (EditText) view
                    .findViewById(R.id.et_password);
            final EditText etPasswordConfirm = (EditText) view
                    .findViewById(R.id.et_password_confirm);
    
            Button btnOK = (Button) view.findViewById(R.id.btn_ok);
            Button btnCancel = (Button) view.findViewById(R.id.btn_cancel);
    
            btnOK.setOnClickListener(new OnClickListener() {
    
                @Override
                public void onClick(View v) {
                    String password = etPassword.getText().toString();
                    String passwordConfirm = etPasswordConfirm.getText().toString();
    
                    if (!TextUtils.isEmpty(password) && !passwordConfirm.isEmpty()) {
                        if (password.equals(passwordConfirm)) {
                            dialogInterface.saveSp(password);
    
                            dialog.dismiss();
    
                        } 
                }
            });
    
            btnCancel.setOnClickListener(new OnClickListener() {
    
                @Override
                public void onClick(View v) {
                    dialog.dismiss();// 隐藏dialog
                }
            });
    
            dialog.show();
    }
    
    private interface AlertDialogEngineInterface{
    
            void saveSp(String value);
    
        }
    }

    结论:
    内部类调用外部类方法时传参是可以传参的,不管外部类方法是private,还是public;而且内部类里可以修改外部类的成员变量。
    如果外部类方法无法得到内部类局部变量的值,那应该是哪里写错了。

    展开全文
  • 成员内部类外部类:因为成员内部类就相当于一个成员函数一样,所以成员内部类可以直接访问外部类的所有成员。 ;外部类要访问成员内部类就需要实例化它。这很容易理解。  需要注意的是:成员内部类不能访问外部...
  • ——————————————————... 注意实现四:使用this关键字获取内部类外部类对象的引用。  在外部类成员内部类中,都可以定义变量。成员内部类可以随意访问外部类中的变量,而外部类不能够直接访...
  • 内部类如何调用外部类的方法

    千次阅读 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{ ...
  • 分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍中来!请点击http://www.captainbed.net 一个内部类对象可以访问创建它的外部类对象的成员,包括私有成员。 ...
  • 之前在看Java的访问权限的时候,书中写道,如果一个中某个属性被设置为private,那么“ 除了包含该成员,其他任何都无法访问这个成员 ”,但是今天在看内部类的时候发现一个有意思的例子,如下 ...
  • 内部类调用外部类变量

    千次阅读 2019-09-12 15:07:08
    要求:使用已知的变量,在控制台输出30,20,10。 class Outer { public int num = 10; class Inner { public int num = 20; public void show() { int num = 30; Sy...
  • 今天在写代码的时候,涉及到使用一个内部类调用外部类方法的问题,总是得不到我想要的结果,后经过DEBUG,才发现哪里出现了问题。现写了一个简单的代码,来重现这个问题。   打印出来的结果为: a: 20 a: 0 ...
  • Java内部类外部类

    2019-10-18 19:53:25
    在这种情况下,这个内部类可以被看成外部类的一个成员(与的属性和方法类似)。还有一种类被称为顶层(Top-level),指的是定义代码不嵌套在其他定义中的内部类 内部类主要有四种类型: 静态内部类...
  • a) 内部类可以直接调用外部类包括private的成员变量,使用外部类引用的this.关键字调用即可 b) 而外部调用内部类需要建立内部类对象 转载于:https://www.cnblogs.com/xwb583312435/p/10075537.html...
  • 内部类里,想引用外部类的对象,为什么是外部类.this而不是外部类引用变量,还有.操作应该是成员操作符吧,这样this不就成了外部类成员
  • 1.内部类引用外部类局部变量时,外部类的局部变量一定要用final修饰。 因为内部类外部类的局部变量生命周期不一样,外部类方法执行完该局部变量可能会被释放掉,但该方法中的内部类可能还在执行(如线程),还要...
  • 内部类外部类

    2018-08-18 20:47:16
    10、内部类与外部的调用 a) 内部类可以直接调用外部类包括private的成员变量,使用外部类引用的this.关键字调用即可 b) 而外部调用内部类需要建立内部类对象...
  • 内部类外部类

    千次阅读 2013-11-18 16:02:40
     内部类是一个单独的,可以随意直接访问外部类的所有变量(包括private),这是通过this 的关系形成的,使得内部类的对象可以随意的访问外部类的所有成员,在内部类中访问外部类的覆盖成员可以用classname.this。...
  • 在Java中内部类的定义与使用一般为成员内部类与匿名内部类,他们的对象都会隐式持有外部类对象的引用,影响外部类对象的回收。解决方案为 1.将内部类定义为static 2.用static的变量引用匿名内部类的实例或将匿名...
  • public class Test5 {   //定义包含私有成员变量和函数  private int a = 201320883;  private void funcOut(){  System.out.println("out function run print:" + a);   
  • 内部类外部类

    2019-02-18 21:43:06
    内部类和外部:  内部类可以使用外部的私有成员和方法(当成员变量一样时,...调用外部类非静态成员时,new 外部.成员。);  创建内部类对象时,需要用外部对象创建。创建内部静态对象时,直接创建。...
  • 普通内部类持有外部类引用的原理

    千次阅读 2018-08-18 15:54:21
    1、编译器自动为内部类添加一个成员变量, 这个成员变量的类型和外部类的类型相同, 这个成员变量就是指向外部类对象(this)的引用; 2、编译器自动为内部类的构造方法添加一个参数, 参数的类型是外部类的类型, 在...
  • java内部类成员内部类、局部内部类和匿名内部类

    千次阅读 多人点赞 2018-07-15 16:13:30
    内部类概念 一个中包含另外一个。 分类 1、成员内部类。 2、局部内部类(包含匿名内部类)。...内部类使用外部,可以随意访问,但是外部类使用内部类要借助内部类的对象。 使用成员内部类 两种方法: 1...
  • 外部类调用内部类

    2014-08-05 23:56:34
    之间除了继承关系之外,还存在嵌套关系,即一个可以声明包含另一个,被包含的称为内部类(inner class),包含内部类称为外部类,此时内部类成为外部类成员。 Java不支持C++语言的结构(struct)...
  • 昨天下午字节跳动的面试中,问到了这个问题:内部类能访问外部类成员吗? 当时只是回答了静态内部类能访问外部类的静态方法,成员内部类能访问外部类的所有方法。然后面试官问我原因我就答不上来了。还是原来看的...
  • 内存泄漏-内部类持有外部类引用

    千次阅读 2019-11-25 00:28:45
    1.内部类持有外部类引用 我们在处理Android内存泄漏的时候,经常会遇到一些是由于内部类持有外部类引用而引发的。严格来说是非static的内部类的非static对象或匿名内部类的非static对象持有了当前所在外部类引用...
  • 尝试在C++中模仿apple objective-c 的Grand Dispatch简化多线程编程时,使用了boost::function,线程池,和内部类技术,需要在内部类访问外部类的私有成员,由于标准的C++不允许这么做,内部类只能访问外部类的公有...
  • java内部类获得外部类对象

    千次阅读 2018-11-06 22:32:13
    前几天遇到一个问题,在内部类中获取外部类引用,怎么获取? 外部类名.this
  • 内部类: ①静态内部类中可以有非...一般内部类外部类成员变量位置,像这样: 1 public class Outer { 2 class Inner{ 3 4 } 5 } 1、外部类访问内部类:  内部类被static修饰:可以直接new  Inner i...
  • 众所周知,在定义成员方法或者成员变量的时候,可以给其加上一些...也就是说,在成员内部类中可以随意引用外部类成员方法以及成员变量,即使这些类成员方法或者成员变量被修饰了private.如在成员外部类中定义了一个i

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 207,238
精华内容 82,895
关键字:

内部类引用外部类成员