java笔记（类之间关系、内部类、设计模式）

一、类之间关系

1.继承

//类和类之间是单继承
class A extends Code{
}
interface B {
}
interface C{
}
//接口和接口之间是继承,多继承用逗号隔开
interface D extends B,C{
}

2.实现

//类和接口之间是实现,多个实现用逗号隔开
class E implements B,C{
}

3.依赖

//局部变量保存的是其他类的引用
//依赖关系
A a=new A();
//类和类之间是单继承
class A extends Code{
	
}

个人理解:一般是局部变量,生命周期不同,例:临时朋友,一旦一段关系结束那么就不再联系

4.关联

//成员变量保存其他类对象
//关联,也叫强依赖
A a=new A();

个人理解:一般是成员变量,生命周期相同,例:好朋友,什么时候联系都可以,不会影响关系

5.聚合

User user=new User();
new Code(user);
new Code(user);
new Code(user);
public Code(User user){
	this.user=user;
}

个人理解:一个对象,内部是一个整体,没被其他地方储存,会互相影响,例:类似橙子,有一个地方破了整个就破了,一起死

6.组合

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

个人理解:一个对象,内部不是一个整体,被其他地方储存,不会互相影响,例:类似橘子,拿走一块不应影响其他的,不一起死

二、内部类

1.概述

概念:类体中的类叫内部类

当一个事物的内部还需要另一个完整的结构时,并且该结构又只对当前这个类提供服务,这种情况下,就不需要单独创建实体类,只要把这个实体类写在这个类的内部就行

内部类可以访问外部类的私有化属性

内部类的类名=外部类的类名$内部类类名

class A{class B{}}

此时编译后生成的class文件B的名字叫A$B

2.成员内部类

成员内部类可以看做成员变量,类体中没有static修饰,成员内部类可以使用权限修饰符

成员内部类中不能有静态声明

成员内部类可以直接访问外部类中所有的属性

public class Code {
    private static int a2=1;
	private int b2 =2;
	private class InnerClass {
		int b2=3;
		public void m2(){
			System.out.println(a2);
			System.out.println(b2);
			//区分外部类和内部类同名的成员属性
			System.out.println(Code.this.b2);
		}
	}
    public static void main(String[] args) {
        //创建外部类对象
		Code out =new Code();
		//创建成员内部类对象
		InnerClass inner=out.new InnerClass();
		inner.m2();
    }

3.静态内部类

静态内部类可以看做静态变量,需要用static修饰

静态内部类中可以声明静态也可以声明成员

但是在静态内部类中,无法直接访问外部类的成员属性,需要创建对象

public class Code {
    private static int a3=1;
	private int b3=2;
	//静态内部类
		private static class InnerClass2{
			public static void m3(){
				System.out.println(a3);
			}
			public void m4(){
				System.out.println(a3);
				System.out.println(new Code().b3);
			}
		} 
    public static void main(String[] args) {
        //可以直接new内部类对象
        InnerClass2 inner2=new InnerClass2();
		inner2.m4();
		InnerClass2.m3();
    }

4.局部内部类

局部内部类可以看做局部变量

局部内部类不能有静态声明

局部内部类的名字为外部类类名$1内部类类名

如果局部内部类名字相同,则为外部类类名$1内部类类名,外部类类名$2内部类类名,…

如果内部类访问外部方法中的局部变量,则该变量需要加final修饰,不可以二次复制,从1.8开始final可以省略

public class Code {
    private static int a4=1;
	private int b4=2;
	public static void m5(){
		int c4=3;
		//局部内部类
		class InnerClass3{
			public void m6(){
				System.out.println(a4);
				System.out.println(c4);
			}
		}
		//使用局部内部类也只能在这个方法中使用
		InnerClass3 inner3=new InnerClass3();
		inner3.m6();
	}
    public void m7(){
		class InnerClass3{
			public void m6(){
				System.out.println(a4);
				//成员方法的局部内部类,可以直接访问外部成员属性
				System.out.println(b4);
			}

5.匿名内部类

匿名内部类的类名为外部类类名$1,…

一般在方法调用时,需要传入一个对象的时候(一般是接口实现类对象),这时如果这个类也不会复用,就可以不创建class类,直接传入一个匿名内部类即可

语法: 方法名 (new 父类/父接口(){匿名内部类的类体});

匿名内部类就是一个子类,就是不创建对应的子类文件,直接创建一个临时使用的子类对象

匿名内部类数不能进行复用的

静态内部类中不能有静态声明,但是可以声明常量

不能直接访问外部的成员属性,需要有对象才行

test(new IUserService() {
	@Override
	public void login() {
		System.out.println("登陆成功");
	}
});
//1.8新特性,lambda表达式,也叫箭头函数,是匿名内部类的简写形式
test(()->System.out.println("登陆成功"));
public static void test(IUserService userService){
	userService.login();
}
interface IUserService{
	public void login();
}

三、设计模式

1.概述

设计模式代表了最佳的实践方式

软件设计模式又称设计模式,是一套被反复使用的、多人知晓的、经过分类编目的代码设计经验的总结

使用设计模式是为了可重用代码,让代码更容易被他人理解,保证代码可靠性,程序的重用性

2.单例模式

2.1.概述

让某个类只创建一个对象,提供一个获取对象的方法,调用多次,得到的对象是同一个对象

1. 构造该方法私有化,不能让外部直接访问
2. 需要提供一个用于获取对象的静态方法
3. 提供一个用于保存对象的静态变量

根据对象的创建时机可分为两种

1. 饿汉模式:类加载后立即创建对象
2. 懒汉模式:第一次获取对象时,在创建对象

2.2.懒汉模式

//静态变量在类加载时进行初始化赋值,类生命周期中,只会加载一次并且初始化一次
static Code2 c6=new Code2();
private Code2(){
}
public static Code2 getInStance1(){
	return c6;
}

2.3.饿汉模式

private Code2(){
}
private static Code2 c7=null;
	public static Code2 getInStance2(){
		if (c7==null) {
			c7 =new Code2();
		}
		return c7;
	}