成员内部类
1.成员内部类简介
package cn.com.inner;
/**
* 成员内部类<br>
* 使用方式:OuterClass.InnerClass
* @author wutz
*
*/
public class OuterClass { //外部类
InnerClass inner = new InnerClass();
private class InnerClass{ //内部类
int y = 0; //内部类成员变量
InnerClass(){ //内部类构造函数
}
public void innerFunction(){ //内部类成员函数
System.out.println("调用内部类的方法");
}
}
public InnerClass getInsatnceOfInnerClass(){ //外部类操作内部类的属性
//y = 4;
inner.y = 100;
inner.innerFunction();
return inner;
}
public static void main(String[] args) {
OuterClass outer = new OuterClass();
OuterClass.InnerClass inner1 = outer.getInsatnceOfInnerClass();
System.out.println(inner1.y);
System.out.println("********************");
OuterClass.InnerClass inner2 = outer.new InnerClass();
System.out.println(inner2.y);
inner2.innerFunction();
}
}
console:
调用内部类的方法
100
********************
0
调用内部类的方法
2.使用this关键字获取内部类与外部类的引用
package cn.com.inner;
/**
* 通过this获取外部类内部类的引用
* @author wutz
*
*/
public class TheSameName {
private int x;
private class Inner{
private int x = 9;
public void doit(int x){
x++; //调用的是形参x
System.out.println(x);
this.x++; //调用的是内部类x
System.out.println(this.x);
TheSameName.this.x++; //调用的是外部类x
System.out.println(TheSameName.this.x);
}
}
public static void main(String[] args) {
TheSameName outClass = new TheSameName();
TheSameName.Inner inner = outClass.new Inner();
inner.doit(100);
}
}
console:
101
10
1
局部内部类
局部内部类是指在类的方法中定义内部类,它的作用范围也是在这个方法体内
package cn.com.inner;
/**
* 局部内部类<br>
* 定义在方法内的类,作用方法仅限该方法
* @author wutz
*
*/
public class SellOutClass {
private String name;
public SellOutClass(){
name = "苹果";
}
public void sell(){
class Apple{
int innerPrice = 0;
public Apple(int price){
innerPrice = price;
}
public void price(){
System.out.println("现在开始销售:"+name);
System.out.println("价格:"+innerPrice);
}
}
Apple apple = new Apple(100);
apple.price();
}
public static void main(String[] args) {
SellOutClass outClass = new SellOutClass();
outClass.sell();
}
}
console:
现在开始销售:苹果
价格:100
匿名内部类
在编写程序代码时,不一定要给内部类取一个名字,可以直接以对象名来代替。匿名内部类的所有实现代码都需要在大括号之间进行编写。
package cn.com.inner;
/**
* 服务于匿名内部类
* @author wutz
*
*/
public interface OuterString {
public String filterBlankChar();
}
package cn.com.inner;
/**
* 匿名内部类
* @author wutz
*
*/
public class OutString{
public static void main(String[] args) {
final String sourceStr = "h e l l o w o r d";
OuterString outString = new OuterString() {
@Override
public String filterBlankChar() {
return sourceStr.replaceAll(" ","");
}
};
System.out.println("源字符串:" + sourceStr);
System.out.println("转换后的字符串:" +outString.filterBlankChar());
}
}
console:
源字符串:h e l l o w o r d
转换后的字符串:helloword
静态内部类
在内部类前添加修饰符static,这个内部类就变成静态内部类。一个静态内部类中可以声明static成员,但是在非静态内部类中不可以声明静态成员。静态内部类有一个最大的特点,就是不可以使用外部类的非静态成员。所以静态内部类在程序开发中比较少见。
静态内部类具有以下两个特点:
1.创建静态内部类的对象,不需要先创建外部类对象。
2.不能从静态内部类的对象中访问非静态外部类的对象。
package cn.com.inner;
/**
* 静态内部类1
* @author wutz
*
*/
public class StaticInnerClass {
private static int x = 0;
static class InnerClass{
static void doInner() {
System.out.println(x);
}
}
public static void main(String[] args) {
StaticInnerClass.InnerClass b = new StaticInnerClass.InnerClass();
b.doInner();
}
}
package cn.com.inner;
/**
* 静态内部类2
* @author wutz
*
*/
public class StaticInnerClass {
private static int x = 0;
static class InnerClass{
static void doInner() {
System.out.println(x);
}
public static void main(String[] args) {
doInner();
}
}
}
内部类的继承
package cn.com.inner;
public class Outer {
class Inner{
}
}
package cn.com.inner;
public class InnerExtend extends Outer.Inner{
public InnerExtend(Outer outer) {
outer.super();
}
}