2022-07-27 第四小组 王星苹 学习笔记

学习心得

设计模式:是人们为了软件开发中抽象出可重复利用的解决方案，是软件开发工程师沟通之间的行话，对面对对象的一些总结

心情

今天讲解代码块有什么。要记住。有继承关系时，执行顺序：父类静态块 子类静态块 父类实力块 父类构造器 子类实力块 子类构造器。碎知识很多，学多了心态小崩

掌握程度：一般😂😂😂😂😂

 

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

*  类的内部结构
*  代码块 属性 方法 构造器 内部类
*
*  代码块：
*  可以称为初始化块 属于类的一个成员，是将一些逻辑语句，封装在方法体中
*  通过一个大括号{}包裹，代码块不是方法，没有方法名，没有参数，没有返回值，只有方法体
*  是不需要通过对像和类进行显式的调用，会在类加载或创建的时候主动的（隐式）调用。
*
*  1.静态代码块  一个类中可以有n个，但是开发中一般就写一个
*  一个类被加载时会被调用一次，做一些初始化的工作
*  2.实例代码块  也可以有多个
*  每次创建对象都会被调用一次，很少用

public class Ch01 {
    static {
        //静态代码块
        System.out.println("静态代码块...");
    }
    {
        //实例代码块，有实例才行，创建个对象
        System.out.println("实例代码块...");
    }


    public static void main(String[] args) {
        Ch01 ch01 = new Ch01(); //主函数里写
    }

* 面试题：
* 当没有继承关系时， 一个类 优先顺序：静态 实例 构造器
* 有继承关系时，执行顺序：父类静态块 子类静态块 父类实力块 父类构造器 子类实力块 子类构造器

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

*  static静态
*  可以修饰 ： 属性 方法 代码块
*  用static修饰的结构，不属于任何一个对象
*
*  static内存解析：
*  1.静态的变量或者静态方法存在于方法区的，静态的结构不会被垃圾回收
*  2.不属于某一个实例对象，只存在于方法区。调用 静态结构，直接用   类名.方法名    就可以了。
*
*  实例方法和静态方法的相互调用
*  1.静态方法中可以直接调用实例方法吗？  不可以！！！
*      如果想用，必须  对象.方法名
*  2.实例方法中可以直接调用静态方法吗？  可以！！！
*
*  静态的结构的加载，是随着类的加载而加载的！！！
*  非静态的结构 随着对象的创建而加载的！！！
*
*  调用实例方法必须有主体，不能直接调用
*
*  静态方法无论在哪里，都是类名.方法名调用，同一个类的静态方法直接可以相互调用
this 和 super
无论是谁，都不可以在静态结构中使用
this.方法   super.方法
静态结构是属于类的，静态结构是优先于对象就存在的
this和super必须有对象才能出现，必须有实例
 外部类
一个public声明的类，必须和.java的文件名相同
生成的.class文件是两个独立的.class类
外部类就是两个类
开发中尽量不要写外部类
---------------------------------------------------------------------------------------------------------------------------------------

    类的组成结构
    属性 方法 构造器 代码块 内部类
     内部类：
     在一个类内部进行其它类结构的嵌套操作


    我们可以把Node类定义在SuperLinked中

public class Ch01 {
    static {
        System.out.println("外部类被加载...");
    }
    //实例内部类
    public class Inner{
        {
            System.out.println("实例内部类被加载..");
        }
    }
    //静态内部类
    public static class InnerStatic{
        static {
            System.out.println("静态内部类被加载...");
        }
    }


    public static void main(String[] args) {
        //实例内部类的对象
        Inner inner = new Ch01().new Inner();
        //静态内部类的对象
        InnerStatic innerStatic = new Ch01.InnerStatic();
    }

面向对象的设计原则:
1.开闭原则（Lose Principle）
    对扩展开放 对修改关闭 （继承 实现接口）
    我们可以通过“抽象约束 封装变化”来实现开闭原则
    通过接口或抽象类为软件定义一个相对稳定的抽象层
    将相同的可变因素封装在相同的具体实现类中派生一个实体类就可以了
2.里氏代换原则
    在子类继承父类时 除了添加方法 完成新增功能 尽量不要重写
3.依赖倒转原则：
    要面向接口编程 尽量不要面向类去编程
    a.每个类尽量提供接口或抽象类 或者两者兼备
    b.变量的声明尽量是接口或者是抽象类
    c.任何类都不应该从具体类派生
    d.在使用继承时要遵循里氏代换原则
4.接口隔离原则
    使用多个隔离的接口
5.迪米特原则
6.合成复用原则
7.单一原则：一个类只做一件
-----------------------------------------------------------------------------------------------------------------------------

 *   单例模式
 *   一个类只有一个实例
 *
 *   思路：
 *   1.别人不能new，构造器私有化,不能在类的外部通过new去实例化
 *   2.在该类的内部，产生一个唯一的实例对象 把它封装成static类型
 *   3.定义一个静态方法返回这个唯一对象
 *
 *   饿汉单例模式。
 *     不管以后会不会使用到该实例化对象，先创建再说
 *     实现的办法就是直接new实例化

public class Ch03 {
    private static final Ch03 ch03 = new Ch03();
    private Ch03(){


    }
    public static Ch03 getInstance(){
        return ch03;//返回的永远是同一个
    }

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 *   懒汉式（延迟加载）
 *   什么时候调用getInstance方法，什么时候new
 *
 *   这种懒汉式在多线程环境中是完全错误的，根本不能保证单例的

public class Ch04 {
    //将自身实例化对象设置成一个属性，现在是没有赋值的
    private static Ch04 ch04;
    private Ch04(){


    }
    public static Ch04 getInstance(){
        if (ch04==null){
            ch04 = new Ch04();
        }
        return ch04;
    }

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

     内部类实现单例
 *
 *   也是懒汉式一种，没有线程问题
 *
 *   结合了饿汉式和懒汉式的优点
 *   只要不调用getInstance方法，就不会使用内部类

public class Ch05 {
    private Ch05(){


    }
    public static Ch05 getInstance(){
        return SingletonHoider.INSTANCE;
    }
    public static class SingletonHoider{
        private static final Ch05 INSTANCE = new Ch05();
    }

                                                                                                                             
* 箭头函数：JDK8的新特性
*
* 函数式接口：如果一个接口只有一个抽象方法，这个接口就称为函数式接口。
*
* 可以用注解@FunctionalInterface标识。
*
* 1、有参数，有返回值。
*  (i,j) -> {
*      return i + j;
*  }
*  如果方法体只是一句返回值(i,j) -> i+j
* 2、有参数，无返回值
*  (i,j) -> {
*      // 方法体
*  }
*  如果方法体只有一句话(i,j) -> 方法体的一句话
* 3、无参数
*  ()->{
*      方法体
*  }