2022.01.13_Java学习总结_面向对象_4_类之间关系、内部类、设计模式

1. 类之间关系

1.1 继承

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

// 类之间单继承
class A{}
class B extends A{}
interface C{}
interface D{}
// 接口之间多继承
interface E extends C,D{}

1.2 实现

类和接口之间是多实现,多个用逗号隔开
Class 类名 implements 接口,接口,....{}

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

类实现接口后,必须实现所有的抽象方法,否则该类需要加abstract修饰

1.3 依赖

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

1.4 关联

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

class A{}

1.5 聚合

整体和局部都有独立的生命周期

	// 如果不手动创建,需要调用处传递,那就不一样了,此时尽管test对象销毁,那么调用处依然保存了person对象的引用
	// 那么 person就不会是垃圾数据,不用被回收,还可以继续复用
	Person person;
	public Test(Person person) {
		this.person = person;
	}

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

1.6 组合

部分和整体不可分离

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

2. 内部类

2.1 概述

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内 部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使 用内部类

在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者 称为外部类。
Inner class一般用在定义它的类或语句块之内，在外部引用它时必须给出完 整的名称。

2.2 成员内部类

 * 成员内部类,可以看做成员变量
 * 
 * 内部类优点 : 可以访问外部类的私有化属性

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

	// 成员内部类
	// 可以使用访问权限控制修饰符
	// 在成员内部类中不能有静态声明
	// 在成员内部类中,可以直接访问外部类所有属性
	// 内部类类名 编译之后 : 外部类类名$内部类类名
	class InnerClass {
		// static int i = 2;
		public void m1(){
			System.out.println(s1);
			System.out.println(s2);
		}
	}
	public static void main(String[] args) {
		// 1 创建外部类对象
		OuterClass_01 o = new OuterClass_01();
		// 2 创建内部类对象
		InnerClass inner = o.new InnerClass();
		// 3 访问属性
		inner.m1();
	}
}

2.3 静态内部类

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

public class OuterClass_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
		OuterClass_02.InnerClass.m1();
		// 当前类中 类名可以省略
		InnerClass.m1();
		// 创建静态内部类对象
		InnerClass inner = new OuterClass_02.InnerClass();
		// 类名可以省略
		inner = new InnerClass();
		// 调用m2
		inner.m2();
	}
}

2.4 局部内部类

 * 局部内部类可以看做局部变量 
 * 
 * 如果通过局部内部类访问外部方法中的局部变量的时候,该变量需要加final修饰,但是在1.8开始,final可以省略
 * 
 * 局部内部类,不能使用权限修饰符 也不能使用static
 * 
 * 局部内部类的类名为外部类类名$1内部类类名,假如内部类类名一样了,那么就是外部类类名$2内部类,以此类推

	// 静态方法中的局部内部类,无法直接使用外部类中的成员属性
	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();
	}
}

2.5 匿名内部类

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

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

	public static void main(String[] args) {
		// UserServiceImpl userServiceImpl = new UserServiceImpl();
		// test(userServiceImpl);

		// 优点 少定义一个类,并且还能访问外部类中的私有化属性,
		// 缺点 : 无法复用
		test(new IUserService() {
			@Override
			public void login() {
				System.out.println("登陆成功");
			}
		});
	}
}

interface IUserService {
	public void login();
}

3. 设计模式

3.1 概述

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

3.2 饿汉模式

public class Singleton_01 {
	private SingLeon_01(){}
	private static Singleton_01 s = new Singleton_01();

	public static Singleton_01 getInstance() {
		return s;
	}
}

3.3 懒汉模式

public class Singleton_02 {
	private SingLeon_02(){}
	private static Singleton_02 s = null;

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