面向对象

1.类之间的关系

1.1继承

使用extends表示，类和类之间是单继承，接口和接口之间是多继承，多个用逗号隔开

1.2实现

class A{
}
//类之间单继承
class B extends A{
}
interface C{
}
interface D{
}
//接口之间多继承
interface E extends C,D{
}
//类和接口之间多实现，类实现接口后，必须实现所有的抽象方法
//否则该类需要添加abstract修饰
class F implements C,D{
}

1.3依赖

局部变量，保存另一个类 对象引用，方法执行完，关系就不存在了

	public static void main(String[] args) {
		A a = new A();
	}

1.4关联

成员变量保存了另一个类 对象引用，关系是长期的

1.5聚合

整体和局部都有独立的声明周期

public class Test_02 {
	Person person;

	public Test_02(Person person) {
		// 不手动创建，需要调用传递
		this.person = person;
	}

	public static void main(String[] args) {
		Person person = new Person();
		Test_02 t1 = new Test_02(person);
		System.out.println(t1);
		System.out.println(t1.person);
		Test_02 t2 = new Test_02(person);
		System.out.println(t2);
		System.out.println(t2.person);
		// 尽管此时Test对象销毁，但是调用处依然保存了person对象的引用
		// 那么person就不会是垃圾数据，不用被回收，还可以继续复用
		t1 = null;
		t2 = null;
		System.out.println(person);

	}

}

class Person {
}

1.6组合

部分和整体不可分离

public class Test {
	// person对象的生命周期和Test对象绑定
	// 当创建了多个Test对象的时候一般也会创建多个Person对象
	// 由于该Person对象是手动创建的，那么也就意味着其他地方没有保存person的引用
	// 当test对象销毁时，该person对象也被视为垃圾，等待回收
	Person person = new Person();

	public static void main(String[] args) {
		Test t = new Test();
		System.out.println(t);
		System.out.println(t.person);
		t = null;
		System.out.println(t.person);
	}

}

class Person {
}

2.内部类

2.1概述

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内 部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使 用内部类
在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者 称为外部类。
Inner class一般用在定义它的类或语句块之内，在外部引用它时必须给出完 整的名称。

2.2成员内部类

可以看做成员变量
优点：可以访问外部类的私有属性

package Outclass;

public class OutClass_01 {
	private static String s1 = "私有化静态变量";
	private String s2 = "私有化成员变量";

	// 成员内部类
	// 可以使用访问权限控制修饰符
	// 内部类名编译之后：外部类类名$内部类类名
	public class InnerClass {
		// 内部类里面不能有静态声明
		// static int i =1;
		public void m1() {
			// 成员内部类中可以直接访问外部类所有属性
			System.out.println(s1);
			System.out.println(s2);
		}
	}

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

}

2.3静态内部类

可以看做静态变量，在静态内部类中可以声明成员属性也可以声明静态属性
在静态内部类中无法直接访问外部类的成员属性，需要创建外部类对象访问才行

package Outclass;

public class OutClass_02 {
	private static String s1 = "私有化静态变量";
	private String s2 = "私有化成员变量";

	// 静态内部类
	static class InnerClass {
		public static void m1() {
			System.out.println(s1);
			// System.out.println(s2);←会报错
		}

		public void m2() {
			System.out.println(s1);
			// System.out.println(s2);←会报错
		}
	}

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

}

2.4局部内部类

可以看做局部变量
如果通过局部内部类访问外部方法中的局部变量的时候，该变量需要加final修饰，但是在1.8开始，final可以省略

局部内部类不能用权限修饰符，也不能用static
局部内部类的类名为外部类类名$1内部类类名，假如类名都一样就是$2，以此类推

package Outclass;

public class OutClass_03 {
	public void m1() {
		int age = 19;
		class InnerClass {
			public void m2() {
				System.out.println(age);
				System.out.println(s1);
				System.out.println(s2);
			}
		}
		// 局部内部类调用
		InnerClass iclass = new InnerClass();
		System.out.println(iclass);
		iclass.m2();
	}

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

		}
		// 局部内部类调用
		InnerClass a = new InnerClass();
		System.out.println(a);
		a.m1();
	}

	private static String s1 = "私有化静态变量";
	private String s2 = "私有化成员变量";

	public static void main(String[] args) {
		new OutClass_03().m1();
		OutClass_03.m3();
	}

}

2.5匿名内部类

在方法调用的时候，需要传入一个接口的实现类对象的时候，可以不写实现类，直接写一个匿名类
类名为 外部类类名$1，外部类类名$2，以此类推

package Outclass;

public class OutClass_04 {

	public static void test(IUserService userService) {
		userService.login();
	}

	public static void main(String[] args) {
		test(new IUserService() {

			@Override
			public void login() {
				System.out.println(this);
				System.out.println("登录成功");
			}

		});
	}
}

interface IUserService {
	public void login();
}

class UserService implements IUserService {
	public void login() {
		System.out.println("登录成功");
	}
}

3.设计模式

3.1概述

设计模式就是在编码实践中，人们发现有很多的编码经常被用到，于是就总结出来，形成固定的结构，该结构一般代表了最佳的实现方式
让当前类只能被创建一个实例化对象
1.要控制创建对象的数量，也就意味着不能让客户直接操作构造方法，所以需要构造方法私有化
2.类对外提供一个用于获取对象的方法
（没有入参，出参是当前类类型 的静态方法）
3.创建一个静态变量，用来保存实例化后的对象

3.2饿汉模式

加载阶段就创建对象

package SingleTon;

public class SingleTon_01 {
	private static SingleTon_01 s =new SingleTon_01();
	public static SingleTon_01 getInstance(){
		return s;
	}
}

3.3懒汉模式

用到的时候再创建对象

package SingleTon;

//用到的时候再创建对象，称为懒汉模式
public class SingleTon_02 {
	private static SingleTon_02 s = null;

	public static SingleTon_02 getInstance() {
		if (s == null)
			s = new SingleTon_02();
		return s;
	}

}