【无标题】

1. 类之间的关系

1.1 继承

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

class A{}

class B extends A{}         类之间单继承

interface C{}         

interfaceD{}

interface E extends C,D{}        接口之间多继承

1.2 实现

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

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

Class 类名 implements 接口，接口，.....{}

class F implementsC,D{}

1.3 依赖

在局部变量，保存另一个类，对象引用

方法执行完，关系就不存在了

public static void main(String[] args){

A a=new A();

}

1.4关联

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

public class A{

A a=new A();

}

1.5聚合

整体和局部都有独立周期

public class A{

    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);              

}

}

class Test{

                 Person person=new Person();    手动创建的对象，person对象的生命周期和Test对象                                                                        的生命周期绑定，没有保存person的引用，test对象销                                                                      毁，person对象当垃圾数据，等待回收                                                               

                 Person personal;                           不手动创建的对象，调用处传递，当test对象销毁时

                 public Test(Person person){           依旧保存了person对象的引用，person就不会当作

                        this.person=person;              垃圾数据回收，还可以继续复用

                                                                  

}

}

class Person{}

1.6组合

​​​​​​部分和整体不可分离

 Person personal;                           不手动创建的对象，调用处传递，当test对象销毁时

public Test(Person person){           依旧保存了person对象的引用，person就不会当作

       this.person=person;                 垃圾数据回收，还可以继续复用

}

2. 内部类

2.1概述

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

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

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

2.2成员内部类

成员内部类，可以看做成员变量

优点：可以访问外部类的私有化属性

成员内部类可以使用访问权限控制修饰符

内部类类名编译之后：外部类类名$内部类类名

public class OuterClass_01 {
    private static String s1="私有化静态变量";
    private String s2="私有化成员变量";
    
    class InnerClass{
        //static int=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);
        }
        public void m2(){
            System.out.println(s1)；
        }
    }
    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 class OuterClass_03 {
    private static String s1 = "私有化静态变量";
    private String s2 = "私有化成员变量";

    public static void main(String[] args) {

    }

    // 静态方法中的局部内部类,无法直接使用外部类中的成员属性
    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;  final可以省略，但age不能更改和二次赋值
        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.4匿名内部类

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

类名为 外部类类名$1, 外部类类名$2 以此类推

优点：少定义一个类，并且还能访问外部类中的私有化属性

缺点：无法复用

3. 设计模式

3.1概述

设计模式 : 就是在编码实践中,人们发现有很多的编码经常被用到,

于是就总结出来,形成固定的结构,该结构一般代表了最佳的实现方式

让当前类只能被创建一个实例化对象

1 要控制创建对象的数量,也就意味着 不能让客户,直接操作构造方法
            所以 需要构造方法私有化
2 对外提供一个用于获取对象的方法
           没有入参 , 出参是当前类类型 的静态方法

3 创建一个静态变量,用来保存实例化之后的对象

结合对象的创建时机不同,又分为两种情况
        1 加载阶段就创建对象,称为饿汉模式
         2 用到的时候,再创建对象,称为懒汉模式

3.2饿汉模式

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

    public static Singleton_01 getInstance() {
        return s;
    }

}

3.3懒汉模式

public class Singleton_02 {
    private static Singleton_02 s = null;

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

}