类关系
继承
使用extends表示
类A extends 类B
接口A extends 接口B，接口C
类和类是单继承，接口和接口是多继承
实现
implements
类A implement 接口B，接口C
类和接口是多实现
依赖
一个类的方法中的局部变量是另外一个对象的引用
关系是临时性的，方法执行结束 关系就不存在了
关联
一个类的成员/静态变量是另一个类对象的引用
这个关系是长期的
聚合
整体和局部分离，各自具有生命周期
把好多有意义的模块聚合到一起使用，形成一个有意义的功能，就算这个功能结束也不会影响每个小模块的生命周期（就是有其他的调用）。
组合
关系要强于聚合，也有的叫做强聚合
同样是整体和局部，只不过不可分离，局部没有生命周期
比如A保存B的引用,这个引用一般是自己创建的,(A的构造方法中或者成员变量直接初始化另一个类对象), 这样每创建一个A对象,都会去创建一个B对象,A对象销毁,B对象也会销毁,成为垃圾数据。
代码奉上：
public class ClassRelation_01 {
// 关联关系：成员变量是另一个类对象引用
A a = new A();
public static void main(String[] args) {
// 依赖关系：局部变量是另一个类对象引用
// B b=new B();
}
}
class A {
}
//继承关系，类单继承
class B extends A {
}
interface C {
}
interface D {
}
//继承 接口可以多继承
interface E extends C, D {
}
//实现关系，多实现
class F implements C, D {
}
内部类
定义
类体中编写的类
作用
可以访问外部类私有化数据
分类
根据它所在位置不同，分为：
普通内部类/成员内部类
可以看作成员变量，类体中方法外没有static修饰的类就是普通内部类/成员内部类。
成员内部类中不能有静态声明；类中可以直接访问外部类所有数据。
怎么在main中打印：通过对象，使用外部类对象.new内部类（）来创建内部类对象。
代码奉上：
private static String s1="静态变量";
private String s2="成员变量";
// 类体中没有static修饰的类 是成员内部类
class InnerClass{
// 不能静态声明
// static String s3="";
// public static void m1();
public void m1() {
// 可以直接访问外部类所有属性
System.out.println(s1);
System.out.println(s2);
}
// 可以再套内部类
class A{
}
}
public static void main(String[] args) {
// 怎么打印
// 外部类对象
OuterClass_01 oc=new OuterClass_01();
// 使用外部类对象.new内部类（）来创建内部类对象
InnerClass inner=oc.new InnerClass();
// 或者等价于
// InnerClass inner=new OuterClass_01().new InnerClass();
inner.m1();
System.out.println(inner);
}
静态内部类
可以看作静态变量，类体中方法外用static修饰的类就是静态内部类
在静态内部类中可以声明成员属性也可以声明静态属性；但是内部类中不能直接访问外部类的成员属性（需要使用外部类对象调用外部类成员方法）
怎么打印：访问静态属性 时 OuterClass_02.类名可以省略
非静态属性时，使用new内部类（）来创建内部类对象
public class OuterClass_02 {
private static String s1="静态变量";
private String s2="成员变量";
// 类体中有static修饰的类 是静态内部类
static class InnerClass{
// 能静态声明
static String s3="";
public static void m2() {
};
public void m1() {
// 可以直接访问外部类静态属性
System.out.println(s1);
// 不能直接调用外部类成员属性
// System.out.println(s2);
// 需要使用外部类对象调用成员属性
System.out.println(new OuterClass_02().s2);
}
// 可以再套内部类
static class A{
}
}
public static void main(String[] args) {
// 怎么打印
// 访问静态属性 OuterClass_02.类名可以省略
OuterClass_02.InnerClass.m2();
// 使用外部类对象.new内部类（）来创建内部类对象
InnerClass inner=new InnerClass();
inner.m1();
System.out.println(inner);
}
}
局部内部类
等同于局部变量
这里分为成员方法里面还是静态方法里面，成员方法里面内部类中可以直接访问外部类所有的属性，如果是静态方法，不能直接访问外部类成员属性，需要创建对象去访问。
不管是静态方法还是成员方法，都不能用static修饰内部类；外部的方法的局部变量都不能二次赋值（如同final修饰）；局部内部类都不可以有静态声明。
类名规则:如果多个方法的内部类类名不一致，就是 外部类类名$1内部类类名;如果内部类类名一致 , 就是 外部类类名$1内部类类名 , 外部类名$2内部类类名 依次类推
注意：局部内部类想要调用必须现在外部的该方法里面先调用
private static String s1 = "静态变量";
private String s2 = "成员变量";
public void m1() {
int i = 10;
// 不能改i的值,等于是final修饰
// i=2;
class InnerClass {
// 不能有静态声明
// public static void m3(){}
public void m4() {
System.out.println(s1);
System.out.println(s2);
System.out.println(i);
}
}
// 使用局部内部类 必须在方法内部调用
InnerClass inner = new InnerClass();
inner.m4();
System.out.println(inner);
}
public static void m2() {
int i = 10;
// 不能更改i的值,等于是final修饰
// i=2;
class InnerClass {
// 不能有静态声明
// public static void m3(){}
public void m4() {
System.out.println(s1);
// 静态方法中的内部类,没有办法直接访问外部类的成员属性,需要用对象调用
// System.out.println(s2);
System.out.println(new OuterClass_03().s2);
System.out.println(i);
}
}
// 使用局部内部类 必须在方法内部调用
InnerClass inner = new InnerClass();
inner.m4();
System.out.println(inner);
}
public static void main(String[] args) {
OuterClass_03 oc=new OuterClass_03();
oc.m1();
OuterClass_03.m2();
}
}
匿名内部类
调用方法的时候,需要传入一个接口的实现类对象,这个时候可以不传递实现类对象,传递一个匿名内部类。
语法 : 方法( new 接口名(){ 类体 ;} )。
不能有静态声明（静态变量 / 静态方法 都不行）,但是可以声明常量(public static final int i = 10；（静态常量）)；不能直接访问外部类的成员属性,需要使用对象调用
private static String s1 = "静态变量";
@SuppressWarnings("unused")
private String s2 = "成员变量";
public static void main(String[] args) {
// 几乎等同于实现，只不过实现这是一次性的，如若只调用一次可以用这个，较简单
m1( 1,new IUserService() {
@SuppressWarnings("unused")
// 静态常量
public static final int i = 2;
@SuppressWarnings("unused")
// 可以声明成员方法
public void m1() {
}
@Override
public void login() {
System.out.println("阿道夫v");
System.out.println(this);
System.out.println(s1);
// 需要使用对象调用,不能直接调用外部类的成员属性
// System.out.println(s2);
}
});
}
public static void m1(int i ,IUserService userService) {
userService.login();
}
}
//接口
interface IUserService {
public void login();
}