内部类总结

内部类不是很好理解，但说白了其实也就是一个类中还包含着另外一个类

如同一个人是由大脑、肢体、器官等身体结果组成，而内部类相当于其中的某个器官之一，例如心脏：它也有自己的属性和行为（血液、跳动）

显然，此处不能单方面用属性或者方法表示一个心脏，而需要一个类

而心脏又在人体当中，正如同是内部类在外部内当中

实例1：内部类的基本结构


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

//外部类

class Out {

    private int age = 12;

    

    //内部类

    class In {

        public void print() {

            System.out.println(age);

        }

    }

}

public class Demo {

    public static void main(String[] args) {

        Out.In in = new Out().new In();

        in.print();

        //或者采用下种方式访问

        /*

        Out out = new Out();

        Out.In in = out.new In();

        in.print();

        */

    }

}

运行结果：12

从上面的例子不难看出，内部类其实严重破坏了良好的代码结构，但为什么还要使用内部类呢？

因为内部类可以随意使用外部类的成员变量（包括私有）而不用生成外部类的对象，这也是内部类的唯一优点

如同心脏可以直接访问身体的血液，而不是通过医生来抽血

程序编译过后会产生两个.class文件，分别是Out.class和Out$In.class

其中$代表了上面程序中Out.In中的那个 .

Out.In in = new Out().new In()可以用来生成内部类的对象，这种方法存在两个小知识点需要注意

　　1.开头的Out是为了标明需要生成的内部类对象在哪个外部类当中

　　2.必须先有外部类的对象才能生成内部类的对象，因为内部类的作用就是为了访问外部类中的成员变量

实例2：内部类中的变量访问形式


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

class Out {

    private int age = 12;

    

    class In {

        private int age = 13;

        public void print() {

            int age = 14;

            System.out.println("局部变量：" + age);

            System.out.println("内部类变量：" + this.age);

            System.out.println("外部类变量：" + Out.this.age);

        }

    }

}

public class Demo {

    public static void main(String[] args) {

        Out.In in = new Out().new In();

        in.print();

    }

}

运行结果：

局部变量：14
内部类变量：13
外部类变量：12

从实例1中可以发现，内部类在没有同名成员变量和局部变量的情况下，内部类会直接访问外部类的成员变量，而无需指定Out.this.属性名

否则，内部类中的局部变量会覆盖外部类的成员变量

而访问内部类本身的成员变量可用this.属性名，访问外部类的成员变量需要使用Out.this.属性名

实例3：静态内部类


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

class Out {

    private static int age = 12;

    

    static class In {

        public void print() {

            System.out.println(age);

        }

    }

}

public class Demo {

    public static void main(String[] args) {

        Out.In in = new Out.In();

        in.print();

    }

}

运行结果：12

可以看到，如果用static 将内部内静态化，那么内部类就只能访问外部类的静态成员变量，具有局限性

其次，因为内部类被静态化，因此Out.In可以当做一个整体看，可以直接new 出内部类的对象（通过类名访问static，生不生成外部类对象都没关系）

实例4：私有内部类


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

class Out {

    private int age = 12;

    

    private class In {

        public void print() {

            System.out.println(age);

        }

    }

    public void outPrint() {

        new In().print();

    }

}

public class Demo {

    public static void main(String[] args) {

        //此方法无效

        /*

        Out.In in = new Out().new In();

        in.print();

        */

        Out out = new Out();

        out.outPrint();

    }

}

运行结果：12

如果一个内部类只希望被外部类中的方法操作，那么可以使用private声明内部类

上面的代码中，我们必须在Out类里面生成In类的对象进行操作，而无法再使用Out.In in = new Out().new In() 生成内部类的对象

也就是说，此时的内部类只有外部类可控制

如同是，我的心脏只能由我的身体控制，其他人无法直接访问它

实例5：方法内部类


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

class Out {

    private int age = 12;

    public void Print(final int x) {

        class In {

            public void inPrint() {

                System.out.println(x);

                System.out.println(age);

            }

        }

        new In().inPrint();

    }

}

public class Demo {

    public static void main(String[] args) {

        Out out = new Out();

        out.Print(3);

    }

}

运行结果：

3
12

在上面的代码中，我们将内部类移到了外部类的方法中，然后在外部类的方法中再生成一个内部类对象去调用内部类方法

如果此时我们需要往外部类的方法中传入参数，那么外部类的方法形参必须使用final定义

至于final在这里并没有特殊含义，只是一种表示形式而已

时间： 2024-08-24 22:20:48

内部类总结的相关文章

修饰符-包-内部类-代码块执行顺序

1.访问权限修饰符     从大到小的顺序为:public--protected--default--private     private--只能在同一类中使用;     default--不用写出来,默认不加.可以被同一包中的类使用     protected--可以被不同包的子类使用     public--可以被不同包的其它类使用 2.各种修饰符的修饰对象(可修饰哪些:类/接口/方法/属性)(多个修饰符连用是可以没有顺序的!)     1)访问权限修饰符:public/default--

内部类实现接口

帮人解答题目,顺便提升思维. 原题目: 于是有了下面的代码: interface Interf{//1.定义接口 abstract public void print(); } public class tt { public static void main(String[] args) { fun(); //6.返回的接口引用,有一个print方法,可以调用fun().print(); } public static Interf fun(){//2.写一个函数 class inner im

包、修饰符、内部类、匿名内部类(java基础知识十)

1.package关键字的概述及作用 * A:为什么要有包     * 将字节码(.class)进行分类存放  * B:包的概述     *   * C:包的作用     * 包名要定义在第一行,     * 包名.*这个包下所有的类都可见     * 具体的类比较好,能提高效率 2.包的定义及注意事项 * A:定义包的格式 * package 包名; * 多级包用.分开即可* B:定义包的注意事项 * A:package语句必须是程序的第一条可执行的代码 * B:package语句在一个jav

Java内部类

本文是<Java核心技术 卷1>中第六章接口与内部类中关于内部类的阅读总结. Java中的内部类(inner class)是定义在另一个类内部的类.那么内部类有什么用呢?这里主要由三个内部类存在的原因: 内部类方法可以访问该类定义所在的作用域中的数据,包括私有的数据.即,如果类A中定义了类B,那么类B可以访问类A中的数据,甚至是私有数据,但类A不能访问类B中的私有数据: 内部类可以对同一个包中的其他类隐藏起来.在一个包中,定义一个类时,即使不加上访问权限关键词,这个类也是包内其他类可访问的,不

从头认识java-18.2 基本的线程机制（6）-使用构造器或者内部类来实现多线程的编码变体

这一章节我们来讨论一下使用构造器或者内部类来实现多线程的编码变体. 1.基础实现 package com.ray.ch17; public class Test { public static void main(String[] args) { Thread thread1 = new ExtendsThread(); thread1.start(); Thread thread2 = new Thread(new ImplRunnable()); thread2.start(); } } c

我的java学习笔记(18)关于内部类(part 3)

1.当使用内部类只是为了把一个类隐藏在另外一个类的内部,并不需要在内部类引用外部类对象时,可以将内部类为static,以便取消产生的引用. 2.只有内部类可以声明为static.静态内部类的对象除了没有对生成它的外部类对象的引用特权外,其他与所有内部类完全一样. 实例代码 测试类 public class test { public static void main(String[] args) { double[] d = new double[20]; for(int i = 0; i <

内部类与匿名类（转）

Java 中的内部类和匿名类* 为什么需要内部类? Java 内部类有什么好处?为什么需要内部类? 首先举一个简单的例子,如果你想实现一个接口,但是这个接口中的一个方法和你构想的这个类中的一个方法的名称,参数相同,你应该怎么办?这时候,你可以建一个内部类实现这个接口.由于内部类对外部类的所有内容都是可访问的,所以这样做可以完成所有你直接实现这个接口的功能. 不过你可能要质疑,更改一下方法的不就行了吗? 的确,以此作为设计内部类的理由,实在没有说服力.真正的原因是这样的,java 中的内部类和接口

java-多态、内部类

1.多态: 1)意义: 1.1)同一类型的引用,指向不同的对象时,有不同的实现-------行为的多态: cut(),run(),teach()... 1.2)同一个对象,被造型为不同的类型时,有不同的功能-------对象的多态: 我,你,水... 2)向上造型: 2.1)父类型的引用指向子类的对象 2.2)能造型成为的类型有: 父类+所实现的接口 2.3)能点出来什么,看引用的类型 3)强制类型转换,成功的条件只有如下两种: 3.1)引用所指向的对象,就是该类型 3.2)引用所指向的对象,实

【java基础】（6）内部类

内部类不是很好理解,但说白了其实也就是一个类中还包含着另外一个类 如同一个人是由大脑.肢体.器官等身体结果组成,而内部类相当于其中的某个器官之一,例如心脏:它也有自己的属性和行为(血液.跳动) 显然,此处不能单方面用属性或者方法表示一个心脏,而需要一个类 而心脏又在人体当中,正如同是内部类在外部内当中 实例1:内部类的基本结构 //外部类 class Out { private int age = 12; //内部类 class In { public void print() { System

内部类

一个类嵌套在另一个类中,称为内部类. 内部类可以使用外部所有的变量,方法(包括私有方法).是说内部类实例可以存取外部类实例的内容.