首页 > 代码库 > Java中内部类

Java中内部类

2024-07-08 06:24:23   233人阅读

内部类的规则：

1.内部类可以直接访问外部类中的成员，包括私有。

          之所以可以直接访问外部类中的成员，是因为内部类中持有一个外部类的引用，格式：外部类名.this

2.外部类要访问内部类，必须建立内部类对象

访问格式：

1.当内部类定义在外部类的成员位置了，而且非私有，可以在外部其他类中。

可以直接建立内部类对象。

格式：

         外部类类名.内部类名  变量名= new 外部类对象.new 内部类对象。

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

2.当内部类在成员位置上，就可以被成员修饰符所修饰，

比如private：将内部类在外部类中进行封装。

        static:内部类就具备了static的特性。

        当内部类被static 修饰后，只能访问外部类中的static成员。出现了访问局限。

      

在外部其它类中,如何访问static内部类的非静态成员：

       new Outer2.inner().funciton();


 在外部其它类中,如何访问static内部类的静态成员：

        Outer2.inner.funciton();

注意：当内部类中的定义了static成员,该内部类必须是静态的。

          当外部类中的静态方法访问内部类时，内部类也必须是静态的。


当描述事物时，事物的内部还有事物，该事物用内部类来描述

 因为内部事务在使用外部使用的内容。

class Body{

      private class XinZang //心脏不对外暴露

       {

       }

       public void show()

       {

             new XinZang();

       }

}

定义内部类主要为了访问外部类的数据



成员内部类代码：

package com.heima.io;

class Outer {
	private int i = 3;

	class inner {
		private int i = 4;
		// 内部类可以定义为私有,因为他是外部类的成员
		void funciton() {
			System.out.println(Outer.this.i);
		}
	}
}

public class InnerClassDemo {
	public static void main(String[] args) {
		// 直接访问内部类中的成员
		Outer.inner out = new Outer().new inner();
		out.funciton();
	}
}


静态内部内代码：

package com.heima.inner;

import com.heima.inner.Outer.inner;

class Outer2 {
	private static int i = 3;

	static class inner {

		// 在静态内部中，无法访问外部类非static数据
		static void funciton() {

			System.out.println("inner:" + " " + i);
		}
	}
}

public class InnerClassDemo2 {
	public static void main(String[] args) {
		Outer2.inner.funciton();
	}
}


局部内部类：

内部类定义在局部时，

1.不可以被成员修饰符修饰

2.可以直接访问外部类中的成员，因为还持有外部类中的引用。

      但是不可以访问访问它所在的局部中(方法中)的变量。只能访问被final修饰的局部变量。

package com.heima.inner;

/**
 * 局部内部类
 * 
 * @author zp
 * 
 */
class Outer3 {
	int i = 5;

	void method(final int a) {
		
		//final int i=3;//局部内部类中访问局部变量，需要被声明最终类型
		class Inner {
			int i=4;
			void funtion() {
				System.out.println(a);//4
			}
		}
		new Inner().funtion();

	}
}

public class InnerClassDemo3 {
	public static void main(String[] args) {
		 Outer3 out = new Outer3();
		 out.method(7);
		 out.method(8);
	}
}

匿名内部类：

1.匿名内部类其实就是内部类简写格式。

2.定义匿名内部类的前提：

           内部类必须继承一个类或者实现一个接口。

3.匿名内部类的格式： new 父类 或者 接口（）{定义子类的内容}.

4.其实匿名内部类就是一个匿名子类对象。而且有点胖。可以理解为带内容的对象，匿名对象对方法只能调用一次。

5.匿名内部类中定义的方法最好不要超过3个。


匿名内部类代码：

package com.heima.inner;

/**
 * 匿名内部类
 * 
 * @author
 * 
 */
abstract class AbsDemo {
	abstract void show();

}

class Outer4 {

	public void function() {

		final int a = 3;//匿名内部类中访问局部变量需要添加修饰符final
		new AbsDemo() {// 匿名实现类，AbsDemo的子类对象

			@Override
			void show() {
				System.out.println("show()" + a);
			}

			void abc() {
				System.out.println("abc()");
			}
		}.show();

	}
}

public class InnerClassDemo4 {
	public static void main(String[] args) {
		new Outer4().function();

	}
}



package com.heima.inner;

interface Inter {
	public void method();
}

class Test {
	public static Inter function() {
		return new Inter() {

			@Override
			public void method() {
				System.out.println("avcs");

			}
		};

	}
}

public class InnerClassDemo5 {
	public static void main(String[] args) {
		// Test.function():Test类中有一个静态的方法叫做function(),
		// function这个方法运算结果后返回的是一个对象

		Test.function().method();
		new Object() {//创建一个Object子类 如果Object obj =new Object(){};这样写是错的，因为Object没有show()；
			public void show() {
				System.out.println("abc");
			}
		}.show();
	}
}

          





联系
我们