内部类
- 成员内部类
- 静态成员内部类
- 非静态成员内部类
- 局部内部类
- 带名字的局部内部类
- 匿名内部类
概念:
一个类定义在另一个类的类体中,这个里面的类叫内部类,外面的类叫外部类
分类:
1、静态成员内部类:声明在外部类的类体,由static关键字修饰
特点:可以在内部类中声明静态成员,
可以不需要创建外部类对象,直接创建内部对象类,可以访问外部静态类的成员
不能访问外部类普通成员。
2、普通成员内部类:声明在外部类的类体中,没有static修饰
特点:只能在内部类类体中声明普通成员,需要先创建外部类对象,在由外部类对象创建内部类对象,可以访问外部类所有的成员。
3、局部内部类:声明在方法体中的内部类
特点:不能脱离声明内部类的方法使用
4、匿名内部类是局部内部类的特殊形式,匿名内部类通常作为类的子类或者接口的实现类。
静态成员内部类
/*
*静态内部类:
* 可以在静态内部类里声明:静态属性、静态方法、普通属性、普通方法
* 只能访问外部静态属性,静态方法
*
* 其他类使用时可以直接创建对象, 外部类.静态内部类 XXX = new 外部类.内部类();
*/
public class InStaticClass {
//外部普通属性
private String outOne;
//外部静态属性
private static String outTwo;
//外部普通方法
public void outMethodOne(){
System.out.println("外部普通方法");
}
//外部静态方法
public static void outMethodTwo(){
System.out.println("外部静态方法");
}
/************静态内部类*******************************************/
static class Inner{
//内部静态属性
private static String innerOne;
//内部普通属性
private String innerTwo;
//内部静态方法
public static void innerStaticMethod(){
//调用外部静态属性
outTwo = " ";
//outOne = ""; //不能调用外部普通属性
innerOne = "innerOne";
System.out.println("内部静态方法");
//内部静态方法可以调用静态方法
System.out.println("----------------内部类的静态方法调用外部静态方法");
outMethodTwo();
}
//内部普通方法
public void innerMethod(){
innerOne = "innerOne";
innerTwo = "innerTwo";
outTwo = " "; //内部普通方法调用外部静态属性
System.out.println("内部普通方法");
//内部普通方法可以调用静态方法
System.out.println("----------------内部类的 普通方法 调用外部静态方法");
outMethodTwo();
// outMethodOne(); //静态内部类不能调用外部普通方法
}
}
}
调用内部类时:
public class InStaticClassTest {
public static void main(String[] args) {
//匿名调用innerMethod方法
new InStaticClass.Inner().innerMethod();
//创建对象调用内部静态类的方法
InStaticClass.Inner inner = new InStaticClass.Inner();
inner.innerMethod();
}
}
普通成员内部类
*
*内部普通类
*
* 可以在内部普通类中声明普通属性、普通方法
* 可以访问外部静态属性、静态方法、普通属性、普通方法
*
* 调用时,必须先创建外部类的对象,
*
*方法一:
* 外部类.内部普通类 XXX = new外部类().new 内部普通类();
*
* 方法二:
* 外部类 XXX = new 外部类();
*
* 外部类.内部普通类 *** = new XXX.内部普通类();
*/
public class PuInnerClass {
//外部普通属性
private String outOne;
//外部静态属性
private static String outTwo;
//外部普通方法
public void outMethodOne(){
System.out.println("外部普通方法");
}
//外部静态方法
public static void outMethodTwo(){
System.out.println("外部静态方法");
}
//普通内部类
class Inner{
//不能定义内部静态属性
//private static String innerOne;
//内部普通属性
private String innerTwo;
//不能定义内部静态方法
// public static void innerStaticMethod(){
// innerOne = "innerOne";
// System.out.println("内部静态方法");
内部静态方法可以调用静态方法
// System.out.println("----------------内部类的静态方法调用外部静态方法");
// outMethodOne();
//
// }
//内部普通方法
public void innerMethod(){
System.out.println("内部普通方法");
//内部普通方法可以调用静态方法
System.out.println("----------------内部类的 普通方法 调用外部静态方法");
outMethodOne();
innerTwo = "innerTwo";
//内部普通类的方法可以调用外部普通方法,外部普通变量
outMethodOne();
outOne = "innerOne";
//普通内部类的方法调用外部静态方法,外部静态属性
outTwo = " ";
outMethodTwo();
}
}
}
调用时:
public class PuInnerClassTest {
public static void main(String[] args) {
//不可以直接调用,必须先创建外部类,才能调用内部类
// PuInnerClass.Inner = new PuInnerClassTest.Inner();
//方法一
PuInnerClass puInnerClass = new PuInnerClass();
PuInnerClass.Inner inner = puInnerClass.new Inner();
inner.innerMethod();
//方法二
PuInnerClass.Inner inner2 = new PuInnerClass().new Inner();
inner2.innerMethod();
}
}
带名字的局部内部类
/*
*局部内部类
*
* 可以在局部内部类中声明普通属性、普通方法
* 可以访问外部静态属性、静态方法、普通属性、普通方法
*
* 调用时只能在定义的方法中使用,(有作用域限制)
*
*/
public class NameInnerClass {
//外部普通属性
private String outOne;
//外部静态属性
private static String outTwo;
//外部普通方法
public void outMethodOne(){
System.out.println("外部普通方法");
}
//外部静态方法
public static void outMethodTwo(){
System.out.println("外部静态方法");
}
public void method(){
//method方法内的局部类,注意public、private、static、是修饰类的成员的,不能用作局部变量的修饰
class PartInner{
//局部类静态属性
//private static String innerOne;
//局部类普通属性
private String innerTwo = "innerwTwo";
// //局部类静态方法
// public static void innerStaticMethod(){
//
// //调用外部静态属性
// outTwo = " ";
// //outOne = ""; //不能调用外部普通属性
// System.out.println("内部静态方法");
内部静态方法可以调用静态方法
// System.out.println("----------------内部类的静态方法调用外部静态方法");
// outMethodTwo();
// }
//局部类普通方法
public void innerMethod(){
innerTwo = "innerTwo";
outTwo = " "; //局部类普通方法调用外部静态属性
outOne = " "; //局部类普通方法调用外部普通属性
System.out.println("内部普通方法");
//局部类普通方法可以调用静态方法
System.out.println("----------------内部类的 普通方法 调用外部静态方法");
outMethodTwo();
outMethodOne(); //静态内部类调用外部普通方法
}
}
PartInner partInner = new PartInner();
String a = partInner.innerTwo;
partInner.innerMethod();
new PartInner().innerMethod();
}
}
匿名局部类
//声明一个接口
public interface Teacher {
public void gaToClass();
}
//匿名内部类
public class NoNameInnerClass {
public static void main(String[] args) {
//创建对象匿名内部类
Teacher teacher = new Teacher() {
@Override
public void gaToClass() {
System.out.println("class is Begining");
}
};
method(teacher);
//匿名对象,匿名内部类
method(new Teacher() {
@Override
public void gaToClass() {
System.out.println("class is Beging-----byAnonymity");
}
});
}
public static void method(Teacher teacher){
teacher.gaToClass();
}
}