内部类，单例，工厂，代理

• 内部类

在一个类中定义的类就是内部类

• 成员内部类

 *         1.Outer01$Inner.class class文件名   $ 代表内部类的意思
 *      2.内部类也是类,是类就可以继承,实现接口...
 *      3.成员内部类处于成员位置,就可以使用成员修饰符进行修饰
 *      4.在内部类中可以直接使用外部类中的成员变量
 *      5.在外部类中不可以直接使用内部类中的成员,需要通过对象使用
 *      6.在成员内部类中不可以定义静态的内容,除了static final修饰的变量
 *      7.成员内部类要定义在类中成员的位置

           内部类声明成静态的，就不能随便的访问外部类的成员变量了，

       此时内部类只能访问外部类的静态成员变量 。

public class Outer {
	// 成员属性
	int age = 19;
	String name = "卢双双";
	static double d = 2.2;

	// 成员内部类
	class Inner extends Test implements Face {
		// 内部成员属性
		int num = 555;
		static final char ch = 'a';

		// 内部类成员方法
		public void inMethod() {
			System.out.println("内部类成员方法" + a);
			System.out.println("内部类静态变量ch	" + ch);
			// 测试内部类中使用外部类中的成员属性
			System.out.println("外部类age" + age);
			System.out.println("外部类静态属性" + d);
			// 测试内部类中使用外部类中的成员方法
			outMethod();
		}

		@Override
		public void face() {
			System.out.println("重写的face");

		}
	}

	// 成员方法
	public void outMethod() {
		System.out.println("外部类的成员方法");
		// 创建内部类对象调用内部属性
		Inner in = new Inner();
		System.out.println("使用内部类的成员属性" + in.num);
		System.out.println("使用内部类的成员属性" + in.ch);
		// in.ch='ddd';常量
		in.face();
		//in.inMethod();  不能循环调用
	}
}

interface Face {
	void face();
}




/*
 * 测试成员内部类
 * 		使用内部类是有公式的
 */
public class Test {
	int a = 7;

	public static void main(String[] args) {
		Outer out = new Outer();

		// 内部类创建对象的 ----第一种方式
		Outer.Inner in = out.new Inner();
		System.out.println(in.num);
		in.inMethod();

		// 内部类创建对象的 ----第二种方式
		Outer.Inner in2 = new Outer().new Inner();
		System.out.println(in2.num);
		in2.inMethod();

		OuterDemo.Inner in3 = new OuterDemo().new Inner();
		in3.innerTest();
	}
}

• 静态内部类

 *         静态内部类可以定义静态内容和非静态内容
 *         静态内部类中不可以直接使用外部类中的非静态内容,可以
 *     直接使用静态内容
 *         
 *         静态内部类的使用:
 *             StaticInner.Inner in = new StaticInner.Inner();

public class StaticInner {
	public static void main(String[] args) {
		//静态内部类的使用方式
		System.out.println(StaticOuter.Inner.ch);
		//通过创建对象使用静态内部类的成员
		StaticOuter.Inner in = new StaticOuter.Inner();
		in.inMethod();
		in.inMethod2();
	}
}
//外部类
class StaticOuter{
	String type = "藏獒";
	static int a = 5;
	
	//静态内部类
	static class Inner{
		//成员属性
		double d = 1210.11;
		//静态属性
		static char ch = 'a';
		
		//静态方法----不可以直接使用静态内部类的非静态属性
		static void inMethod(){
			System.out.println("内部类静态方法");
			Inner in = new Inner();
			System.out.println(in.d);
			System.out.println(ch);
			System.out.println(new StaticOuter().type);
			new StaticOuter().outMether();
		}
		
		//成员方法---静态内部类中不可以直接使用外部类中的非静态内容
		public void inMethod2(){
			System.out.println("内部类非静态方法");
			System.out.println(d);
			System.out.println(a);
			System.out.println(ch);
			StaticOuter in = new StaticOuter();
			System.out.println(in.type);
			in.outMether();
		}
	}
	public void outMether(){
		System.out.println("静态外部类的成员方法");
	}
}

• 私有内部类

 * 私有内部类:
 *         1.私有的内容只能本类中使用;
 *         2.私有内部类无法在其他外部类中使用或者访问,
 *     只能在当前外部类中通过创建对象使用.

public class PrivateInner {
	public static void main(String[] args) {
		// 创建私有内部类的对象
		// PrivateOuter.Inner in = new PrivateOuter().new Inner();
		PrivateOuter p = new PrivateOuter();
		p.outMethod();
	}
}

// 外部类
class PrivateOuter {
	private String name;
	private int age;

	// 内部类
	private class Inner {
		// 成员属性
		private String s = "哈哈";
		private int i = 123;

		// 私有内部类的方法
		private void inMethod() {
			System.out.println("私有内部类的私有方法");
		}
	}

	// 成员方法
	public void outMethod() {
		System.out.println("外部类中的成员方法");
		// 创建内部类对象
		Inner in = new Inner();
		System.out.println(in.i);
		in.inMethod();
	}
}

 

• 局部内部类

 * 局部内部类
 *         在一个方法中定义的内部类,就是局部内部类
 *         局部内部类在外部无法使用,只能在定义的方法中通过东西使用
 *         如果想要使用局部内部类的成员属性,可以使用方法的返回值
 *         局部内部类不能被public  static  private   protected 成员修饰符修饰
 *         局部内部类想使用当前定义中的参数,必须在前面加final
 *  JDK1.8 后,可以省略,默认有final

public class PartInner {
	public static void main(String[] args) {
		PartOuter out = new PartOuter();
		out.test(5);
		out.outMethod1();
	}
}

// 外部类
class PartOuter {
	// 方法
	Object test(final int i) {
		// 局部变量
		int a = 10;// 方法中的局部变量不能被调用
		// i++;

		// 局部内部类
		class Inner {
			private int b = 3;

			public int inMethod() {
				System.out.println("局部内部类方法");
				System.out.println(i);
				System.out.println("方法内" + b);
				return -1;
			}
		}
		Inner in = new Inner();
		System.out.println("方法外" + in.b);
		return in.inMethod();
	}

	void outMethod1() {
		System.out.println("外部类成员方法");
		// Inner in = new Inner();
		// - Inner cannot be resolved to a type
	}
}

• 匿名内部类

匿名内部类就是没有名字的局部内部类，

不使用关键字class, extends, implements, 没有构造方法。

匿名内部类隐式地继承了一个父类或者实现了一个接口。

匿名内部类使用得比较多，通常是作为一个方法参数

/*
 * 匿名内部类
 */
public class AnonymousInner {
	public static void main(String[] args) {
		// Father fa = new Son();

		// 匿名内部类 ---第一种使用方式:只能使用一次
		new Father() {// 匿名内部类 Father就是匿名内部类的父接口或者父类

			@Override
			public void laugh() {
				System.out.println("富士山下");
			}

			@Override
			public void eat() {
				System.out.println("淘汰");
			}

		}.eat();// = new Son.eat();

		// 匿名内部类 ----第二种方式
		// 接口多态
		Father fa = new Father() {

			@Override
			public void laugh() {
				System.out.println("一条大河波浪宽");
			}

			@Override
			public void eat() {
				System.out.println("风吹稻花香两岸");
			}

		};
		fa.eat();
		fa.laugh();

		// 匿名内部类 ----第三种方式
		test(new Father() {

			@Override
			public void laugh() {
				System.out.println("我吃车厘子!!!");
			}

			@Override
			public void eat() {
				System.out.println("我吃披萨!!!");
			}

		});
	}

	static void test(Father fa) {
		fa.eat();
		fa.laugh();
	}
}

// 接口 Father
interface Father {
	void laugh();

	void eat();

}

// 实现类
/*
 * class Son implements Father {
 * 
 * @Override public void laugh() {
 * 
 * }
 * 
 * @Override public void eat() {
 * 
 * } }
 */

• 单例

 * 单例模式: 一个类只能创建一个对象
 * 
 * 单例模式分类:
 *         1.饿汉式:第一次加载类就创建一个对象
 *         2.懒汉式:当第一次调用功能的时候才会创建对象(线程不安全--锁解决)
 * 
 * 步骤:
 *         1.私有构造器
 *         2.定义一个私有的,静态的,该类的,引用
 *         3.提供一个静态的,公共的方法,返回给用户一个对象

• 懒汉式

public class SingleTon {
	//1.私有构造器:不想让其他类直接通过调用构造器创建对象
	private SingleTon(){
		
	}
	//2.定义一个私有的,静态的,该类的,引用
	private static SingleTon singleTon=null;
	//3.公共的静态的方法,返回给用户一个对象
/*	public static SingleTon getInstance(){
		if (singleTon==null) {
			singleTon=new SingleTon();
		}
		return singleTon;
	}*/
	
	public static SingleTon getInstance(){
		if (singleTon==null) {
			//创建对象  A  B  C  
			synchronized (SingleTon.class) {//双重锁
				if (singleTon==null) {
					singleTon=new SingleTon();
				}
			}
		}
		return singleTon;
	}
	
	
}

 

• 饿汉式

/*
 * 饿汉式:第一次加载就创建对象
 */
public class SingleTon2 {
	// 1.私有的构造器
	private SingleTon2() {

	}

	// 2.私有的静态的该类的引用
	private static SingleTon2 singleTon = new SingleTon2();

	// 公共的静态的方法
	public static SingleTon2 getInstance() {
		return singleTon;
	}
}

public class Test0809 {
	public static void main(String[] args) {
		// 测试懒汉式
		// SingleTon s=new SingleTon();--私有构造器无法创建对象
		SingleTon s1 = SingleTon.getInstance();
		SingleTon s2 = SingleTon.getInstance();
		System.out.println(s1 == s2);

		// 饿汉式
		SingleTon2 s3 = SingleTon2.getInstance();
		SingleTon2 s4 = SingleTon2.getInstance();
		System.out.println(s3 == s4);
	}
}

 

• 工厂模式

 * 简单工厂模式:
 *         1.工厂角色
 *         2.抽象产品角色
 *         3.具体产品角色

public class Factory11 {
	public static void main(String[] args) {
		Car car = factory("BMW");
		car.run();
	}

	// 工厂角色
	public static Car factory(String type) {
		Car car = null;
		if (type.equals("BMW")) {
			car = new BMW();
			//return new BMW();
		} else {
			car = new QQ();
		}
		return car;
	}
}

// 抽象产品角色
interface Car {
	void run();
}

// 具体产品角色
class BMW implements Car {

	@Override
	public void run() {
		System.out.println("宝马在跑...");
	}

}

class QQ implements Car {

	@Override
	public void run() {
		System.out.println("qq在跑...");
	}
}

• 静态代理

 * 静态代理:
 *     1.真实角色和代理角色持有相同的接口
 *     2.代理角色持有持有真实角色的引用
 *     3.代理行为

public class StaticPox12 {
	public static void main(String[] args) {
		// 1,真实角色
		Boss boss = new Boss();
		boss = null;
		// 2.代理角色
		Hr hr = new Hr(boss);
		hr.addUser();
	}
}

// 接口 录用人
interface AddUser {
	void addUser();
}

// 真实角色
class Boss implements AddUser {

	@Override
	public void addUser() {
		System.out.println("项目经理说录用...");
	}

}

// 代理角色 功能的拓展
class Hr implements AddUser {
	// 2.代理角色持有持有真实角色的引用
	private Boss boss;

	// 无参构造
	public Hr() {
		// TODO Auto-generated constructor stub
	}

	// 在有代理角色之前就应该存在真实角色
	public Hr(Boss boss) {
		super();
		this.boss = boss;
	}

	@Override
	public void addUser() {
		System.out.println("通知求职者来面试");
		boss.addUser();
		System.out.println("谈薪资...");
	}
}