java方法内部类,java内部类写法

　　00-1010 1.内部类别2的概念和分类。实例内部类2.1创建实例内部类2.2使用。这个还有。new2.3内部类2.4内部类的继承3。静态内部类4。匿名内部类

　　00-1010在另一个类、接口或方法体中定义了一个类。这个类称为内部类。我们不妨称内部类所在的类为外围类。除了在类、接口、方法中定义的内部类之外，还有一种特殊的内部类，即使用关键字new创建匿名类对象。这个匿名类实际上是一个内部类，确切地说是一个匿名内部类。时常

　　当一个类被定义在另一个类或接口中，并且没有静态修饰时，这个内部类被称为实例内部类。当使用静态装饰时，这个内部类称为静态内部类(嵌套类)。类是在代码块中定义的，尤其是在方法体中。这个内部类叫做局部内部类或者局部内部类，另一个就是上面提到的匿名内部类。

　　00-1010实例内部类的定义很简单，直接在外围类内部定义就可以了。问题是如何创建一个内部类对象。首先要明白内部类和外围类中的成员变量和方法是相等的，都属于外围类对象(没有静态修改)。所以，想要一个内部类对象，首先要有一个外围类对象。创建内部类对象的第一种方法是使用方法返回内部类对象，这个内部类对象的类型是OutClassName。InnerClassName，即外围类名和内部类名。

　　公共类Outer { class inner 1 { private String str；public inner 1(String s){ this . str=s；} public String readStr(){ return this . str；} } class Inner2 { private int valpublic inner 2(int I){ this . val=I；} public int read val(){ return this . val；} }//创建内部类public inner 1 creation er 1(strings){ return new inner 1(s)；} public inner 2 creation inner 2(int I){ return new inner 2(I)；}公共静态void main(String[]args){ Outer Outer=new Outer()；外部。inner 1 inner 1=outer . creation inner 1( inner 1 )；外部。inner 2 inner 2=outer . creation inner 2(2)；system . out . println(inner 1 . readstr())；system . out . println(inner 2 . read val())；} }//output : inner 12进程结束，退出代码为0

1.内部类概念及分类

当然还有其他创建内部类的方法，就是使用对象创建内部类对象。新的外围类。语法是：

　　外部类对象。新的内部类构造方法；

　　blic static void main(String[] args) { Outer outer = new Outer(); Outer.Inner1 inner1 = outer.new Inner1("Inner1"); Outer.Inner2 inner2 = outer.new Inner2(2); System.out.println(inner1.readStr()); System.out.println(inner2.readVal()); }}

//output:Inner12Process finished with exit code 0

内部类的特性不止如此，内部类还能与外围类链接，首先实例内部类对象的创建是依赖外围类对象的引用，实例内部类与外围类的成员变量地位一样，如果想要通过内部类对象访问外围类的成员变量与方法（特别是同名变量）。在内部类中，可以使用外围类名.this获取外围类对象，然后使用获得的这个外围类对象来使用外围类的变量与方法。

public class Outer { private String outStr; public Outer(String str) { this.outStr = str; } public void printOuter() { System.out.println(this.outStr); } class Inner { private String str; public Inner(String s) { this.str = s; } public String readStr() { return this.str; } //使用.this获取父类对象引用 public Outer outer() { return Outer.this; } } public static void main(String[] args) { Outer outer = new Outer("outerString"); Outer.Inner inner = outer.new Inner("innerString"); Outer out = inner.outer(); out.printOuter(); }}

//output:outerStringProcess finished with exit code 0

其实内部类对象中有两个this，直接使用this.成员获取的是内部类对象自己的成员，而像上面使用外围类名.this.成员获取的是外围类的成员，也就是说在内部类中this指向内部类对象自己的引用，外部类名.this指向外围类对象的引用。

　　当出现内部类与外围类变量名相同时，这两个this就有很大的用处了。

public class Outer { public int a = 12; public int b = 16; public int c = 20; class Inner{ public int a = 8; public int c = 48; public int d = 2; public void printVal() { System.out.println("外围类变量a=" + Outer.this.a); System.out.println("外围类变量b=" + Outer.this.b); System.out.println("外围类变量c=" + Outer.this.c); System.out.println("内部类变量a=" + this.a); System.out.println("内部类变量c=" + this.c); System.out.println("内部类变量d=" + this.d); } } public Inner creatInner() { return new Inner(); } public static void main(String[] args) { Outer outer = new Outer(); Outer.Inner inner = outer.creatInner(); inner.printVal(); }}

//output:外围类变量a=12外围类变量b=16外围类变量c=20内部类变量a=8内部类变量c=48内部类变量d=2Process finished with exit code 0

如果没有出现同名，直接获取的成员即可，可以不用使用上面所说的this，出现同名，直接访问的成员默认是内部类对象的。

2.3内部类实现迭代打印

内部类可以与外围类的所有元素的访问权限，所以我们可以尝试使用内部类来遍历输出外围类中的元素，虽然内部类与外围类的成员地位是平等，但内部类毕竟也是类，它也可以像外围类一样继承类和实现接口。

import java.util.Arrays;interface Selector{ //判断是否迭代完全部元素 public boolean end(); //获取当前元素 public Object current(); //迭代下一个元素 public void next();}public class SequeArray { private Object[] items; private int usedSize; public SequeArray(int capacity) { items = new Object[capacity]; } public void add(Object val) { if (usedSize == items.length) items = Arrays.copyOf(items, 2 * usedSize); items[usedSize++] = val; } private class SequeSelector implements Selector{ private int index; public boolean end() { return index == usedSize; } public Object current() { return items[index]; } public void next() { if (index < usedSize) index++; } } public SequeSelector sequeSelector() { return new SequeSelector(); } public static void main(String[] args) { SequeArray array = new SequeArray(10); for (int i = 0; i < 10; i++) { array.add(i+1); } //发生了向上转型 Selector selector = array.sequeSelector(); while (!selector.end()) { System.out.print(selector.current() + " "); selector.next(); } }}

//output:1 2 3 4 5 6 7 8 9 10 Process finished with exit code 0

2.4内部类的继承

内部类的继承有一点麻烦，因为内部类的构造器必须依赖外围类的引用，所以需要一段特殊的语法来说明内部类与外围类的关联：

外围类引用.super();

　　

具体怎么使用看如下一段代码：

public class Outer { class Inner{ }}class Person extends Outer.Inner { private String str; private int id; public Person(Outer out, String str, int id) { out.super(); this.str = str; this.id = id; } public void readVal() { System.out.println(this.str + this.id); }}

当内部类被继承的时候，需要通过外围类的引用传入父类的构造方法中并调用super()才能通过编译。

　　如果内部类继承外部类，直接继承即可，不需要这么麻烦。

　　程序生成一个java文件的字节码文件时，命名为公共外部类$内部类。

　　内部类可以无限嵌套，一般没人这么干。

3.静态内部类

静态内部类也称嵌套类，它就是在实例内部类的定义前加入一个static关键字，像下面这样：

public class Outer { static class Inner{ }}

与实例内部类的区别是静态内部类是属于类的而不是属于对象的，因此静态内部类的创建不依赖与外部类对象，这是和实例内部类最大的区别之一。

public class Outer { static class Inner{ private String str; public Inner(String s) { str = s; } } public static void main(String[] args) { Outer.Inner inner = new Outer.Inner("我是静态内部类！"); System.out.println(inner.str); }}

//output:我是静态内部类！Process finished with exit code 0

4.匿名内部类

匿名内部类的用法我们已经见过了，就是创建PriorityQueue对象时，默认创建的是小堆，需要传入比较器来创建大堆。

 PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { return o1 - o2; } });

像上面这种在方法中使用new关键字创建一个匿名类的对象作为实参，里面这个匿名类就是匿名内部类，创建过程中的Comparator匿名类对象是继承所需传参类型的，在这里也就是Comparator类。

　　如果使用自定义类型传入优先队列，是一定要实现比较器的，实现比较器最常见的方式就是匿名内部类与Lambda表达式。

　　假设我有一个Person类数组，需要对他们的name排序，如果不使用内部类，就需要在Person类中实现比较器。

import java.util.Arrays;import java.util.Comparator;class Preson { public String name; public Integer id; public Preson(String name, Integer id) { this.name = name; this.id = id; } @Override public String toString() { return "Preson{" + "name=" + name +  + ", id=" + id + }; }}class PersonComparator implements Comparator<Preson> { @Override public int compare(Preson o1, Preson o2) { return o1.name.compareTo(o2.name); }}public class Main { public static void main(String[] args) { Preson preson1 = new Preson("aboluo", 24); Preson preson2 = new Preson("zhousi", 25); Preson preson3 = new Preson("syyfjy", 2); Preson[] presons = {preson1, preson2, preson3}; Arrays.parallelSort(presons, new PersonComparator()); System.out.println(Arrays.toString(presons)); }}

//output:[Preson{name=aboluo, id=24}, Preson{name=syyfjy, id=2}, Preson{name=zhousi, id=25}]Process finished with exit code 0

使用内部类上述代码就变为：

import java.util.Arrays;import java.util.Comparator;class Preson { public String name; public Integer id; public Preson(String name, Integer id) { this.name = name; this.id = id; } @Override public String toString() { return "Preson{" + "name=" + name +  + ", id=" + id + }; }}public class Main { public static void main(String[] args) { Preson preson1 = new Preson("aboluo", 24); Preson preson2 = new Preson("zhousi", 25); Preson preson3 = new Preson("syyfjy", 2); Preson[] presons = {preson1, preson2, preson3}; Arrays.parallelSort(presons, new Comparator<Preson>() { @Override public int compare(Preson o1, Preson o2) { return o1.name.compareTo(o2.name); } }); System.out.println(Arrays.toString(presons)); }}

//output:[Preson{name=aboluo, id=24}, Preson{name=syyfjy, id=2}, Preson{name=zhousi, id=25}]Process finished with exit code 0

还有一个本地内部类，就是类定义在方法中，就不多说了，基本上不用，用法如下：

public class Outer { public void func() { class Inner{ // } }}

以上就是Java基本语法之内部类示例详解的详细内容，更多关于Java内部类的资料请关注盛行IT其它相关文章！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。