欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

java内部类用法小结

程序员文章站 2022-04-15 11:22:18
...
定义:
顾名思义,创建于外部类之内的类。可以定义于外部类的方法内。
下面用I类表内部类,O类表外部类。(I:inner,O:outer)


用途:
1.private修饰的内部类用来隐藏实现的细节
2.匿名类使方法实现更简洁、优美(例:工厂方法,适配器方法)
3.可用于有效的实现“多重继承”
4.水平有限暂不明。


特性:(可类比O类方法)
1.可以使用O类所有成员(包括private)
2.可以被static、private修饰(O类不可以)
3.可以匿名,但必须进行继承
4.可实例化,如果被static修饰:new O.I();否则:new O().new I()  (O类引用.new I())
5.不可在O类的导出类中被覆盖 (这点不像O类方法)
6.可被继承,但其指向O类的“秘密的”引用必须被初始化


用途示例1:
class Outer {
	private class Inner {
		void innerMethod(String s) {
			System.out.println(s);
		}
	}
	private Inner inner = new Inner();
	public void outerMethod(String s) {
		inner.innerMethod(s);
	}
}
public class Test1 {
	public static void main(String[] args) {
		new Outer().outerMethod("InnerMethod print the string");
	}
}

用途示例2:
//工厂模式示例
interface Product {
	String getName();
}
interface ProductFactory {
	Product getProduct();
}
class CandyFactory implements ProductFactory {
	public Product getProduct() {
		return new Product() {
			public String getName() {
				return "Candy";
			}
		};
	}
}
class JellyFactory implements ProductFactory {
	public Product getProduct() {
		return new Product() {
			public String getName() {
				return "Jelly";
			}
		};
	}
}
public class Test1 {
	static void production(ProductFactory factory) {
		Product p = factory.getProduct();
		String name = p.getName();
		System.out.println(name);
	}
	public static void main(String[] args) {
		production(new CandyFactory());
		production(new JellyFactory());
	}
}

用途示例3:
interface Interface1 { void methodI1(); }
interface Interface2 { void methodI2(); }
class Class1 { void methodC1() {} }
class Class2 { void methodC2() {} }

public class Test1 {
	private class RealInterface implements Interface1,Interface2 {
		public void methodI1() { System.out.println("Implements Interface1"); }
		public void methodI2() { System.out.println("Implements Interface2"); }
	}
	private class RealClass1 extends Class1 {
		@Override
		void methodC1() { System.out.println("Implements Class1"); }
	}
	private class RealClass2 extends Class2 {
		@Override
		void methodC2() { System.out.println("Implements Class2"); }
	}
	private RealInterface i = new RealInterface();
	private RealClass1 c1 = new RealClass1();
	private RealClass2 c2 = new RealClass2();
	public void methodI1() { i.methodI1(); }
	public void methodI2() { i.methodI2(); }
	void methodC1() { c1.methodC1(); }
	void methodC2() { c2.methodC2(); }
	public static void main(String[] args) {
		Test1 t = new Test1();
		t.methodI1();
		t.methodI2();
		t.methodC1();
		t.methodC2();
	}
}

特性示例:
/*
1.可以使用O类所有成员(包括private) 
2.可以被static、private修饰(O类不可以) 
3.可以匿名,但必须进行继承 
4.可实例化,如果被static修饰:new O.I();否则:new O().new I()  (O类引用.new I()) 
5.不可在O类的导出类中被覆盖 (这点不像O类方法)
6.可被继承,但其指向O类的“秘密的”引用必须被初始化
 */
interface Anonymity {}
class Outer {
	Outer() { 
		System.out.println("Outer()");
		new Inner1();
	}
	private String s = "Outer string s";
	public class Inner1 {
		Inner1() { 
			System.out.println("Inner1()");
		}
		private String s = "Inner string s";
		void print() {
			System.out.println(s);
			//特性1
			System.out.println(Outer.this.s);
		}
	}
	//特性2
	private static class Inner2 {}
	public static class StaticInner {
		StaticInner() { 
			System.out.println("StaticInner()");
		}
	}
	public Anonymity getAnonumityClass() {
		//特性3
		return new Anonymity() {
			{
				System.out.println("AnonymityClass()");
			}
		};
	}
}
class ExtendsOuter extends Outer{
	//特性5
	ExtendsOuter() {
/*	==    super();
	==    System.out.println("Outer()");
     +      new Inner1();
*/	}
	public class Inner1 {
		Inner1() { 
			System.out.println("ExtendsOuter.Inner1()");
		}
	}
	//特性6特例
	//因为ExtendsOuter已经继承了Outer
	//从而指向外围类(Outer)的“秘密的”的引用已经通过继承关系(ExtendsOuter extends Outer)进行了初始化
	//所以不必再进行“特殊处理”
	public class ExtendsInner1 extends Outer.Inner1 {
		ExtendsInner1() { 
			System.out.println("ExtendsOuter.ExtendsInner1()");
		}
	}
}
public class Test1 {
	//特性6
	public class ExtendsInner2 extends Outer.Inner1 {
		ExtendsInner2() { 
			new Outer().super();
			System.out.println("Test1.ExtendsOuter2()");
		}
		ExtendsInner2(Outer outer) { 
			outer.super();
			System.out.println("Test1.ExtendsOuter2(Outer outer)");
		}
	}
	public static void main(String[] args) {
		Test1 t = new Test1();
		//特性4
		new Outer().new Inner1();
		new Outer.StaticInner();
		//特性5
		new ExtendsOuter();
	}
}