可以在一个类的内部定义另一个类, 这种类称为嵌套类(nested classes),它有两种类型:
静态嵌套类和非静态嵌套类.静态嵌套类使用很少, 最重要的是非静态嵌套类, 也即是被称作为
内部类(inner).嵌套类从JDK1.1开始引入.其中inner类又可分为三种:
(1) 在一个类(外部类)中直接定义的内部类;
(2) 在一个方法(外部类的方法)中定义的内部类;
(3) 匿名内部类.
一、什么是静态嵌套类?
直接在外部类里面定义的静态类
public class StaticTest
{
private static String name = "gugu";
private String num = "001";
static class Person //静态嵌套类
{
private String address = "China";
public String mail = "xxxxxx.com";//内部类公有成员
public void display()
{
//System.out.println(num);//不能直接访问外部类的非静态成员
System.out.println(name);//只能直接访问外部类的静态成员
System.out.println("Inner " + address);//访问本内部类成员。
}
}
public void printInfo()
{
Person person = new Person();
person.display();
//System.out.println(mail);//不可访问
//System.out.println(address);//不可访问
System.out.println(person.address);//可以访问内部类的私有成员
System.out.println(person.mail);//可以访问内部类的公有成员
}
public static void main(String[] args)
{
StaticTest staticTest = new StaticTest();
staticTest.printInfo();
}
}
1.在静态嵌套类内部, 不能访问外部类的非静态成员, 这是由Java语法中"静态方法不能直接访问非静态成员"所限定.若想访问外部类的变量, 必须通过其它方法解决, 由于这个原因, 静态嵌套类使用很少.
2.外部类访问内部类的的成员有些特别, 不能直接访问, 但可以通过内部类实例来访问, 这是因为静态嵌套内的所有成员和方法默认为静态的了.同时注意, 内部静态类Person只在类StaticTest 范围内可见, 若在其它类中引用或初始化, 均是错误的.
二、什么是内部类?
内部类分为①定义在外部类的内部类②定义在方法里面的内部类③匿名内部类
特点:内部类可以直接访问外部类的成员,包括私有。
外部类要访问内部类的成员,必须创建对象
1.内部类生成外部的引用 外部类名.this
2.局部内部类只能在其所在的方法内访问
3.成员内部类私有 paivate, 其他类调用不能直接创建对象(类似私有成员变量),在外部类写一个方法,访问,类似于setXX,getXX访问私有成员,且只在外部类的范围内可见
(一)定义在外部类的内部类
class Outer {
public String outer__public_name = "外部类public";
private String outer_private_name = "外部类private";
public int a =100;
private class InnerOne // 私有的内部类 起
{
public String innerone_public_name = "内部类1public";
private String innerone_private_name = "内部类1private";
public void display() {
System.out.println(" Outer_outer__public_name:" + outer__public_name);
System.out.println(Outer.this.a);
}
private void display2() {
System.out.println(" Outer_outer_private_name:" + outer_private_name);
}
}// 私有的内部类 止
public InnerOne getInnerOne() {
// 即使是对外公开的方法,外部类也无法调用
return new InnerOne();
}
class InnerTwo //内部类 起
{
InnerOne innerx = getInnerOne();// 可以访问
public void show() {
//System.out.println(innerone_public_name); // 不可访问Innter的y成员
//System.out.println(innerone_private_name); // 不可直接访问Inner的任何成员和方法
innerx.display();// 可以访问
innerx.display2();// 可以访问
System.out.println(innerx.innerone_public_name);// 可以访问
System.out.println(innerx.innerone_private_name);// 可以访问
}
}//内部类 止
void test() {
InnerOne inner = new InnerOne();// 可以访问
inner.display();
inner.display2();
// System.out.println("Inner y:" + inner_y); // 不能访问内部内变量
System.out.println("Inner y:" + inner.innerone_public_name);// 可以访问
System.out.println("Inner z:" + inner.innerone_private_name);// 可以访问
InnerTwo innerTwo = new InnerTwo();
innerTwo.show();
}
}
public class test {
public static void main(String args[]) {
Outer outer = new Outer();
// Outer.InnerOne a=outer.getInnerOne();
// InnerOne类是私有的,外部类不能访问, 如果InnerOne类是public ,则可以.
outer.test();
}
}
内部类InnerOne及InnterTwo只在类Outer的作用域内是可知的, 如果类Outer外的任何代码尝试初始化类Inner或使用它, 编译就不会通过.同时, 内部类的变量成员只在内部内内部可见, 若外部类或同层次的内部类需要访问, 需采用示例程序
中的方法, 不可直接访问内部类的变量.
(二)方法中定义的内部类
package com.guxilong;
public class test {
int out_x = 100;
public void test() {//方法内部的内部类
class Inner {
String inner_x = "x";
void display() {
System.out.println(out_x);
}
}
Inner inner = new Inner();
inner.display();
}
public void showStr(String str) {
// public String str1 = "test Inner";
// 不可定义, 只允许final修饰
// static String str4 = "static Str";
// 不可定义, 只允许final修饰
String str2 = "test Inner";
final String str3 = "final Str";
class InnerTwo {
public void testPrint() {
System.out.println(out_x);
// 可直接访问外部类的变量
// System.out.println(str2); // 不可访问本方法内部的非final变量
System.out.println(str3); // 只可访问本方法的final型变量成员
}
}
InnerTwo innerTwo = new InnerTwo();
innerTwo.testPrint();
}
public void use() {
// Inner innerObj = new Inner();//此时Inner己不可见了
// System.out.println(Inner.x);//此时Inner己不可见了
}
public static void main(String[] args) {
test outer = new test();
outer.test();
}
}
从上面的例程我们可以看出定义在方法内部的内部类的可见性更小, 它只在方法内部
可见, 在外部类(及外部类的其它方法中)中都不可见了.同时, 它有一个特点, 就是方法内的内部类连本方法的成员变量都不可访问, 它只能访问本方法的final型成员.同时另一个需引起注意的是方法内部定义成员, 只允许final修饰或不加修饰符, 其它像static等均不可用.
(三)匿名内部类
本质:是一个继承了该类或者实现了该接口的子类匿名对象
new Inter() {
Public void print(){
Sysotem.out.println.(“print”);
}
}.print();
PS:匿名内部类只针对重写一个方法时使用
多个方法的话可以用多态来解决。
内部类调用外部定义的对象,那么其参数引用是final类型的
参考:https://blog.youkuaiyun.com/machinecat0898/article/details/80071242