2022-07-27 第八小组 田龙月 学习笔记

代码块(初始化块)

在类加载或创建对象时自行隐式调用（静态块》实例块》构造器）（父类》子类）（父静》子静》父实例》父构》子实例》子构）
1.static静态代码块：跟随类一起被加载 static{}
2.实例代码块：每次创建实例时都执行一次 {}

具体查看代码

public class Father {
    static {
        System.out.println("fanther静态块执行");
    }
    {
        System.out.println("fanther实例块执行");
    }
    public Father(){
        System.out.println("fanther构造器执行");
    }
}
public class Child extends Father{
    static {
        System.out.println("child静态块执行");
    }
    {
        System.out.println("child实例块执行");
    }
    public Child(){
        System.out.println("child构造器执行");
    }
}

static关键字

static属性（--因为它属于类，在一个类中只有一个，类的所有东西操作的都是都是这个属性），方法，修饰的属性和方法都存在在方法区（方法区）不会被垃圾回收机制回收。
普通数据类型存储在栈中（static，和final修饰的东西都存在方法区(常量池)中，因为static需要经常加载，final修饰的不会改变-常量）
静态方法和实例方法：实例方法可以直接调静态方法(属性)，静态方法必须创建对象才能调用实例方法(属性)（加载了类就可以创建对象）
重写和静态方法没关系（父类的静态结构就是父类的样子，你也可以有跟我一样的模样，但你不是重写我的，是你自己长得这个样子）；this和super不能出现在static结构中(this必须要有对象，super出现在继承关系中，但静态结构和重写无关，所以不存在使用super)

内部类

实例(成员)内部类 Inner inner=new Outter（）.new Inner（）
静态内部类 InnerStatic is=new Outer.InnerStatic()
匿名内部类(接口实现类) 直接创建抽象类或者接口的对象，直接实例化接口，在内部把需要重写的抽象方法都实现（匿名内部类不能有静态结构(因为需要重写)，不能写抽象结构）

设计原则：

1.开闭原则：开闭原则（Open Close Principle）：对扩展开放，对修改关闭（继承，接口）可以继承类接口，但不能修改类或接口“抽象约束，封装变化”
2.里氏代换原则：除了新增的功能外，重写父类的功能时不要过分重写父类的功能(新增功能就写新的方法，不要在原来的方法写太多的新功能)
3.依赖倒转原则：要面向接口变成，不要面向类编程：a.每个类尽量提供接口和抽象类，或者俩者兼备 b.**变量的类型声明尽量是接口或抽象类(参数) c.任何类都不应从具体类派生Animal a=new Dog();不适用具体类型定义对象 d.使用继承时，遵循里氏代换（多使用接口传参）
4.接口隔离原则：接口之间隔离性好（干啥就是干啥）

lambda表达式(函数时编程，需要传递的参数类型为接口类型时可以使用)

接口中只有一个抽象方法时可以使用，相当于直接重写了接口的抽象方法(格式:(参数列表)->{重写的方法体}(没有都可以为空) )

单例模式：单例模式(只返回一个实例对象)

饿汉式单例

//饿汉式，无论用不用我都创建了对象占用了空间
//public class Single {
////    声明变量:一定要是静态因为外面私有化构造函数只能使用静态方法
//        private static Single single=new Single();
////    私有化构造函数，不让其他类创建我的对象
//        private Single(){}
////    对外只暴漏我这一个实例
//        public static Single getInstance(){
//                return single;
//        }
//}

懒汉单例

////懒汉式单例：用我时我才创建，不安全（线程安全）
//public class Single {
////        只声明不赋值
//        private static Single single;
////        私有化构造函数
//        private Single(){}
//
//        public static Single getInstance(){
////                single=new Single();
////                return single;
////                这样写并不是单例，每调用一次就返回了一个实例，我们需要加一个判断为空的时候我们才创建
////             但多线程时容易出现多例
//                if (single=null){
//                        single=new Single();
//                }
//                return single;
//
//        }
//}

懒饿汉结合

//懒汉饿汉式集合
public class Single {
        private Single(){}
        public static Single getInstance(){
                return Singletn.single;
        }
//        使用时才被加载
        private static final class Singletn{
//                static，类所有东西都操作这个元素
                private static final Single single=new Single();
        }
}