Java_Day_13_总结

1.依赖关系

所谓依赖就是某个对象的功能依赖于另外的某个对象，而被依赖的对象只是作为一种工具在使用，而并不持有对它的引用。

2.关联关系

某个对象会长期的持有另一个对象的引用，而二者的关联往往也是相互的。

关联的两个对象彼此间没有任何强制性的约束，只要二者同意，可以随时解除关系或是进行关联，它们在生命周期问题上没有任何强制性的约束，被关联的对象还可以再被别的对象关联，所以关联是可以共享的。

public class ClassRelation_01 {
	// 关联关系,成员变量保存了另一个类 对象引用
	// 关系是长期的
	A a = new A();

	public static void main(String[] args) {
		// 依赖关系,局部变量,保存另一个类 对象引用
		// 方法执行完,关系就不存在了
		A a = new A();
	}
}

// 类之间单继承
class A {
}

class B extends A {
}

interface C {
}

interface D {
}

// 接口之间多继承
interface E extends C, D {
}

// 类和接口之间多实现
class F implements C, D {

局部内部类:可以看做局部变量
不能使用权限修饰符、也不能static
局部内部类的类名为外部类$内部类类名
内部类访问方法的局部变量，必须是final 类型，不能更改
 

public static void main(String[] args) {

	}

	// 静态方法中的局部内部类,无法直接使用外部类中的成员属性
	public static void m1() {
		final int age = 19;
		class InnerClass {
			// public static void m1(){}
			public void m3() {
				System.out.println(age);
				System.out.println(s1);
				// System.out.println(s2);
			}
		}
	}

	// 成员方法中的内部类,可以直接访问外部类中的所有属性
	public void m2() {
		final int age = 19;
		// age = 2;
		class InnerClass {
			// public static void m1(){}
			public void m3() {
				System.out.println(age);
				System.out.println(s1);
				System.out.println(s2);
			}
		}
		// 局部内部类调用
		InnerClass i = new InnerClass();
		i.m3();
	}

匿名内部类：方法调用时，需要传入接口的实现类的对象时。
可以不写实现类，直接写匿名内部类

public class nullname {

	public static void main(String[] args) {
		// 覆写？
		test(new User() {
			// 优点：少搞一个类，访问外部类私有化
			// 缺点：无法复用
			@Override
			public void login() {
				// TODO Auto-generated method stub

			}
		});
	}

	public static void test(User user) {
		user.login();
	}

}

interface User {
	public void login();
}

成员内部类

public static void main(String[] args) {
		// 1 创建外部类对象
		OuterClass_01 o = new OuterClass_01();
		// 2 创建内部类对象
		InnerClass inner = o.new InnerClass();
		// 3 访问属性
		inner.m1();
	}

可以使用访问权限控制修饰符
在成员内部类中不能有静态声明
内部类类名 编译之后 : 外部类类名$内部类类名

静态内部类

public static void main(String[] args) {
		// 调用m1
		OuterClass_02.InnerClass.m1();
		// 当前类中 类名可以省略
		InnerClass.m1();
		// 创建静态内部类对象
		InnerClass inner = new OuterClass_02.InnerClass();
		// 类名可以省略
		inner = new InnerClass();
		// 调用m2
		inner.m2();
	}

设计模式:前辈们对代码开发经验的总结，是解决特定问题的一系列套路
于是就总结出来,形成固定的结构,该结构一般代表了最佳的实现方式
让当前类只能被创建一个实例化对象
1要控制创建对象的数量,也就意味着不能让客户，直接操作构造方法
所以需要构造方法私有化2对外提供一个用于获取对象的方法没有入参，
出参是当前类类型的静态方法
3创建一个静态变量,用来保存实例化之后的对象
结合对象的创建时机不同，又分为两种情况
1加载阶段就创建对象,称为饿汉模式
2用到的时候,再创建对象,称为懒汉模式