内部类

时间: 2020-09-18｜50次围观｜0 条评论

内部类Nested Class 

静态内部类

非静态内部类

普通内部类

匿名内部类

方法内部类


package com.lgd.nested;

/**
 * 内部类
 * @author liguodong
 *
 */
public class NestedClass {
    public static void main(String[] args) {       
    }
        
    /**
     * 静态内部类
     * @author liguodong
     *
     */
    private static class StaticNestedClass{              
    }
    //普通内部类(成员内部类)
    private class FieldInnerClass{               
    }
    
    void sayHello()
    {
        //方法内部类(局部内部类)
        class LocalClass{            
        }
    }
    
    //匿名内部类
    //并不是new 接口
    //两个作用：定义了匿名内部类的类;创建了匿名内部类的一个实例。
    Runnable runnable = new Runnable() {
        
        @Override
        public void run() {
            // TODO Auto-generated method stub           
        }
    };
}

内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的class文件，但是前面冠以外部类的类名和$符号。

内部类可以使用修饰符（public,protected,default,private）

一 静态内部类

静态内部类可以包含静态成员和非静态成员。

静态内部类可以直接调用外部类的静态属性和方法。但不能调用外部类的普通属性和普通方法。

在不相关类中，可以直接创建静态内部类的对象

静态内部类时间上和外部类联系很少，也就是命名空间上的联系。

package com.lgd.nested;

import com.lgd.nested.Outer.StaticInnerClass;

public class NestDemo {
	public static void main(String[] args) {
		Outer.StaticInnerClass osic = new Outer.StaticInnerClass();//推荐
		StaticInnerClass sic = new StaticInnerClass();//import com.lgd.nested.Outer.StaticInnerClass;
	}		
}

class Outer
{
	int c = 5;
	static int d = 10;
	
	void createstaticinner()
	{
		StaticInnerClass sic = new StaticInnerClass();
		
	}
	
	//静态内部类
	static class StaticInnerClass{
		int a= 3;
		static int b = 5;
		public void test()
		{
			System.out.println(d);
			//静态内部类中不能调用外部类的普通成员。只能调用静态成员。
			//System.out.println(c);
		}		
	}
}

二  非静态内部类

1、普通内部类（成员内部类）

--成员内部类就像一个成员变量一样存在于外部类中

--成员内部类可以访问外部类的所有成员（包括private）

--成员内部类的this指内部类对象本身。要拿到外部类对象可以使用 [  外部类名+ .this  ]

      成员内部类的对象是一定要绑定到一个外部类的对象上的。因此，创建成员内部类对象时需要持有外部类对象的引用。因此，要先有外部类对象，后有成员内部类对象。

--成员内部类不能有静态成员。

成员内部类对象的创建方式：

外部类内部

   Inner inner = new Inner();

外部类外部

   Inner inner = new Outer().new Inner();

package com.lgd.nested;

import com.lgd.nested.Outer02.InnerClass;

public class NestDemo02 {
	public static void main(String[] args) {
		//InnerClass ic = new InnerClass();//不能这样
		//外部类外部
		Outer02 out = new Outer02();
		InnerClass ic = out.new InnerClass();
		ic.test();
	}
}

class Outer02
{
	private int a = 3;
	int b = 10;
	//外部类内部
	public void test()
	{
		InnerClass ic = new InnerClass();
	}
	
	//成员内部类
	class InnerClass
	{
                int c=1;
                //static int d=80;//成员内部类不能有静态成员,除非声明为final,并且编译器可以确定值的常量表达式
                final static int d=80; 
                //final static Date d2 = new Date();
                void test()
		{
			 System.out.println(a);
			 System.out.println("内部类对象"+this);//成员内部类对象的创建。必须先有外部类对象！
			 System.out.println("外部类对象"+Outer02.this);
		}
	}
}


内部类插图

2、方法内部类（局部内部类）

--方法内部类的地位和方法内的局部变量的位置类似。

因此不能修饰局部变量的修饰符也不能修饰局部内部类，譬如public private protected  static transient 等

--方法内部类只能在声明的方法内是可见的。

因此定义局部内部类之后，想用的话就要在此方法内直接实例化，记住这里必须先声明后使用，否则编译器会报找不到。

--方法内部类不能引用所在方法内的普通局部变量，除非这个变量被定义为final。

本质原因：局部变量和方法内部类生命周期不一致所致！

--方法内部类中只能包含非静态成员。

package com.lgd.nested;

/**
 * 方法内部类
 * @author liguodong
 *
 */
public class NestDemo03 {
	public static void main(String[] args) {
		
	}
}

class Outer03
{
	public void test()
	{
		int a=3;
		class Inner
		{
			int b = 10;
			//static int c = 20;//在方法内部类中只能定义非静态成员
			
			void test()
			{
				System.out.println(b);
				//方法内部类不能引用所在方法内的普通局部变量，除非这个变量被定义为final。
				//方法的生命周期和方法类的生命周期不一致。方法执行外，内部类对象可能仍然存在。
				//System.out.println(a);
			}
		}
		Inner i = new Inner();//一般情况下仅限本方法使用		
	}
	
	void test2()
	{		
	}
}


3、匿名内部类（适合于仅限于使用一次的时候使用）

根据声明的位置，判断匿名内部类是成员内部类还是方法内部类。

注：一般是方法内部类，这就要具备方法内部类的特性。

三种使用方式：

继承式

接口式

参数式

package com.lgd.nested;

public class NestDemo04 {
	public static void main(String[] args) {
		Outer04   out = new Outer04();
		out.test();
	}
	 
}

class Outer04
{
	//参数式
	public void test02(Car c)
	{
		c.run();
	}
	public void test()
	{
		//匿名内部类(接口式)，由于本内部类定义在方法中，同时也是方法内部类
		Runnable runnable = new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				
			}
		};
		//匿名内部类，继承式
		Car car = new Car()
		{
			@Override		
			public void run() {
				System.out.println("子类的车跑！");
			}		
		};
		car.run();
                //参数式
                test02(new Car(){
			@Override
			public void run()
			{
				System.out.println("参数式匿名内部类，车载跑");
			}
		});
	}
}

class Car
{
	public void run()
	{
		System.out.println();
	}
}

原文链接：https://blog.csdn.net/scgaliguodong123_/article/details/42084989

本站声明:网站内容来源于网络,如有侵权,请联系我们,我们将及时处理。

本博客所有文章如无特别注明均为原创。
复制或转载请以超链接形式注明转自起风了，原文地址《内部类》
　 　

还没有人抢沙发呢~