类关系、内部类

1. 类之间的关系

1.1. 继承

继承关系(泛化关系) : 继承指的是一个子类或者一个子类接口继承另外的父类或者父类 接口的功能 , 并可以增加他自己的的新功能的能力 . 继承关系通过关键字 extends明确标识 .

UML中 , 继承关系用一条带空心三角箭头的实线表示 , 子类指向父类 , 或者子接口指向父接口 .

类和类之间是单继承

接口和接口之间是多继承 , 多个用逗号隔开

1.2. 实现

实现关系 : 实现是指一个class类实现Interface接口(可以是多个)的功能 , 实现是类与 接口之间最常见的关系 , 实现关系通过关键字implements明确标识 , UML中 , 实现是用一条带空心三角箭头的虚线表示 , 从类指向实现的接口

类和接口之间是多实现 , 多个用逗号隔开

1.3. 依赖

依赖关系 : 简单理解 , 就是一个类A用到了另一个类B , 而且这种关系具有偶然性、 临时性、非常弱 , 方法执行完 , 这个关系就不存在了 , 就是临时使用了以下功能 , 但是类B的变化会影响到类A

在程序的生命周期中 , 某个步骤或者某几个步骤需要另外一个类的功能才能完成

其实就是一个类的局部变量是另外一个类的对象的引用

//依赖关系
public class Relation_01 {
	public static void main(String[] args) {
		Relation_01 us = new Relation_01();
		//在一个类中创建另一个类的对象就是依赖关系
		User user = new User();
		us.m1(user);
	}
	public void m1(User user) {
		
	}
}
class User{
	
}

1.4. 关联

关联关系 : 关联关系体现的就是两个类之间语义级别的一种强依赖关系 , 这种关系比 依赖更强、不存在依赖关系的偶然性、关系也不是临时的 , 一般是长期的 , 而且双方关系一般是平等的 . 关联可以是单向的 , 也可以是双向的 .

1.5. 聚合

聚合关系 : 聚合是关联关系的一种特例 , 它体现的是整体与部分的关系 , 此时整体与部 分之间是不可分割的 , 他们可以具有各自的生命周期 , 部分可以属于多个整 体对象 , 也可以为多个整体对象共享

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

在UML中,聚合关系用空心菱形加实现箭头来表示

package _08_Relation;

//如果不手动重建 , 需要调用处进行传递 , 此时尽管Relation_02对象销毁
//调用处依旧保存着person对象的引用 , 那么person就不会是垃圾数据 , 不会被回收 , 还可以继续复用

public class Relation_02 {
	Person person;
	public Relation_02(Person person) {
		this.person = person;
	}
}
class Person{
	
}

1.6. 组合

组合关系 : 组合关系也是关联关系的一种特例 , 这种关系比聚合强 , 也称为强聚合 .整 体与部分是不可分割的 , 整体的生命周期结束也就意味着部分的生命周期结束

在UML中 , 组合关系以菱形实心加实线箭头表示

class Test{
    Person person = new Person();
}
class Person{
    
}

关联关系 , 但是这个对象是自己创建的 , person对象的生命周期会对Test对象的生命周期绑定 , 当创建多个Test对象的时候 , 一般会创建多个Person对象 , 由于该person对象是手动创建的 , 所以其他地方没有保存person的引用 , 当Test对象销毁时 , person对象也被当做垃圾数据 , 等待被回收

2. 内部类

2.1. 内部类概念

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

在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者 称为外部类。

Inner class一般用在定义它的类或语句块之内，在外部引用它时必须给出完 整的名称。

内部类的名字 : 外部类类名$内部类类名

2.2. 成员内部类

public class OuterClass_01 {
	int a = 1;
	static int b = 2;
	private int c = 3;
	private static int d = 4;
	
	
	// 成员内部类,等同于成员变量,没有static修饰
	// 内部类,可以使用权限控制修饰符
	// 内部类,可以访问外部类中的私有化属性
	 class InnerClass{
		int e = 5;
		//成员内部类中不能有静态声明
//		static int f = 6;
		public void m1() {
			//静态内部类中可以直接访问外部类的所有数据
			System.out.println(a);
			System.out.println(b);
			System.out.println(c);
			System.out.println(d);
			System.out.println(e);
		}
//		public static void name() {
			
		
	}
	 
	 public static void main(String[] args) {
		OuterClass_01 out = new OuterClass_01();
		InnerClass innerClass = out.new InnerClass();
		innerClass.m1();
	}
}

2.3. 静态内部类

public class OuterClass_02 {
	int a = 1;
	static int b = 2;
	
	// 静态内部类,可以等同看做静态变量
	// 静态内部类中,可以声明任何数据(静态/成员)
	// 静态内部类中无法直接访问外部类的成员属性,需要创建对象
	static class InnerClass{
		int c = 2;
		static int d = 4;
		public void m1() {
			System.out.println(c);
			// 静态内部类中无法直接访问外部类的成员属性
			// System.out.println(a);
			// 创建外部类对象后,可以访问成员属性
			OuterClass_01 out = new OuterClass_01();
			System.out.println(out.a);
			System.out.println(b);
			
		}
		public static void m2() {
			
		}
	}
	public OuterClass_02() {
		
	}
	public static void main(String[] args) {
		//创建静态内部类对象
		InnerClass inner = new OuterClass_02.InnerClass();
		inner = new InnerClass();
		inner.m1();
		InnerClass.m2();
	}
}

2.4. 局部内部类

// 方法中的类是局部内部类

// 成员方法中的内部类,不能有静态声明

// 并且可以直接访问外部类的成员属性

// 局部内部类命名 : 外部类类名$1内部类类名

// 如果内部类类名重复,则为 外部类类名$2内部类类名,以此类推

// 局部内部类不能使用权限修饰符,也不能使用static

public class OuterClass_03 {
	public static void main(String[] args) {
		OuterClass_03 out = new OuterClass_03();
		out.m1();
		
	}
	int a = 1;
	static int b = 2;
	public void m1() {
		int c = 3;
		// 方法中的类是局部内部类
		// 成员方法中的内部类,不能有静态声明
		// 并且可以直接访问外部类的成员属性
		// 局部内部类命名 : 外部类类名$1内部类类名
		// 如果内部类类名重复,则为 外部类类名$2内部类类名,以此类推
		// 局部内部类不能使用权限修饰符,也不能使用static
		class InnerClass{
			public void m2() {
				System.out.println(a);
				System.out.println(b);
				// 如果访问外部方法的局部变量,则该变量不能修改(不能二次赋值)
				// 1.8之前,需要加final修饰局部变量,1.8开始不用加final了,但是也不能修改
				System.out.println(c);
			}
		}
		// 由于类在方法中,所以该类只能在这个方法中使用
		InnerClass inner =new InnerClass();
		inner.m2();
	}
	
	public static void m3() {
		// 局部内部类不能有静态声明
		// 静态方法中的局部内部类,不能直接访问外部类的成员属性
		class InnerClass{
			public void m4() {
//				System.out.println(a);
				System.out.println(b);
			}
		}
		// 由于类在方法中,所以该类只能在这个方法中使用
		InnerClass inner = new InnerClass();
		inner.m4();
	}
}

2.5. 匿名内部类***

/**
 * 
 * 匿名内部类 : 当一个方法参数需要传入一个类对象时 , 均可以使用匿名内部类
 * 			一般情况下 , 是需要传入接口的实现类对象的
 * 此匿名内部类 , 就等于该类(接口)的子类 , 只不过不用定义class
 * 
 * 匿名内部类类名 : 外部类类名$1内部类类名 , 外部类类名$2内部类类名 ,以此类推
 * 
 * @author 善良的王铁柱
 *@date 2023年10月11日
 *
 */

第一种传入的是类对象的时候

public class OuterClass_04 {
    //
	public static void main(String[] args) {
        //传入类对象
		m2(new Cat());
	}
	public static void m2(Animal animal) {
		animal.eat();
	}
	//
}
class Animal{
	public void eat() {
		
	}
}
class Cat extends Animal{
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

第二种是传入的是接口的实现类对象的时候

public class OuterClass_06 {
	public static void main(String[] args) {
//		OuterClass_06 out = new OuterClass_06();
		m1(new Login1() {
			
			@Override
			public void login(String username, String password) {
				if (username.equals("admin")) {
					if (password.equals("root")) {
						System.out.println("登陆成功");
					}else {
						System.out.println("密码错误");
					}
				}else {
					System.out.println("用户名错误");
				}
				
			}
		});
	}
	public static void m1(Login1 login) {
		login.login("admin","root");
	}
}



interface Login1{
	public void login(String username, String password);
}

3. 设计模式

3.1. 设计模式概念

软件设计模式（Design pattern），又称设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。

一般代表了最佳实践

单例模式 : 让某个类只创建一个对象

1 构造方法私有化,因为创建对象,使用构造方法,所以我们想要限制对象的创建,就要限制构造方法的使用

2 创建一个用于保存对象的静态变量

3 对外提供一个用于获取对象的方法(一定是静态方法)

3.2. 饿汉模式

public class Singleton_01 {
	public static void main(String[] args) {
		Test_01 t = new Test_01();
		Test_01 t1 = Test_01.getobj();
	}
}
class Test_01{
	private static Test_01 t = new Test_01();
	public static Test_01 getobj() {
		return t;
	}
}

3.3. 懒汉模式

class Test_2 {
	private Test_2() {
		System.out.println("构造方法执行了");
	}

	private static Test_2 obj = null;

	public static Test_2 getObj() {
		if (obj == null) {
			obj = new Test_2();
		}
		return obj;
	}
}