JAVA编程思想之内部类

文章目录

1. 1. 一、彻底学习JAVA基础非编程思想莫属。越看越觉得自己基础薄弱，很多用法都没有见过。学而时习之，学而时总结之。
2. 2. 二、内部类语法总结
   1. 2.1. 1、定义：将一个类的定义放在另一个类内部
   2. 2.2. 2、静态内部类：嵌套类

一、彻底学习JAVA基础非编程思想莫属。越看越觉得自己基础薄弱，很多用法都没有见过。学而时习之，学而时总结之。

二、内部类语法总结

1、定义：将一个类的定义放在另一个类内部

/** * 访问非静态内部类的方法 * 访问外部类的属性 * @author 杜伟 */
 * 访问非静态内部类的方法
 * 访问外部类的属性
 * @author 杜伟
 */
public class OutterClass {
	private String name = "duwei";		//私有变量
	public String sex = "man";			//公有变量
	private static int age = 15;		//静态变量
	
	interface IPrintString{
		String print();
	}

	public String sayOutter()  {		//1、这是局部内部类
		class PrintString implements IPrintString{
			@Override
			public String print() {
				return "Outter";
			}
		}
		return new PrintString().print();
	}
	
	public String sayOutter2(){
		return new IPrintString() {		//2、这是匿名内部类
			@Override
			public String print() {
				return "Outter2";
			}
		}.print();
	}

	class InnerClass {
		//private static String name = "123";	//不可以有静态变量
		public void sayInner() {			//访问外部类的私有，共有，静态属性
			System.out.println("inner：name="+name+",sex="+sex+",age = "+age);
			System.out.println(OutterClass.this.sayOutter()+";匿名内部类："
			+OutterClass.this.sayOutter2());//访问外部类的方法
		}
	}

	public static void main(String[] args) {
		OutterClass outter = new OutterClass();
		InnerClass inner = outter.new InnerClass();//内部类对象的初始化方式
		inner.sayInner();
	}
}

• 1、内部类自动拥有对外围类的所有成员的访问权。
• 2、上述1处演示了局部内部类
• 3、上述2处演示了匿名内部类
• 4、当方法的参数在匿名内部类使用时要用final关键字修饰参数
• 5、匿名内部类既可以扩展类也可以实现接口，但二者不可兼得，如果实现接口也只能实现一个

2、静态内部类：嵌套类

/** * 静态内部类 * @author 杜伟 */
 * 静态内部类
 * @author 杜伟
 */
public class StaticInnerClassTest {
	private String name = "StaticInnerClassTest";
	private static String name2 = "StaticInnerClassTest2";
	
	interface InnerClassInterface{	//接口里面定义类
		void print();
		class TestInnerClassInterface implements InnerClassInterface{//接口里面的类可以实现该接口
			@Override
			public void print() {
				System.out.println("InnerClassInterface");
			}
		}
	}
	
	static class InnerClass{
		private static String name = "innerclass";
		public void say(){
			System.out.println("inner="+name);
			//System.out.println(StaticInnerClassTest.this.name);//内部类先加载了，外部类不可达
		}
	}

	public static void main(String[] args) {
		InnerClass inner = new InnerClass();
		inner.say();
		System.out.println(inner.name);
		new StaticInnerClassTest.InnerClassInterface.TestInnerClassInterface().print();
	}

}

• 普通的内部类对象隐式的保存了一个引用，指向创建它的外围类对象，然而static内部类不是这样：
  • 要创建嵌套类的对象，并不需要其外围类的对象
  • 不能从嵌套类的对象中访问非静态的外围类对象